Author: steve.ebersole(a)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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;key&gt;</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>&lt;column&gt;</literal> element, but on the <literal>&lt;key&gt;</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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;class&gt;</literal> mappings, as shown above. It is however good practice (and expected by some tools) to map only a single persistent class (or a single class hierarchy) in one mapping file and name it after the persistent superclass, 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>&lt;hibernate-mapping&gt;</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>&lt;hibernate-mapping&gt;</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>&lt;union-subclass&gt;</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>&lt;subclass&gt;</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>&lt;class&gt;</literal> declaration as a <literal>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</literal>. For most purposes the default, <literal>polymorphism=\"implicit\"</literal>, is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table (this allows a \"lightweight\" class that contains a subset of the table columns)." +msgstr "" + +#: 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>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</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>&lt;subselect&gt;</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>&lt;id&gt;</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>&lt;composite-id&gt;</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>&lt;generator&gt;</literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal>&lt;param&gt;</literal> element." +msgstr "" + +#: 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>&lt;generator&gt;</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>&lt;one-to-one&gt;</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>&lt;generator&gt;</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>&lt;composite-id&gt;</literal> element accepts <literal>&lt;key-property&gt;</literal> property mappings and <literal>&lt;key-many-to-one&gt;</literal> mappings as child elements." +msgstr "" + +#: 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>&lt;composite-id&gt;</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&mdash;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>&lt;discriminator&gt;</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>&lt;class&gt;</literal> and <literal>&lt;subclass&gt;</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>&lt;version&gt;</literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis> (see below)." +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>&lt;timestamp&gt;</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>&lt;timestamp&gt;</literal> is equivalent to <literal>&lt;version type=\"timestamp\"&gt;</literal>. And <literal>&lt;timestamp source=\"db\"&gt;</literal> is equivalent to <literal>&lt;version type=\"dbtimestamp\"&gt;</literal>" +msgstr "" + +#: basic_mapping.xml:1479(title) +msgid "property" +msgstr "" + +#: basic_mapping.xml:1481(para) +msgid "The <literal>&lt;property&gt;</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>&lt;column&gt;</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>&lt;formula&gt;</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>&lt;column&gt;</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>&lt;properties&gt;</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>&lt;natural-id&gt;</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>&lt;component&gt;</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>&lt;property&gt;</literal> tags map properties of the child class to table columns." +msgstr "" + +#: basic_mapping.xml:2197(para) +msgid "The <literal>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity." +msgstr "" + +#: basic_mapping.xml:2203(para) +msgid "The <literal>&lt;dynamic-component&gt;</literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map, see <xref linkend=\"components-dynamic\"/>." +msgstr "" + +#: basic_mapping.xml:2212(title) +msgid "properties" +msgstr "" + +#: basic_mapping.xml:2214(para) +msgid "The <literal>&lt;properties&gt;</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>&lt;properties&gt;</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>&lt;subclass&gt;</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>&lt;version&gt;</literal> and <literal>&lt;id&gt;</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>&lt;joined-subclass&gt;</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>&lt;key&gt;</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>&lt;class&gt;</literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal>&lt;union-subclass&gt;</literal> mapping." +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>&lt;join&gt;</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>&lt;join&gt;</literal> defined by a class or its superclasses and an outer join for a <literal>&lt;join&gt;</literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal>&lt;join&gt;</literal> defined on a subclass, 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>&lt;join&gt;</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>&lt;key&gt;</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>&lt;key not-null=\"true\"&gt;</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>&lt;column&gt;</literal> subelement. Likewise, <literal>&lt;formula&gt;</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>&lt;any&gt;</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>&lt;class&gt;</literal>, <literal>&lt;subclass&gt;</literal> and so on. For value types we use <literal>&lt;property&gt;</literal>, <literal>&lt;component&gt;</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>&lt;column&gt;</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>&lt;type&gt;</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>&lt;typedef&gt;</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&gt;(a)hibernate.tags&lt;/literal&gt;. 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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;component&gt;</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>&lt;natural-id&gt;</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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;set&gt;</literal> element is used for mapping properties of type <literal>Set</literal>." +msgstr "" + +#: collection_mapping.xml:97(para) +msgid "Apart from <literal>&lt;set&gt;</literal>, there is also <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal>, <literal>&lt;array&gt;</literal> and <literal>&lt;primitive-array&gt;</literal> mapping elements. The <literal>&lt;map&gt;</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>&lt;key&gt;</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>&lt;key&gt;</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>&lt;element&gt;</literal> or <literal>&lt;composite-element&gt;</literal>, or in the case of entity references, with <literal>&lt;one-to-many&gt;</literal> or <literal>&lt;many-to-many&gt;</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>&lt;map-key&gt;</literal>, it may be an entity reference mapped with <literal>&lt;map-key-many-to-many&gt;</literal>, or it may be a composite type, mapped with <literal>&lt;composite-map-key&gt;</literal>. The index of an array or list is always of type <literal>integer</literal> and is mapped using the <literal>&lt;list-index&gt;</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>&lt;bag&gt;</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>&lt;element&gt;</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>&lt;many-to-many&gt;</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>&lt;many-to-many&gt;</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>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</literal> association is declared <literal>NOT NULL</literal>, you must declare the <literal>&lt;key&gt;</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>&lt;list&gt;</literal> or <literal>&lt;map&gt;</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 &lt;idbag&gt;" +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>&lt;idbag&gt;</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>&lt;idbag&gt;</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>&lt;idbag&gt;</literal> is <emphasis>much</emphasis> better than a regular <literal>&lt;bag&gt;</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>&lt;idbag&gt;</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>&lt;key&gt;</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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity." +msgstr "" + +#: 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>&lt;element&gt;</literal> tag with a <literal>&lt;composite-element&gt;</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>&lt;nested-composite-element&gt;</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>&lt;set&gt;</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>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal> or <literal>&lt;idbag&gt;</literal>." +msgstr "" + +#: component_mapping.xml:187(para) +msgid "A special case of a composite element is a composite element with a nested <literal>&lt;many-to-one&gt;</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>&lt;composite-map-key&gt;</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>&lt;composite-id&gt;</literal> tag (with nested <literal>&lt;key-property&gt;</literal> elements) in place of the usual <literal>&lt;id&gt;</literal> declaration. For example, the <literal>OrderLine</literal> class has a primary key that depends upon the (composite) primary key of <literal>Order</literal>." +msgstr "" + +#: 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>&lt;column&gt;</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>&lt;one-to-many&gt;</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>&lt;dynamic-component&gt;</literal> mapping are identical to <literal>&lt;component&gt;</literal>. The advantage of this kind of mapping is the ability to determine the actual properties of the bean at deployment time, just by editing the mapping document. Runtime manipulation of the mapping document is also possible, using a DOM parser. 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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;property&gt;</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 "&lt;propertyName&gt;" +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 "&lt;cache&gt;" +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&mdash;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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;listener/&gt;</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>&lt;listener type=\"...\" class=\"...\"/&gt;</literal> is just a shorthand for <literal>&lt;event type=\"...\"&gt;&lt;listener class=\"...\"/&gt;&lt;/event&gt;</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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;one-to-many&gt;</literal> association from <literal>Parent</literal> to <literal>Child</literal>. (The alternative approach is to declare the <literal>Child</literal> as a <literal>&lt;composite-element&gt;</literal>.) 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>&lt;one-to-many&gt;</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>&lt;composite-element&gt;</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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;filter-def/&gt;</literal> element within a <literal>&lt;hibernate-mapping/&gt;</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>&lt;filter-def/&gt;</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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;subclass&gt;</literal>, and <literal>&lt;joined-subclass&gt;</literal> and <literal>&lt;union-subclass&gt;</literal> mappings under the same root <literal>&lt;class&gt;</literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies, under the the same <literal>&lt;class&gt;</literal> element, by combining the <literal>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</literal> elements (see below)." +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>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</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>&lt;many-to-one&gt;</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>&lt;union-subclass&gt;</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>[ &lt;!ENTITY allproperties SYSTEM \"allproperties.xml\"&gt; ]</literal> in the <literal>DOCTYPE</literal> declartion and <literal>&amp;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>&lt;any&gt;</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>&lt;class&gt;</literal> element (and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy! (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>&lt;union-subclass&gt;</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 "&lt;many-to-one&gt;" +msgstr "" + +#: inheritance_mapping.xml:447(literal) inheritance_mapping.xml:458(literal) inheritance_mapping.xml:469(literal) +msgid "&lt;one-to-one&gt;" +msgstr "" + +#: inheritance_mapping.xml:448(literal) inheritance_mapping.xml:459(literal) inheritance_mapping.xml:470(literal) +msgid "&lt;one-to-many&gt;" +msgstr "" + +#: inheritance_mapping.xml:449(literal) inheritance_mapping.xml:460(literal) inheritance_mapping.xml:471(literal) +msgid "&lt;many-to-many&gt;" +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 "&lt;any&gt;" +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 "&lt;many-to-any&gt;" +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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;cache&gt;</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>&lt;class-cache&gt;</literal> and <literal>&lt;collection-cache&gt;</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>&lt;key&gt;</literal> and <literal>&lt;index&gt;</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>&lt;key&gt;</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>&lt;set&gt;</literal> for you, you must declare all columns as <literal>not-null=\"true\"</literal>.)" +msgstr "" + +#: performance.xml:1110(para) +msgid "<literal>&lt;idbag&gt;</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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;natural-id&gt;</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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;any&gt;</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>=, &gt;=, &lt;=, &lt;&gt;, !=, 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 &amp; 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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</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>&lt;return-scalar&gt;</literal> element:" +msgstr "" + +#: query_sql.xml:452(para) +msgid "You can externalize the resultset mapping informations in a <literal>&lt;resultset&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-discriminator&gt;</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>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</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(&lt;parameters&gt;) }</literal> or <literal>{ ? = call procedureName(&lt;parameters&gt;}</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>&lt;sql-insert&gt;</literal>, <literal>&lt;sql-delete&gt;</literal>, and <literal>&lt;sql-update&gt;</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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;hibernate-mapping&gt;</literal> element requires a global unique name for the query, while a query declaration inside a <literal>&lt;class&gt;</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>&lt;version&gt;</literal> or <literal>&lt;timestamp&gt;</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>&lt;many-to-one&gt;</literal> or <literal>&lt;many-to-many&gt;</literal> association. Cascade is often useful for <literal>&lt;one-to-one&gt;</literal> and <literal>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;column&gt;</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 "&lt;one-to-one&gt;" +msgstr "" + +#: toolset_guide.xml:227(literal) +msgid "&lt;many-to-one&gt;" +msgstr "" + +#: toolset_guide.xml:227(literal) +msgid "&lt;key&gt;" +msgstr "" + +#: toolset_guide.xml:228(literal) +msgid "&lt;many-to-many&gt;" +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 "&lt;column&gt;" +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>&lt;comment&gt;</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>&lt;property&gt;</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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;version&gt;</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>&lt;class&gt;</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>&lt;class&gt;</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>&lt;class&gt;</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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;session-factory&gt;</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>&lt;set&gt;</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>&lt;key&gt;</literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal>&lt;many-to-many&gt;</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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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>&lt;one-to-many&gt;</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@ADDRESS>\n" +"Language-Team: LANGUAGE <LL(a)li.org&gt;\n&quot; +"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.openc... +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(a)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@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&#x00e1;tico" + +#: index.docbook:27 +msgid "Hibernate Reference Documentation" +msgstr "Documentaci&#x00f3;n de Referencia de Hibernate" + +#: index.docbook:41 +msgid "&copyrightHolder;" +msgstr "&copyrightHolder;" + +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@ADDRESS>\n" +"Content-Type: text/plain; charset=utf-8\n" +#: index.docbook:21 +msgid "Architecture" +msgstr "Arquitectura" + +#: index.docbook:24 +msgid "Overview" +msgstr "Visi&#x00f3;n General" + +#: index.docbook:26 +msgid "A (very) high-level view of the Hibernate architecture:" +msgstr "Una visi&#x00f3;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&#x00f3;n para proveer servicios de persistencia (y objetos persistentes) a la aplicaci&#x00f3;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&#x00ed;a mostrar una vista m&#x00e1;s detallada de la arquitectura de tiempo de ejecuci&#x00f3;n. Desafortunadamente, Hibernate es flexible y soporta diferentes enfoques. Mostraremos los dos extremos. En la arquitectura \"sencilla\", es la aplicaci&#x00f3;n la que provee su propias conexiones JDBC y gestiona sus propias transacciones. Este enfoque usa un m&#x00ed;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&#x00f3;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&#x00ed; 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&#x00e9; threadsafe (inmutable) de mapeos compilados para una sola base de datos. Es una f&#x00e1;brica de <literal>Session</literal> y un cliente de <literal>ConnectionProvider</literal>. Opcionalmente, puede mantener una cach&#x00e9; (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&#x00f3;n entre la aplicaci&#x00f3;n y el almacenamiento persistente. Envuelve una conexi&#x00f3;n JDBC. Es una f&#x00e1;brica de <literal>Transaction</literal>. Mantiene una cach&#x00e9; 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&#x00f3;nalidad de negocio. Estos pueden ser JavaBeans/POJOs (Plain Old Java Objects, o sea, cualquier objeto Java), la &#x00fa;nica cosa especial en ellos es que estan asociados actualmente con una (y s&#x00f3;lo una) <literal>Session</literal>. Tan pronto como la <literal>Session</literal> sea cerrada, ser&#x00e1;n separados y estar&#x00e1;n libres para ser usados en cualquier capa de aplicaci&#x00f3;n. (por ejemplo, directamente como objetos de transferencia de datos hacia y desde la capa de presentaci&#x00f3;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&#x00f3;n y (a&#x00fa;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&#x00f3;n para especificar unidades at&#x00f3;micas de trabajo. Abstrae a la aplicaci&#x00f3;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&#x00f3;n de la transacci&#x00f3;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&#x00e1;brica (y pool) de conexiones JDBC. Abstrae a la aplicaci&#x00f3;n del <literal>Datasource</literal> o <literal>DriverManager</literal> subyacente. No se expone a la aplicaci&#x00f3;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&#x00e1;brica de instancias de <literal>Transaction</literal>. No se expone a la aplicaci&#x00f3;n, pero puede ser extendido/implementado por el desarrollador." + +#: index.docbook:160 +msgid "Extension Interfaces" +msgstr "Interfaces de Extensi&#x00f3;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&#x00f3;n opcional que puedes implementar para modificar a medida el comportamiento de tu capa de persistencia. Para m&#x00e1;s detalles, mira la documentaci&#x00f3;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&#x00f3;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&#x00e1; 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&#x00e1; actualmente asociada con un contexto de persistencia. Tiene una identidad persistente (valor de clave primaria) y, quiz&#x00e1;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&#x00f3;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&#x00e1;s, una fila correspondiente en la base de datos. Para las instancias separadas, Hibernate no establece ninguna garant&#x00ed;a sobre la relaci&#x00f3;n entre identidad persistente e identidad Java." + +#: index.docbook:229 +msgid "JMX Integration" +msgstr "Integraci&#x00f3;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&#x00e1;ndar J2EE para la gesti&#x00f3;n de componentes Java. Hibernate puede ser gestionado por medio de un servicio est&#x00e1;ndar JMX. Proveemos una implementaci&#x00f3;n de MBean en la distribuci&#x00f3;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&#x00f3;mo desplegar Hibernate como un servicio JMX en un Servidor de Aplicaciones JBoss, por favor, mira la Gu&#x00ed;a del Usuario de JBoss. En JBoss AS, tienes adem&#x00e1;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&#x00f3;n de Sesi&#x00f3;n:</emphasis> El ciclo de vida de la <literal>Session</literal> de Hibernate puede estar autom&#x00e1;ticamente ligado al &#x00e1;mbito de una transacci&#x00f3;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&#x00e1;s tampoco tienes que preocuparte m&#x00e1;s de la demarcaci&#x00f3;n de la transacci&#x00f3;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&#x00f3;n usuales de una <literal>SessionFactory</literal> de Hibernate. Sin embargo, todav&#x00ed;a tienes que nombrar todos tus ficheros de mapeo en el descriptor de despliegue. Si decides usar el depliegue de HAR opcional, JBoss detectar&#x00e1; autom&#x00e1;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&#x00e1;s informaci&#x00f3;n sobre estas opciones, consulta la Gu&#x00ed;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&#x00ed;sticas en tiempo de ejecuci&#x00f3;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&#x00e1;s ser configurado como un conector JCA. Por favor mira el sitio web para m&#x00e1;s detalles. Por favor ten en cuenta que el soporte de JCA de Hibernate est&#x00e1; a&#x00fa;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@ADDRESS>\n" +"Content-Type: text/plain; charset=utf-8\n" +#: index.docbook:6 +msgid "Association Mappings" +msgstr "Mapeos de Asociaci&#x00f3;n" + +#: index.docbook:9 +msgid "Introduction" +msgstr "Introducci&#x00f3;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&#x00f3;n son frecuentemente las cosas mas dif&#x00ed;ciles de hacer correctamente. En esta secci&#x00f3;n iremos a trav&#x00e9;s de los casos can&#x00f3;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&#x00f3;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&#x00e1;neas que aceptan valores nulos (en adelante, nullables) no son consideradas una buena pr&#x00e1;ctica en el modelado tradicional de datos, as&#x00ed; que todos nuestros ejemplos usan claves for&#x00e1;neas no nullables. Esto no es un requerimiento de Hibernate, y todos los mapeos funcionar&#x00e1;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&#x00f3;n unidireccional muchos-a-uno</emphasis> es el tipo m&#x00e1;s com&#x00fa;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&#x00f3;n unidireccional uno-a-uno en una clave primaria</emphasis> es casi id&#x00e9;ntica. La &#x00fa;nica diferencia es la restricci&#x00f3;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&#x00f3;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&#x00f3;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&#x00f3;n unidireccional uno-a-muchos en una clave for&#x00e1;nea</emphasis> es un caso muy inusual, y realmente no est&#x00e1; 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&#x00f3;n para este tipo de asociaci&#x00f3;n." + +#: index.docbook:91 +msgid "Unidirectional associations with join tables" +msgstr "Asociaciones unidireccionales con tablas de uni&#x00f3;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&#x00f3;n unidireccional uno-a-muchos en una tabla de uni&#x00f3;n</emphasis> es m&#x00e1;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&#x00f3;n unidireccional muchos-a-uno en una tabla de uni&#x00f3;n</emphasis> es bastante com&#x00fa;n cuando la asociaci&#x00f3;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&#x00f3;n unidireccional uno-a-uno en una tabla de uni&#x00f3;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&#x00f3;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&#x00f3;n bidireccional muchos-a-uno</emphasis> es el tipo m&#x00e1;s com&#x00fa;n de asociaci&#x00f3;n. (Esta es la relaci&#x00f3;n est&#x00e1;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&#x00f3;n bidireccional uno-a-uno en una clave for&#x00e1;nea</emphasis> es bastante com&#x00fa;n." + +#: index.docbook:173 +msgid "It is important that you define <literal>not-null=\"true\"</literal> on the <literal>&lt;key&gt;</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>&lt;column&gt;</literal> element, but on the <literal>&lt;key&gt;</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&#x00f3;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&#x00f3;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&#x00f3;n bidireccional uno-a-uno en una tabla de uni&#x00f3;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&#x00f3;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@ADDRESS>\n" +"Content-Type: text/plain; charset=utf-8\n" +#: index.docbook:5 +msgid "Basic O/R Mapping" +msgstr "Mapeo O/R B&#x00e1;sico" + +#: index.docbook:8 +msgid "Mapping declaration" +msgstr "Declaraci&#x00f3;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&#x00e1; dise&#x00f1;ado para ser le&#x00ed;ble y editable a mano. El lenguaje de mapeo es Java-c&#x00e9;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&#x00f3;lo los elementos y atributos que son usados por Hibernate en tiempo de ejecuci&#x00f3;n. El documento de mapeo contiene adem&#x00e1;s algunos atributos y elementos extra opcionales que afectan los esquemas de base de datos exportados por la herramienta de exportaci&#x00f3;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&#x00e1; el DTD primero en el classpath. Si experimentas b&#x00fa;squedas del DTD usando una conexi&#x00f3;n de Internet, chequea tu declaraci&#x00f3;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&#x00e1;logo mencionado(s). De especificarse, los nombres de tablas ser&#x00e1;n cualificados por el nombre de esquema y cat&#x00e1;logo dados. De omitirse, los nombres de tablas no ser&#x00e1;n cualificados. El atributo <literal>default-cascade</literal> especifica qu&#x00e9; 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&#x00e1;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&#x00f3;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&#x00f3;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&#x00e1; una excepci&#x00f3;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>&lt;class&gt;</literal> persistentes, como se muestra arriba. Sin embargo, es una buena pr&#x00e1;ctica (y se espera de algunas herramientas) mapear s&#x00f3;lo a una sola clase persistente (o a una sola jerarqu&#x00ed;a de clases) en un fichero de mapeo y nombrarlo despu&#x00e9;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&#x00f3;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>&lt;class&gt;</literal> mappings, as shown above. It is however good practice (and expected by some tools) to map only a single persistent class (or a single class hierarchy) in one mapping file and name it after the persistent superclass, 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&#x00ed;z <literal>&lt;hibernate-mapping&gt;</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&#x00e1;logo especificado por el elemento ra&#x00ed;z <literal>&lt;hibernate-mapping&gt;</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&#x00f3;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&#x00f3;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&#x00f3;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&#x00f3;lo cuando un objeto transitorio ha sido asociado con una sesi&#x00f3;n nueva usando <literal>update()</literal>), esto significa que Hibernate realizar&#x00e1; 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&#x00ed;cito o expl&#x00ed;cito." + +#: index.docbook:240, index.docbook:2204 +msgid "<literal>schema</literal> (optional): Override the schema name specified by the root <literal>&lt;hibernate-mapping&gt;</literal> element." +msgstr "<literal>where</literal> (opcional) especifica una condici&#x00f3;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>&lt;hibernate-mapping&gt;</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&#x00f1;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&#x00f3;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&#x00ed;cito arbitrario para la entidad. Para m&#x00e1;s informaci&#x00f3;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&#x00f3;n SQL usada para generar una restricci&#x00f3;n <emphasis>check</emphasis> multi-fila para la generaci&#x00f3;n autom&#x00e1;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&#x00e1;pidas si estableces esta opci&#x00f3;n a <literal>rowid</literal>. Un ROWID es un detalle de implementaci&#x00f3;n y representa la posici&#x00f3;n f&#x00ed;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&#x00f3;lo lectura a una subselect de base de datos. Es &#x00fa;til si quieres tener una vista en vez de una tabla base, pero no tienes vistas. Mira debajo para m&#x00e1;s informaci&#x00f3;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&#x00ed;as <literal>&lt;union-subclass&gt;</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&#x00ed;as clases que implementan esa interface usando el elemento <literal>&lt;subclass&gt;</literal>. Puedes persistir cualquier clase interna <emphasis>est&#x00e1;tica</emphasis>. Debes especificar el nombre de la clase usando la forma est&#x00e1;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&#x00f3;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&#x00f3;n postergada de instancias persistentes de la clase. Hibernate inicialmente retornar&#x00e1; proxies CGLIB que implementan la interface mencionada. El objeto persistente real ser&#x00e1; cargado cuando se invoque un m&#x00e9;todo del proxy. Mira \"Proxies para Inicializaci&#x00f3;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&#x00ed;cito</emphasis> se entiende que las instancias de la clase ser&#x00e1;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&#x00e1;n devueltas por una clase que mencione a la clase en s&#x00ed;. Por polimorfismo <emphasis>expl&#x00ed;cito</emphasis> se entiende que instancias de la clase ser&#x00e1;n devueltas s&#x00f3;lo por consultas que mencionen expl&#x00ed;citamente la clase; y que las consultas que mencionen la clase devolver&#x00e1;n s&#x00f3;lo instancias de subclases mapeadas dentro de esta declaraci&#x00f3;n <literal>&lt;class&gt;</literal> como una <literal>&lt;subclass&gt;</literal> o <literal>&lt;joined-subclass&gt;</literal>. Para la mayor&#x00ed;a de los prop&#x00f3;sitos el defecto, <literal>polymorphism=\"implicit\"</literal>, resulta apropiado. El polimorfismo expl&#x00ed;cito es &#x00fa;til cuando ! dos clases diferentes est&#x00e1;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&#x00f3;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&#x00f3;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>&lt;subclass&gt;</literal> o <literal>&lt;joined-subclass&gt;</literal>. Estos ajustes pueden incrementar el rendimiento en algunos casos, pero podr&#x00ed;an mermarlo en otros. Ten juicio en su uso." + +#: index.docbook:348 +msgid "<literal>abstract</literal> (optional): Used to mark abstract superclasses in <literal>&lt;union-subclass&gt;</literal> hierarchies." +msgstr "Generalmente el uso de <literal>select-before-update</literal> disminuir&#x00e1; el rendimiento. Es muy &#x00fa;til prevenir que se llame innecesariamente a un disparador de actualizaci&#x00f3;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>&lt;subclass&gt;</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&#x00e1;s opci&#x00f3;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&#x00f3;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>&lt;class&gt;</literal> declaration as a <literal>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</literal>. For most purposes the default, <literal>polymorphism=\"implicit\"</literal>, is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table (this allows a \"lightweight\" class that contains a subset of the table columns)." +msgstr "<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>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</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&#x00f3;n/timestamp para bloqueo optimista con Hibernate. Esta es la estrategia &#x00f3;ptima con respecto al rendimiento y es la &#x00fa;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&#x00f3;lo lectura a una expresi&#x00f3;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>&lt;subselect&gt;</literal> est&#x00e1; 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&#x00ed;a de los casos tendr&#x00e1; tambi&#x00e9;n una propiedad estilo Javabeans que tenga el identificador &#x00fa;nico de una instancia. El elemento <literal>&lt;id&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;&gt;\n&quot; + "\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>&lt;subselect&gt;</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&#x00e1; reci&#x00e9;n instanciada (sin salvar), distingui&#x00e9;ndola de instancias separadas que fueran salvadas o cargadas en una sesi&#x00f3;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>&lt;id&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "\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&#x00f3;n <literal>&lt;composite-id&gt;</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>&lt;generator&gt;</literal> nombra una clase Java usada en generar identificadores &#x00fa;nicos para instancias de la clase persistente. De requerirse alg&#x00fa;n par&#x00e1;metro para configurar o inicializar la instancia del generador, se pasa usando el elemento <literal>&lt;param&gt;</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&#x00f3;lo son &#x00fa;nicos cuando ning&#x00fa;n otro proceso est&#x00e1; insertando datos en la misma tabla. <emphasis>No usar en un cluster.</emphasis>" + +#: index.docbook:526 +msgid "There is an alternative <literal>&lt;composite-id&gt;</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>&lt;generator&gt;</literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal>&lt;param&gt;</literal> element." +msgstr "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 &#x00fa;nicos s&#x00f3;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, &#x00fa;nicos en una ref (se usa la direcc&#x00f3;n IP). El UUID se codifica como una cadena hexadecimal de 32 d&#x00ed;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&#x00f3;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>&lt;generator&gt;</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 &#x00fa;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&#x00f3;n a una asociac&#x00f3;n de clave primaria <literal>&lt;uno-a-uno&gt;</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&#x00f3;n de identificadores. La primera implementaci&#x00f3;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>&lt;generator&gt;</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&#x00e1; 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>&lt;one-to-one&gt;</literal> primary key association." +msgstr "El UUID contiene: la direcci&#x00f3;n IP, el instante de arranque de la JVM (con una precisi&#x00f3;n de un cuarto de segundo), el tiempo de sistema y un valor de contador (&#x00fa;nico en la JVM). No es posible obtener una direcci&#x00f3;n MAC o una direcci&#x00f3;n de memoria desde c&#x00f3;digo Java, as&#x00ed; 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&#x00f3;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&#x00f3;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&#x00e1; 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&#x00f3;n asigne los identificadores (en contraposici&#x00f3;n a que los genere Hibernate), puedes usar el generador <literal>assigned</literal>. Este generador especial usar&#x00e1; 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>&lt;generator&gt;</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&#x00f3;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 &#x00e1;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&#x00fa;ltiples propiedades de la clase como propiedades identificadoras. El elemento <literal>&lt;composite-id&gt;</literal> acepta los mapeos de propiedad <literal>&lt;key-property&gt;</literal> y los mapeos <literal>&lt;key-many-to-one&gt;</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>&lt;generator&gt;</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&#x00e9;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&#x00e1;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&#x00e1;s conveniente donde el identificador compuesto est&#x00e1; 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&#x00f3;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&#x00f3;n): La clase del componente usado como identificador compuesto (ver siguiente secci&#x00f3;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&#x00e9;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>&lt;discriminator&gt;</literal> es requerido para la persistencia polim&#x00f3;rfica usando la estrategia de mapeo de tabla-por-jerarqu&#x00ed;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&#x00e9; 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&#x00ed;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&#x00e9;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&#x00f3;n SQL arbitraria que es ejecutada cuando un tipo tenga que ser evaluado. Permite dicriminaci&#x00f3;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&#x00e1;n especificados por el atributo <literal>discriminator-value</literal> de los elementos <literal>&lt;class&gt;</literal> y <literal>&lt;subclass&gt;</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&#x00f3;lo) &#x00fa;til si la tabla contiene filas con valores discriminadores \"extra\" que no est&#x00e1;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&#x00f3;n SQL arbitraria que ser&#x00e1; 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>&lt;version&gt;</literal> es opcional e indica que la tabla contiene datos versionados. Esto es particularmente &#x00fa;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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" + +#: 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&#x00fa;mero de versi&#x00f3;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&#x00fa;.mero de vesi&#x00f3;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&#x00f3;n que indica que una instancia est&#x00e1; reci&#x00e9;n instanciada (sin guardar), distingui&#x00e9;ndola de instancias separadas que fueran guardadas o cargadas en una sesi&#x00f3;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&#x00fa;meros de versi&#x00f3;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&#x00f3;n o timestamp nunca debe ser nula para una instancia separada, de modo que Hibernate detectar&#x00e1; cualquier instancia con una versi&#x00f3;n o timestamp nulo como transitoria, sin importar qu&#x00e9; otras estrategias <literal>unsaved-value</literal> se hayan especificado. <emphasis>Declarar una propiedad de vers&#x00f3;n o timestamp nulable es una forma f&#x00e1;cil de evitar cualquier problema con la re-uni&#x00f3;n transitiva en Hibernate, especialmente &#x00fa;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>&lt;timestamp&gt;</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&#x00f3;n menos segura de bloqueo optimista. Sin embrago, a veces la aplicaci&#x00f3;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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" + +#: index.docbook:941 +msgid "For a table with a composite key, you may map multiple properties of the class as identifier properties. The <literal>&lt;composite-id&gt;</literal> element accepts <literal>&lt;key-property&gt;</literal> property mappings and <literal>&lt;key-many-to-one&gt;</literal> mappings as child elements." +msgstr "<literal>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&#x00f3;n que indica que una instancia est&#x00e1; reci&#x00e9;n instanciada (sin guardar), distingui&#x00e9;ndola de instancias separadas que hayan sido guardadas o cargadas en una sesi&#x00f3;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>&lt;composite-id&gt;</literal> element are duplicated on both the persistent class and a separate identifier class." +msgstr "Note that <literal>&lt;timestamp&gt;</literal> is equivalent to <literal>&lt;version type=\"timestamp\"&gt;</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&mdash;code duplication." +msgstr "El elemento <literal>&lt;property&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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&#x00fa;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&#x00e9;n ser especificado con elemento(s) <literal>&lt;column&gt;</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&#x00ed;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&#x00f3;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&#x00ed;da perezosamente cuando la variable de instancia sea accedida por primera vez (requiere instrumentaci&#x00f3;n en tiempo de compilaci&#x00f3;n)." + +#: index.docbook:1038 +msgid "discriminator" +msgstr "<literal>unique</literal> (opcional): Habilita la generaci&#x00f3; DDL de una restricci&#x00f3;n de unicidad para las columnas. Adem&#x00e1;s, permite que &#x00e9;sta sea un blanco objetivo de una <literal>property-ref</literal>." + +#: index.docbook:1040 +msgid "The <literal>&lt;discriminator&gt;</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&#x00f3; DDL de una restricci&#x00f3;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&#x000f3;n de un bloqueo optimista. En otras palabras, determina si debe ocurrir un incremento de versi&#x00f3;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&#x00e1;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&#x00e1;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>&lt;class&gt;</literal> and <literal>&lt;subclass&gt;</literal> elements." +msgstr "Si no especificas un tipo, Hibernate usar&#x00e1; reflecci&#x00f3;n sobre la propiedad mencionada para deducir el tipo Hibernate correcto. Hibernate intentar&#x00e1; 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&#x00e1;s a&#x00fa;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&#x00f3;mo Hibernate acceder&#x00e1; a la propiedad en tiempo de ejecuci&#x00f3;n. Por defecto, Hibernate llamar&#x00e1; al par de getter/setter de la propiedad. Si especificas <literal>access=\"field\"</literal>, Hibernate se saltar&#x00e1; el par get/set y acceder&#x00e1; al campo directamente usando reflecci&#x00f3;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&#x00f3;n de s&#x00f3;lo lectura, el valor de la propiedad es computado en tiempo de carga. Tu declaras la computaci&#x00f3;n como una expresi&#x00f3;n SQL, y &#x00e9;sta se traduce a cl&#x00e1;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&#x00e1;s que puedes usar el elemento anidado de mapeo <literal>&lt;formula&gt;</literal> si no te gusta usar el atributo." + +#: index.docbook:1120 +msgid "The <literal>&lt;version&gt;</literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis> (see below)." +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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" +msgstr "Una asociaci&#x00f3;n ordinaria a otra clase persistente se declara usando el elemento <literal>many-to-one</literal>. El modelo relacional es una asociaci&#x00f3;n muchos-a-uno: una clave for&#x00e1;nea en una tabla est&#x00e1; 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&#x00f3;n SQL\"\n" + " node=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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&#x00e1;nea. Tambi&#x00e9;n puede ser especificado por uno o varios elementos anidados <literal>&lt;column&gt;</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&#x00e9; 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&#x00f3;n outer-join o por selecci&#x00f3;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&#x00ed;das en las sentencias SQL <literal>UPDATE</literal> y/o <literal>INSERT</literal>. Establecer ambas a <literal>false</literal> permite una asociaci&#x00f3;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&#x00f3;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&#x00e1; unida a la clave for&#x00e1;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&#x00f3;n DDL de una restricci&#x00f3;n de unicidad para la columna de clave for&#x00e1;nea. Adem&#x00e1;s, permite que &#x00e9;sta sea el objetivo de una <literal>property-ref</literal>. Esto hace efectivamente la multiplicidad de la asociaci&#x00f3;n uno a uno." + +#: index.docbook:1206 +msgid "The optional <literal>&lt;timestamp&gt;</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&#x00f3;n DDL de una restricci&#x00f3;n de nulabilidad para las columnas de clave for&#x00e1;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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" +msgstr "<literal>optimistic-lock</literal> (opcional - por defecto a <literal>true</literal>): Especifica que las actualizaciones a esta propiedad requieran o no la obtenci&#x00f3;n del bloqueo optimista. En otras palabras, determina si debe darse un incremento de versi&#x00f3;n cuando esta propiedad est&#x00e9; 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 &#x00fa;nico van con proxies. <literal>lazy=\"true\"</literal> especifica que esta propiedad debe ser tra&#x00ed;da perezosamente cuando la variable de instancia sea accedida por primera vez (requiere instrumentaci&#x00f3;n del bytecode en tiempo de compilaci&#x00f3;n). <literal>lazy=\"false\"</literal> especifica que la asociaci&#x00f3;n siempre ser&#x00e1; 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&#x00f3;mo deben manejarse las claves for&#x00e1;neas que referencien filas inexistentes: <literal>ignore</literal> tratar&#x00e1; una fila perdida como una asociaci&#x00f3;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&#x00f3;n SQL que define el valor para una clave for&#x00e1;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&#x00e1; ciertas operaciones al objeto asociado. Los valores significativos son los nombres de las operaciones b&#x00e1;sicas de Hibernate, <literal>persist, merge, delete, save-update, evict, replicate, lock, refresh</literal>, as&#x00ed; 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&#x00f3;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&#x00f3;n t&#x00ed;pica <literal>muchos-a-uno</literal> se parece a esto:" + +#: index.docbook:1274 +msgid "Note that <literal>&lt;timestamp&gt;</literal> is equivalent to <literal>&lt;version type=\"timestamp\"&gt;</literal>. And <literal>&lt;timestamp source=\"db\"&gt;</literal> is equivalent to <literal>&lt;version type=\"dbtimestamp\"&gt;</literal>" +msgstr "<![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&#x00e1;nea referencia una clave &#x00fa;nica de la tabla asociada, distinta de la clave primaria. Este es un modelo relacional feo. Por ejemplo, sup&#x00f3;n que la clase <literal>Product</literal> tuviera un n&#x00fa;mero &#x00fa;nico serial que no es la clave primaria. (El atributo <literal>unique</literal> controla la generaci&#x00f3;n de DDL con la herramienta SchemaExport.)" + +#: index.docbook:1286 +msgid "The <literal>&lt;property&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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&#x00ed;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>&lt;column&gt;</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 &#x00fa;nica referenciada abarca m&#x00fa;ltiples propiedades de la entidad asociada, debes mapear las propiedades dentro de un elemento <literal>&lt;properties&gt;</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&#x00f3;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&#x00f3;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&#x00e9; 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&#x00f3;n de clave for&#x00e1;nea de la tabla mapeada referencia a la tabla de la clase asociada. Esta opci&#x00f3;n afecta el orden en que van en cascada <literal>save()</literal> y <literal>delete()</literal>, y determina cu&#x00e1;ndo la asociaci&#x00f3;n pueden ser virtualizados por proxies (es tambi&#x00e9;n usado por la herramienta de exportaci&#x00f3;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&#x00f3;n outer-join o recuperaci&#x00f3;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&#x00e9; 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&#x00f3;n para unir usando una f&#x00f3;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 &#x00fa;nico van con proxies. <literal>lazy=\"true\"</literal> especifica que esta propiedad debe ser tra&#x00ed;da perezosamente cuando la variable de instancia sea accedida por primera vez (requiere instrumentaci&#x00f3;n del bytecode en tiempo de compilaci&#x00f3;n). <literal>lazy=\"false\"</literal> especifica que la asociaci&#x00f3;n siempre ser&#x00e1; recuperada tempranamente. <emphasis>Observa que si <literal>constrained=\"false\"</literal>, la aplicaci&#x00f3;n de proxies es imposible e Hibernate traer&#x00e1; temprano la asociaci&#x00f3;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&#x00e1;neas &#x00fa;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&#x00e1;n relacionadas por la asociaci&#x00f3;n entonces las dos filas de tablas comparten el mismo valor de clave primaria. Por lo tanto, si quieres que dos objetos est&#x00e9;n relacionados por una asociaci&#x00f3;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&#x00f3;n de clave primaria, a&#x00f1;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>&lt;formula&gt;</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&#x00f3;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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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&#x00e9;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>&lt;column&gt;</literal> element(s)." +msgstr "Alternativamente, una clave for&#x00e1;nea con una restricci&#x00f3;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&#x00f3;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&#x00e1; 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>&lt;component&gt;</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&#x00f3;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&#x00f3;n de bytecode en tiempo de compilaci&#x00f3;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&#x00f3;n de un bloqueo optimista. En otras palabras, determina si debe ocurrir un incremento de versi&#x00f3;n cuando esta propiedad est&#x00e1; 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&#x00f3;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>&lt;property&gt;</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>&lt;properties&gt;</literal> element." +msgstr "El elemento <literal>&lt;component&gt;</literal> permite un subelemento <literal>&lt;parent&gt;</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>&lt;dynamic-component&gt;</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>&lt;properties&gt;</literal> permite la definici&#x00f3;n de un grupo de propiedades l&#x00f3;gico con nombre de una clase. El uso m&#x00e1;s importante de la contrucci&#x00f3;n es que permite que una combinaci&#x00f3;n de propiedades sea objetivo de una <literal>property-ref</literal>. Es tambi&#x00e9;n una forma conveniente de definir una restricci&#x00f3;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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " embed-xml=\"true|false\"\n" + " foreign-key=\"foreign_key_name\"\n" + "/>]]>" +msgstr "<literal>name</literal>: El nombre l&#x00f3;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&#x00f3;n de un bloqueo optimista. En otras palabras, determina si debe ocurrir un incremento de versi&#x00f3;n cuando estas propiedades est&#x00e1;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&#x00f3;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&#x00f3;rfica requiere la declaraci&#x00f3;n de la clase persistente ra&#x00ed;z. Para la estrategia de mapeo tabla-por-jerarqu&#x00ed;a-de-clases, se usa la declaraci&#x00f3;n de <literal>&lt;subclass&gt;</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&#x00f3;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&#x00f3;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>&lt;version&gt;</literal> y <literal>&lt;id&gt;</literal> son heredadas de la clase ra&#x00ed;z. Cada subclase en una jerarqu&#x00ed;a debe definir un <literal>discriminator-value</literal> &#x00fa;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&#x00ed;a de clases con s&#x00f3;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&#x00ed;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&#x00ed;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&#x00f3;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>&lt;joined-subclass&gt;</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&#x00f3;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>&lt;natural-id&gt;</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&#x00f3;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>&lt;key&gt;</literal>. El mapeo del comienzo del cap&#x00ed;tulo deber&#x00ed;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&#x00f3;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>&lt;component&gt;</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&#x00f3;n es mapear s&#x00f3;lo las clases concretas de una jerarqu&#x00ed;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&#x00ed;as de herencia. Puedes simplemente mapear cada clase con una declaraci&#x00f3;n <literal>&lt;class&gt;</literal> separada. Sin embargo, si deseas usar asociaciones polim&#x00f3;rficas (por ejemplo, una asociaci&#x00f3;n a la superclase de tu jerarqu&#x00ed;a), debes usar el mapeo <literal>&lt;union-subclass&gt;</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&#x00f3;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&#x00f3;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&#x00f3;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>&lt;join&gt;</literal>, es posible mapear propiedades de una clase a varias tablas." + +#: index.docbook:1908 +msgid "The child <literal>&lt;property&gt;</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>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity." +msgstr "<literal>table</literal>: El nombre de la clase unida." + +#: index.docbook:1919 +msgid "The <literal>&lt;dynamic-component&gt;</literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map, see <xref linkend=\"components-dynamic\"/>." +msgstr "<literal>schema</literal> (opcional): Sobrescribe el nombre de esquema especificado por el elemento ra&#x00ed;z <literal>&lt;hibernate-mapping&gt;</literal>." + +#: index.docbook:1928 +msgid "properties" +msgstr "<literal>catalog</literal> (opcional): Sobrescribe el nombre de cat&#x00e1;logo especificado por el elemento ra&#x00ed;z <literal>&lt;hibernate-mapping&gt;</literal>." + +#: index.docbook:1930 +msgid "The <literal>&lt;properties&gt;</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&#x00e1; una uni&#x00f3;n interior (inner join) para recuperar un <literal>&lt;join&gt;</literal> definido por una clase o sus superclases y una uni&#x00f3;n externa (outer join) para un <literal>&lt;join&gt;</literal> definido por una subclase. Si se establece a <literal>select</literal>, entonces Hibernate usar&#x00e1; una select secuencial para un <literal>&lt;join&gt;</literal> definido en una subclase, que ser&#x00e1; publicada s&#x00f3;lo si una fila resulta representar una instancia de la subclase. Las uniones interiores todav&#x00ed;a ser&#x00e1;n usados para recuperar un <literal>&lt;join&gt;</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&#x00e1; insertar o actualizar las propiedades definidas por esta uni&#x00f3;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&#x00e1; una fila s&#x00f3;lo si las propiedades definidas por esta uni&#x00f3;n son no nulas y siempre usar&#x00e1; una uni&#x00f3;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 &#x00fa;til para modelos de datos heredados; recomendamos menos tablas que clases un modelo de dominio m&#x00e1;s granularizado. Sin embargo, es &#x00fa;til para cambiar entre estrategias de mapeo de herencias en una misma jerarqu&#x00ed;a, como se explica luego." + +#: index.docbook:1984 +msgid "For example, if we have the following <literal>&lt;properties&gt;</literal> mapping:" +msgstr "Hasta ahora hemos visto el elemento <literal>&lt;key&gt;</literal> pocas veces. Aparece en cualquier sitio en que el elemento padre de mapeo defina una uni&#x00f3;n a una nueva tabla, y define la clave for&#x00e1;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&#x00e1;nea. Puede ser tambi&#x00e9;n especificado por elemento(s) anidado(s) <literal>&lt;column&gt;</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&#x00f3;n de clave for&#x00e1;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&#x00e1;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&#x00e1;nea son no nulables (esto est&#x00e1; implicado si la clave for&#x00e1;nea es tambi&#x00e9;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>&lt;subclass&gt;</literal> declaration is used." +msgstr "<literal>update</literal> (opcional): Especifica que la clave for&#x00e1;nea nunca debe ser actualizada (esto est&#x00e1; implicado si la clave for&#x00e1;nea es tambi&#x00e9;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&#x00e1;nea debe tener una restricci&#x00f3;n de unicidad (esto est&#x00e1; implicado si la clave for&#x00e1;nea es tambi&#x00e9;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&#x00e1; una restricci&#x00f3;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 &#x00fa;tiles al mapear una asociaci&#x00f3;n uno a muchos unidireccional. Si mapeas una uno a muchos unidireccional a una clave for&#x00e1;nea no nulable, <emphasis>debes</emphasis> declarar la columna clave usando <literal>&lt;key not-null=\"true\"&gt;</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&#x00e1; alternativamente un subelemento <literal>&lt;column&gt;</literal>. De forma similar, <literal>&lt;formula&gt;</literal> es una alternativa al atributo <literal>formula</literal>." + +#: index.docbook:2048 +msgid "Each subclass should declare its own persistent properties and subclasses. <literal>&lt;version&gt;</literal> and <literal>&lt;id&gt;</literal> properties are assumed to be inherited from the root class. Each subclass in a 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&#x00f3;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&#x00f3;n para expresar, por ejemplo, condiciones de uni&#x00f3;n ex&#x00f3;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>&lt;joined-subclass&gt;</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>&lt;key&gt;</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&#x00e1; 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&#x00f3;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>&lt;class&gt;</literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal>&lt;union-subclass&gt;</literal> mapping." +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>&lt;join&gt;</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&#x00ed;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&#x00e1;s de cerca a c&#x00f3;mo los objetos de aplicaci&#x00f3;n son usados habitualmente en grandes sistemas. Las entidades soportan referencias circulares y compartidas, que tambi&#x00e9; 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>&lt;join&gt;</literal> defined by a class or its superclasses and an outer join for a <literal>&lt;join&gt;</literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal>&lt;join&gt;</literal> defined on a subclass, 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>&lt;join&gt;</literal> defined by the class and its superclasses." +msgstr "Volveremos a visitar ambos conceptos a lo largo de la documentaci&#x00f3;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&#x00ed;o es mapear el sistema de tipos de Java (y la definici&#x00f3;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>&lt;class&gt;</literal>, <literal>&lt;subclass&gt;</literal>, etc. Para los tipos de valor usamos <literal>&lt;property&gt;</literal>, <literal>&lt;component&gt;</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&#x00e1;brica muchos mapeos (para tipos de valores del JDK est&#x00e1;ndar). Puedes escribir tus propios mapeos de tipo, as&#x00ed; como implementar tus estrategias de conversi&#x00f3;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&#x00e1;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&#x00e1;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&#x00e1;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&#x00ed;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>&lt;key&gt;</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>&lt;key not-null=\"true\"&gt;</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&#x00f3;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>&lt;column&gt;</literal> subelement. Likewise, <literal>&lt;formula&gt;</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&#x00e1;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&#x00e1;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&#x00f3;n (Adem&#x00e1;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 &#x00fa;nicos de entidades y collecciones pueden ser de cualquier tipo b&#x00e1;sico excepto <literal>binary</literal>, <literal>blob</literal> y <literal>clob</literal>. (Los identificadores compuestos est&#x00e1;n tambi&#x00e9;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&#x00e1;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>&lt;any&gt;</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&#x00e1;cil para los desarrolladores crear sus propios tipos de valor. Por ejemplo, podr&#x00ed;as querer persistir propiedades del tipo <literal>java.lang.BigInteger</literal> a columnas <literal>VARCHAR</literal>. Hibernate no provee un tipo de f&#x00e1;brica para esto. Pero los tipos personalizados no est&#x00e1;n limitados a mapear una propiedad (o elemento de colecci&#x00f3;n) a una sola columna de tabla. As&#x00ed;, por ejemplo, podr&#x00ed;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&#x00e9; 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>&lt;column&gt;</literal> para mapear una propiedad a m&#x00fa;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&#x00e1;s especializados." + +#: index.docbook:2440 +msgid "<literal>id-type</literal>: the identifier type." +msgstr "Puedes incluso proveer de par&#x00e1;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&#x00e1;metros a tu tipo personalizado, puedes usar el elemento <literal>&lt;type&gt;</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&#x00e1;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&#x00e9;n es posible sobrescribir los par&#x00e1;metros provistos en un typedef sobre una base caso por caso usando par&#x00e1;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&#x00f3;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&#x00f3;n. Con un tipo personalizado, tus documentos de mapeo estar&#x00e1; 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&#x00e1;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&#x00e1;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&#x00f3;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>&lt;class&gt;</literal>, <literal>&lt;subclass&gt;</literal> and so on. For value types we use <literal>&lt;property&gt;</literal>, <literal>&lt;component&gt;</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&#x00e1; 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&#x00e1; 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&#x00f3;n de mapeo directamente en el c&#x00f3;digo fuente usando las <literal&gt;(a)hibernate.etiquetas&lt;/literal&gt; XDoclet. No cubriremos este enfoque en este documento, pues estrictamente es considerado parte de XDoclet. Sin embargo, inclu&#x00ed;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&#x00e1;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&#x00f3;n. Este mecanismo es m&#x00e1;s potente y que las anotaciones XDoclet, y mejor soportado por herramientas e IDEs. IntelliJ IDEA, por ejemplo, soporta auto-compleci&#x00f3;n y resaltado de sintaxis de anotaciones JDK 5.0. La nueva revisi&#x00f3;n de la especificaci&#x00f3;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&#x00e1; disponible v&#x00ed;a el paquete <emphasis>Hibernate Annotations</emphasis>, como una descarga por separado. Tanto metadatos de EJB3 (JSR-220) como de Hibernate3 est&#x00e1;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&#x00ed;a un trabajo en progreso y no completado. Por favor, para m&#x00e1;s detalles refi&#x00e9;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>&lt;column&gt;</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>&lt;type&gt;</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>&lt;typedef&gt;</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&gt;(a)hibernate.tags&lt;/literal&gt;. 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@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@ADDRESS>\n" +"Content-Type: text/plain; charset=utf-8\n" +#: index.docbook:5 +msgid "Best Practices" +msgstr "Mejores Pr&#x00e1;cticas" + +#: index.docbook:9 +msgid "Write fine-grained classes and map them using <literal>&lt;component&gt;</literal>." +msgstr "Escribe clase finamente granularizadas y mapealas usando <literal>&lt;component&gt;</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&#x00f3;n</literal> para encapsular <literal>calle</literal>, <literal>distrito</literal>, <literal>estado</literal>, <literal>c&#x00f3;digo postal</literal>. Esto alienta la reutilizaci&#x00f3;n de c&#x00f3;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&#x00e9;ticos' (generados, sin ning&#x00fa;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>&lt;natural-id&gt;</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>&lt;natural-id&gt;</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&#x00ed;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&#x00e1;ctica si tus consultas llaman a funciones SQL que no son del est&#x00e1;ndar ANSI. Externalizar las cadenas de consulta a ficheros de mapeo har&#x00e1; la aplicaci&#x00f3;n m&#x00e1;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 \"?\". &#x00a1;Nunca uses manipulaci&#x00f3;n de cadenas para ligar un valor no constante en una consulta! Incluso mejor, considera usar par&#x00e1;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&#x00f3;n administre las conexiones JDBC. Este enfoque debe considerarse como &#x00fa;ltimo recurso. Si no puedes usar los provedores de conexi&#x00f3;n prefabricados, considera prover tu propia implementaci&#x00f3;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&#x00f3;n que tienes un tipo Java, digamos de alguna biblioteca, que necesita hacerse persistente pero no provee los m&#x00e9;todos de acceso necesarios para mapearlo como un componente. Debes considerar implementar <literal>org.hibernate.UserType</literal>. Este enfoque libera al c&#x00f3;digo de aplicaci&#x00f3;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 &#x00e1;reas del sistema de rendimiento cr&#x00ed;tico, algunos tipos de operaciones podr&#x00ed;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&#x00e1;s r&#x00e1;pido. Si necesitas usar JDBC directo, podr&#x00ed;a ser valioso abrir una <literal>Session</literal> de Hibernate y usar esa conexi&#x00f3;n JDBC. De esta forma puedes usar a&#x00fa;n la misma estrategia de transacci&#x00f3;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&#x00f3;n sincroniza su estado persistente con la base de datos. El rendimiento se ver&#x00e1; afectado si este proceso ocurre demasiado frecuentemente. A veces puedes minimizar limpieza innecesaria deshabilitando la limpieza autom&#x00e1;tica o incluso cambiando el orden de las consultas u otras operaciones en una transacci&#x00f3;n en particular." + +#: index.docbook:121 +msgid "In a three tiered architecture, consider using detached objects." +msgstr "En una aplicaci&#x00f3;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&#x00f3;n, puedes pasar objetos persistentes en el bean de sesi&#x00f3;n hacia y desde la capa de servlet / JSP. Usa una sesi&#x00f3;n nueva para atender el servicio de cada petici&#x00f3;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&#x00f3;n</emphasis> ejecut&#x00e1;ndose en largo, una sola unidad de trabajo desde el punto de vista de un usuario. Una transacci&#x00f3;n de aplicaci&#x00f3;n puede abarcar muchos ciclos petici&#x00f3;n/respuesta del cliente. Es com&#x00fa;n usar objetos separados para implementar transacciones de aplicaci&#x00f3;n. Una alternativa, extremadamente apropiada en arquitecturas en dos gradas, es mantener un solo contacto de persistencia abierto (sesi&#x00f3;n) para todo el ciclo de vida de la transacci&#x00f3;n de aplicaci&#x00f3;n y simplemente desconectar de la conexi&#x00f3;n JDBC al final de cada petici&#x00f3;n, y reconectar al comienzo de la petici&#x00f3;n subsecuente. Nunca compartas una &#x00fa;nica sesi&#x00f3;n a trav&#x00e9;s de m&#x00e1;s de una transacci&#x00f3;n de aplicaci&#x00f3;n, o est! ar&#x00e1;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&#x00e1;s una pr&#x00e1;ctica necesaria que una \"mejor\" pr&#x00e1;ctica. Cuando ocurra una excepci&#x00f3;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&#x00f3;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&#x00f3;n temprana. Usa proxies y colecciones perezosas para la mayor&#x00ed;a de asociaciones a clases probablemente no est&#x00e9;n mantenidas en el cach&#x00e9; de segundo nivel. Para las asociaciones a clases en cach&#x00e9;, donde hay una probabilidad de acceso a cach&#x00e9; extremadamente alta, deshabilita expl&#x00ed;citamente la recuperaci&#x00f3;n temprana usando <literal>lazy=\"false\"</literal>. Cuando sea apropiada la recuperaci&#x00f3;n por uni&#x00f3;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&#x00f3;n <emphasis>sesi&#x00f3;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&#x00f3;sito doble: primero, atacan el problema que los beans de entidad no son serializables. Segundo, definen impl&#x00ed;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&#x00f3;n. Hibernate elimina el primer prop&#x00f3;sito. Sin embargo, a&#x00fa;n necesitas una fase de ensamblado (piensa en tus m&#x00e9;todos de negocio como si tuviesen un contrato estricto con la grada de presentaci&#x00f3;n sobre qu&#x00e9; datos est&#x00e1;n disponibles en los objetos separados) a menos que est&#x00e9;s preparado para tener el contexto de persistencia (la sesi&#x00f3;n) abierto a trav&#x00e9;s del proceso de renderizaci&#x00f3;n de la vista. &#x00a1;Est! a no es una limitaci&#x00f3;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&#x00f3;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&#x00f3;digo de acceso a datos (Hibernate) detr&#x00e1;s de una interface. Combina los patrones <emphasis>DAO</emphasis> y <emphasis>Sesi&#x00f3;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&#x00e1; pensado para aplicaciones \"suficientemente grandes\"; &#x00a1;no es apropiado para una aplicaci&#x00f3;n con cinco tablas!)" + +#: index.docbook:203 +msgid "Don't use exotic association mappings." +msgstr "No uses mapeos de asociaci&#x00f3;n ex&#x00f3;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&#x00f3;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&#x00ed;a de asociaciones son uno-a-muchos y muchos-a-uno, debes ser cuidadoso al usr cualquier otro estilo de asociaci&#x00f3;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&#x00e1;s dif&#x00ed;ciles de consultar. En una aplicaci&#x00f3;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@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&#x00f3;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&#x00ed;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&#x00e1;s que escribir una implementaci&#x00f3;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&#x00f3;mo hemos inicializado la variable de instancia de <literal>HashSet</literal>. Esta es la mejor forma de inicializar propiedades valuadas en colecci&#x00f3;n de instancias reci&#x00e9;n instanciadas (no persistentes). Cuando haces persistente la instancia - llamando a <literal>persist()</literal>, por ejemplo - Hibernate realmente remplazar&#x00e1; el <literal>HashSet</literal> con una instancia de una implementaci&#x00f3;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&#x00e1;ticamente persistidas al ser referenciadas por un objeto persistente y autom&#x00e1;ticamente borradas al desreferenciarse. Si una colecci&#x00f3;n es pasada de un objeto persistente a otro, sus elementos ser&#x00ed;an movidos de una tabla a otra. Dos entidades pueden no compartir una referencia a la misma instancia de colecci&#x00f3;n. Debido al modelo relacional subyacente, las propiedades valuadas en colecci&#x00f3;n no soportan la sem&#x00e1;ntica de valor nulo. Hibernate no distingue entre una referencia de colecci&#x00f3;n nula y una colecci&#x00f3;n vac&#x00ed;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&#x00f3;lo aseg&#x00fa;rate que entiendes la sem&#x00e1;ntica de las asociaciones bidireccionales (discutida luego)." + +#: index.docbook:65 +msgid "Collection mappings" +msgstr "Mapeos de colecci&#x00f3;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>&lt;set&gt;</literal> element is used for mapping properties of type <literal>Set</literal>." +msgstr "El elemento de mapeo de Hibernate usado para mapear una colecci&#x00f3;n depende del tipo de la interface. Por ejemplom un elemento <literal>&lt;set&gt;</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>&lt;set&gt;</literal>, there is also <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal>, <literal>&lt;array&gt;</literal> and <literal>&lt;primitive-array&gt;</literal> mapping elements. The <literal>&lt;map&gt;</literal> element is representative:" +msgstr "Aparte de <literal>&lt;set&gt;</literal>, existen adem&#x00e1;s los elementos de mapeo <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal>, <literal>&lt;array&gt;</literal> y <literal>&lt;primitive-array&gt;</literal>. El elemento <literal>&lt;map&gt;</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&#x00f3;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&#x00f3;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&#x00ed;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&#x00f3;n perezosa y especificar que la asociaci&#x00f3;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&#x00f3;n como el extremo \"inverso\" de una asociaci&#x00f3;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&#x00f3;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&#x00f3;lo JDK1.4) especifica una columna de tabla (o columnas) que definen el orden de iteraci&#x00f3;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&#x00f3;n <literal>WHERE</literal> de SQL arbitrario para ser usada al recuperar o quitar la colecci&#x00f3;n (&#x00fa;til si la colecci&#x00f3;n debe contener s&#x00f3;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&#x00f3;n por uni&#x00f3;n externa (outer-join), recuperar por selecci&#x00f3;n secuencial, y recuperaci&#x00f3;n por subselecci&#x00f3;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&#x00f1;o de lote\" para la recuperar perezosamente instancias de esta colecci&#x00f3;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&#x00f3;n resultan en incrementos de versi&#x00f3;n de la entidad due&#x00f1;a. (Para asociaciones uno a muchos, frecuentemente es razonable deshabilitar esta opci&#x00f3;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&#x00e1;neas de collecci&#x00f3;n" + +#: index.docbook:198 +msgid "Collection foreign keys" +msgstr "Las instancias de colecci&#x00f3;n se distinguen en la base de datos por la clave for&#x00e1;nea de la entidad que posee la colecci&#x00f3;n. Se hace referencia a esta clave for&#x00e1;nea como la <emphasis>columna clave de colecci&#x00f3;n</emphasis> (o columnas) de la tabla de colecci&#x00f3;n. La columna clave de la colecci&#x00f3;n es mapeada por el elemento <literal>&lt;key&gt;</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>&lt;key&gt;</literal> element." +msgstr "Puede haber una restricci&#x00f3;n de nulabilidad sobre la columna de clave for&#x00e1;nea. Para la mayor&#x00ed;a de colecciones, esto est&#x00e1; implicado. Para asociaciones unidireccionales uno a muchos, la columna de clave for&#x00e1;nea es nulable por defecto, de modo que podr&#x00ed;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&#x00f3;n de clave for&#x00e1;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&#x00ed;tulo anterior por una definici&#x00f3;n completa del elemento <literal>&lt;key&gt;</literal>." + +#: index.docbook:223 +msgid "See the previous chapter for a full definition of the <literal>&lt;key&gt;</literal> element." +msgstr "Elementos de collecci&#x00f3;n" + +#: index.docbook:231 +msgid "Collection elements" +msgstr "Las colecciones pueden contener casi cualquier tipo de Hibernate, incluyendo todos los tipos b&#x00e1;sicos, componentes, y por supuesto, referencias a otras entidades. Esta es una distinci&#x00f3;n importante: un objeto en una colecci&#x00f3;n puede ser manejado con una sem&#x00e1;ntica de \"valor\" (su ciclo de vida depende completamente del propietario de la colecci&#x00f3;n) o podr&#x00ed;a ser una referencia a otra entidad, con su propio ciclo de vida. En el &#x00fa;ltimo caso, s&#x00f3;lo el estado del \"enlace\" entre los dos objetos se considera mantenido por la colecci&#x00f3;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&#x00f3;n</emphasis>. Los elementos de colecci&#x00f3;n son mapeados por <literal>&lt;element&gt;</literal> o <literal>&lt;composite-element&gt;</literal>, o en el caso de referencias de entidades, con <literal>&lt;one-to-many&gt;</literal> o <literal>&lt;many-to-many&gt;</literal>. Las dos primeras mapean elementos con sem&#x00e1;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>&lt;element&gt;</literal> or <literal>&lt;composite-element&gt;</literal>, or in the case of entity references, with <literal>&lt;one-to-many&gt;</literal> or <literal>&lt;many-to-many&gt;</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&#x00f3;n, excepto aquellos con sem&#x00e1;ntica de set o bag, necesitan una <emphasis>columna &#x00ed;ndice</emphasis> en la tabla de colecci&#x00f3;n, una columna que mapea a un &#x00ed;ndice de array, o &#x00ed;ndice de <literal>List</literal>, o clave de <literal>Map</literal>. El &#x00ed;ndice de un <literal>Map</literal> puede ser de cualquier tipo b&#x00e1;sico, mapeado con <literal>&lt;map-key&gt;</literal>, o puede ser una referencia de entidad, mapeada con <literal>&lt;map-key-many-to-many&gt;</literal>, o puede ser un tipo compuesto, mapeado con <literal>&lt;composite-map-key&gt;</literal>. El &#x00ed;ndice de un array o lista es siempre de tipo <literal>integer</literal> y se mapea usando el elemento <literal>&lt;list-index&gt;</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>&lt;map-key&gt;</literal>, it may be an entity reference mapped with <literal>&lt;map-key-many-to-many&gt;</literal>, or it may be a composite type, mapped with <literal>&lt;composite-map-key&gt;</literal>. The index of an array or list is always of type <literal>integer</literal> and is mapped using the <literal>&lt;list-index&gt;</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 &#x00ed;ndice de la colecci&#x00f3;n. </para> </callout> <callout arearefs=\"index1\"> <para> <literal>base</literal> (opcional, por defecto a <literal>0</literal>): El valor de la columna &#x00ed;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 &#x00ed;ndice de la colecci&#x00f3;n. </para> </callout> <callout arearefs=\"mapkey2\"> <para> <literal>formula</literal> (opcional): Una f&#x00f3;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&#x00e1;nea para los valores &#x00ed;ndice de la colecci&#x00f3;n. </para> </callout> <callout arearefs=\"indexmanytomany2\"> <para> <literal>formula</literal> (opcional): Una f&#x00f3;rmula SQL usada para evaluar la clave for&#x00e1;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 &#x00ed;ndice, y deseas a&#x00fa;n usar <literal>List</literal> como tipo de propiedad, debes mapear la propiedad como un <emphasis>&lt;bag&gt;</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>&lt;bag&gt;</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&#x00f3;n de esquemas para obtener una idea de c&#x00f3;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&#x00f3;n de valores o asociaci&#x00f3;n muchos a muchos requiere una <emphasis>tabla de colecci&#x00f3;n</emphasis> dedicada con una columna o columnas de clave for&#x00e1;nea, <emphasis>columna de elemento de colecci&#x00f3;n</emphasis> o columnas y posiblemente una columna o columnas &#x00ed;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&#x00f3;n de valores, usamos la etiqueta <literal>&lt;element&gt;</literal>." + +#: index.docbook:373 +msgid "For a collection of values, we use the <literal>&lt;element&gt;</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&#x00f3;n. </para> </callout> <callout arearefs=\"element2b\"> <para> <literal>formula</literal> (opcional): Una f&#x00f3;rmula SQL usada para evaluar el elemento. </para> </callout> <callout arearefs=\"element3b\"> <para> <literal>type</literal> (requerido): El tipo del elemento de colecci&#x00f3;n. </para> </callout> </calloutlist> </programlistingco> <para> Una <emphasis>asociaci&#x00f3;n muchos-a-muchos</emphasis> se especifica usando el elemento <literal>&lt;many-to-many&gt;</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\"/! + " 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&#x00e1;nea del elemento. </para> </callout> <callout arearefs=\"manytomany2\"> <para> <literal>formula</literal> (opcional): Una f&#x00f3;rmula SQL opcional usada para evaluar el valor de clave for&#x00e1;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&#x00f3;n por uni&#x00f3;n externa o selecci&#x00f3;n secuencial para esta asociaci&#x00f3;n. Este es un caso especial; para una recuperaci&#x00f3;n completamente temprana (en un solo <literal>SELECT</literal>) de una entidad y sus relaciones muchos-a-muchos a otras entidades, deber&#x00ed;as habilitar la re! cuperaci&#x00f3;n <literal>join</literal> no s&#x00f3;lo de la colecci&#x00f3;n misma, sino tambi&#x00e9;n con este atributo en el elemento anidado <literal>&lt;many-to-many&gt;</literal>. </para> </callout> <callout arearefs=\"manytomany5\"> <para> <literal>unique</literal> (opcional): Habilita la generaci&#x00f3;n DDL de una restricci&#x00f3;n de unicidad para la columna clave for&#x00e1;nea. Esto hace la multiplicidad de la asociaci&#x00f3;n efectivamente uno a muchos. </para> </callout> <callout arearefs=\"manytomany6\"> <para> <literal>not-found</literal> (opcional - por defecto a <literal>exception</literal>): Especifica c&#x00f3;mo ser&#x00e1;n manejadas las claves for&#x00e1;neas que referencian filas perdidas: <literal>ignore</literal> tratar&#x00e1; una fila perdida como una asociaci&#x00f3;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>&lt;many-to-many&gt;</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>&lt;many-to-many&gt;</literal! 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&#x00f3;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&#x00f3;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 &#x00ed;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&#x00f3;ximo cap&#x00ed;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&#x00f3;n uno a muchos</emphasis> enlaza las tablas de dos clases por medio de una clave for&#x00e1;nea, sin intervenci&#x00f3;n de tabla de colecci&#x00f3;n alguna. Este mapeo pierde cierta sem&#x00e1;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&#x00e1;s de una instancia de la colecci&#x00f3;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&#x00e1;s de un valor del &#x00ed;ndice de colecci&#x00f3;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&#x00f3;n de <literal>Product</literal> a <literal>Part</literal> requiere la existencia de una columna clave for&#x00e1;nea y posiblemente una columna &#x00ed;ndice a la tabla <literal>Part</literal>. Una etiqueta <literal>&lt;one-to-many&gt;</literal> indica que &#x00e9;sta es una asociaci&#x00f3;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>&lt;one-to-many&gt;</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&#x00f3;mo ser&#x00e1;n manejados los identificadores en cach&#x00e9; que referencien filas perdidas: <literal>ignore</literal> tratar&#x00e1; una fila perdida como una asociaci&#x00f3;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>&lt;one-to-many&gt;</literal> no necesita declarar ninguna columna. Ni es necesario especificar el nombre de <literal>table</literal> en ning&#x00fa;n sitio." + +#: index.docbook:573 +msgid "Notice that the <literal>&lt;one-to-many&gt;</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&#x00e1;nea de una asociaci&#x00f3;n <literal>&lt;one-to-many&gt;</literal> es declarada <literal>NOT NULL</literal>, debes declarar el mapeo de <literal>&lt;key&gt;</literal> <literal>not-null=\"true\"</literal> o <emphasis>usar una asociaci&#x00f3;n bidireccional</emphasis> con el mapeo de colecci&#x00f3;n marcado <literal>inverse=\"true\"</literal>. Ver la discusi&#x00f3;n sobre asociaciones bidireccionales m&#x00e1;s adelante en este cap&#x00ed;tulo." + +#: index.docbook:579 +msgid "<emphasis>Very important note:</emphasis> If the foreign key column of a <literal>&lt;one-to-many&gt;</literal> association is declared <literal>NOT NULL</literal>, you must declare the <literal>&lt;key&gt;</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 &#x00ed;ndice basado en f&#x00f3;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&#x00f3;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&#x00f3;n usa el atributo <literal>order-by</literal> de los mapeos <literal>set</literal>, <literal>bag</literal> o <literal>map</literal>. Esta soluci&#x00f3;n est&#x00e1; disponible s&#x00f3;lo bajo el JDK 1.4 o superior (est&#x00e1; implementado usando <literal>LinkedHashSet</literal> o <literal>LinkedHashMap</literal>). Esto realiza la ordenaci&#x00f3;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&#x00f3;n SQL, no una ordenaci&#x00f3;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&#x00fa;n criterio arbitrario en tiempo de ejecuci&#x00f3;n usando un <literal>filter()</literal> de colecci&#x00f3;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&#x00f3;n bidireccional</emphasis> permite la nevegaci&#x00f3;n desde ambos \"extremos\" de la asociaci&#x00f3;n. Son soportados dos tipos de asociaci&#x00f3;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&#x00f3;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&#x00e1;l de ellos es tu elecci&#x00f3;n, pero no puede ser una colecci&#x00f3;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&#x00ed; un ejemplo de una asociaci&#x00f3;n bidireccional muchos-a-muchos; cada categor&#x00ed;a puede tener muchos &#x00ed;tems y cada &#x00ed;tem puede estar en muchas categor&#x00ed;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&#x00f3;lo al extremo inverso de la asociaci&#x00f3;n <emphasis>no</emphasis> son persistidos. Esto significa que Hibernate tiene dos representaciones en memoria para cada asociaci&#x00f3;n bidireccional, una enlaza de A a B y otra enlaza de B a A. Esto es m&#x00e1;s f&#x00e1;cil de entender si piensas en el modelo de objetos de Java y c&#x00f3;mo creamos una relaci&#x00f3;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&#x00f3;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&#x00f3;n bidireccional uno-a-muchos mapeando una asociaci&#x00f3;n uno-a-muchos a la misma columna (o columnas) de tabla como una asociaci&#x00f3;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&#x00f3;n con <literal>inverse=\"true\"</literal> no afecta la operaci&#x00f3;n de cascadas; &#x00e9;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&#x00f3;n una asociaci&#x00f3;n bidireccional donde un extremo est&#x00e9; representado como una <literal>&lt;list&gt;</literal> o <literal>&lt;map&gt;</literal>. Si hay una propiedad de la clase hija que mapee a la columna &#x00ed;ndice, no hay problema, podemos seguir usando <literal>inverse=\"true\"</literal> en el mapeo de la colecci&#x00f3;n:" + +#: index.docbook:722 +msgid "A bidirectional association where one end is represented as a <literal>&lt;list&gt;</literal> or <literal>&lt;map&gt;</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&#x00f3;n como verdaderamente bidireccional (hay informaci&#x00f3;n en un extremo de la asociaci&#x00f3;n que no est&#x00e1; disponible en el otro extremo). En este caso, no podemos mapear la colecci&#x00f3;n con <literal>inverse=\"true\"</literal>. En cambio, podr&#x00ed;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&#x00f3;n valuado en colecci&#x00f3;n es responsable de las actualizaciones a la clave for&#x00e1;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&#x00f3;n ternaria. Una es usar un <literal>Map</literal> con una asociaci&#x00f3;n como su &#x00ed;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&#x00f3;n como una clase de entidad. Este es el enfoque que usamos m&#x00e1;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&#x00e1;s adelante." + +#: index.docbook:764 +msgid "A final alternative is to use composite elements, which we will discuss later." +msgstr "Usando un &lt;idbag&gt;" + +#: index.docbook:771 +msgid "Using an &lt;idbag&gt;" +msgstr "Si has adoptado completamente nuestra visi&#x00f3;n de que las claves compuestas son una cosa mala y que las entidades deben tener identificadores sit&#x00e9;ticos (claves delegadas), entonces podr&#x00ed;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&#x00f3;n no parece beneficiarse demasiado de una clave delegada (aunque s&#x00ed; <emphasis>podr&#x00ed;a</emphasis> una colecci&#x00f3;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>&lt;idbag&gt;</literal> te permite mapear una <literal>List</literal> (o <literal>Collection</literal>) con sem&#x00e1;ntica de bag." + +#: index.docbook:784 +msgid "The <literal>&lt;idbag&gt;</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>&lt;idbag&gt;</literal> tiene un generador de id sint&#x00e9;tico, igual que una clase de entidad! Una clave delegada diferente se asigna a cada fila de la colecci&#x00f3;n. Hibernate no provee ning&#x00fa;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>&lt;idbag&gt;</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&#x00f3;n de un <literal>&lt;idbag&gt;</literal> es <emphasis>mucho</emphasis> mejor que el de un <literal>&lt;bag&gt;</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>&lt;idbag&gt;</literal> is <emphasis>much</emphasis> better than a regular <literal>&lt;bag&gt;</literal>! Hibernate can locate individual rows efficiently and update or delete them individually, just like a list, map or set." +msgstr "En la implementaci&#x00f3;n actual, la estrategia de generaci&#x00f3;n de identificador <literal>native</literal> no est&#x00e1; soportada para identificadores de colecciones <literal>&lt;idbag&gt;</literal>." + +#: index.docbook:805 +msgid "In the current implementation, the <literal>native</literal> identifier generation strategy is not supported for <literal>&lt;idbag&gt;</literal> collection identifiers." +msgstr "Ejemplos de colecci&#x00f3;n" + +#: index.docbook:829 +msgid "Collection examples" +msgstr "Las secciones previas son bastantes confusas. As&#x00ed; 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&#x00f3;n de instancias de <literal>Child</literal>. Si cada hijo tiene como mucho un padre, el mapeo m&#x00e1;s natural es una asociaci&#x00f3;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&#x00f3;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&#x00f3;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&#x00f3;n debe ser unidireccional, puedes declarar la restricci&#x00f3;n <literal>NOT NULL</literal> en el mapeo de <literal>&lt;key&gt;</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>&lt;key&gt;</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&#x00fa;ltiples padres, ser&#x00ed;a apropiada una asociaci&#x00f3;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&#x00e1;s ejemplos y un paseo completo a trav&#x00e9;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&#x00f3;n a&#x00fa;n m&#x00e1;s complejos. Catalogaremos todas las posibilidades en el pr&#x00f3;ximo cap&#x00ed;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@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&#x00f3;n de un <emphasis>componente</emphasis> es reusada en muchos contextos diferentes, para prop&#x00f3;sitos diferentes, a trav&#x00e9;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&#x00e9;rmino \"componente\" hace referencia a la noci&#x00f3;n orientada a objetos de composici&#x00f3;n (no a componentes a nivel de arquitectura). Por ejemplo, podr&#x00ed;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&#x00e9;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&#x00ed;a as&#x00ed;:" + +#: 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&#x00ed;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&#x00ed;an dos objetos nombre independientes, s&#x00f3;lo \"iguales\" en valor. La sem&#x00e1;ntica de valor nulo de un componente es <emphasis>ad hoc</emphasis>. Cuando se recargue el objeto contenedor, Hibernate asumir&#x00e1; que si todas las columnas del componente son nulas, el componente entero es nulo. Esto debe estar bien para la mayor&#x00ed;a de prop&#x00f3;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&#x00f3;tico. Hibernate est&#x00e1; concebido para soportar un modelo de objetos granularizado en fino." + +#: index.docbook:62 +msgid "The <literal>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity." +msgstr "El elemento <literal>&lt;component&gt;</literal> permite un subelemento <literal>&lt;parent&gt;</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>&lt;element&gt;</literal> tag with a <literal>&lt;composite-element&gt;</literal> tag." +msgstr "Las colecciones de componentes est&#x00e1;n soportadas (por ejemplo, un array de tipo <literal>Name</literal>). Declara tu colecci&#x00f3;n de componentes remplazando la etiqueta <literal>&lt;element&gt;</literal> por una etiqueta <literal>&lt;composite-element&gt;</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>&lt;nested-composite-element&gt;</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>&lt;nested-composite-element&gt;</literal>. Este es un caso bastante ex&#x00f3;tico - una colecci&#x00f3;n de componentes que a su vez tienen componentes. A esta altura debes estar pregunt&#x00e1;ndote si una asociaci&#x00f3;n uno-a-muchos es m&#x00e1;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&#x00e1;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>&lt;set&gt;</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>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal> or <literal>&lt;idbag&gt;</literal>." +msgstr "Por favor observa que un mapeo de elemento compuesto no soporta propiedades nulables si est&#x00e1;s usando un <literal>&lt;set&gt;</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&#x00f3;lo propiedades no nulas en un elemento compuesto o elegir un <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal> o <literal>&lt;idbag&gt;</literal>." + +#: index.docbook:113 +msgid "A special case of a composite element is a composite element with a nested <literal>&lt;many-to-one&gt;</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>&lt;many-to-one&gt;</literal>. Un mapeo como este te permite mapear columnas extra de una tabla de asociaci&#x00f3;n muchos-a-muchos a la clase del elemento compuesto. La siguiente es una asociaci&#x00f3;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&#x00f3;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&#x00f3;n bidireccional de la asociaci&#x00f3;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&#x00e1;xis que las asociaciones a otras entidades." + +#: index.docbook:145 +msgid "Components as Map indices" +msgstr "Componentes como &#x00ed;ndices de Map" + +#: index.docbook:147 +msgid "The <literal>&lt;composite-map-key&gt;</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>&lt;composite-map-key&gt;</literal> te permite mapear una clase componente como la clave de un <literal>Map</literal>. Aseg&#x00fa;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&#x00f3;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&#x00ed;gido de Hibernate. Pero de todas formas, h&#x00e1;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&#x00f3;n debe, en cambio, asignar sus propios identificadores." + +#: index.docbook:188 +msgid "Use the <literal>&lt;composite-id&gt;</literal> tag (with nested <literal>&lt;key-property&gt;</literal> elements) in place of the usual <literal>&lt;id&gt;</literal> declaration. For example, the <literal>OrderLine</literal> class has a primary key that depends upon the (composite) primary key of <literal>Order</literal>." +msgstr "Usa la etiqueta <literal>&lt;composite-id&gt;</literal> (con elementos anidados <literal>&lt;key-property&gt;</literal>) en lugar de la usual declaraci&#x00f3;n <literal>&lt;id&gt;</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&#x00e1;nea que referencie la tabla de <literal>OrderLine</literal> es tambi&#x00e9;n compuesta. Debes declarar esto en tus mapeos de otras clases. Una asociaci&#x00f3;n a <literal>OrderLine</literal> ser&#x00ed;a mapeado as&#x00ed;:" + +#: 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>&lt;column&gt;</literal> tag is an alternative to the <literal>column</literal> attribute everywhere.)" +msgstr "(Nota que la etiqueta <literal>&lt;column&gt;</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&#x00f3;n <literal>muchos-a-muchos</literal> a <literal>OrderLine</literal> tambi&#x00e9;n usa la clave for&#x00e1;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&#x00f3;n de <literal>OrderLine</literal>s en <literal>Order</literal> usar&#x00ed;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>&lt;one-to-many&gt;</literal> element, as usual, declares no columns.)" +msgstr "(El elemento <literal>&lt;one-to-many&gt;</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&#x00f3;n por s&#x00ed; misma, tiene tambi&#x00e9;n una clave for&#x00e1;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&#x00e1;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>&lt;dynamic-component&gt;</literal> mapping are identical to <literal>&lt;component&gt;</literal>. The advantage of this kind of mapping is the ability to determine the actual properties of the bean at deployment time, just by editing the mapping document. Runtime manipulation of the mapping document is also possible, using a DOM parser. Even better, you can access (and change) Hibernate's configuration-time metamodel via the <literal>Configuration</literal> object." +msgstr "La sem&#x00e1;ntica de un mapeo <literal>&lt;dynamic-component&gt;</literal> es &#x00ed;dentica a la de <literal>&lt;component&gt;</literal>. La ventaja de este tipo de mapeos es la habilidad para determinar las propiedades reales del bean en tiempo de despliegue, s&#x00f3;lo con editar el documento de mapeo. La manipulaci&#x00f3;n del documento de mapeo en tiempo de ejecuci&#x00f3;n es tambi&#x00e9;n posible, usando un analizador DOM. Incluso mejor, puedes acceder (y cambiar) el metamodelo de tiempo de configuraci&#x00f3;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@ADDRESS>\n" +"Content-Type: text/plain; charset=utf-8\n" +#: index.docbook:5 +msgid "Configuration" +msgstr "Configuraci&#x00f3;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&#x00e1; dise&#x00f1;ado para operar en muchos entornos diferentes, hay un gran n&#x00fa;mero de par&#x00e1;metros de configuraci&#x00f3;n. Afortunadamente, la mayor&#x00ed;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&#x00f3;lo pon el fichero de ejemplo en tu classpath y personal&#x00ed;zalo." + +#: index.docbook:16 +msgid "Programmatic configuration" +msgstr "Configuraci&#x00f3;n program&#x00e1;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&#x00f3;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&#x00e1;ndola directamente y especificando documentos de mapeo XML. Si los ficheros de mapeo est&#x00e1;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&#x00e1; 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&#x00f3;digo." + +#: index.docbook:48 +msgid "A <literal>Configuration</literal> also allows you to specify configuration properties:" +msgstr "Una <literal>Configuration</literal> tambi&#x00e9;n te permite especificar propiedades de configuraci&#x00f3;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 &#x00fa;nica forma de pasar propiedades de configuraci&#x00f3;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&#x00ed;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>&lt;property&gt;</literal> elements in <literal>hibernate.cfg.xml</literal> (discussed later)." +msgstr "Incluir elementos <literal>&lt;property&gt;</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&#x00e1;s f&#x00e1;cil si quieres comenzar r&#x00e1;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&#x00e1; 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&#x00f3;n debe obtener una f&#x00e1;brica de instancias de <literal>Session</literal>. Esta f&#x00e1;brica est&#x00e1; concebida para ser compartida por todas las hebras de aplicaci&#x00f3;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&#x00f3;n instancie m&#x00e1;s de una <literal>SessionFactory</literal>. Esto es &#x00fa;til si est&#x00e1;s usando m&#x00e1;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&#x00e1; una conexi&#x00f3;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&#x00f3;n JDBC a Hibernate. Todos los nombres de propiedades y su sem&#x00e1;ntica est&#x00e1;n definidas en la clase <literal>org.hibernate.cfg.Environment</literal>. Describiremos ahora las configuraciones m&#x00e1;s importantes para la conexi&#x00f3;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&#x00e1; (y tendr&#x00e1; 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&#x00f3;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&#x00f1;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&#x00fa;mero m&#x00e1;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&#x00e1; concebido para ayudarte a comenzar y <emphasis>no est&#x00e1; concebido para usar en un sistema de producci&#x00f3;n</emphasis> ni siquiera para pruebas de rendimiento. Debes usar un pool de terceros para un mejor rendimiento y estabilidad. S&#x00f3;lo remplaza la propiedad <literal>hibernate.connection.pool_size</literal> con configuraciones espec&#x00ed;ficas del pool de conexiones. Esto desactivar&#x00e1; el pool interno de Hibernate. Por ejemplo, podr&#x00ed;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&#x00f3;digo abierto distribuido junto a Hibernate en el directorio <literal>lib</literal>. Hibernate usar&#x00e1; su <literal>C3P0ConnectionProvider</literal> para pooling de conexiones si estableces propiedades <literal>hibernate.c3p0.*</literal>. Si quieres usar Proxool refi&#x00e9;rete al <literal>hibernate.properties</literal> empaquetado y al sitio web de Hibernate para m&#x00e1;s informaci&#x00f3;n." + +#: index.docbook:221 +msgid "Here is an example <literal>hibernate.properties</literal> file for C3P0:" +msgstr "Aqu&#x00ed; 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&#x00e1;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&#x00f1;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&#x00ed; 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&#x00e1;n autom&#x00e1;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&#x00f3;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&#x00f3;n personalizada estableciendo <literal>hibernate.connection.provider_class</literal>." + +#: index.docbook:317 +msgid "Optional configuration properties" +msgstr "Par&#x00e1;metros de configuraci&#x00f3;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&#x00fa;mero de otras propiedades que controlan el comportamiento de Hibernate en tiempo de ejecuci&#x00f3;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&#x00f3;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&#x00e9;cnicas arriba descritas." + +#: index.docbook:332 +msgid "Hibernate Configuration Properties" +msgstr "Propiedades de Configuraci&#x00f3;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&#x00e1;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&#x00e1; ligada a este nombre en JNDI autom&#x00e1;ticamente despu&#x00e9;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&#x00e1;xima del &#x00e1;rbol de recuperaci&#x00f3;n por outer join para asociaciones de un extremo solo (uno-a-uno, muchos-a-uno). Un <literal>0</literal> deshabilita la recuperaci&#x00f3;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&#x00f1;o por defecto para la recuperaci&#x00f3;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&#x00f3;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&#x00e1; en menos bloqueos muertos de transacci&#x00f3;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&#x00e1; estad&#x00ed;sticas &#x00fa;tiles para la afinaci&#x00f3;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&#x00e1;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&#x00e1; comentarios dentro del SQL, para una m&#x00e1;s f&#x00e1;cil depuraci&#x00f3;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&#x00f3;n). Hibernate usar&#x00e1; DML en lote para versionar autom&#x00e1;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&#x00ed;a de las aplicaciones no necesitar&#x00e1;n esta propiedad de configuraci&#x00f3;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&#x00f3;lo es necesaria cuando se usan conexiones JDBC provistas por el usuario, en caso contrario Hibernate usa los metadatos de conexi&#x00f3;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&#x00e9;s de insertar. Requiere un driver JDBC3+ y un JRE1.4+. Establ&#x00e9;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&#x00f3;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&#x00f3;n JDBC. Comprueba <literal>java.sql.Connection</literal> para valores significativos pero observa que la mayor&#x00ed;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&#x00e1;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&#x00e1;ndo Hibernate debe liberar las conexiones JDBC. Por defecto, una conexi&#x00f3;n JDBC es retenida hasta que la sesi&#x00f3;n es cerrada expl&#x00ed;citamente o desconectada. Para un datasource JTA del servidor de aplicaciones, debes usar <literal>after_statement</literal> para liberar agresivamente las conexiones despu&#x00e9;s de cada llamada JDBC. Para una conexi&#x00f3;n no JTA, frecuentemente tiene sentido liberar la conexi&#x00f3;n al final de cada transacci&#x00f3;n, usando <literal>after_transaction</literal>. <literal>auto</literal> eligir&#x00e1; <literal>after_statement</literal> para las estrategias JTA o CMT de transacci&#x00f3;n y <literal>after_transaction</literal> para la estrategia JDBC de transacci&#x00f3;n." + +#: index.docbook:668 +msgid "hibernate.connection.release_mode" +msgstr "hibernate.connection.<emphasis>&lt;propertyName&gt;</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>&lt;propertyName&gt;</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>&lt;propertyName&gt;</emphasis>" +msgstr "Propiedades de Cach&#x00e9; 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>&lt;propertyName&gt;</emphasis>" +msgstr "Prop&#x00f3;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&#x00f3;n del cach&#x00e9; de segundo nivel para minimizar escrituras, al costo de lecturas m&#x00e1;s frecuentes. Esto es m&#x00e1;s &#x00fa;til para cach&#x00e9;s en cluster y, en Hibernate3, est&#x00e1; habilitado por defecto para implementaciones de cach&#x00e9; 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&#x00e9; de lectura, consultas individuales todav&#x00ed;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&#x00e9; de segundo nivel, que est&#x00e1; habilitado por defecto para clases que especifican un mapeo <literal>&lt;cache&gt;</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>&lt;cache&gt;</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&#x00f3;n del cach&#x00e9; 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&#x00e9; de segundo nivel en un formato m&#x00e1;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&#x00f3;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&#x00f3;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&#x00e9; a nivel de JVM est&#x00e1; 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&#x00f3;n se limpiar&#x00e1; (flushed) autom&#x00e1;ticamente durante la fase previa a la compleci&#x00f3;n de la transacci&#x00f3;n. (Muy &#x00fa;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&#x00f3;n ser&#x00e1; cerrada autom&#x00e1;ticamente durante la fase posterior a la compleci&#x00f3;n de la transacci&#x00f3;n. (Muy &#x00fa;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&#x00f3;sito" + +#: index.docbook:914 +msgid "Miscellaneous Properties" +msgstr "Elige la implementaci&#x00f3;n de parser HQL." + +#: index.docbook:927 +msgid "hibernate.current_session_context_class" +msgstr "Mapeos de s&#x00ed;mbolos en consultas Hibernate a s&#x00ed;mbolos SQL. (los s&#x00ed;mbolos puedem ser nombres de funci&#x00f3;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&#x00e1;ticamente DDL de esquema cuando al crear la <literal>SessionFactory</literal>. Con <literal>create-drop</literal>, el esquema de base de datos ser&#x00e1; desechado cuando la <literal>SessionFactory</literal> se cierre expl&#x00ed;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&#x00f3;n en tiempo de ejecuci&#x00f3;n (propiedad a nivel de sistema). La reflecci&#x00f3;n a veces puede ser &#x00fa;til ante la aparici&#x00f3;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&#x00f3;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&#x00f3;n por Uni&#x00f3;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&#x00f3;n por uni&#x00f3;n externa</emphasis> aumentar&#x00e1; frecuentemente el rendimiento limitando el n&#x00fa;mero de llamadas a la base de datos (al costo de m&#x00e1;s trabajo posiblemente realizado por la base de datos misma). La recuperaci&#x00f3;n por uni&#x00f3;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&#x00ed;do en una sola <literal>SELECT</literal> SQL." + +#: index.docbook:1085 +msgid "org.hibernate.dialect.PointbaseDialect" +msgstr "La recuperaci&#x00f3;n por uni&#x00f3;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&#x00f3;n por uni&#x00f3;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&#x00e1;s informaci&#x00f3;n." + +#: index.docbook:1088 +msgid "org.hibernate.dialect.FrontbaseDialect" +msgstr "Flujos Binarios" + +#: index.docbook:1091 +msgid "Firebird" +msgstr "Oracle limita el tama&#x00f1;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&#x00e9; 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&#x00e9; de segundo nivel en el &#x00e1;mbito de un proceso o cluster con Hibernate. Ver <xref linkend=\"performance-cache\"/> para m&#x00e1;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&#x00f3;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&#x00ed;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&#x00ed;a que los s&#x00ed;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&#x00ed;a renombrar la funci&#x00f3;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&#x00e1; un n&#x00fa;mero de m&#x00e9;tricas que son &#x00fa;tiles al afinar un sistema en ejecuci&#x00f3;n v&#x00ed;a <literal>SessionFactory.getStatistics()</literal>. Hibernate puede incluso ser configurado para exponer estas estad&#x00ed;sticas v&#x00ed;a JMX. Lee el Javadoc de las interfaces en <literal>org.hibernate.stats</literal> para m&#x00e1;s informaci&#x00f3;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&#x00e1; 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&#x00e1;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&#x00f3;n de problemas. Las categor&#x00ed;as de registro m&#x00e1;s interesantes son las siguientes:" + +#: index.docbook:1167 +msgid "would allow you to rename the SQL <literal>LOWER</literal> function." +msgstr "Categor&#x00ed;as de Registro de Hibernate" + +#: index.docbook:1174 +msgid "Hibernate statistics" +msgstr "Categor&#x00ed;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&#x00f3;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&#x00e1;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&#x00e1;ximo de 20 entidades) asociadas con la sesi&#x00f3;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&#x00e9; 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&#x00f3;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&#x00f3;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&#x00ed; como otra informaci&#x00f3;n sobre an&#x00e1;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&#x00f3;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&#x00f3;n, pero muy &#x00fa;til para la resoluci&#x00f3;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&#x0ed;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&#x00e1;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&#x00e1;ticamente identificadores de base de datos a partir de identificadores JDBC o para procesar nombres \"l&#x00f3;gicos\" de columnas y tablas dados en el fichero de mapeo en nombres \"f&#x00ed;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&#x00ed;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 &#x00fa;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&#x00f3;n XML" + +#: index.docbook:1286 +msgid "Implementing a <literal>NamingStrategy</literal>" +msgstr "Un enfoque alternativo de configuraci&#x00f3;n es especificar una configuraci&#x00f3;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&#x00e1;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&#x00f3;n XML se espera por defecto en la ra&#x00ed;z o tu <literal>CLASSPATH</literal>. He aqu&#x00ed; 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&#x00f3;n de los nombres de los fichero de mapeo a configuraci&#x00f3;n. El <literal>hibernate.cfg.xml</literal> es tambi&#x00e9;n m&#x00e1;s conveniente una vez que hayas afinado el cach&#x00e9; de Hibernate. Observa que elecci&#x00f3;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&#x00f3;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&#x00f3; 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&#x00f3;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&#x00e9;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&#x00ed;das a trav&#x00e9;s de varios datasources. Puedes tambi&#x00e9;n, por supuesto, demarcar los l&#x00ed;mites de las transacciones program&#x00e1;ticamente (BMT) o podr&#x00ed;as querer usar para esto la API opcional de <literal>Transaction</literal> de Hibernate para mantener tu c&#x00f3;digo portable." + +#: index.docbook:1342 +msgid "With the XML configuration, starting Hibernate is then as simple as" +msgstr "<emphasis>Ligamento Autom&#x00e1;tico JNDI</emphasis>: Hibernate puede ligar sus <literal>SessionFactory</literal> a JNDI despu&#x00e9;s del arranque." + +#: index.docbook:1346 +msgid "<![CDATA[SessionFactory sf = new Configuration().configure().buildSessionFactory();]]>" +msgstr "<emphasis>Ligamento de Sesi&#x00f3;n JTA:</emphasis> La <literal>Session</literal> de Hibernate puede ser ligada autom&#x00e1;ticamente al &#x00e1;mbito de transacciones JTA si usas EJBs. Simplemente busca la <literal>SessionFactory</literal> de JNDI y obt&#x00e9;n la <literal>Session</literal> actual. Deja que Hibernate cuide de limpiar y cerrar la <literal>Session</literal> cuando se complete tu transacci&#x00f3;n JTA. La demarcaci&#x00f3;n de transacci&#x00f3;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&#x00f3;digo de una l&#x00ed;nea de arranque para construir tu <literal>SessionFactory</literal> desde una <literal>Configuration</literal>. El contenedor arrancar&#x00e1; tu <literal>HibernateService</literal>, e idealmente tambi&#x00e9;n cuidar&#x00e1; 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&#x00ed;as tener que establecer la opci&#x00f3;n de configuraci&#x00f3;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&#x00f3;n de la estrategia de transacci&#x00f3;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&#x00f3;n de transacci&#x00f3;n en tu arquitectura. Si dejas que Hibernate use JDBC directamente, a trav&#x00e9;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&#x00e9;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&#x00f3;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&#x00e1;brica para las instancias de <literal>Transaction</literal> estableciendo la propiedad de configuraci&#x00f3;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&#x00e1;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&#x00f3;n existente est&#x00f3; por debajo en este contexto (ej. m&#x00e9;todo de un bean de sesi&#x00f3;n EJB), en otro caso una nueva transacci&#x00f3;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&#x00e9;n tus propias estrategias de transacci&#x00f3;n (para un servicio de transacci&#x00f3;n CORBA, por ejemplo)." + +#: index.docbook:1443 +msgid "org.hibernate.transaction.JDBCTransactionFactory" +msgstr "Algunas funcionalidades en Hibernate (ej, el cach&#x00e9; de segundo nivel, ligamento autom&#x00e1;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&#x00f3;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&#x00f3;n de la f&#x00e1;brica y la creaci&#x00f3;n de nuevas <literal>Session</literal>s. Observa que esto no est&#x00e1; 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&#x00e1; ligada a JNDI (Esto es especialmente &#x00fa;til en entornos con una implementaci&#x00f3; JNDI de s&#x00f3;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&#x00e1; los valores de <literal>hibernate.jndi.url</literal>, <literal>hibernate.jndi.class</literal> para instanciar un contexto inicial. Si &#x00e9;tos no se especifican, se usar&#x00e1; el <literal>InitialContext</literal> por defecto." + +#: index.docbook:1524 +msgid "JRun4" +msgstr "Hibernate colocar&#x00e1; autom&#x00e1;ticamente la <literal>SessionFactory</literal> en JNDI despu&#x00e9;s que llames a <literal>cfg.buildSessionFactory()</literal>. Esto significa que tendr&#x00e1;s al menos esta llamada en alg&#x00fa;n c&#x00f3;digo de arranque (o clase de utilidad) en tu aplicaci&#x00f3;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&#x00fa;squeda JNDI. Observa que esta configuraci&#x00f3;n no es necesaria si usas la clase de ayuda <literal>HibernateUtil</literal> introducida en el cap&#x00ed;tulo uno, que act&#x00fa;a como un registro Singleton. Sin embargo, <literal>HibernateUtil</literal> es m&#x00e1;s com&#x00fa;n en un entorno no manejado." + +#: index.docbook:1528 +msgid "Borland ES" +msgstr "Ligado autom&#x00e1;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&#x00e1;tica, y administraci&#x00f3;n de la <literal>Session</literal> de Hibernate. Este enfoque no es f&#x00e1;cil de usar en un entorno EJB, al poder ejecutarse muchos EJBs dentro de la misma transacci&#x00f3;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&#x00e9;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&#x00f3;n JTA actual, se arrancar&#x00e1; y asignar&#x00e1; una. Ambas opciones de configuraci&#x00f3;n <literal>hibernate.transaction.flush_before_completion</literal> y <literal>hibernate.transaction.auto_close_session</literal>, ser&#x00e1;n establecidas autom&#x00e1;ticamente para cada <literal>Session</literal> que obtengas con <literal>getCurrentSession()</literal>, de modo que &#x00e9;stas ser&#x00e1;n limpiadas (flushed) y cerradas autom&#x00e1;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&#x00f3;n de dise&#x00f1;o DAO para escribir tu capa de persistencia, todos los DAO's buscan la <literal>SessionFactory</literal> cuando se necesite y abren la sesi&#x00f3;n \"actual\". No hay necesidad de pasar las instancias de <literal>SessionFactory</literal> o <literal>Session</literal> alrededor entre el c&#x00f3;digo de control y el c&#x00f3;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&#x00ed;nea <literal>cfg.buildSessionFactory()</literal> todav&#x00ed;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&#x00f3;n reales son espec&#x00ed;ficos del vendedor. He aqu&#x00ed; 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&mdash;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&#x00f3;n <literal>.sar</literal> (fichero de servicio). Tambi&#x00e9;n necesitas empaquetar Hibernate, sus bibliotecas de terceros requeridas, tus clases persistentes compiladas, as&#x00ed; como tus ficheros de mapeo en el mismo fichero. Tus beans de empresa (usualmente beans de sesi&#x00f3;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&#x00f3;n de JBoss AS para m&#x00e1;s informaci&#x00f3;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@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 &#x00fa;til para la aplicaci&#x00f3;n reaccionar a ciertos eventos que ocurran dentro de Hibernate. Esto permite la implementaci&#x00f3;n de ciertos tipos de funcionalidade gen&#x00e9;rica, y extensi&#x00f3;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&#x00f3;n a la aplicaci&#x00f3;n permitiendo a &#x00e9;sta &#x00fa;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&#x00f3;n de auditor&#x00ed;a. Por ejemplo, el siguiente <literal>Interceptor</literal> establece autom&#x00e1;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&#x00ed;a ser especificado cuando se crea la sesi&#x00f3;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&#x00e1;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&#x00e9;n la arquitectura de <emphasis>eventos</emphasis> de Hibernate3. El sistema de eventos puede ser usado en adici&#x00f3;n o como un remplazo a los interceptores." + +#: index.docbook:61 +msgid "Event system" +msgstr "Esencialmente todos los m&#x00e9;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&#x00f3;n XML o el paquete <literal>org.hibernate.event</literal> para la lista completa de tipos de evento definidos). Cuando se hace una petici&#x00f3;n de uno de estos m&#x00e9;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&#x00e1;brica, estos oyentes implementan el mismo procesamiento en los que siempre resultan aquellos m&#x00e9;todos. Sin embargo, eres libre de implementar una personalizaci&#x00f3;n de una de las interfaces oyentes (es decir, el <literal>LoadEvent</literal> es procesado por la implementaci&#x00f3;n registrada de la interface <literal>LoadEventListener</literal>), en cuyo caso su implementaci&#x00f3;n ser&#x0! 0ed;a responsable de procesar cualquier petici&#x00f3;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&#x00fa;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&#x00e1;brica al ser &#x00e9;stos declarados non-final para este prop&#x00f3;sito). Los oyentes personalizados pueden ser registrados program&#x00e1;ticamente a trav&#x00e9;s del objeto <literal>Configuration</literal>, o especificados en el XML de configuraci&#x00f3;n de Hibernate (la declaraci&#x00f3;n declarativa a trav&#x00e9;s del fichero de propiedades no est&#x00e1; soportada). He aqu&#x00ed; 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&#x00e1;s una entrada de configuraci&#x00f3;n dici&#x00e9;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&#x00e1;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&#x00fa;ltiples elementos <literal>&lt;listener/&gt;</literal>, cada referencia resultar&#x00e1; 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&#x00f3;n program&#x00e1;tica." + +#: index.docbook:112 +msgid "" + "<![CDATA[Configuration cfg = new Configuration();\n" + "LoadEventListener[] stack = { new MyLoadListener(), new DefaultLoadEventListener() };\n" + "cfg.EventListeners().setLoadEventListeners(stack);]]>" +msgstr "&#x00bf;Por qu&#x00e9; implementar una interface y definir el tipo espc&#x00ed;fico durante la configuraci&#x00f3;n? Bueno, una implementaci&#x00f3;n de oyente podr&#x00ed;a implementar m&#x00fa;ltiples interfaces de oyente de eventos. Teniendo el tipo definido adicionalmente durante la registraci&#x00f3;n lo hace m&#x00e1;s f&#x00e1;cil para activar o desactivar oyentes personalizados durante la configuraci&#x00f3;n." + +#: index.docbook:114 +msgid "Listeners registered declaratively cannot share instances. If the same class name is used in multiple <literal>&lt;listener/&gt;</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&#x00f3;n. Ahora, Hibernate3 permite que ciertas acciones sean permitidas v&#x00ed;a JACC, y autorizadas v&#x00ed;a JAAS. Esta en una funcionalidad opcional constru&#x00ed;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&#x00f3;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&#x00fa;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>&lt;listener type=\"...\" class=\"...\"/&gt;</literal> is just a shorthand for <literal>&lt;event type=\"...\"&gt;&lt;listener class=\"...\"/&gt;&lt;/event&gt;</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@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&#x00ed;tulo muestra mapeos de asociaciones m&#x00e1;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&#x00f3;n entre <literal>Employer</literal> y <literal>Employee</literal> usa una clase de entidad real (<literal>Employment</literal>) para representar la asociaci&#x00f3;n. Esto se ha hecho esto porque podr&#x00ed;a haber m&#x00e1;s de un per&#x00ed;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&#x00ed; 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&#x00ed; 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&#x00f3;n entre <literal>Work</literal> y <literal>Author</literal> como una asociaci&#x00f3;n muchos-a-muchos. Elegimos representar la relaci&#x00f3;n entre <literal>Author</literal> y <literal>Person</literal> como una asociaci&#x00f3;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&#x00f3;n enlazando autores a obras. He aqu&#x00ed; 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&#x00f3;n uno-a-muchos entre <literal>Customer</literal> y <literal>Order</literal>, pero, &#x00bf;c&#x00f3;mo deber&#x00ed;amos representar <literal>Order</literal> / <literal>LineItem</literal> / <literal>Product</literal>? He elegido mapear <literal>LineItem</literal> como una clase de asociaci&#x00f3;n representando la asociaci&#x00f3;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, &#x00ed;tem de l&#x00ed;nea de orden y producto respectivamente. Adem&#x00e1;s <literal>line_items</literal> act&#x00fa;a como una tabla de asociaci&#x00f3;n enlazando &#x00f3;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&#x00e1;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&#x00e1;n tomados de la bater&#x00ed;a de pruebas de Hibernate. Encontrar&#x00e1;s muchos otros mapeos de ejemplo &#x00fa;tiles all&#x00ed;. Mira en la carpeta <literal>test</literal> de la distribuci&#x00f3;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&#x00f3;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&#x00f3;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@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>&lt;one-to-many&gt;</literal> association from <literal>Parent</literal> to <literal>Child</literal>. (The alternative approach is to declare the <literal>Child</literal> as a <literal>&lt;composite-element&gt;</literal>.) 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&#x00ed;simas cosas que los usuarios nuevos intentan hacer con Hibernate es modelar una relaci&#x00f3;n de tipo padre / hijo. Para esto hay dos enfoques diferentes. Por varias razones, el enfoque m&#x00e1;s conveniente, especialmente para usuarios nuevos, es modelar tanto <literal>Parent</literal> como <literal>Child</literal> como clases de entidad con una asociaci&#x00f3;n <literal>&lt;one-to-many&gt;</literal> desde <literal>Parent</literal> a <literal>Child</literal>. (El enfoque alternativo es declarar el <literal>Child</literal> como un <literal>&lt;composite-element&gt;</literal>.) Ahora, resulta que la sem&#x00e1;ntica por defecto de una asociaci&#x00f3;n uno a muchos (en Hibernate) es mucho menos cercana a la sem&#x00e1;ntica usual de una relaci&#x00f3;n padre / hijo que aquellas de un mapeo de elementos compuestos. Explicaremos c&#x00f3;mo usar una <emphasis>asociaci&#x00f3;n uno a muchos bidireccional con tratamiento en cascada</emphasis>! para modelar una relaci&#x00f3;n padre / hijo eficiente y elegantemente. &#x00a1;No es para nada dif&#x00ed;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&#x00f3;gica de la entidad que las posee; nunca de las entidades contenidas. &#x00a1;Esta es una distinci&#x00f3;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&#x00f1;ade un objeto desde / a una colecci&#x00f3;n, se incrementa el n&#x00fa;mero de versi&#x00f3;n del due&#x00f1;o de la colecci&#x00f3;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&#x00f3;n es una instancia de un tipo de valor (por ejemplo, un elemento compuesto), ese objeta cesar&#x00e1; de ser persistente y su estado ser&#x00e1; completamente quitado de la base de datos. Asimismo, a&#x00f1;adir una instancia de tipo de valor a la colecci&#x00f3;n causar&#x00e1; 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&#x00f3;n (una asociaci&#x00f3;n uno-a-muchos o muchos-a-muchos), no ser&#x00e1; borrado, por defecto. Este comportamiento es completamente consistente. &#x00a1;Un cambio en el estado interno de otra entidad no hace desaparecer la entidad asociada! Asimismo, a&#x00f1;adir una entidad a una colecci&#x00f3;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&#x00f1;adir una entidad a una colecci&#x00f3;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&#x00f3;n padre / hijo. donde la vida del hijo est&#x00e1; 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>&lt;one-to-many&gt;</literal> association from <literal>Parent</literal> to <literal>Child</literal>." +msgstr "Sup&#x00f3;n que empezamos con una asociaci&#x00f3;n simple <literal>&lt;one-to-many&gt;</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&#x00e1;semos el siguiente c&#x00f3;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&#x00ed;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&#x00f3;lo ineficiente, sino que adem&#x00e1;s viola cualquier restricci&#x00f3;n <literal>NOT NULL</literal> en la columna <literal>parent_id</literal>. Podemos reparar la violaci&#x00f3;n de restricci&#x00f3;n de nulabilidad especificando <literal>not-null=\"true\"</literal> en el mapeo de la colecci&#x00f3;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&#x00f3;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&#x00e1;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&#x00f3;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&#x00e1;s a&#x00f1;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&#x00e1; gestionando el estado del enlace, le decimos a la colecci&#x00f3;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&#x00f3;digo podr&#x00ed;a ser usado para a&#x00f1;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, &#x00a1;S&#x00f3;lo se publicar&#x00ed;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&#x00e1;s las cosas, podr&#x00ed;amos crear un m&#x00e9;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&#x00f3;digo para a&#x00f1;adir un <literal>Child</literal> se ve as&#x00ed;" + +#: 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&#x00ed;cita a <literal>save()</literal> es a&#x00fa;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&#x00f3;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&#x00f3;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&#x00e1; <literal>c</literal> de la base de datos; s&#x00f3;lo quitar&#x00e1; el enlace a <literal>p</literal> (y causar&#x00e1; una violaci&#x00f3;n a una restricci&#x00f3;n <literal>NOT NULL</literal>). Necesitas borrar el hijo expl&#x00ed;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&#x00f3;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&#x00f3;n especifique <literal>inverse=\"true\"</literal>, el tratamiento en cascada se procesa a&#x00fa;n al iterar los elementos de colecci&#x00f3;n. De modo que si requieres que un objeto sea salvado, borrado o actualizado en cascada, debes a&#x00f1;adirlo a la colecci&#x00f3;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&#x00f3;n que hemos cargado un <literal>Parent</literal> en una <literal>Session</literal>, hemos hecho algunos cambios en una acci&#x00f3;n de UI y deseamos hacer persistentes estos cambios en una nueva sesi&#x00f3;n llamando a <literal>update()</literal>. El <literal>Parent</literal> contendr&#x00e1; una colecci&#x00f3;n de hijos y, ya que est&#x00e1; habilitado el tratamiento en cascada, Hibernate necesita saber qu&#x00e9; hijos est&#x00e1;n reci&#x00e9;n instanciados y cu&#x00e1;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&#x00e1; el identificador y el valor de la propiedad de versi&#x00f3;n/timestamp para determinar cu&#x00e1;les de los hijos son nuevos. (Ver <xref linkend=\"objectstate-saveorupdate\"/>.) <emphasis>En Hibernate3, no es m&#x00e1;s necesario especificar un <literal>unsa! ved-value</literal> expl&#x00ed;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&#x00e1; muy bien para el caso de un identificador generado, pero &#x00bf;qu&#x00e9; de los identificadores asignados y de los identificadores compuestos? Esto es m&#x00e1;s dif&#x00ed;cil, ya que Hibernate no puede usar la propiedad identificadora para distinguir entre un objeto reci&#x00e9;n instanciado (con un identificador asignado por el usuario) y un objeto cargado en una sesi&#x00f3;n previa. En este caso, Hibernate bien usar&#x00e1; la propiedad de versi&#x00f3;n o timestamp, o bien consultar&#x00e1; realmente el cach&#x00e9; 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&#x00f3;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&#x00ed; y podr&#x00ed;a parecer confuso a la primera vez. Sin embargo, en la pr&#x00e1;ctica, todo funciona muy agradablemente. La mayor&#x00ed;a de las aplicaciones de Hibernate usan el patr&#x00f3;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>&lt;composite-element&gt;</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&#x00e1;rrafo. Ninguno de los temas anteriores existe en el caso de los mapeos <literal>&lt;composite-element&gt;</literal>, que tienen exactamente la sem&#x00e1;ntica de una relaci&#x00f3;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 &#x00fa;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@ADDRESS>\n" +"Content-Type: text/plain; charset=utf-8\n" +#: index.docbook:5 +msgid "Example: Weblog Application" +msgstr "Ejemplo: Aplicaci&#x00f3;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 &#x00ed;tem enviado a un weblog. Van a ser modelados como una relaci&#x00f3;n padre/hijo est&#x00f1;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&#x00f3;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@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>&lt;filter-def/&gt;</literal> element within a <literal>&lt;hibernate-mapping/&gt;</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>&lt;filter-def/&gt;</literal> dentro de un elemento <literal>&lt;hibernate-mapping/&gt;</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>&lt;filter-def/&gt;</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@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&#x00e1;sicas de mapeo de herencia:" + +#: index.docbook:16 +msgid "table per class hierarchy" +msgstr "<para>tabla por jerarqu&#x00ed;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&#x00f3;n, Hibernate soporta un cuarto, ligeramente diferente tipo de polimorfismo:" + +#: index.docbook:39 +msgid "implicit polymorphism" +msgstr "polimorfismo impl&#x00ed;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>&lt;subclass&gt;</literal>, and <literal>&lt;joined-subclass&gt;</literal> and <literal>&lt;union-subclass&gt;</literal> mappings under the same root <literal>&lt;class&gt;</literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies, under the the same <literal>&lt;class&gt;</literal> element, by combining the <literal>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</literal> elements (see below)." +msgstr "Es posible usar estrategias de mapeo diferentes para diferentes ramificaciones de la misma jerarqu&#x00ed;a de herencia, y entonces usar polimorfismo impl&#x00ed;cito para conseguir polimorfismo a trav&#x00e9;s de toda la jerarqu&#x00ed;a. Sin embargo, Hibernate no soporta la mezcla de mapeos <literal>&lt;subclass&gt;</literal>, y <literal>&lt;joined-subclass&gt;</literal> y <literal>&lt;union-subclass&gt;</literal> bajo el mismo elemento <literal>&lt;class&gt;</literal> ra&#x00ed;z. Es posible mezclar juntas las estrategias de tabla por jerarqu&#x00ed;a y tabla por subclase, bajo el mismo elemento <literal>&lt;class&gt;</literal>, combinando los elementos <literal>&lt;subclass&gt;</literal> y <literal>&lt;join&gt;</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&#x00ed;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&#x00f3;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&#x00ed;a se ver&#x00ed;a as&#x00ed;:" + +#: 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&#x00f3;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&#x00ed;a as&#x00ed;:" + +#: 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&#x00f3;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&#x00f3;n de Hibernate de tabla por subclase no requiere ninguna columna discriminadora. Otros mapeadores objeto/relacional usan una implementaci&#x00f3;n diferente de tabla por subclase que requiere una columna discriminadora de tipo en la tabla de superclase. Este enfoque es mucho m&#x00e1;s dif&#x00ed;cil de implementar pero discutiblemente m&#x00e1;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>&lt;subclass&gt;</literal> y <literal>&lt;join&gt;</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>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</literal>, as follow:" +msgstr "la declaraci&#x00f3;n opcional <literal>fetch=\"select\"</literal> dice a Hibernate que no recupere los datos de la subclase <literal>ChequePayment</literal> usando una uni&#x00f3;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&#x00ed;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&#x00ed;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&#x00f3;n polim&#x00f3;rfica a la clase ra&#x00ed;z <literal>Payment</literal> es mapeada usando <literal>&lt;many-to-one&gt;</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>&lt;many-to-one&gt;</literal>." +msgstr "Tabla por clase concreta" + +#: index.docbook:151 +msgid "<![CDATA[<many-to-one name=\"payment\" column=\"PAYMENT_ID\" class=\"Payment\"/>]]>" +msgstr "Podr&#x00ed;amos ir de dos maneras a la estrategia de mapeo de tabla por clase concreta. La primera es usar <literal>&lt;union-subclass&gt;</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>&lt;union-subclass&gt;</literal>." +msgstr "Est&#x00e1;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&#x00f3;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&#x00ed;amos relajar esto en un lanzamiento futuro de Hibernate.) La estrategia de generador de indentidad no est&#x00e1; permitida en la herencia de uni&#x00f3;n de subclase, de hecho la semilla de clave primaria tiene que ser compartida a trav&#x00e9;s de todas las subclases unidas de una jerarqu&#x00ed;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&#x00ed;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&#x00ed;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&#x00fa;n sitio mencionamos la interface <literal>Payment</literal> expl&#x00ed;citamente. Nota adem&#x00e1;s que las propiedades de <literal>Payment</literal> son mapeadas en cada una de las subclases. Si quieres evitar duplicaci&#x00f3;n, considera usar entidades XML. (por ejemplo, <literal>[ &lt;!ENTITY allproperties SYSTEM \"allproperties.xml\"&gt; ]</literal> en la declaraci&#x00f3;n <literal>DOCTYPE</literal> y <literal>&amp;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&#x00f3;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&#x00f3;n polim&#x00f3;rfica a <literal>Payment</literal> es mapeada generalmente usando <literal>&lt;any&gt;</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>[ &lt;!ENTITY allproperties SYSTEM \"allproperties.xml\"&gt; ]</literal> in the <literal>DOCTYPE</literal> declartion and <literal>&amp;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&#x00ed;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>&lt;any&gt;</literal>." +msgstr "Hay una cosa m&#x00e1;s por notar acerca de este mapeo. Ya que las subclases se mapean cada una en su propio elemento <literal>&lt;class&gt;</literal> (y ya que <literal>Payment</literal> es s&#x00f3;lo una interface), cada una de las subclases podr&#x00ed;a ser parte de otra jerarqu&#x00ed;a de herencia! (Y todav&#x00ed;a puedes seguir usando consultas polim&#x00f3;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&#x00e1;s, no mencionamos a <literal>Payment</literal> expl&#x00ed;citamente. Si ejecutamos una consulta contra la interface <literal>Payment</literal> - por ejemplo, <literal>from Payment</literal> - Hibernate devuelve autom&#x00e1;ticamente instancias de <literal>CreditCardPayment</literal> (y sus subclases, ya que ellas tambi&#x00e9;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>&lt;class&gt;</literal> element (and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy! (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&#x00ed;cito\" en la estrategia de mapeo de tabla por clase concreta. Existen limitaciones algo menos restrictivas a los mapeos <literal>&lt;union-subclass&gt;</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&#x00ed;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>&lt;union-subclass&gt;</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&#x00f3;rfica" + +#: index.docbook:264 +msgid "Features of inheritance mappings" +msgstr "uno-a-uno polim&#x00f3;rfica" + +#: index.docbook:276 +msgid "Inheritance strategy" +msgstr "uno-a-muchos polim&#x00f3;rfica" + +#: index.docbook:277 +msgid "Polymorphic many-to-one" +msgstr "mushos-a-muchos polim&#x00f3;rfica" + +#: index.docbook:278 +msgid "Polymorphic one-to-one" +msgstr "<literal>load()/get()</literal> polim&#x00f3;rficos" + +#: index.docbook:279 +msgid "Polymorphic one-to-many" +msgstr "Consultas polim&#x00f3;rficas" + +#: index.docbook:280 +msgid "Polymorphic many-to-many" +msgstr "Uniones polim&#x00f3;rficas" + +#: index.docbook:281 +msgid "Polymorphic <literal>load()/get()</literal>" +msgstr "Recuperaci&#x00f3;n por uni&#x00f3;n externa (outer join)" + +#: index.docbook:282 +msgid "Polymorphic queries" +msgstr "<entry>tabla por jerarqu&#x00ed;a de clases</entry>" + +#: index.docbook:283 +msgid "Polymorphic joins" +msgstr "&lt;many-to-one&gt;" + +#: index.docbook:284 +msgid "Outer join fetching" +msgstr "&lt;one-to-one&gt;" + +#: index.docbook:289 +msgid "table per class-hierarchy" +msgstr "&lt;one-to-many&gt;" + +#: index.docbook:290, index.docbook:301, index.docbook:312 +msgid "&lt;many-to-one&gt;" +msgstr "&lt;many-to-many&gt;" + +#: index.docbook:291, index.docbook:302, index.docbook:313 +msgid "&lt;one-to-one&gt;" +msgstr "s.get(Payment.class, id)" + +#: index.docbook:292, index.docbook:303 +msgid "&lt;one-to-many&gt;" +msgstr "from Payment p" + +#: index.docbook:293, index.docbook:304, index.docbook:315 +msgid "&lt;many-to-many&gt;" +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 "&lt;many-to-one&gt;" + +#: index.docbook:297, index.docbook:308, index.docbook:319 +msgid "supported" +msgstr "&lt;one-to-one&gt;" + +#: index.docbook:300 +msgid "<entry>table per subclass</entry>" +msgstr "&lt;one-to-many&gt;" + +#: index.docbook:311 +msgid "table per concrete-class (union-subclass)" +msgstr "<literal>&lt;one-to-many&gt;</literal> (para <literal>inverse=\"true\"</literal> solamente)" + +#: index.docbook:314 +msgid "<literal>&lt;one-to-many&gt;</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 "&lt;any&gt;" +msgstr "&lt;many-to-any&gt;" + +#: 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 "&lt;many-to-any&gt;" +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@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&#x00f3;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&#x00f3;n</emphasis> es la estrategia que usar&#x00e1; Hibernate para recuperar los objetos asociados cuando la aplicaci&#x00f3;n necesite navegar la asociaci&#x00f3;n. Las estrategias de recuperaci&#x00f3;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&#x00f3;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&#x00f3;n por uni&#x00f3;n (join fetching)</emphasis> - Hibernate recupera la instancia asociada o colecci&#x00f3;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&#x00f3;n por selecci&#x00f3;n (select fetching)</emphasis> - se usa una segunda <literal>SELECT</literal> para recuperar la entidad asociada o colecci&#x00f3;n. A menos que deshabilites expl&#x00ed;citamente la recuperaci&#x00f3;n perezosa especificando <literal>lazy=\"false\"</literal>, la segunda selecci&#x00f3;n s&#x00f3;lo ser&#x00e1; ejecutada cuando realmente accedas a la asociaci&#x00f3;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&#x00f3;n por subselecci&#x00f3;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&#x00f3;n previa. A menos que deshabilites expl&#x00ed;citamente la recuperaci&#x00f3;n perezosa especificando <literal>lazy=\"false\"</literal>, esta segunda selecci&#x00f3;n s&#x00f3;lo ser&#x00e1; ejecutada cuando realmente accedas a la asociaci&#x00f3;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&#x00f3;n en lote</emphasis> - una estrategia de optimizaci&#x00f3;n para la recuperaci&#x00f3;n por selecci&#x00f3;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&#x00e1;neas." + +#: index.docbook:57 +msgid "Hibernate also distinguishes between:" +msgstr "Hibernate tambi&#x00e9;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&#x00f3;n inmediata</emphasis> - una asociaci&#x00f3;n, colecci&#x00f3;n o atributo es recuperado inmediatamente, cuando el due&#x00f1;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&#x00f3;n perezosa de colecciones</emphasis> - se recupera una colecci&#x00f3;n cuando la aplicaci&#x00f3;n invoca una operaci&#x00f3;n sobre la colecci&#x00f3;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&#x00f3;n por proxy</emphasis> - se recupera una asociaci&#x00f3;n monovaluada cuando se invoca un m&#x00e9;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&#x00f3;n perezosa de atributos</emphasis> - se recupera un atributo o una asociaci&#x00f3;n monovaluada cuando se accede a la variable de instancia (requiere instrumentaci&#x00f3;n del bytecode en tiempo de ejecuci&#x00f3;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&#x00ed; tenemos dos nociones ortogonales: <emphasis>cu&#x00e1;ndo</emphasis> se recupera la aplicaci&#x00f3;n, y <emphasis>c&#x00f3;mo</emphasis> es recuperada (qu&#x00e9; SQL es usado). &#x00a1;No las confundas! Usamos <literal>fetch</literal> para afinar el rendimiento. Podemos usar <literal>lazy</literal> para definir un contrato sobre qu&#x00e9; datos est&#x00e1;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&#x00f3;n perezosa por selecci&#x00f3;n para colecciones y una recuperaci&#x00f3;n por proxy perezosa para asociaciones monovaluadas. Estas pol&#x00ed;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&#x00e1; la optimizaci&#x00f3;n de recuperaci&#x00f3;n en lotes para recuperaci&#x00f3;n perezosa (esta optimizaci&#x00f3;n tambi&#x00e9;n puede ser habilitada a un nivel m&#x00e1;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&#x00f3;n perezosa plantea un problema del que tienes que estar al tanto. Acceder a una asociaci&#x00f3;n perezosa fuera del contexto de una sesi&#x00f3;n de Hibernate abierta resultar&#x00e1; en una excepci&#x00f3;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&#x00f3;n de permisos no fue inicializada cuando se cerr&#x00f3; la <literal>Session</literal>, la colecci&#x00f3;n no ser&#x00e1; capaz de cargar su estado. <emphasis>Hibernate no soporta la inicializaci&#x00f3;n perezosa de objetos separados</emphasis>. La soluci&#x00f3;n es mover el c&#x00f3;digo que lee de la colecci&#x00f3;n a justo antes que la transacci&#x00f3;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&#x00ed;amos usar una colecci&#x00f3;n no perezosa o asociaci&#x00f3;n, especificando <literal>lazy=\"false\"</literal> para el mapeo de asociaci&#x00f3;n. Sin embargo, est&#x00e1; pensado que la inicializaci&#x00f3;n perezosa sea usada para casi todas las colecciones y asociaciones. &#x00a1;Si defines demasiadas asociaciones no perezosas en tu modelo de objetos, Hibernate terminar&#x00e1; necesitando recuperar la base de datos entera en cada transacci&#x00f3;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&#x00f3;n por uni&#x00f3;n (que es no perezosa por naturaleza) en vez de la recuperaci&#x00f3;n por selecci&#x00f3;n en una transacci&#x00f3;n en particular. Veremos ahora c&#x00f3;mo personalizar la estrategia de recuperaci&#x00f3;n. En Hibernate3, los mecanismos para elegir una estrategia de recuperaci&#x00f3;n son id&#x00e9;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&#x00f3;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&#x00f3;n por selecci&#x00f3;n (la preestablecida) es extremadamente vulnerable a problemas de selecci&#x00f3;n N+1, de modo querr&#x00ed;amos habilitar la recuperaci&#x00f3;n por uni&#x00f3;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&#x00f3;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&#x00ed;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&#x00ed;citamente cuando se navega una asociaci&#x00f3;n (recuperaci&#x00f3;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&#x00f3;n. En cambio, mantenemos el comportamiento por defecto, y lo sobrescribimos para una transacci&#x00f3;n en particular, usando <literal>left join fetch</literal> en HQL. Esto le dice a Hibernate que recupere la asociaci&#x00f3;n tempranamente en la primera selecci&#x00f3;n, usando una uni&#x00f3;n externa. En la API de consulta de <literal>Criteria</literal>, usar&#x00ed;as <literal>setFetchMode(FetchMode.JOIN)</literal>." + +#: index.docbook:197 +msgid "<literal>Criteria</literal> queries" +msgstr "Si acaso lo deseases, podr&#x00ed;as cambiar la estrategia de recuperaci&#x00f3;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&#x00f3;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&#x00e9; 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&#x00f3;n perezosa de colecciones est&#x00e1; implementada usando la implementaci&#x00f3;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&#x00f3;n debe ser tratada con proxies. Hibernate implementa proxies de inicializaci&#x00f3;n perezosa para objetos persistentes usando mejora del bytecode en tiempo de ejecuci&#x00f3;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&#x00f3;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. &#x00a1;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&#x00f3;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&#x00e1;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&#x00f3;n no en absoluta tan mala como parece. Aunque tenemos ahora dos referencias a objetos proxy diferentes, la instancia subyacente ser&#x00e1; a&#x00fa;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&#x00fa;n m&#x00e9;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&#x00f3;n (por ejemplo, en inicializadores o constructores por defecto), entonces esos recursos ser&#x00e1;n adquiridos tambi&#x00e9;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 &#x00fa;nica de Java. Si deseas evitar estos problemas cada una de tus clases persistentes deben implementar una interface que declare sus m&#x00e9;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&#x00e9;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&#x00f3;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&#x00e9;todo getter del identificador" + +#: index.docbook:328 +msgid "Certain operations do <emphasis>not</emphasis> require proxy initialization" +msgstr "Hibernate detectar&#x00e1; 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&#x00e1; lanzada por Hibernate si una colecci&#x00f3;n o proxy sin inicializar es accedido fuera del &#x00e1;mbito de la <literal>Session</literal>, es decir, cuando la entidad que posee la colecci&#x00f3;n o que tiene la referencia al proxy est&#x00e9; en el estado separada." + +#: index.docbook:346 +msgid "The identifier getter method" +msgstr "A veces necesitamos asegurarnos que un proxy o colecci&#x00f3;n est&#x00e9; inicializado antes de cerrar la <literal>Session</literal>. Por supuesto, siempre podemos forzar la inicializaci&#x00f3;n llamando a <literal>cat.getSex()</literal> o <literal>cat.getKittens().size()</literal>, por ejemplo. Pero esto es confuso a lectores del c&#x00f3;digo y no es conveniente para c&#x00f3;digo gen&#x00e9;rico." + +#: index.docbook:352 +msgid "Hibernate will detect persistent classes that override <literal>equals()</literal> or <literal>hashCode()</literal>." +msgstr "Los m&#x00e9;todos est&#x00e1;ticos <literal>Hibernate.initialize()</literal> y <literal>Hibernate.isInitialized()</literal> proveen a la aplicaci&#x00f3;n de una forma conveniente de trabajar con colecciones o proxies inicializados perezosamente. <literal>Hibernate.initialize(cat)</literal> forzar&#x00e1; la inicializaci&#x00f3;n de un proxy, <literal>cat</literal>, en tanto su <literal>Session</literal> est&#x00e9; todav&#x00ed;a abierta. <literal>Hibernate.initialize( cat.getKittens() )</literal> tiene un efecto similar para la colecci&#x00f3;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&#x00f3;n es mantener la <literal>Session</literal> abierta hasta que todas las colecciones y proxies necesarios hayan sido cargados. En algunas arquitecturas de aplicaci&#x00f3;n, particularmente en aquellas donde el c&#x00f3;digo que accede a los datos usando Hibernate, y el c&#x00f3;digo que los usa est&#x00e1;n en capas de aplicaci&#x00f3;n diferentes o procesos f&#x00ed;sicos diferentes, puede ser un problema asegurar que la <literal>Session</literal> est&#x00e9; abierta cuando se inicializa una colecci&#x00f3;n. Existen dos formas b&#x00e1;sicas de tratar este tema:" + +#: index.docbook:367 +msgid "Initializing collections and proxies" +msgstr "En una aplicaci&#x00f3;n basada web, puede usarse un filtro de servlets para cerrar la <literal>Session</literal> s&#x00f3;lo bien al final de una petici&#x00f3;n de usuario, una vez que el rendering de la vista est&#x00e9; completa (el patr&#x00f3;n <emphasis>Sesi&#x00f3;n Abierta en Vista (Open Session in View)</emphasis>). Por supuesto, estos sitios requieren una fuerte demanda de correcci&#x00f3;n del manejo de excepciones de tu infraestructura de aplicaci&#x00f3;n. Es de una importancia vital que la <literal>Session</literal> est&#x00e9; cerrada y la transacci&#x00f3;n terminada antes de volver al usuario, incluso cuando ocurra una excepci&#x00f3;n durante el rendering de la p&#x00e1;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&#x00ed;tulo 1, <xref linkend=\"quickstart-pla! yingwithcats\"/>, para una implementaci&#x00f3;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&#x00f3;n con una grada de negocios separada, la l&#x00f3;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&#x00f3;n web todos los datos que se requieran para un caso de uso en particular ya inicializados. Usualmente, la aplicaci&#x00f3;n llama a <literal>Hibernate.initialize()</literal> para cada colecci&#x00f3;n que se necesitar&#x00e1; en la grada web (esta llamada debe ocurrir antes que la sesi&#x00f3;n sea cerrada) o recupera la colecci&#x00f3;n tempranamente usando una consulta de Hibernate con una cl&#x00e1;usula <literal>FETCH</literal> o una <literal>FetchMode.JOIN</literal> en <literal>Criteria</literal>. Esto es usualmente m&#x00e1;s f&#x00e1;cil si adoptas el patr&#x00f3;n <emphasis>Comando</emphasis> en vez de un <emphasis>Fachada de Sesi&#x00f3;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&#x00e9;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). &#x00a1;No, Hibernate no, y ciertamente <emphasis>no debe</emphasis> hacer esto autom&#x00e1;ticamente, ya que introducir&#x00ed;a sem&#x00e1;nticas de transacci&#x00f3;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&#x00f3;n grande, pero necesitas a&#x00fa;n alguna informacion sobre ella (como su tama&#x00f1;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&#x00f1;o de una colecci&#x00f3;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&#x00e9;todo <literal>createFilter()</literal> se usa tambi&#x00e9;n para recuperar eficientemente subconjuntos de una colecci&#x00f3;n sin necesidad de inicializar toda la colecci&#x00f3;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&#x00f3;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&#x00f3;n en lotes, esto es, Hibernate puede cargar muchos proxies sin inicializar si se accede a un proxy (o colecciones). La recuperaci&#x00f3;n en lotes es una optimizaci&#x00f3;n de la estrategia de recuperaci&#x00f3;n por selecci&#x00f3;n perezosa. Hay dos formas en que puedes afinar la recuperaci&#x00f3;n en lotes: a nivel de la clase o de la colecci&#x00f3;n." + +#: index.docbook:449 +msgid "<![CDATA[( (Integer) s.createFilter( collection, \"select count(*)\" ).list().get(0) ).intValue()]]>" +msgstr "La recuperaci&#x00f3;n en lotes para clases/entidades es m&#x00e1;s f&#x00e1;cil de entender. Imagina que tienes la siguiente situaci&#x00f3;n en tiempo de ejecuci&#x00f3;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&#x00e1; mapeada con un proxy, <literal>lazy=\"true\"</literal>. Si ahora iteras a trav&#x00e9;s de todos los gatos y llamas a <literal>getOwner()</literal> para cada uno, Hibernate por defecto ejecutar&#x00e1; 25 sentencias <literal>SELECT</literal> para traer los due&#x00f1;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&#x00e1; s&#x00f3;lo tres consultas, el patr&#x00f3;n es 10, 10, 5." + +#: index.docbook:461 +msgid "Using batch fetching" +msgstr "Tambi&#x00e9;n puedes habilitar la recuperaci&#x00f3;n en lotes para colecciones. Por ejemplo, si cada <literal>Person</literal> tiene una colecci&#x00f3;n perezosa de <literal>Cat</literal>s, y hay 10 personas actualmente cargadas en la <literal>Session</literal>, iterar a trav&#x00e9;s de las 10 personas generar&#x00e1; 10 <literal>SELECT</literal>s, una para cada llamada a <literal>getCats()</literal>. Si habilitas la recuperaci&#x00f3;n en lotes para la colecci&#x00f3;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&#x00e1; 3, 3, 3, 1 colecciones en cuatro <literal>SELECT</literal>s. Una vez m&#x00e1;s, el valor del atributo depende del n&#x00fa;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&#x00f3;n de coleccione en lotes es particularmente &#x00fa;til si tienes un &#x00e1;rbol anidado de &#x00ed;tems, es decir, el t&#x00ed;pico patr&#x00f3;n de cuenta de materiales. (Aunque un <emphasis>conjunto anidado</emphasis> o una <emphasis>ruta materializada</emphasis> podr&#x00ed;a ser una mejor opci&#x00f3;n para &#x00e1;rboles que sean de lectura en la mayor&#x00ed;a de los casos.)" + +#: index.docbook:481 +msgid "Hibernate will now execute only three queries, the pattern is 10, 10, 5." +msgstr "Usando recuperaci&#x00f3;n por subselecci&#x00f3;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&#x00f3;n perezosa o proxy monovaluado tiene que ser recuperado, Hibernate los carga a todos, volviendo a ejecutar la consulta original en una subselecci&#x00f3;n. Esto funciona de la misma forma que la recuperaci&#x00f3;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&#x00f3;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&#x00f3;n perezosa de propiedades individuales. Esta t&#x00e9;cnica de optimizaci&#x00f3;n es tambi&#x00e9;n conocida como <emphasis>grupos de recuperaci&#x00f3;n (fetch groups)</emphasis>. Por favor, nota que &#x00e9;ste es mayormente un aspecto de marketing, ya que en la pr&#x00e1;ctica, optimizar lecturas de filas es mucho m&#x00e1;s importante que la optimizaci&#x00f3;n de lectura de columnas. Sin embargo, cargar s&#x00f3;lo algunas propiedades de una clase podr&#x00ed;a ser &#x00fa;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 "&#x00a1;La carga perezosa de propiedades requiere la instrumentaci&#x00f3;n del bytecode en tiempo de construcci&#x00f3;n! Si tus clases persistentes no son mejoradas, Hibernate ignorar&#x00e1; silenciosamente la configuraci&#x00f3;n perezosa de propiedades y caer&#x00e1; en recuperaci&#x00f3;n inmediata." + +#: index.docbook:524 +msgid "Using lazy property fetching" +msgstr "Para la instrumentaci&#x00f3;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 (&#x00bf;mejor?) de evitar lecturas innecesarias de columnas, al menos para transacciones de s&#x00f3;lo lectura es usar las funcionalidades de proyecci&#x00f3;n de consultas HQL o Criteria. Esto evita la necesidad de procesar el bytecode en tiempo de construcci&#x00f3;n y ciertamente es una soluci&#x00f3;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&#x00f3;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&#x00e9; 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&#x00e9; de datos persistentes a nivel de transacci&#x00f3;n. Es posible configurar un cluster o cach&#x00e9; a nivel de JVM (a nivel de <literal>SessionFactory</literal>) sobre una base de clase-a-clase o colecci&#x00f3;n-a-colecci&#x00f3;n. Puedes incluso enchufar una cach&#x00e9; en cluster. S&#x00e9; cuidadoso. Las cach&#x00e9;s nunca est&#x00e1;n al tanto de los cambios hechos por otra aplicaci&#x00f3;n al almac&#x00e9;n persistente (aunque pueden ser configurados para expirar regularmente los datos en cach&#x00e9;)." + +#: 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&#x00e1; despreciado y ser&#x00e1; quitado en una futura versi&#x00f3;n de Hibernate.) Puedes elegir una implementaci&#x00f3;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&#x00e9;" + +#: index.docbook:561 +msgid "You may force the usual eager fetching of properties using <literal>fetch all properties</literal> in HQL." +msgstr "Cach&#x00e9;" + +#: 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&#x00e9; de Consultas Soportado" + +#: index.docbook:601, index.docbook:774 +msgid "Cache" +msgstr "Hashtable (no pensado para uso en producci&#x00f3;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&#x00ed;" + +#: 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&#x00ed;" + +#: 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&#x00ed;" + +#: 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&#x00ed; (replicaci&#x00f3;n)" + +#: index.docbook:634 +msgid "yes (clustered invalidation)" +msgstr "s&#x00ed; (requiere sincronizaci&#x00f3;n de reloj)" + +#: index.docbook:638, index.docbook:811 +msgid "JBoss TreeCache" +msgstr "Mapeos de cach&#x00e9;" + +#: index.docbook:639 +msgid "org.hibernate.cache.TreeCacheProvider" +msgstr "El elemento <literal>&lt;cache&gt;</literal> de una mapeo de clase o colecci&#x00f3;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 (&#x00bf;preferiblemente?), puedes especificar los elementos <literal>&lt;class-cache&gt;</literal> y <literal>&lt;collection-cache&gt;</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&#x00e9;</emphasis>." + +#: index.docbook:651 +msgid "The <literal>&lt;cache&gt;</literal> element of a class or collection mapping has the following form:" +msgstr "Estrategia: s&#x00f3;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&#x00f3;n necesita leer pero nunca modificar las instancias de una clase persistente, puede usarse un cach&#x00e9; <literal>read-only</literal>. Esta es la mejor y m&#x00e1;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&#x00f3;n necesita actualizar datos, un cach&#x00e9; <literal>read-write</literal> podr&#x00ed;a ser apropiado. Esta estrategia de cach&#x00e9; nunca debe ser usada si se requiere nivel de aislamiento serializable de transacciones. Si el cach&#x00e9; 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&#x00f3;n est&#x00e9; 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&#x00f3;n de cach&#x00e9; subyacente soporta bloqueos. Los provedores de cach&#x00e9; internos predeterminados <emphasis>no</emphasis> no lo soportan." + +#: index.docbook:691 +msgid "Alternatively (preferrably?), you may specify <literal>&lt;class-cache&gt;</literal> and <literal>&lt;collection-cache&gt;</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&#x00f3;n necesita s&#x00f3;lo ocasionalmente actualizar datos (es decir, es extremadamente inprobable que dos transacciones intenten actualizar el mismo &#x00ed;tem simult&#x00e1;neamente) y no se requiere de un aislamiento de transacciones estricto, un cach&#x00e9; <literal>nonstrict-read-write</literal> podr&#x00ed;a ser apropiado. Si se usa el cach&#x00e9; en un entorno JTA, debes especificar <literal>hibernate.transaction.manager_lookup_class</literal>. En otros entornos, debes asegurarte que la transacci&#x00f3;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&#x00e9; <literal>transactional</literal> brinda soporte a provedores de cach&#x00e9;s completamente transaccionales como TreeCache de JBoss. Un cach&#x00e9; as&#x00ed;, puede s&#x00f3;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&#x00e9; soporta todas las estrategias de concurrencia al cach&#x00e9;. La siguiente tabla muestra qu&#x00e9; provedores son compatibles con qu&#x00e9; 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&#x00e9;" + +#: 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&#x00e9;" + +#: 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&#x00f3;n)" + +#: index.docbook:765 +msgid "Cache Concurrency Strategy Support" +msgstr "s&#x00ed;" + +#: index.docbook:775 +msgid "read-only" +msgstr "s&#x00ed;" + +#: index.docbook:776 +msgid "nonstrict-read-write" +msgstr "EHCache" + +#: index.docbook:777 +msgid "read-write" +msgstr "s&#x00ed;" + +#: index.docbook:778 +msgid "transactional" +msgstr "s&#x00ed;" + +#: 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&#x00f3;mo una sesi&#x00f3;n en particular interact&#x00fa;a con el cach&#x00e9; 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 &#x00ed;tems desde y escribe &#x00ed;tems hacia el cach&#x00e9; 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 &#x00ed;tems del cach&#x00e9; de segundo nivel, pero no escribe al cach&#x00e9; 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 &#x00ed;tems al cach&#x00e9; de segundo nivel, pero no lee del cach&#x00e9; 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 &#x00ed;tems al cach&#x00e9; de segundo nivel, pero no lee del cach&#x00e9; de segundo nivel, salt&#x00e1;ndose el efecto de <literal>hibernate.cache.use_minimal_puts</literal>, forzando un refresco del cach&#x00e9; de segundo nivel para todos los &#x00ed;tems le&#x00ed;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&#x00f3;n de cach&#x00e9; 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&#x00e1;s habilitar las estad&#x00ed;sticas y, opcionalmente, forzar a Hibernate para que guarde las entradas del cach&#x00e9; en un formato m&#x00e1;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&#x00e9; 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&#x00e9;n pueden tratarse en cach&#x00e9;. Esto s&#x00f3;lo es &#x00fa;til para consultas que se ejecutan frecuentemente con los mismos par&#x00e1;metros. Para usar el cach&#x00e9; 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&#x00f3;n causa la creaci&#x00f3;n de dos nuevas regiones de cach&#x00e9; - una teniendo en cach&#x00e9; conjuntos resultado de consulta (<literal>org.hibernate.cache.StandardQueryCache</literal>), el otro teniendo timestamps de las actualizaciones m&#x00e1;s recientes a tablas consultables (<literal>org.hibernate.cache.UpdateTimestampsCache</literal>). Nota que el cach&#x00e9; de consultas no pone en cach&#x00e9; el estado de las entidades reales en el conjunto resultado; s&#x00f3;lo tiene en cach&#x00e9; valores indentificadores y resultados de tipo de valor. De modo que el cach&#x00e9; de consultas siempre debe ser usado en conjunci&#x00f3;n con el cach&#x00e9; de segundo nivel." + +#: index.docbook:897 +msgid "" + "<![CDATA[Map cacheEntries = sessionFactory.getStatistics()\n" + " .getSecondLevelCacheStatistics(regionName)\n" + " .getEntries();]]>" +msgstr "La mayor&#x00ed;a de consultas no se benefician del tratamiento en cach&#x00e9;, de modo que por defecto las consultas no son tratadas en cach&#x00e9;. Para habilitar el tratamiento en cach&#x00e9;, llama a <literal>Query.setCacheable(true)</literal>. Esta llamada permite a la consulta buscar resultados existentes en cach&#x00e9; o agregar sus resultados al cach&#x00e9; 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&#x00ed;ticas de expiraci&#x00f3;n del cach&#x00e9; de consultas, puedes especificar una regi&#x00f3;n de cach&#x00e9; 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&#x00f3;n del cach&#x00e9; de consultas, debes llamar a <literal>Query.setCacheMode(CacheMode.REFRESH)</literal>. Esto es particularmente &#x00fa;til en casos donde los datos subyacentes pueden haber sido actualizados por medio de un proceso separado (es decir, no modificados a trav&#x00e9;s de Hibernate) y permite a la aplicaci&#x00f3;n refrescar selectivamente conjuntos resultado de consultas en particular. Esto es una alternativa m&#x00e1;s eficient al desahuciamiento de una regi&#x00f3;n del cach&#x00e9; de consultas v&#x00ed;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&#x00f3;n resaltaremos un par de temas m&#x00e1;s sobre c&#x00f3;mo las colecciones se comportan en tiempo de ejecuci&#x00f3;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&#x00e1;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&#x00f3;n distingue las varias tablas y relaciones de clave for&#x00e1;nea pero no nos dice absolutamente todo lo que necesitamos saber sobre el modelo relacional. Para entender completamente la estructura relacional y las caracter&#x00ed;sticas de rendimiento, debemos considerar la estructura de la clave primaria que es usada por Hibernate para actualizar o borrar filas de colecci&#x00f3;n. Esto sugiere la siguiente clasificaci&#x00f3;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>&lt;key&gt;</literal> y <literal>&lt;index&gt;</literal>. En este caso las actualizaciones de colecciones son usualmente extremadamente eficientes. La clave primaria puede ser indexada f&#x00e1;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>&lt;key&gt;</literal> y columnas de elemento. Esto puede ser menos eficiente para algunos tipos de elemento de colecci&#x00f3;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&#x00e9;ticos, es probable que s&#x00f3;lo sea tan eficiente. (Nota al m&#x00e1;rgen: si quieres que <literal>SchemaExport</literal> realmente cree la clave primaria de un <literal>&lt;set&gt;</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>&lt;idbag&gt;</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 &#x00ed;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&#x00f3;n siempre que cambia. Esto podr&#x00ed;a ser muy ineficiente." + +#: index.docbook:991 +msgid "indexed collections" +msgstr "Nota que para una asociaci&#x00f3;n uno-a-muchos, la \"clave primaria\" puede no ser la clave primaria f&#x00ed;sica de la tabla de base de datos; pero incluso en este caso, la clasificaci&#x00f3;n anterior es &#x00fa;til todav&#x00ed;a. (A&#x00fa;n refleja c&#x00f3;mo Hibernate \"localiza\" filas individuales de la colecci&#x00f3;n.)" + +#: index.docbook:994 +msgid "sets" +msgstr "Las listas, mapas, idbags y conjuntos son las colecciones m&#x00e1;s eficientes de actualizar" + +#: index.docbook:997 +msgid "bags" +msgstr "Desde la discusi&#x00f3;n anterior, debe quedar claro que las colecciones indexadas y (usualmente) los conjuntos permiten la operaci&#x00f3;n m&#x00e1;s eficiente en t&#x00e9;rminos de a&#x00f1;adir, quitar y actualizar elementos." + +#: index.docbook:1001 +msgid "All indexed collections (maps, lists, arrays) have a primary key consisting of the <literal>&lt;key&gt;</literal> and <literal>&lt;index&gt;</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&#x00e1;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&#x00e1;s, esta consideraci&#x00f3;n no se aplica a las asociaciones uno a muchos." + +#: index.docbook:1009 +msgid "Sets have a primary key consisting of <literal>&lt;key&gt;</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>&lt;set&gt;</literal> for you, you must declare all columns as <literal>not-null=\"true\"</literal>.)" +msgstr "Despu&#x00e9;s de observar que los arrays no pueden ser perezosos, podr&#x00ed;amos concluir que las listas, mapas e idbags son los tipos m&#x00e1;s eficientes de colecciones (no inversas), con los conjuntos (sets) no muy por detr&#x00e1;s. Se espera que los sets sean el tipo m&#x00e1;s com&#x00fa;n de colecci&#x00f3;n en las aplicaciones de Hibernate. Esto es debido a que la sem&#x00e1;ntica de los sets es la m&#x00e1;s natural en el modelo relacional." + +#: index.docbook:1020 +msgid "<literal>&lt;idbag&gt;</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&#x00f1;ados, usualmente vemos que la mayor&#x00ed;a de las colecciones son de hecho asociaciones uno-a-muchos con <literal>inverse=\"true\"</literal>. Para estas asociaciones, la actualizaci&#x00f3;n es manejada por el extremo muchos-a-uno de la asociaci&#x00f3;n, y las consideraciones de este tipo sobre el rendimiento de actualizaci&#x00f3;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&#x00e1;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&#x00e1;s eficientes que los conjuntos. Para una colecci&#x00f3;n con <literal>inverse=\"true\"</literal> (el idioma est&#x00e1;ndar de relaciones uno-a-muchos bidireccionales, por ejemplo) &#x00a1;podemos a&#x00f1;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&#x00f3;digo com&#x00fa;n mucho m&#x00e1;s r&#x00e1;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&#x00f3;n uno a uno puede ser extremadamente ineficiente. Hibernate no es completamente est&#x00fa;pido, de modo que sabe no hacer eso, en el caso de una colecci&#x00f3;n nueva-vac&#x00ed;a (si has llamado a <literal>list.clear()</literal>, por ejemplo). En este caso, Hibernate publicar&#x00e1; una sola <literal>DELETE</literal>, &#x00a1;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&#x00f3;n que a&#x00f1;adimos un solo elemento a una colecci&#x00f3;n de tama&#x00f1;o veinte y luego quitamos dos elementos. Hibernate publicar&#x00e1; una sentencia <literal>INSERT</literal> y dos sentencias <literal>DELETE</literal> (a menos que la colecci&#x00f3;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&#x00f3;n que quitamos dieciocho elementos, dejando dos y luego a&#x00f1;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&#x00f3;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&#x00f3;n es probablemente m&#x00e1;s r&#x00e1;pida en este caso. (Y que ser&#x00ed;a probablemente indeseable para Hibernate ser tan inteligente; este comportamiento podr&#x00ed;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&#x00f3;n original y devolviendo una colecci&#x00f3;n nuevamente instanciada con todos los elementos actuales. Esto puede ser muy &#x00fa;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&#x00f3;n no es de mucho uso sin el monitoreo y el acceso a n&#x00fa;meros de rendimiento. Hibernate provee un rango completo de figuras sobre sus operaciones internas. Las estad&#x00ed;sticas en Hibernate est&#x00e1;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&#x00e9;tricas de <literal>SessionFactory</literal> de dos formas. Tu primera opci&#x00f3;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&#x00e9;n usar JMX para publicar las m&#x00e9;tricas si habilitas el MBean <literal>StatisticsService</literal>. Puede habilitar un solo MBean para todas tus <literal>SessionFactory</literal> o una por f&#x00e1;brica. Mira el siguiente c&#x00f3;digo para ejemplos de configuraci&#x00f3;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&#x00e1;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&#x00f3;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&#x00f3;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&#x00ed;sticas pueden ser reajustadas program&#x00e1;ticamente usando el m&#x00e9;todo <literal>clear()</literal>. Puede enviarse un resumen a un logger (nivel info) usando el m&#x00e9;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&#x00e9;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&#x00fa;mero de m&#x00e9;tricas, desde informaci&#x00f3;n muy b&#x00e1;sica a la especializada s&#x00f3;lo relevante en ciertos escenarios. Todos los contadores disponibles se describen en la API de la interface <literal>Statistics</literal>, en tres categor&#x00ed;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&#x00e9;tricas relacionadas al uso general de <literal>Session</literal> usage, tales como n&#x00fa;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&#x00e9;tricas relacionadas a las entidades, colecciones, consultas, y cach&#x00e9;s como un todo. (tambi&#x00e9;n conocidas como m&#x00e9;tricas globales)." + +#: index.docbook:1185 +msgid "at configuration time, set <literal>hibernate.generate_statistics</literal> to <literal>false</literal>" +msgstr "M&#x00e9;tricas detalladas relacionadas a una entidad, colecci&#x00f3;n, consulta o regi&#x00f3;n de cach&#x00e9; 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&#x00e9;rdida, y radio de colocaci&#x00f3;n de entidades, colecciones y consultas en el cach&#x00e9;, y el tiempo promedio que necesita una consulta. Ten en cuenta que el n&#x00fa;mero de milisegundos est&#x00e1; sujeto a aproximaci&#x00f3;n en Java. Hibernate est&#x00e1; pegado a la precisi&#x00f3;n de la JVM, en algunas plataformas esto podr&#x00ed;a incuso ser tener s&#x00f3;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&#x00e9;tricas globales (es decir, no pegadas a una entidad, colecci&#x00f3;n, regi&#x00f3;n de cach&#x00e9;, etc, en particular). Puedes acceder a las m&#x00e9;tricas de una entidad, colecci&#x00f3;n, regi&#x00f3;n de cach&#x00e9; en particular a trav&#x00e9;s de su nombre, y a trav&#x00e9;s de su representaci&#x00f3;n HQL o SQL para las consultas. Por favor refi&#x00e9;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&#x00e1;s informaci&#x00f3;n. El siguiente c&#x00f3;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&#x00e9;s, puedes recuperar la lista de nombres de entidades, colecciones, consultas y regiones de cach&#x00e9;s con los siguientes m&#x00e9;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@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&#x00f3;n que implementan las entidades del problema de negocio (por ejemplo, Customer y Order en una aplicaci&#x00f3;n de comercio electr&#x00f3;nico). No todas las instancias de una clase persistente se considera que est&#x00e9;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&#x00e9;n conocidas como el modelo de programaci&#x00f3;n de Viejas Clases Java Planas (Plain Old Java Object o POJO). Sin embargo, ninguna de estas reglas son requerimientos r&#x00ed;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 &#x00e1;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&#x00ed;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&#x00ed; 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&#x00fa;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&#x00f3;n de proxies en tiempo de ejecuci&#x00f3;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&#x00ed;a llamarse cualquierCosa, y su tipo podr&#x00ed;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&#x00f3;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&#x00e1; disponible s&#x00f3;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&#x00f3;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&#x00fa;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&#x00f3;n de una interface que declare todos los m&#x00e9;todos p&#x00fa;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&#x00e1;s capaz de usar proxies para recuperaci&#x00f3;n perezosa de asociaciones, lo que limitar&#x00e1; 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&#x00e9;n evitar declarar m&#x00e9;todos <literal>public final</literal> en clases non-final. Si quieres usar una clase con un m&#x00e9;todo <literal>public final</literal>, debes deshabilitar expl&#x00ed;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&#x00e9;todos de acceso y modificaci&#x00f3;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&#x00e9;todos de acceso para todos sus campos persistente. Muchas otras herramientas ORM persisten directamente variables de instancia. Creemos que es mejor proveer una indirecci&#x00f3;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&#x00e9;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&#x00fa;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&#x00e9;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&#x00f3;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&#x00f3;lo dentro del &#x00e1;mbito de una sesi&#x00f3;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&#x00e1;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&#x00e1;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&#x00f3;lo tendremos un elemento en el <literal>Set</literal>). Desafortunadamente, no podemos usar este enfoque con identificadores generados! Hibernate s&#x00f3;lo asignar&#x00e1; valores identificadores a objetos que son persistentes, una instancia reci&#x00e9;n creada no tendr&#x00e1; ning&#x00fa;n valor identificador! Adem&#x00e1;s, si una instancia no est&#x00e1; salvada y est&#x00e1; actualmente en un <literal>Set</literal>, salvarla asignar&#x00e1; un valor identificador al objeto. Si <literal>equals()</literal> and <literal>hashCode()</literal> est&#x00e1;n basados en el valor identificador, el c&#x00f3;digo hash podr&#x00ed;a cambiar, rompiendo el contrato de! <literal>Set</literal>. Ver el sitio web de Hibernate para una discusi&#x00f3;n completa de este problema. Observa que esto no es una incidencia de Hibernate, sino la sem&#x00e1;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&#x00e9;todo <literal>equals()</literal> compara s&#x00f3;lo las propiedades que forman la clave de negocio, una clave que podr&#x00ed;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&#x00f3;lida como una clave primaria candidata de base de datos (ver <xref linkend=\"transactions-basics-identity\"/>). Las propiedades inmutables o &#x00fa;nicas son usualmente buenas candidatas para una clave de negocio." + +#: index.docbook:212 +msgid "Dynamic models" +msgstr "Modelos din&#x00e1;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&#x00e1;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&#x00f3;n. Hibernate soporta adem&#x00e1;s modelos din&#x00e1;micos (usando <literal>Map</literal>s de <literal>Map</literal>s en tiempo de ejecuci&#x00f3;n) y la representaci&#x00f3;n de entidades como &#x00e1;rboles de DOM4J. Con este enfoque no escribes clases persistentes, s&#x00f3;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&#x00f3;n de entidad por defecto para una <literal>SessionFactory</literal> en particular usando la opci&#x00f3;n de configuraci&#x00f3;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&#x00f3;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&#x00f3;n puede ser adem&#x00e1;s una entidad din&#x00e1;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&#x00e9;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&#x00f3;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&#x00e1;mico es r&#x00e1;pido tiempo de ciclo de prototipado sin la necesidad de implementaci&#x00f3;n de clases de entidad. Sin embargo, pierdes chequeo de tipos en tiempo de compilaci&#x00f3;n y muy probablemente tratar&#x00e1;s con muchas excepciones en tiempo de ejecuci&#x00f3;n. Gracias al mapeo de Hibernate, el esquema de base de datos puede estar facilmente sano y normalizado, permitiendo agregar una implementaci&#x00f3;n apropiada del modelo de dominio m&#x00e1;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&#x00f3;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&#x00e1; 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&#x00f3;n JDBC, transacci&#x00f3;n y otra informaci&#x00f3;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&#x00e9;n dejar el manejo de la transacci&#x00f3;n y de la conexi&#x00f3;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&#x00e1;s informaci&#x00f3;n sobre las capacidades de representaci&#x00f3;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@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&#x00f3;modo y consumir tiempo en los entornos de empresa de hoy. Hibernate es una herramienta de mapeo objeto/relacional para entornos Java. El t&#x00e9;rmino mapeo objeto/relacional (MOR) hace referencia a la t&#x00e9;cnica de mapear una representaci&#x00f3;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&#x00f3;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&#x00e9;n provee facilidades de consulta y recuperaci&#x00f3;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&#x00f3;n de la persistencia de los datos. Hibernate puede no ser la mejor soluci&#x00f3;n para aplicaciones que usan solamente procedimientos almacenados para implementar la l&#x00f3;gica de negocio en la base de datos, es mas &#x00fa;til con modelos de dominio orientados a objetos y l&#x00f3;gica de negocio en middle-tier basada en Java. Sin embargo, Hibernate ciertamente puede ayudarte a quitar o encapsular c&#x00f3;digo SQL espec&#x00ed;fico de vendedor y ayudar&#x00e1; con la tarea com&#x00fa;n de traducci&#x00f3;n de resultados desde una representaci&#x00f3;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&#x00f3;n de Hibernate, contiene una aplicaci&#x00f3;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&#x00ed;nea de comandos en el directorio de la distribuci&#x00f3;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&#x00f3;n de referencia como tu fuente de informaci&#x00f3;n primaria. Ten en consideraci&#x00f3;n leer <emphasis>Java Persistence with Hibernate</emphasis> (http://www.manning.com/bauer2) si necesitas mas ayuda con el dise&#x00f1;o de aplicaciones o si prefieres un tutorial paso a paso. Visita tambi&#x00e9;n http://caveatemptor.hibernate.org y descarga la aplicaci&#x00f3;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&#x00f1;o y varias soluciones de integraci&#x00f3;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&#x00e9;n proveemos un sistema de seguimiento JIRA para reportes de defectos y peticiones de nuevas caracter&#x00ed;sticas. Si estas interesado en el desarrollo de Hibernate, &#x00fa;nete a la lista de correo de desarrolladores. Si estas interesado en traducir esta documentaci&#x00f3;n a tu lenguaje, cont&#x00e1;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&#x00e9;s de JBoss Inc. (see http://www.hibernate.org/SupportTraining/) hay disponibilidad de soporte comercial de desarrollo, soporte de producci&#x00f3;n y entrenamiento en Hibernate. Hibernate es un proyecto de la suite de productos de c&#x00f3;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@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&#x00f1;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&#x00e1;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&#x00e9;todos de f&#x00e1;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&#x00f3;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&#x00e1; 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&#x00e1;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&#x00f3;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 "&#x00a1;Observa que las colecciones de gatitos tenidas por las instancias de <literal>Cat</literal> devueltas por las dos consultas previas <emphasis>no</emphasis> est&#x00e1;n prefiltradas por los criterios! Si deseas recuperar s&#x00f3;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&#x00f3;n din&#x00e1;mica de asociaciones" + +#: index.docbook:121 +msgid "You may specify association fetching semantics at runtime using <literal>setFetchMode()</literal>." +msgstr "Puedes especificar la sem&#x00e1;ntica de recuperaci&#x00f3;n de asociaciones en tiempo de ejecuci&#x00f3;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&#x00e1; tanto <literal>mate</literal> como <literal>kittens</literal> por uni&#x00f3;n exterior (outer join). Ver <xref linkend=\"performance-fetching\"/> para m&#x00e1;s informaci&#x00f3;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&#x00f3;n, los identificadores y las asociaciones son ignorados. Por defecto, las propiedades valuadas a nulo son exclu&#x00ed;das." + +#: index.docbook:150 +msgid "You can adjust how the <literal>Example</literal> is applied." +msgstr "Puedes ajustar c&#x00f3;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&#x00f3;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&#x00e1;brica de instancias de <literal>Projection</literal>. Aplicamos una proyecci&#x00f3;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&#x00ed;cito en una consulta por criterios. Ciertos tipos de proyecciones son definidos para ser <emphasis>proyecciones agrupadas</emphasis>, que adem&#x00e1;s aparecen en la cl&#x00e1;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&#x00f3;n, de modo que el valor proyectado pueda ser referido en restricciones u ordenamientos. Aqu&#x00ed; 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&#x00e9;todos <literal>alias()</literal> y <literal>as()</literal> simplemente envuelven una instancia de proyecci&#x00f3;n en otra instancia de <literal>Projection</literal> con alias. Como un atajo, puedes asignar un alias cuando agregas la proyecci&#x00f3;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&#x00e9;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 &#x00e1;mbito de una sesi&#x00f3;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&#x00e9;n una <literal>DetachedCriteria</literal> puede usarse para expresar una subconsulta. Las instancias de Criterion implicando subconsultas pueden obtenerse v&#x00ed;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&#x00ed;a de consultas, incluyendo las consultas por criterios, el cach&#x00e9; de consulta no es muy eficiente, debido a que la invalidaci&#x00f3;n del cach&#x00e9; de consulta ocurre demasiado frecuentemente. Sin embargo, hay un tipo especial de consulta donde podemos optimizar el algoritmo de invalidaci&#x00f3;n de cach&#x00e9;: búsquedas por una clave natural constante. En algunas aplicaciones, este tipo de consulta, ocurre frecuentemente. La API de criterios brinda especial provisi&#x00f3;n para este caso de uso." + +#: index.docbook:255 +msgid "First, you should map the natural key of your entity using <literal>&lt;natural-id&gt;</literal>, and enable use of the second-level cache." +msgstr "Primero, debes mapear la clave natural de tu entidad usando <literal>&lt;natural-id&gt;</literal>, y habilitar el uso del cach&#x00e9; 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&#x00e1; 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&#x00e9; 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&#x00e9; m&#x00e1;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@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&#x00e1; equipado con un lenguaje de consulta extremadamente potente que (intencionalmente en absoluto) se parece much&#x00ed;simo a SQL. Pero no te enga&#x00f1;es por la sintaxis; HQL es completamente orientado a objetos, entendiendo nociones como herencia, polimorfismo y asociaci&#x00f3;n." + +#: index.docbook:14 +msgid "Case Sensitivity" +msgstr "Sensibilidad a May&#x00fa;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&#x00fa;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&#x00fa;sculas. Algunos usuarios encuentran las consultas con palabras clave en may&#x00fa;sculas m&#x00e1;s le&#x00ed;bles, pero encontramos esta convenci&#x00f3;n fea cuando se encaja en c&#x00f3;digo Java." + +#: index.docbook:35 +msgid "The from clause" +msgstr "La cl&#x00e1;usula from" + +#: index.docbook:37 +msgid "The simplest possible Hibernate query is of the form:" +msgstr "La consulta m&#x00e1;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&#x00e1; 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&#x00ed;a del tiempo, necesitar&#x00e1;s asignar un <emphasis>alias</emphasis>, ya que querr&#x00e1;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&#x00ed;amos usar ese alias luego en la consulta. La palabra clave <literal>as</literal> es opcional; tambi&#x00e9;n podr&#x00ed;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&#x00fa;ltiples clases, resultando en un producto cartesiano o uni&#x00f3;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&#x00e1;ctica el nombrar los alias de consulta usando una inicial en min&#x00fa;sculas, consistente con los est&#x00e1;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&#x00e9;n asignar aliases a entidades asociadas, e incluso a elementos de una colecci&#x00f3;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 &#x00fa;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&#x00f3;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&#x00f3;n, un \"fetch\" join permite a las asociaciones o colecciones de valores ser inicializadas junto a sus objetos padres, usando una sola selecci&#x00f3;n. Esto es particularmente &#x00fa;til en el case de una colecci&#x00f3;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&#x00e1;s informaci&#x00f3;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&#x00e1;rsele un alias, porque los objetos asociados no deben ser usados en la cl&#x00e1;usula <literal>where</literal> (ni en cualquier otra cl&#x00e1;usula). Adem&#x00e1;s, los objetos asociados no son devueltos directamente en los resultados de consulta. En cambio, pueden ser accedidos v&#x00ed;a el objeto padre. La &#x00fa;nica raz&#x00f3;n por la que necesitar&#x00ed;amos un alias es estamos uniendo recursivamente otra colecci&#x00f3;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&#x00f3;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&#x00f3;n <literal>with</literal> ad hoc. Es posible crear un producto cartesiano trayendo por join m&#x00e1;s de una colecci&#x00f3;n en una colecci&#x00f3;n, as&#x00ed; que ten cuidado en este caso. Traer por join m&#x00fa;ltiples roles de colecci&#x00f3;n tambi&#x00e9;n da a veces resultados inesperados para mapeos de bag, as&#x00ed; que s&#x00e9; cuidadoso sobre c&#x00f3;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&#x00e1;s usando recuperaci&#x00f3;n perezosa a nivel de propiedad (con instrumentaci&#x00f3;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&#x00e1;usula select" + +#: index.docbook:186 +msgid "HQL supports two forms of association joining: <literal>implicit</literal> and <literal>explicit</literal>." +msgstr "La cl&#x00e1;usula <literal>select</literal> escoge qu&#x00e9; 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&#x00e1; <literal>mate</literal>s de otros <literal>Cat</literal>s. Realmente, puedes expresar esta consulta en un forma m&#x00e1;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&#x00fa;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&#x00e1;s &#x00fa;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&#x00f3;n" + +#: index.docbook:273 +msgid "or as a <literal>List</literal>," +msgstr "Las consultas HQL pueden incluso devolver resultados de funciones de agregaci&#x00f3;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&#x00f3;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&#x00e9;ticos, concatenaci&#x00f3;n, y funciones SQL reconocidas en la cl&#x00e1;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&#x00e1;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&#x00f3;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&#x00f3;lo de <literal>Cat</literal>, sino tambi&#x00e9;n de subclases como <literal>DomesticCat</literal>. Las consultas de Hibernate pueden mencionar <emphasis>cualquier</emphasis> clase o interface Java en la cl&#x00e1;usula <literal>from</literal>. La consulta devolver&#x00e1; instancias de todas las clases persistentes que extiendan esa clase o implementen la interface. La siguiente consulta devolver&#x00ed;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&#x00ed;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 &#x00fa;ltimas consultas requerir&#x00e1;n m&#x00e1;s de un <literal>SELECT</literal> SQL. Esto significa que la cl&#x00e1;usula <literal>order by</literal> no ordenar&#x00e1; correctamente todo el conjunto resultado. (Significa adem&#x00e1;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&#x00e1;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&#x00e1;usula where te permite estrechar la lista de instancias devueltas. Si no existe ning&#x00fa;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&#x00e1; 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&#x00e1;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&#x00f3;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&#x00ed;as con una consulta que requerir&#x00ed;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&#x00f3;lo propiedades, sino tambi&#x00e9;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&#x00fa;sculas) <literal>id</literal> puede ser usada para referenciar el identificador &#x00fa;nico de un objeto. (Tambi&#x00e9;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. &#x00a1;No se requiere ninguna uni&#x00f3;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&#x00e9;n pueden ser usadas las propiedades de identificadores compuestos. Sup&#x00f3;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&#x00e1;s, la segunda consulta no requiere ninguna uni&#x00f3;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&#x00f3;rfica. Un nombre de clase Java embebido en la cl&#x00e1;usula where ser&#x00e1; 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&#x00e9;n especificar propiedades de componentes o tipos compuestos de usuario (y de componentes de componentes, etc). Nunca intentes usar una expresi&#x00f3;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&#x00e9;ndonos expresar un join en la siguiente forma (donde <literal>AuditLog.item</literal> es una propiedad mapeada con <literal>&lt;any&gt;</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&#x00ed;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&#x00e1;usula <literal>where</literal> incluyen la mayor&#x00ed;a del tipo de cosas que podr&#x00ed;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&#x00e1;ticos <literal>+, -, *, /</literal>" + +#: index.docbook:475 +msgid "Once again, the second query requires no table join." +msgstr "operadores de comparaci&#x00f3;n binarios <literal>=, &gt;=, &lt;=, &lt;&gt;, !=, 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&#x00f3;gicos <literal>and, or, not</literal>" + +#: index.docbook:485 +msgid "<![CDATA[from Cat cat where cat.class = DomesticCat]]>" +msgstr "Par&#x00e9;ntesis <literal>( )</literal>, indicando agrupaci&#x00f3;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>&lt;any&gt;</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&#x00f3;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&#x00f3;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>=, &gt;=, &lt;=, &lt;&gt;, !=, like</literal>" +msgstr "<literal>str()</literal> para convertir valores num&#x00e9;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&#x00f3;n <literal>index()</literal> de HQL, que se aplica a alias de una colecci&#x00f3;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&#x00f3;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&#x00e1;metros posicionales JDBC <literal>?</literal>" + +#: index.docbook:561 +msgid "<literal>current_date()</literal>, <literal>current_time()</literal>, <literal>current_timestamp()</literal>" +msgstr "par&#x00e1;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&#x00e1;cilmente usados en expresiones declarando substituciones de consulta HQL en la configuraci&#x00f3;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&#x00e1; 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&#x00f1;o de una colecci&#x00f3;n con la propiedad especial <literal>size</literal>, o la funci&#x00f3;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 &#x00ed;ndices m&#x00e1;ximo y m&#x00ed;nimo usando las funciones <literal>minindex</literal> y <literal>maxindex</literal>. Similarmente, puedes referirte a los elementos m&#x00e1;ximo y m&#x00ed;nimo de una colecci&#x00f3;n de tipo b&#x00e1;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&#x00e1;n soportadas cuando se les pasa el conjunto de elementos o &#x00ed;ndices de una colecci&#x00f3;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&#x00e1;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 &#x00ed;ndice (en una cl&#x00e1;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&#x00f3;n dentro de <literal>[]</literal> puede incluso ser una expresi&#x00f3;n aritm&#x00e9;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&#x00e1;s el funci&#x00f3;n prefabricada <literal>index()</literal>, para elementos de una asociaci&#x00f3;n uno-a-muchos o colecci&#x00f3;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&#x00fa;n no est&#x00e1;s convencido de todo esto, piensa cu&#x00e1;nto m&#x00e1;s largo y menos le&#x00ed;ble ser&#x00ed;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&#x00e1;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&#x00e1;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&#x00e9;n una cl&#x00e1;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&#x00f3;n SQL est&#x00e1;n permitidas en las cl&#x00e1;usulas <literal>having</literal> y <literal>order by</literal>, si est&#x00e1;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&#x00e1;usula <literal>group by</literal> ni la cl&#x00e1;usula <literal>order by</literal> pueden contener expresiones aritm&#x00e9;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&#x00e9;ntesis (frecuentemente por una llamada a una funci&#x00f3;n de agregaci&#x00f3;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&#x00e1;s de una expresi&#x00f3;n en la lista de selecci&#x00f3;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&#x00e1;s verborr&#x00e1;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&#x00ed;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&#x00ed; algunos consultas de ejemplo muy similares a consultas que he usado en un proyecto reciente. &#x00a1;Nota que la mayor&#x00ed;a de las consultas que escribir&#x00e1;s som mucho m&#x00e1;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&#x00fa;mero de items y valor total de la orden para todas las ordenes inpagas de un cliente en particular y valor total m&#x00ed;nimo dados, ordenando los resultados por valor total. Al determinar los precios, usa el cat&#x00e1;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 "&#x00a1;Qu&#x00e9; 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&#x00f3;xima consulta cuenta el n&#x00fa;mero de pagos en cada estado, excluyendo todos los pagos en el estado <literal>AWAITING_APPROVAL</literal> donde el estado m&#x00e1;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&#x00f3;n <literal>statusChanges</literal> como una lista, en vez de un conjunto, la consulta habr&#x00ed;a sido mucho m&#x00e1;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&#x00f3;xima consulta usa la funci&#x00f3;n <literal>isNull()</literal> de MS SQL Server para devolver todas las cuentas y pagos inpagos de la organizaci&#x00f3;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&#x00ed;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&#x00fa;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&#x00f1;o de una colecci&#x00f3;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&#x00f3;n sobre el tama&#x00f1;o de selecci&#x00f3;n en la cl&#x00e1;usula where de tu consulta:" + +#: index.docbook:924 +msgid "Tips &amp; 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&#x00f3;n no puede devolver un <literal>User</literal> con cero mensajes debido a la uni&#x00f3;n interior, la siguiente forma es tambi&#x00e9;n &#x00fa;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&#x00e1;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&#x00f3;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&#x00f1;o de una colecci&#x00f3;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@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&#x00e9;n expresar consultas en el dialecto SQL nativo de tu base de datos. Esto es &#x00fa;til si quieres utilizar aspectos espec&#x00ed;ficos de base de datos tal como consejos (hints) de consulta o la palabra clave <literal>CONNECT</literal> en Oracle. Provee adem&#x00e1;s una clara ruta de migraci&#x00f3;n desde una aplicaci&#x00f3;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&#x00f3;n, actualizaci&#x00f3;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&#x00e9;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&#x00e9;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&#x00ed;a devolver un valor escalar simple o una combinaci&#x00f3;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&#x00f3;n <literal>{cat.*}</literal> usada arriba es un atajo para \"todas las propiedades\". Alternativamente, puedes listar las columnas expl&#x00ed;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&#x00f3;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&#x00ed;amos incluso usar los alias de propiedad en la cl&#x00e1;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&#x00e1;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&#x00ed;citamente, &#x00a1;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>&lt;return-scalar&gt;</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&#x00ed;citamente nombres de columna/alias" + +#: index.docbook:115 +msgid "This will allow cat.getDog() to function properly." +msgstr "Con <literal>&lt;return-property&gt;</literal> puedes decirle expl&#x00ed;citamente a Hibernate qu&#x00e9; alias de columna usar, en vez de usar la sint&#x00e1;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>&lt;return-property&gt;</literal> tambi&#x00e9;n trabaja con m&#x00fa;ltiples columnas. Esto resuelve una limitaci&#x00f3;n de la sint&#x00e1;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>&lt;return-property&gt;</literal> en combinaci&#x00f3;n con la sint&#x00e1;xis <literal>{}</literal> para inyecci&#x00f3;n, permitiendo a los usuarios elejir c&#x00f3;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>&lt;return-discriminator&gt;</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&#x00ed;a procedimientos almacenados. Los procedimientos almacenados deben devolver un conjunto resultado como el primer par&#x00e1;metro de salida para ser capaces de funcionar con Hibernate. Un ejemplo de uno procedimiento almacenado en Oracle 9 o superior es as&#x00ed;:" + +#: 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&#x00f3;lo devuelven escalares y entidades. No est&#x00e1;n soportados <literal>&lt;return-join&gt;</literal> y <literal>&lt;load-collection&gt;</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&#x00fa;n quisieras usar estos procedimientos tendr&#x00ed;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&#x00e1;nticas/sint&#x00e1;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(&lt;parameters&gt;) }</literal> o <literal>{ ? = call procName }</literal> (esto es m&#x00e1;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&#x00e1;n m&#x00fa;ltiples conjuntos resultados y cuentas de actualizaci&#x00f3;n, Hibernate iterar&#x00e1; los resultados y tomar&#x00e1; el primer resultado que sea un conjunto resultado como su valor a devolver. Todo lo dem&#x00e1;s ser&#x00e1; 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&#x00e1; probablemente m&#x00e1;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&#x00f3;n (insertsql, deletesql, updatesql, etc.). Las etiquetas de mapeo <literal>&lt;sql-insert&gt;</literal>, <literal>&lt;sql-delete&gt;</literal>, y <literal>&lt;sql-update&gt;</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&#x00e1;, por supuesto, la portabilidad de tu mapeo si usas SQL espec&#x00ed;fico de la base de datos." + +#: index.docbook:223 +msgid "Example" +msgstr "Los procedimientos almacenados son soportados si est&#x00e1; 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&#x00e1;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&#x00f3;n para el nivel <literal>org.hibernate.persister.entity</literal>. Con este nivel habilitado, Hibernate imprimir&#x00e1; el SQL est&#x00e1;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&#x00e1;n el sql est&#x00e1;tico generado por Hibernate.)" + +#: index.docbook:237 +msgid "A composite property" +msgstr "Los procedimientos almacenados son, en la mayor&#x00ed;a de los casos (l&#x00e9;ase, mejor hacerlo que no hacerlo), obligados a devolver el n&#x00fa;mero de filas insertadas/actualizadas/borradas, ya que Hibernate tiene algunas comprobaciones en tiempo de ejecuci&#x00f3;n del &#x00e9;xito de la sentencia. Hibernate siempre registra el primer par&#x00e1;metro de la sentencia como un par&#x00e1;metro de salida num&#x00e9;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&#x00e9;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&#x00f3;lo una declaraci&#x00f3;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&#x00ed;as incluso definir un cargador de entidades que cargue una colecci&#x00f3;n por recuperaci&#x00f3;n por uni&#x00f3;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>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</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>&lt;return-scalar&gt;</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>&lt;resultset&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-discriminator&gt;</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>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</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(&lt;parameters&gt;) }</literal> or <literal>{ ? = call procedureName(&lt;parameters&gt;}</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>&lt;sql-insert&gt;</literal>, <literal>&lt;sql-delete&gt;</literal>, and <literal>&lt;sql-update&gt;</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@ADDRESS>\n" +"Content-Type: text/plain; charset=utf-8\n" +#: index.docbook:5 +msgid "appended paragraph 1" +msgstr "Comienzo r&#x00e1;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&#x00f3;n de Hibernate con el contenedor de servlets Apache Tomcat (hemos usado la versi&#x00f3;n 4.1, las diferencias con la 5.0 deben ser m&#x00ed;nimas) para una aplicaci&#x00f3;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&#x00f3;lo una cuesti&#x00f3;n de cambiar la configuraci&#x00f3;n del dialecto SQL de Hibernate y las propiedades de conexi&#x00f3;n." + +#: index.docbook:21 +msgid "appended paragraph 4" +msgstr "Primero, tenemos que copiar todas las bibliotecas requeridas a la instalaci&#x00f3;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&#x00fa;squeda de bibliotecas global (<literal>TOMCAT/common/lib</literal>) como tambi&#x00e9;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&#x00e1;s dentro de la ruta del cargador de clases global en Tomcat, o tendr&#x00e1;s problemas con varias herramientas, incluyendo Log4J, commons-logging y otras. Siempre usa el classpath de contexto para cada aplicaci&#x00f3;n web, esto es, copia las bibliotecas a <literal>WEB-INF/lib</literal> y tus propias clases y ficheros de configuraci&#x00f3;n/propiedades a <literal>WEB-INF/classes</literal>. Ambos directorios est&#x00e1;n a nivel del classpath de contexto por defecto." + +#: index.docbook:62 +msgid "appended paragraph 8" +msgstr "Hibernate est&#x00e1; 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&#x00f3;n. Hibernate requiere algunas bibliotecas de terceros en tiempo de ejecuci&#x00f3;n; &#x00e9;stas vienen inclu&#x00ed;das con la distribuci&#x00f3;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&#x00f3;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&#x00e9;n se necesita en tiempo de ejecuci&#x00f3;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&#x00f3;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&#x00f3;n de c&#x00f3;digo para aumentar las clases en tiempo de ejecuci&#x00f3;n (en combinaci&#x00f3;n con reflecci&#x00f3;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&#x00e9; para el cach&#x00e9; de segundo nivel. EHCache es el provedor de cach&#x00e9; por defecto si no se cambia en la configuraci&#x00f3;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&#x00e1; disponible en el directorio de bibliotecas del contexto, Commons Logging usar&#x00e1; Log4J y la configuraci&#x00f3;n <literal>log4j.properties</literal> en el classpath de contexto. Un fichero de propiedades de ejemplo para Log4J se incluye con la distribuci&#x00f3;n de Hibernate. As&#x00ed; que copia log4j.jar y el fichero de configuraci&#x00f3;n (de <literal>src/</literal>) a tu classpath de contexto si quieres ver que ocurre tras esc&#x00e9;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&#x00f3;n de Hibernate. Esta es una lista actualizada de bibliotecas de terceros distribu&#x00ed;das con Hibernate. Encontrar&#x00e1;s listadas ah&#x00ed; todas las bibliotecas requeridas y opcionales (Observa que \"buildtame required\" significa aqu&#x00ed; para la construcci&#x00f3;n de Hibernate, no de tu aplicaci&#x00f3;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&#x00e1; conexiones JDBC en pool (usando su funcionalidad prefabricada de pooling DBCP). Hibernate pide esas conexiones a trav&#x00e9;s de JNDI. Alternativamente, puedes dejar que Hibernate maneje el pool de conexiones. Tomcat liga su pool de conexiones a JNDI; agregamos una declaraci&#x00f3;n de recurso al fichero de configuraci&#x00f3;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&#x00e9;n ir m&#x00e1;s all&#x00e1; y crear ahora un servlet simple que tenga un m&#x00e9;todo <literal>process()</literal> vac&#x00ed;o." + +#: index.docbook:196 +msgid "appended paragraph 29" +msgstr "Tomcat provee ahora conexiones a trav&#x00e9;s de JNDI en <literal>java:comp/env/jdbc/quickstart</literal>. Si tienes problemas obteniendo el pool de conexiones en ejecuci&#x00f3;n, refi&#x00e9;rete a la documentaci&#x00f3;n de Tomcat. Si obtienes mensajes de excepci&#x00f3;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&#x00f3;ximo paso es configurar Hibernate. Hibernate tiene que saber c&#x00f3;mo debe obtener conexiones JDBC. Usamos la configuraci&#x00f3;n de Hibernate basada en XML. El otro enfoque, usando un ficheros de propiedad, es casi equivalente pero pierde unas pocas funcionalidades que s&#x00ed; permite la sintaxis XML. El fichero de configuraci&#x00f3;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&#x00e9; dialecto SQL de base de datos se usa y d&#x00f3;nde obtener conexiones JDBC (declarando la direcci&#x00f3;n JNDI del pool ligado a Tomcat). El dialecto es una configuraci&#x00f3;n requerida, las bases de datos difieren en su interpretaci&#x00f3;n del \"est&#x00e1;ndar\" de SQL. Hibernate cuidar&#x00e1; de las diferencias y viene con dialectos inclu&#x00ed;dos para todas las principales bases de datos comerciales y de c&#x00f3;digo abierto." + +#: index.docbook:227 +msgid "appended paragraph 33" +msgstr "Una <literal>SessionFactory</literal> es el concepto de Hibernate de un almac&#x00e9;n de datos solo. Pueden usarse m&#x00fa;ltiples bases de datos creando m&#x00fa;ltiples ficheros de configuraci&#x00f3;n XML y creando m&#x00fa;ltiples objetos <literal>Configuration</literal> y <literal>SessionFactory</literal> en tu aplicaci&#x00f3;n." + +#: index.docbook:235 +msgid "appended paragraph 34" +msgstr "El &#x00fa;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&#x00f3;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&#x00ed;a m&#x00e9;todos getter y setter, encapsulando la representaci&#x00f3;n interna de la interfaz publicamente visible (Hibernate puede tambi&#x00e9;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&#x00e1; 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&#x00f3;lo internamente, pero perder&#x00ed;amos algo de la flexibilidad en nuestra arquitectura de aplicaci&#x00f3;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&#x00ed;z en especial. Hibernate tampoco requiere ning&#x00fa;n procesamiento en tiempo de construcci&#x00f3;n, como manipulaci&#x00f3;n del byte-code. Se basa solamente en reflecci&#x00f3;n de Java y aumentaci&#x00f3;n de clases en tiempo de ejecuci&#x00f3;n (a trav&#x00e9;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&#x00f3;n de clases persistentes y el mapeo de propiedades (a columnas y relaciones de claves for&#x00e1;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&#x00f3;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&#x00f3;n). Usamos el generador UUID (recomendado s&#x00f3;lo para pruebas, pues deben preferirse las claves enteras delegadas generadas por la base de datos) y tambi&#x00e9;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&#x00e1;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&#x00f3;n expl&#x00ed;cita de columna de base de datos. Esto es especialmente &#x00fa;til cuando el esquema de base de datos es generado autom&#x00e1;ticamente (como sentencias DDL de SQL) desde la declaraci&#x00f3;n de mapeo con la herramienta <emphasis>SchemaExport</emphasis> de Hibernate. Todas las dem&#x00e1;s propiedades son mapeadas usando la configuraci&#x00f3;n por defecto de Hibernate, que es lo que necesitas la mayor&#x00ed;a del tiempo. La tabla <literal>CAT</literal> en la base de datos se ve as&#x00ed; 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&#x00f3;n de tablas, restricciones personalizadas de tipo de columnas, restricciones de unicidad e &#x00ed;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&#x00f3;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&#x00f3;nde creamos la <literal>SessionFactory</literal> y c&#x00f3;mo accedemos a ella en nuestra aplicaci&#x00f3;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&#x00e9;n que no debes mantenerla en una variable de instancia en tus servlets, sino en alguna otro sitio. Adem&#x00e1;s, necesitamos alg&#x00fa;n tipo de <emphasis>Singleton</emphasis>, de modo que podamos acceder a la <literal>SessionFactory</literal> f&#x00e1;cilmente en el c&#x00f3;digo de aplicaci&#x00f3;n. El siguiente enfoque mostrado resuelve ambos problemas: configuraci&#x00f3;n de arranque y f&#x00e1;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&#x00f3;lo cuida de la <literal>SessionFactory</literal> con su inicializador static, sino que adem&#x00e1;s tiene una variable <literal>ThreadLocal</literal> que tiene la <literal>Session</literal> para la hebra actual. Aseg&#x00fa;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&#x00e1;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&#x00e1; completo. Un ejemplo en el m&#x00e9;todo <literal>process()</literal> de tu servlet podr&#x00ed;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&#x00f3;n de base de datos ocurre dentro de una transacci&#x00f3;n que a&#x00ed;sla las operaciones de base de datos (incluso operaciones de s&#x00f3;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&#x00f3;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&#x00e1;s la <literal>Session</literal> actual de esta hebra. Tienes que asegurarte que la <literal>Session</literal> sea cerrada despu&#x00e9;s que se complete tu unidad-de-trabajo, ya sea en c&#x00f3;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&#x00f3;n es la f&#x00e1;cil inicializaci&#x00f3;n perezosa: la <literal>Session</literal> todav&#x00ed;a est&#x00e1; 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&#x00e9;todos que pueden ser usados para traer objetos desde la base de datos. La forma m&#x00e1;s flexible es usando el Lenguaje de Consulta de Hibernate (Hibernate Query Language o HQL), que es una extensi&#x00f3;n orientada a objetos de SQL f&#x00e1;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&#x00e9;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&#x00e1;metros para toda la comunicaci&#x00f3;n SQL con la base de datos. Tambi&#x00e9;n puedes usar la funcionalidad de consulta SQL directa de Hibernate u obtener una conexi&#x00f3;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&#x00f1;amos solamente la superficie de Hibernate en este peque&#x00f1;o tutorial. Por favor, observa que no incluimos ning&#x00fa;n c&#x00f3;digo espec&#x00ed;fico de servlet en nuestros ejemplos. Tienes que crear un servlet por t&#x00ed; mismo e insertar el c&#x00f3;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&#x00e1; firmemente integrado dentro de tu aplicaci&#x00f3;n. Usualmente, todas las otras capas dependen del mecanismo de persistencia. Aseg&#x00fa;rate de entender las implicaciones de este dise&#x00f1;o." + +#: index.docbook:468 +msgid "appended paragraph 65" +msgstr "Para un ejemplo de aplicaci&#x00f3;n m&#x00e1;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@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&#x00f3;n completa de mapeo objeto/relacional que no s&#x00f3;lo abstrae al desarrollador de los detalles del sistema de manejo de base datos subyacente, sino que adem&#x00e1;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&#x00f3;n de sentencias SQL. Esta parte es cuidada por Hibernate y es s&#x00f3;lo relevante para el desarrollador de la aplicaci&#x00f3;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&#x00e9;n instanciado usando el operador <literal>new</literal>, y no est&#x00e1; asociado a una <literal>Session</literal> de Hibernate. No tiene una representaci&#x00f3;n persistente en la base de datos y no se le ha asignado un valor identificador. Las instancias transitorias ser&#x00e1;n destru&#x00ed;das por el recolector de basura si la aplicaci&#x00f3;n no mantiene m&#x00e1;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&#x00f3;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&#x00f3;n en la base de datos y un valor identificador. Puede haber sido salvado o cargado, sin embargo, est&#x00e1; por definici&#x00f3;n en el &#x00e1;mbito de una <literal>Session</literal>. Hibernate detectar&#x00e1; cualquier cambio hecho a un objeto en estado persistentey sincronizar&#x00e1; 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&#x00ed;a es v&#x00e1;lida, por supuesto, y la instancia separada podr&#x00ed;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&#x00e9;ndola persistente de nuevo (con todas las modificaciones). Este aspecto habilita un modelo de programaci&#x00f3;n para unidades de trabajo de ejecuci&#x00f3;n larga que requieren tiempo-para-pensar del usuario. Las llamamos <emphasis>transaccciones de aplicaci&#x00f3;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&#x00e9;todos de Hibernate que disparan una transici&#x00f3;n) en m&#x00e1;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&#x00e9;n instanciadas de una clase persistente son consideradas <emphasis>transitorias</emphasis> por Hibernate. Podemos hacer una instancia transitoria <emphasis>persistente</emphasis> asoci&#x00e1;ndola con una sesi&#x00f3;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&#x00e9;n usar <literal>persist()</literal> en vez de <literal>save()</literal>, con la sem&#x00e1;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&#x00f3;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&#x00f3;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&#x00f3;n <literal>NOT NULL</literal> sobre una columna clave for&#x00e1;nea. Nunca hay riesgo de violar restricciones de clave for&#x00e1;nea. Sin embargo, podr&#x00ed;as violar una restricci&#x00f3;n <literal>NOT NULL</literal> si llamas a <literal>save()</literal> sobre objetos en orden err&#x00f3;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&#x00e1;s la funcionalidad de <emphasis>persistencia transitiva</emphasis> de Hibernate para salvar los objetos asociados autom&#x00e1;ticamente. Entonces, ni siquiera ocurren violaciones de restricciones <literal>NOT NULL</literal> - Hibernate cuidar&#x00e1; de todo. La persistencia transitiva se discute m&#x00e1;s adelante en este cap&#x00ed;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&#x00e9;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&#x00e1; el estado dentro de una instancia reci&#x00e9;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&#x00e1; una excepci&#x00f3;n irrecuperable si no hay una fila correspondiente en base de datos. Si la clase es mapeada con un proxy, <literal>load()</literal> s&#x00f3;lo devuelve un proxy no inicializado y no llamar&#x00e1; realmente a la base de datos hasta que invoques un m&#x00e9;todo del proxy. Este comportamiento es muy &#x00fa;til si deseas crear una asociaci&#x00f3;n a un objeto sin cargarlo realmente de la base de datos. Permite adem&#x00e1;s que m&#x00fa;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&#x00e9;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&#x00f3;n de la API para m&#x00e1;s informaci&#x00f3;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&#x00f3;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&#x00f3;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&#x00e9;todo <literal>refresh()</literal>. Esto es &#x00fa;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&#x00f3;n importante aparece usualmente en este punto: ¿Cu&#x00e1;nto carga Hibernate de la base de datos y cu&#x00e1;ntos <literal>SELECT</literal>s de SQL usar&#x00e1;? Esto depende de la <emphasis>estrategia de recuperaci&#x00f3;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&#x00e1;s buscando, necesitas una consulta. Hibernate soporta un lenguaje de consulta orientado a objetos (HQL) f&#x00e1;cil de usar pero potente. Para la creaci&#x00f3;n de consultas program&#x00e1;ticas, Hibernate soporta una funcionalidad sofisticada de consulta de Criteria y Example (QBC and QBE). Tambi&#x00e9;n puedes expresar tu consulta en el SQL nativo de tu base de datos, con soporte opcional de Hibernate para la conversi&#x00f3;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&#x00e9;todos para la ligaci&#x00f3;n de par&#x00e1;metros, manejo del conjunto resultado, y para la ejecuci&#x00f3;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&#x00e1; cargado completamente dentro de una colecci&#x00f3;n en memoria. Las instancias de entidad tra&#x00ed;das por una consulta est&#x00e1;n en estado persistente. El m&#x00e9;todo <literal>uniqueResult()</literal> ofrece un atajo si sabes que tu consulta devolver&#x00e1; s&#x00f3;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&#x00ed;as ser capaz de lograr mejor rendimiento al ejecutar la consulta usando el m&#x00e9;todo <literal>iterate()</literal>. Esto s&#x00f3;lo ser&#x00e1; en el caso que esperes que las instancias reales de entidad devueltas por la consulta est&#x00e9;n ya en la sesi&#x00f3;n o cach&#x00e9; de segundo nivel. Si todav&#x00ed;a no est&#x00e1;n en cach&#x00e9;, <literal>iterate()</literal> ser&#x00e1; m&#x00e1;s lento que <literal>list()</literal> y podr&#x00ed;a requerir muchas llamadas a la base de datos para una consulta simple, usualmente <emphasis>1</emphasis> para la selecci&#x00f3;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&#x00e1;usula <literal>select</literal>. Pueden incluso llamar a funciones de agregaci&#x00f3;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&#x00f3;n de par&#x00e1;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&#x00e9;todos en <literal>Query</literal> para ligar valores a par&#x00e1;metros con nombre o par&#x00e1;metros <literal>?</literal> de estilo JDBC. <emphasis>Al contrario de JDBC, Hibernate numera los par&#x00e1;metros desde cero.</emphasis> Los par&#x00e1;metros con nombre son identificadores de la forma <literal>:name</literal> en la cadena de la consulta. Las ventajas de los par&#x00e1;metros con nombre son:" + +#: index.docbook:297 +msgid "Bind parameters" +msgstr "los par&#x00e1;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&#x00fa;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&#x00f3;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&#x00ed;mites sobre tu conjunto resultado (el n&#x00fa;mero m&#x00e1;ximo de filas que quieras traer y/o la primera fila que quieras traer) debes usar los m&#x00e9;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&#x00f3;mo traducir este l&#x00ed;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&#x00f3;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&#x00f3;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&#x00f3;n de base de datos abierta (y cursor) para esta funcionalidad, usa <literal>setMaxResult()</literal>/<literal>setFirstResult()</literal> si necesitas la funcionalidad de paginaci&#x00f3;n fuera de l&#x00ed;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&#x00e1;s definir consultas con nombre en el documento de mapeo. (Recuerda usar una secci&#x00f3;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&#x00f3;n de par&#x00e1;metros y ejecuci&#x00f3;n se hace program&#x00e1;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&#x00f3;digo real del programa es independiente del lenguaje de consulta usado; puedes adem&#x00e1;s definir consultas SQL nativas en metadatos, o migrar consultas existentes a Hibernate coloc&#x00e1;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&#x00f3;n es un tipo especial de consulta que puede ser aplicado a una colecci&#x00f3;n persistente o array. La cadena de consulta puede referirse a <literal>this</literal>, significando el elemento de colecci&#x00f3;n actual." + +#: index.docbook:395 +msgid "Also note that a query declaration inside a <literal>&lt;hibernate-mapping&gt;</literal> element requires a global unique name for the query, while a query declaration inside a <literal>&lt;class&gt;</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&#x00f3;n devuelta es considerada un bag, y es una copia de la colecci&#x00f3;n dada. La colecci&#x00f3;n original no es modificada (esto es contrario a la implicaci&#x00f3;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&#x00e1;usula <literal>from</literal> (aunque pueden tener uno si se requiere). Los filtros no est&#x00e1;n limitados a devolver los elementos de colecci&#x00f3;n por s&#x00ed; 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&#x00ed;o es &#x00fa;til, por ejemplo, para cargar un subconjunto de elementos en una colecci&#x00f3;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&#x00e1;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&#x00e1;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&#x00e1;metros con nombre y posicionales, al igual que las consultas de Hibernate. Puede encontrarse m&#x00e1;s informaci&#x00f3;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&#x00f3;n y cualquier cambio al estado persistente ser&#x00e1; persistido cuando la <literal>Session</literal> sea <emphasis>limpiada (flushed)</emphasis> (discutido m&#x00e1;s adelante en este cap&#x00ed;tulo). No hay necesidad de llamar un m&#x00e9;todo en particular (como <literal>update()</literal>, que tiene un prop&#x00f3;sito diferente) para hacer persistentes tus modificaciones. De modo que la forma m&#x00e1;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&#x00e1; 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&#x00f3;n es ineficiente pues podr&#x00ed;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&#x00f3;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&#x00f3;n directa de sentencias <literal>UPDATE</literal> o <literal>DELETE</literal>. Hibernate es un servicio de <emphasis>gesti&#x00f3;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&#x00e1;s, la noci&#x00f3;n de operaciones masivas entra en conflicto con el mapeo objeto/relacional en aplicaciones en l&#x00ed;nea orientadas al procesamiento de transacciones. Versiones futuras de Hibernate pueden, sin embargo, proveer funciones de operaci&#x00f3;n masiva especiales. Ver <xref linkend=\"batch\"/> por algunos trucos de operaci&#x00f3;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&#x00f3;n, enviarla a la capa de UI para su manipulaci&#x00f3;n, y entonces salvar los cambios en una nueva transacci&#x00f3;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&#x00f3;n de instancias separadas usando los m&#x00e9;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&#x00f3;n intent&#x00f3; volver a unirlo, se habr&#x00ed;a lanzado una excepci&#x00f3;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&#x00e1;s seguro que la sesi&#x00f3;n tenga una instancia ya persistente con el mismo identificador, y <literal>merge()</literal> si quieres fusionar tus modificaciones en cualquier momento sin consideraci&#x00f3;n del estado de la sesi&#x00f3;n. En otras palabras, <literal>update()</literal> es usualmente el primer m&#x00e9;todo que llamar&#x00ed;as en una sesi&#x00f3;n fresca, asegurando que la re-uni&#x00f3;n de tus instancias separadas es la primera operaci&#x00f3;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&#x00f3;n debe actualizar individualmente las instancias separadas alcanzables por la instancia separada dada llamando a <literal>update()</literal>, si y <emphasis>s&#x00f3;lo</emphasis> si quiere que sus estados sean tambi&#x00e9;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&#x00e9;todo <literal>lock()</literal> tambi&#x00e9;n permite a una aplicaci&#x00f3;n reasociar un objeto con una sesi&#x00f3;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&#x00f3;n de la API y el cap&#x00ed;tulo sobre manejo de transacciones para m&#x00e1;s informaci&#x00f3;n. La re-uni&#x00f3;n no es el &#x00fa;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&#x00f3;n autom&#x00e1;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&#x00e9;todo de prop&#x00f3;sito general que bien salve una instancia transitoria generando un identificador nuevo, o bien actualice/re&#x00fa;na las instancias separadas asociadas con su identificador actual. El m&#x00e9;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&#x00e1;ntica de <literal>saveOrUpdate()</literal> parece ser confuso para usuarios nuevos. Primeramente, en tanto no est&#x00e9;s intentando usar instancias de una sesi&#x00f3;n en otra sesi&#x00f3;n nueva, no debes necesitar usar <literal>update()</literal>, <literal>saveOrUpdate()</literal>, o <literal>merge()</literal>. Algunas aplicaciones enteras nunca usar&#x00e1;n ninguno de estos m&#x00e9;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&#x00f3;n carga un objeto en la primera sesi&#x00f3;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&#x00f3;n hace estas modificaciones persistentes llamando a <literal>update()</literal> en una segunda sesi&#x00f3;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&#x00f3;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&#x00f3;n tiene el mismo identificador, lanza una excepci&#x00f3;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&#x00e9;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&#x00e1; versionado (por un <literal>&lt;version&gt;</literal> o <literal>&lt;timestamp&gt;</literal>), y el valor de la propiedad de versi&#x00f3;n es el mismo valor asignado a una objeto reci&#x00e9;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>&lt;version&gt;</literal> or <literal>&lt;timestamp&gt;</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&#x00f3;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&#x00f3;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&#x00f3;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&#x00e1; el estado de un objeto de la base de datos. Por supuesto, tu aplicaci&#x00f3;n podr&#x00ed;a tener a&#x00fa;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&#x00f3;n de clave for&#x00e1;nea. A&#x00fa;n es posible violar una restricci&#x00f3;n <literal>NOT NULL</literal> sobre una columna clave for&#x00e1;nea borrando objetos en un orden err&#x00f3;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&#x00e9;nes de datos diferentes" + +#: index.docbook:719 +msgid "<![CDATA[sess.delete(cat);]]>" +msgstr "Es ocasionalmente &#x00fa;til ser capaz de tomar un grafo de instancias persistentes y hacerlas persistentes en un almac&#x00e9;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&#x00f3;mo <literal>replicate()</literal> tratar&#x00e1; 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&#x00f3;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&#x00fa;mero de versi&#x00f3;n es anterior al n&#x00fa;mero de versi&#x00f3;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&#x00f3;n de configuraci&#x00f3;n de sistema durante actualizaciones de producto, deshacer cambios producidos durante transacciones no-ACID y m&#x00e1;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&#x00f3;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&#x00e1; las sentencias SQL necesarias para sincronizar el estado de la conexi&#x00f3;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&#x00f3;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&#x00f3;n es que los objetos que usan generaci&#x00f3;n de ID <literal>native</literal> se insertan cuando son salvados.)" + +#: index.docbook:838 +msgid "all collection insertions" +msgstr "Excepto cuando llamas expl&#x00ed;citamente a <literal>flush()</literal>, no hay en absoluto garant&#x00ed;as sobre <emphasis>cu&#x00e1;ndo</emphasis> la <literal>Session</literal> ejecuta las llamadas JDBC. s&#x00f3;lo sobre el <emphasis>orden</emphasis> en que son ejecutadas. Sin embargo, Hibernate garantiza que los m&#x00e9;todos <literal>Query.list(..)</literal> nunca devolver&#x00e1;n datos a&#x00f1;ejos o err&#x00f3;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&#x00f3;lo en tiempo de compromiso (y s&#x00f3;lo cuando se use la API de <literal>Transaction</literal> de Hibernate), limpieza autom&#x00e1;tica usando la rutina explicada, o nunca limpiar a menos que se llame a <literal>flush()</literal> expl&#x00ed;citamente. El &#x00fa;ltimo modo es &#x00fa;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&#x00f3;n (por ejemplo, si una operaci&#x00f3;n DML violase una restricci&#x00f3;n). Ya que el manejo de excepciones implica alguna comprensi&#x00f3;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&#x00f3;modo dalvar, borrar, o reunir objetos individuales, especialmente si tratas con un grafo de objetos asociados. Un caso com&#x00fa;n es una relaci&#x00f3;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&#x00f3;n padre/hijo pudieran ser tipificados en valor (por ejemplo, una colecci&#x00f3;n de direcciones o cadenas), sus ciclos de vida depender&#x00ed;an del padre y se requerir&#x00ed;a ninguna otra acci&#x00f3;n para el tratamiento en \"cascada\" de cambios de estado. Cuando el padre es salvado, los objetos hijo tipificados en valor son salvados tambi&#x00e9;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&#x00f3;n. Hibernate detectar&#x00e1; esto y, ya que los objetos tipificados en valor no pueden tener referencias compartidas, borrar&#x00e1; 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&#x00ed;as e &#x00ed;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&#x00f3;n no significa que sea borrada), y no hay por defecto ning&#x00fa;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&#x00f3;n b&#x00e1;sica de la sesi&#x00f3;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&#x00f3;n sea tratada en cascada a lo largo de una asociaci&#x00f3;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&#x00f3;n. El por defecto <literal>cascade=\"none\"</literal> especifica que ninguna operaci&#x00f3;n ser&#x00e1; 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&#x00f3;lo a asociaciones uno-a-muchos, e indica que la operaci&#x00f3;n <literal>delete()</literal> debe aplicarse a cualquier objeto hijo que sea quitado de la asociaci&#x00f3;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&#x00f3;n <literal>&lt;many-to-one&gt;</literal> o <literal>&lt;many-to-many&gt;</literal>. El tratamiento en cascada es frecuentemente &#x00fa;til para las asociaciones <literal>&lt;one-to-one&gt;</literal> y <literal>&lt;one-to-many&gt;</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&#x00e1; ligada a la eesperanza de vida del objeto padre, h&#x00e1;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&#x00e1;s trabajando frecuentemente con padre e hijos juntos en la misma transacci&#x00f3;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>&lt;many-to-one&gt;</literal> or <literal>&lt;many-to-many&gt;</literal> association. Cascade is often useful for <literal>&lt;one-to-one&gt;</literal> and <literal>&lt;one-to-many&gt;</literal> associations." +msgstr "Mapear una asociaci&#x00f3;n (ya sea una asociaci&#x00f3;n monovaluada, o una colecci&#x00f3;n) con <literal>cascade=\"all\"</literal> marca la asociaci&#x00f3;n como una relaci&#x00f3;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&#x00e1;s, una mera referencia a un hijo desde un padre persistente resultar&#x00e1; en un save/update del hijo. Esta met&#x00e1;fora est&#x00e1; incompleta, sin embargo. Un hijo que deje de ser referenciado por su padre <emphasis>no</emphasis> es borrado autom&#x00e1;ticamente, excepto en el caso de una asociaci&#x00f3;n <literal>&lt;one-to-many&gt;</literal> mapeada con <literal>cascade=\"delete-orphan\"</literal>. La sem&#x00e1;ntica precisa de las operaciones en cascada para una relaci&#x00f3;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>&lt;one-to-many&gt;</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&#x00f3;n debe borrar expl&#x00ed;citamente el hijo de ser necesario - a menos que <literal>cascade=\"delete-orphan\"</literal>, en cuyo caso el hijo \"hu&#x00e9;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 &#x00fa;til para la aplicaci&#x00f3;n misma. Por ejemplo, la aplicaci&#x00f3;n podr&#x00ed;a usar los metadatos de Hibernate para implementar un algoritmo \"inteligente\" de copia en profundidad que entienda qu&#x00e9; objetos deben ser copiados (por ejemplo, tipo de valor mutables) y cu&#x00e1;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&#x00ed;a las interfaces <literal>ClassMetadata</literal> y <literal>CollectionMetadata</literal> y la jerarqu&#x00ed;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@ADDRESS>\n" +"Content-Type: text/plain; charset=utf-8\n" +#: index.docbook:5 +msgid "Toolset Guide" +msgstr "Gu&#x00ed;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&#x00ed;a de ida y vuelta con Hibernate es posible usando un conjunto de plugins de Eclipse, herramientas de l&#x00ed;nea de comandos, as&#x00ed; 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&#x00ed; como tareas de Ant para la ingenier&#x00ed;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&#x00f3;n y resaltado de sint&#x00e1;xis. Soporta tambi&#x00e9;n autocompleci&#x00f3;n sem&#x00e1;ntica de nombres de clases y nombres de campos/propiedades, haci&#x00e9;ndolo mucho m&#x00e1;s vers&#x00e1;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&#x00e1;s de la vista de &#x00e1;rbol de tus configuraciones de consola, tienes tambi&#x00e9;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&#x00e1;pidamente ficheros de configuraci&#x00f3;n de Hibernate (cfg.xml), o incluso puedes haceruna ingenier&#x00ed;a inversa completa de un esquema de base de datos existente en ficheros de c&#x00f3;digo de POJO y ficheros de mapeo de Hibernate. El asistente de ingenier&#x00ed;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&#x00e9;rete al paquete <emphasis>Herramientas de Hibernate</emphasis> y su documentaci&#x00f3;n para m&#x00e1;s informaci&#x00f3;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&#x00e9;n conocido como <literal>hbm2ddl</literal>." + +#: index.docbook:55 +msgid "Automatic schema generation" +msgstr "Generaci&#x00f3;n autom&#x00e1;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&#x00e1;neas) para las tablas de entidades y colecciones. Las tablas y secuencias tambi&#x00e9;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&#x00ed;a la propiedad <literal>hibernate.dialect</literal> al usar esta herramienta, ya que el DDL es altamente espec&#x00ed;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&#x00f1;o de una columna. (O, para tipos de datos num&#x00e9;ricos/decimales, la precisi&#x00f3;n.)" + +#: index.docbook:84 +msgid "<![CDATA[<property name=\"zip\" length=\"5\"/>]]>" +msgstr "Algunas etiquetas tambi&#x00e9;n aceptan un atributo <literal>not-null</literal> (para generar una restricci&#x00f3;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 &#x00ed;ndice para esa columna. Se puede usar un atributo <literal>unique-key</literal> para agrupar columnas en una restricci&#x00f3;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&#x00f3;n, s&#x00f3;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&#x00ed;en un elemento hijo <literal>&lt;column&gt;</literal>. Esto es particularmente &#x00fa;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&#x00f3;n de restricci&#x00f3;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>&lt;column&gt;</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&#x00f3;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&#x00f3;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&#x00f3;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 &#x00ed;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&#x00f3;lo atributo del elemento <literal>&lt;column&gt;</literal>)" + +#: index.docbook:187 +msgid "specfies that the column should be non-nullable" +msgstr "check" + +#: index.docbook:190 +msgid "unique" +msgstr "expresi&#x00f3;n SQL" + +#: index.docbook:192 +msgid "specifies that the column should have a unique constraint" +msgstr "El elemento <literal>&lt;comment&gt;</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&#x00e9; 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&#x00f3;n DDL a la salida est&#x00e1;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&#x00ed;nea de Comandos de <literal>SchemaExport</literal>" + +#: index.docbook:206 +msgid "foreign_key_name" +msgstr "Opci&#x00f3;n" + +#: index.docbook:207 +msgid "specifies the name of the foreign key constraint generated for an association, for a <literal>&lt;one-to-one&gt;</literal>, <literal>&lt;many-to-one&gt;</literal>, <literal>&lt;key&gt;</literal>, or <literal>&lt;many-to-many&gt;</literal> mapping element. Note that <literal>inverse=\"true\"</literal> sides will not be considered by <literal>SchemaExport</literal>." +msgstr "Descripci&#x00f3;n" + +#: index.docbook:217 +msgid "sql-type" +msgstr "--quiet" + +#: index.docbook:218 +msgid "SQL column type" +msgstr "no enviar a salida est&#x00e1;ndar el gui&#x00f3;n" + +#: index.docbook:219 +msgid "overrides the default column type (attribute of <literal>&lt;column&gt;</literal> element only)" +msgstr "--drop" + +#: index.docbook:225 +msgid "default" +msgstr "s&#x00f3;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>&lt;comment&gt;</literal> element allows you to specify comments for the generated schema." +msgstr "lee la configuraci&#x00f3;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&#x00f3;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&#x00ed;nea para el gui&#x00f3;n" + +#: index.docbook:273 +msgid "<literal>SchemaExport</literal> Command Line Options" +msgstr "Puedes incluso encajar <literal>SchemaExport</literal> en tu aplicaci&#x00f3;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>&lt;property&gt;</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&#x00f3;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&#x00f3;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&#x00f1;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&#x00f3;n de construcci&#x00f3;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&#x00e1; 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&#x00e1; 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>&lt;property&gt;</emphasis>" +msgstr "Opciones de L&#x00ed;nea de Comandos de <literal>SchemaUpdate</literal>" + +#: index.docbook:348 +msgid "in <literal>hibernate.properties</literal>" +msgstr "Opci&#x00f3;n" + +#: index.docbook:351 +msgid "in a named properties file with <literal>--properties</literal>" +msgstr "Descripci&#x00f3;n" + +#: index.docbook:355 +msgid "The needed properties are:" +msgstr "--quiet" + +#: index.docbook:360 +msgid "SchemaExport Connection Properties" +msgstr "no enviar a salida est&#x00e1;ndar el gui&#x00f3;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&#x00f3;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&#x00f3;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@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&#x00e1;s importante sobre Hibernate y el control de concurrencia es que muy f&#x00e1;cil de comprender. Hibernate usa directamente conexiones JDBC y recursos JTA sin agregar ning&#x00fa;n comportamiento de bloqueo adicional. Recomendamos altamente que gastes algo de tiempo con la especificaci&#x00f3;n de JDBC, ANSI, y el aislamiento de transacciones de tu sistema de gesti&#x00f3;n de base de datos. Hibernate s&#x00f3;lo a&#x00f1;ade versionado autom&#x00e1;tico pero no bloquea objetos en memoria ni cambia el nivel de aislamiento de tus transacciones de base de datos. B&#x00e1;sicamente, usa Hibernate como usar&#x00ed;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&#x00e1;s del versionado autom&#x00e1;tico, Hibernate ofrece una API (menor) para bloqueo pesimista de filas, usando la sint&#x00e1;xis <literal>SELECT FOR UPDATE</literal>. Esta API se discute m&#x00e1;s adelante en este cap&#x00ed;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&#x00f3;n del control de concurrencia en Hibernate con la granularidad de <literal>Configuration</literal>, <literal>SessionFactory</literal>, y <literal>Session</literal>, as&#x00ed; como la base de datos y las transacciones de aplicaci&#x00f3;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 "&#x00c1;mbitos de sesi&#x00f3;n y de transacci&#x00f3;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&#x00f3;n. Es creado una sola vez, usualmente en el arranque de la aplicaci&#x00f3;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&#x00e1; 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&#x00e1;s seguro que se necesitar&#x00e1; acceso a los datos para servir una petici&#x00f3;n en particular. (Esto se vuelve importante en cuanto est&#x00e9;s implementando alguno de los siguientes patrones usando intercepci&#x00f3;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&#x00e9;n en las transacciones de base de datos. Una transacci&#x00f3;n de base de datos tiene que ser tan corta como sea posible, para reducir la contenci&#x00f3;n de bloqueos en la base de datos. Las transacciones largas de base de datos prevendr&#x00e1;n a tu aplicaci&#x00f3;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 "&#x00bf;Qu&#x00e9; es el &#x00e1;mbito de una unidad de trabajo? &#x00bf;Puede una sola <literal>Session</literal> de Hibernate extenderse a trav&#x00e9;s de varias transacciones de base de datos o es &#x00e9;sta una relaci&#x00f3;n uno-a-uno de &#x00e1;mbitos? &#x00bf;Cu&#x00e1;ndo debes abrir y cerrar una <literal>Session</literal> y c&#x00f3;mo demarcas los l&#x00ed;mites de la transacci&#x00f3;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&#x00f3;n <emphasis>sesi&#x00f3;n-por-operaci&#x00f3;n</emphasis>, esto es, &#x00a1;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&#x00f3;n se hacen usando una secuencia prevista, que est&#x00e1;n agrupadas dentro de unidades de trabajo at&#x00f3;micas. (Nota que esto tambi&#x00e9;n significa que el auto-commit despu&#x00e9;s de cada una de las sentencias SQL es in&#x00fa;til en una aplicaci&#x00f3;n, este modo est&#x00e1; 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&#x00f3;n m&#x00e1;s com&#x00fa;n en una aplicaci&#x00f3;n mutiusuario cliente/servidor es <emphasis>sesi&#x00f3;n-por-petici&#x00f3;n</emphasis>. En este modelo, una petici&#x00f3;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&#x00f3;n es limpiada y cerrada. Podr&#x00ed;as usar una sola transacci&#x00f3;n de base de datos para servir a petici&#x00f3;n del cliente, comenz&#x00e1;ndola y comprometi&#x00e9;ndola cuando abres y cierras la <literal>Session</literal>. La relaci&#x00f3;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&#x00ed;o yace en la implementaci&#x00f3;n: no s&#x00f3;lo tienen que comenzarse y terminarse correctamente la <literal>Session</literal> y la transacci&#x00f3;n, sino que adem&#x00e1;s tienen que estar accesibles para las operaciones de acceso a datos. La demarcaci&#x00f3;n de una unidad de trabajo se implementa idealmente usando un interceptor que se ejecuta cuando una petici&#x00f3;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&#x00f3;n, usando una variable <literal>ThreadLocal</literal>. Esto permite un f&#x00e1;cil acceso (como acceder a una variable static) en t&#x00f3;do el c&#x00f3;digo que se ejecuta en esta hebra. Dependiendo del mecanismo de demarcaci&#x00f3;n de transacciones de base de datos que elijas, podr&#x00ed;as mantener tambi&#x00e9;n el contexto de la transacci&#x00f3;n en una variable <literal>Thre! adLocal</literal>. Los patrones de implementaci&#x00f3;n para esto son conocidos como <emphasis>Sesi&#x00f3;n Local de Hebra (ThreadLocal Session)</emphasis> y <emphasis>Sesi&#x00f3;n Abierta en Vista (Open Session in View)</emphasis>. Puedes extender f&#x00e1;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&#x00f3;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&#x00f3;n sesi&#x00f3;n-por-petici&#x00f3;n no es el &#x00fa;nico concepto &#x00fa;til que puedes usar para dise&#x00f1;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&#x00f3;n de base de datos se extienda a trav&#x00e9;s de la interacci&#x00f3;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&#x00e1;logo, los datos vistos por el usuario han sido cargados en una <literal>Session</literal> y transacci&#x00f3;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&#x00e9;s de 5 minutos y espera que sus modificaciones sean hechas persistentes. Tambi&#x00e9;n espera que &#x00e9;l sea la &#x00fa;nica persona editando esta informaci&#x00f3;n y que no puede ocurrir ninguna modificaci&#x00f3;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&#x00f3;n de aplicaci&#x00f3;n</emphasis> ejecut&#x00e1;ndose. Hay muchas formas en que puedes implementar esto en tu aplicaci&#x00f3;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&#x00f3;n ingenua podr&#x00ed;a mantener abierta la <literal>Session</literal> y la transacci&#x00f3;n de base de datos durante el tiempo de pensar del usuario, con bloqueos tomados en la base de datos para prevenir la modificaci&#x00f3;n concurrente, y para garantizar aislamiento y atomicidad. Esto es, por supuesto, un antipatr&#x00f3;n, ya que la contenci&#x00f3;n de bloqueo no permitir&#x00ed;a a la aplicaci&#x00f3;n escalar con el n&#x00fa;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&#x00f3;n de aplicaci&#x00f3;n. En este caso, mantener el aislamiento de los procesos de negocio se vuelve una responsabilidad parcial de la capa de aplicaci&#x00f3;n. Una sola transacci&#x00f3;n de aplicaci&#x00f3;n usualmente abarca varias transacciones de base de datos. Ser&#x00e1; at&#x00f3;mica si s&#x00f3;lo una de estas transacciones de base de datos (la &#x00fa;ltima) almacena los datos actualizados, todas las otras simplemente leen datos (por ejemplo, en un di&#x00e1;logo estilo-asistente abarcando muchos ciclos petici&#x00f3;n/respuesta). Esto es m&#x00e1;s f&#x00e1;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&#x00e1;tico</emphasis> - Hibernate puede llevar un control autom&#x00e1;tico de concurrencia optimista por ti, puede detectar autom&#x00e1;ticamente si una modificaci&#x00f3;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&#x00f3;n de <emphasis>sesi&#x00f3;n-por-petici&#x00f3;n</emphasis>, todas las instancias cargadas estar&#x00e1;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&#x00f3;n se llama <emphasis>sesi&#x00f3;n-por-petici&#x00f3;n-con-objetos-separados</emphasis>. Se usa versionado autom&#x00e1;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&#x00f3;n Larga</emphasis> - La <literal>Session</literal> de Hibernate puede ser desconectada de la conexi&#x00f3;n JDBC subyacente despu&#x00e9;s que se haya sido comprometida la transacci&#x00f3;n de base de datos, y reconectada cuando ocurra una nueva petici&#x00f3;n del cliente. Este patr&#x00f3;n es conocido como <emphasis>sesi&#x00f3;n-por-transacci&#x00f3;n-de-aplicaci&#x00f3;n</emphasis> y hace la re-uni&#x00f3;n innecesaria. Para aislar las modificaciones concurrentes se usa el versionado autom&#x00e1;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&#x00f3;n-por-petici&#x00f3;n-con-objetos-separados</emphasis> como <emphasis>sesi&#x00f3;n-por-transacci&#x00f3;n-de-aplicaci&#x00f3;n</emphasis>, ambas tienen ventajas y desventajas, las discutimos m&#x00e1;s adelante en este cap&#x00ed;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&#x00f3;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 &#x00e1;mbito de una <literal>Session</literal>) las dos nociones son equivalentes, y la identidad JVM para la identidad de base de datos est&#x00e1; garantizada por Hibernate. Sin embargo, mientras la aplicaci&#x00f3;n acceda concurrentemente al \"mismo\" (identidad persistente) objeto de negocio en dos sesiones diferentes, las dos instancias ser&#x00e1;n realmente \"diferentes\" (identidad JVM). Los conflictos se resuelven (con versionado autom&#x00e1;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&#x00e1;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&#x00f3;n. La aplicaci&#x00f3;n nunca necesita sincronizar sobre ning&#x00fa;n objeto de negocio, siempre que se apegue a una sola hebra por <literal>Session</literal>. Dentro de una <literal>Session</literal> la aplicaci&#x00f3;n puede usar con seguridad <literal>==</literal> para comparar objetos." + +#: index.docbook:251 +msgid "foo==bar" +msgstr "Sin embargo, una aplicaci&#x00f3;n que usa <literal>==</literal> fuera de una <literal>Session</literal>, podr&#x00ed;a ver resultados inesperados. Esto podr&#x00ed;a ocurrir incluso en sitios algo inesperados, por ejemplo, si pones dos instancias separadas dentro del mismo <literal>Set</literal>. Ambas podr&#x00ed;an tener la misma identidad de base de datos (es decir, representar la misma fila), pero la identidad JVM, por definici&#x00f3;n, no est&#x00e1; garantizada para las instancias en estado separado. El desarrollador tiene que sobrescribir los m&#x00e9;todos <literal>equals()</literal> y <literal>hashCode()</literal> en las clases persistentes e implementar su propia noci&#x00f3;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&#x00f3;n de atributos &#x00fa;nicos, usualmente inmutables. El identificador de base de datos cambiar&#x00e1; 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&#x00f3;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&#x00f3;lo tienes que garantizar estabilidad en tanto los objetos est&#x00e9;n en el mismo <literal>Set</literal>. Mira el sitio web de Hibernate para una discusi&#x00f3;n m&#x00e1;s cuidadosa de este tema. Nota tambi&#x00e9;n que &#x00e9;ste no es un tema de Hibernate, sino simplemente c&#x00f3;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&#x00f3;n-por-sesi&#x00f3;n-de-usuario</emphasis> o <emphasis>sesi&#x00f3;n-por-aplicaci&#x00f3;n</emphasis> (por supuesto, hay raras excepciones a esta regla). Nota que algunis de los siguientes temas podr&#x00ed;an tambi&#x00e9;n aparecer con los patrones recomendados. Aseg&#x00fa;rate que entiendes las implicaciones antes de tomar una decisi&#x00f3;n de dise&#x00f1;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&#x00f3;n, o workers de Swing, provocar&#x00e1;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&#x00e1;s adelante), debes considerar sincronizar el acceso a tu sesi&#x00f3;n HTTP. De otro modo, un usuario que hace click lo suficientemente r&#x00e1;pido puede llegar a usar la misma <literal>Session</literal> en dos hebras ejecut&#x00e1;ndose concurrentemente." + +#: index.docbook:296 +msgid "Common issues" +msgstr "Una excepci&#x00f3;n lanzada por Hibernate significa que tienes que deshacer (rollback) tu transacci&#x00f3;n de base de datos y cerrar la <literal>Session</literal> inmediatamente (discutido en m&#x00e1;s detalle luego). Si tu <literal>Session</literal> est&#x00e1; ligada a la aplicaci&#x00f3;n, tienes que parar la aplicaci&#x00f3;n. Deshacer (rollback) la transacci&#x00f3;n de base de datos no pone a tus objetos de vuelta al estado en que estaban al comienzo de la transacci&#x00f3;n. Esto significa que el estado de la base de datos y los objetos de negocio quedan fuera de sincron&#x00ed;a. Usualmente esto no es un problema, pues las excepciones no son recuperables y tienes que volver a comenzar despu&#x00e9;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&#x00e9; todo objeto que est&#x00e9; 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&#x00f3;n para esto es llamar a <literal>clear()</literal> y <literal>evict()</literal> para gestionar el cach&#x00e9; 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&#x00f3;n de una sesi&#x00f3;n de usuario significa tambi&#x00e9;n una alta probabilidad de datos a&#x00f1;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&#x00f3;n de la transacci&#x00f3;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&#x00ed;mites de las transacciones de base de datos (o sistema) son siempre necesarios. Ninguna comunicaci&#x00f3;n con la base de datos puede darse fuera de una transacci&#x00f3;n de base de datos (esto parece confundir muchos desarrolladores acostumbrados al modo auto-commit). Siempre usa l&#x00ed;mites de transacci&#x00f3;n claros, incluso para las operaciones de s&#x00f3;lo lectura. Dependiendo del nivel de aislamiento y las capacidades de base de datos, esto podr&#x00ed;a o no ser requerido, pero no hay un merma si siempre demarcas expl&#x00ed;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&#x00f3;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&#x00ed;mites de transacci&#x00f3;n, en otras palabras, hacer begin, commit, o rollback las transacciones de base de datos por s&#x00ed; mismo. Un entorno manejado usualmente provee transacciones gestionadas por contenedor, con el ensamble de transacci&#x00f3;n definido declarativamente en descriptores de despliegue de beans de sesi&#x00f3;n EJB, por ejemplo. La demarcaci&#x00f3;n program&#x00e1;tica de transacciones no es m&#x00e1;s necesario, incluso limpiar (flush) la <literal>Session</literal> es hecho autom&#x00e1;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&#x00e9;s en un bean de sesi&#x00f3;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&#x00f3;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&#x00f3;n" + +#: index.docbook:379 +msgid "Usually, ending a <literal>Session</literal> involves four distinct phases:" +msgstr "cerrar la sesi&#x00f3;n" + +#: index.docbook:385 +msgid "flush the session" +msgstr "manejar excepciones" + +#: index.docbook:390 +msgid "commit the transaction" +msgstr "Limpiar la sesi&#x00f3;n ha sido discutido anteriormente, tendremos ahora una mirada m&#x00e1;s de cerca a la demarcaci&#x00f3;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&#x00f3;n/transacci&#x00f3;n se ve as&#x00ed;:" + +#: 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&#x00ed;citamente - la llamada a <literal>commit()</literal> autom&#x00e1;ticamente dispara la sincronizaci&#x00f3;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&#x00f3;n. La principal implicaci&#x00f3;n de <literal>close()</literal> es que la conexi&#x00f3;n JDBC ser&#x00e1; abandonada por la sesi&#x00f3;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&#x00f3;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&#x00f3;digo de negocio en una aplicaci&#x00f3;n normal; las excepciones fatales (sistema) deben siempre ser capturadas en la \"cima\". En otras palabras, el c&#x00f3;digo que ejecuta las llamadas de Hibernate (en la capa de persistencia) y el c&#x00f3;digo que maneja <literal>RuntimeException</literal> (y usualmente s&#x00f3;lo puede limpiar y salir) est&#x00e1;n en capas diferentes. Esto puede ser un desaf&#x00ed;o de dise&#x00f1;arlo t&#x00fa; mismo y debes usar los servicios de contenedor J2EE/EJB en cuanto estuviesen disponibles. El manejo de excepciones se dicute m&#x00e1;s adelante en este cap&#x00ed;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&#x00e1;s de beans de sesi&#x00f3;n EJB), cada conexi&#x00f3;n de datasource obtenida por Hibernate ser&#x00e1; parte autom&#x00e1;ticamente de la transacci&#x00f3;n JTA global. Hibernate ofrece dos estrategias para esta integraci&#x00f3;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&#x00e1; al servidor de aplicaciones que comience y finalice una transacci&#x00f3;n BMT si usas la API de <literal>Transaction</literal>. De modo que, el c&#x00f3;digo de gesti&#x00f3;n de la transacci&#x00f3;n es id&#x00e9;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&#x00f3;n de la transacci&#x00f3;n se hace en descriptores de despliegue de beans de sesi&#x00f3;n, no program&#x00e1;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&#x00e1; y cerrar&#x00e1; entonces autom&#x00e1;ticamente la <literal>Session</literal> para ti. Lo &#x00fa;nico que resta es deshacer (rollback) la transacci&#x00f3;n cuando ocurra una excepci&#x00f3;n. Afortunadamente, en un bean CMT, incluso esto ocurre autom&#x00e1;ticamente, ya que una <literal>RuntimeException</literal> no manejada disparada por un m&#x00e9;todo de un bean de sesi&#x00f3;n le! dice al contenedor que ponga a deshacer la transacci&#x00f3;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&#x00f3;n BMT, y <literal>org.hibernate.transaction.CMTTransactionFactory</literal> en un bean de sesi&#x00f3;n CMT, cuando configures la f&#x00e1;brica de transacciones de Hibernate. Recuerda adem&#x00e1;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&#x00e1;ticos de la sesi&#x00f3;n, podr&#x00ed;as querer tambi&#x00e9;n usar la misma sesi&#x00f3;n en diferentes partes de tu c&#x00f3;digo. T&#x00ed;picamente, en un entorno no manejado, usar&#x00ed;as una variable <literal>ThreadLocal</literal> para tener la sesi&#x00f3;n, pero una sola petici&#x00f3;n de EJB puede ejecutarse en diferentes hebras (por ejemplo, un bean de sesi&#x00f3;n llamando a otro bean de sesi&#x00f3;n). Si no quieres molestarte en pasar tu <literal>Session</literal> por alrededor, la <literal>SessionFactory</literal> provee el m&#x00e9;todo <literal>getCurrentSession()</literal>, que devuelve una sesi&#x00f3;n que est&#x00e1; pegada al contexto de transacci&#x00f3;n JTA. &#x00a1;Esta es la forma m&#x00e1;s f&#x00e1;cil de integrar Hibernate en una aplicaci&#x00f3;n! La sesi&#x00f3;n \"actual\" siempre tiene habilitados limpieza, cierre y liberaci&#x00f3;n de conexi&#x00f3! ;n autom&#x00e1;ticos (sin importar la configuraci&#x00f3;n de las propiedades anteriores). Nuestra idioma de gesti&#x00f3;n de sesi&#x00f3;n/transacci&#x00f3;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&#x00ed;mites de transacci&#x00f3;n se establecen declarativamente en los descriptores de despliegue de tu bean de sesi&#x00f3;n. El ciclo de vida de la sesi&#x00f3;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&#x00f3;n de conexi&#x00f3;n <literal>after_statement</literal>. Debido a una limitaci&#x00f3;n tonta de la especificaci&#x00f3;n de JTA, no es posible para Hibernate limpiar autom&#x00e1;ticamente ning&#x00fa;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&#x00ed;citamente desde un bloque <literal>finally</literal>. (Por supuesto, la mayor&#x00ed;a de las aplicaciones pueden evitarlo f&#x00e1;cilmente no usando en absoluto ning&#x00fa;n <literal>scroll()</literal> o <literal>iterate()</literal> desde el c&#x00f3;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&#x00f3;n (incluyendo cualquier <literal>SQLException</literal>), debes inmediatamente deshacer (rollback) la transacci&#x00f3;n de base de datos, llamar a <literal>Session.close()</literal> y descartar la instancia de <literal>Session</literal>. Ciertos m&#x00e9;todos de <literal>Session</literal> <emphasis>no</emphasis> dejar&#x00e1;n la sesi&#x00f3;n en un estado consistente. Ninguna excepci&#x00f3;n lanzada por Hibernate puede ser tratada como recuperable. Aseg&#x00fa;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&#x00ed;a de los errores que pueden ocurrir en la capa de persistencia de Hibernate, en una excepci&#x00f3;n no chequeada (no lo era en versiones anteriores de Hibernate). En nuestra opini&#x00f3;n, no debemos forzar al desarrollador de aplicaciones a capturar una excepci&#x00f3;n irrecuperable en una capa baja. En la mayor&#x00ed;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&#x00e9;todos (es decir, en las capas m&#x00e1;s altas) y se presenta un mensaje de error al usuario de la aplicaci&#x00f3;n (o se toma alguna otra acci&#x00f3;n apropiada). Nota que Hibernate podr&#x00ed;a tambi&#x00e9;n lanzar otras excepciones no chequeadas que no sean una <literal>HibernateException</literal>. Una vez m&#x00e1;s, no son recuperables y debe tomarse una acci&#x00f3;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&#x00fa;a con la base de datos en una <literal>JDBCException</literal>. De hecho, Hibernate intentar&#x00e1; convertir la excepci&#x00f3;n en una subclase de <literal>JDBCException</literal> m&#x00e1;s significativa. La <literal>SQLException</literal> est&#x00e1; siempre disponible v&#x00ed;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&#x00e1; definido para el dialecto configurado; sin embargo, es tambi&#x00e9;n posible enchufar una implementaci&#x00f3;n personalizada (ver los javadocs de la clase <literal>SQLExceptionConverterFactory</literal> para los detalles). Los subtipos est&#x00e1;ndar de <literal>JDBCExcep! tion</literal> son:" + +#: index.docbook:524 +msgid "Exception handling" +msgstr "<literal>JDBCConnectionException</literal> - indica un error con la comunicaci&#x00f3;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&#x00e1;tica o sint&#x00e1;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&#x00f3;n de restricci&#x00f3;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&#x00f3;n solicitada." + +#: index.docbook:565 +msgid "<literal>JDBCConnectionException</literal> - indicates an error with the underlying JDBC communication." +msgstr "<literal>GenericJDBCException</literal> - una excepci&#x00f3;n gen&#x00e9;rica que no cay&#x00f3; en ninguna de las otras categor&#x00ed;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 &#x00fa;nico enfoque que es consistente con alta concurrencia y alta escalabilidad es el control optimista de concurrencia con versionamiento. El chuequeo de versi&#x00f3;n usa n&#x00fa;meros de versi&#x00f3;n, o timestamps, para detectar actualizaciones en conflicto (y para prevenir actualizaciones perdidas). Hibernate provee para tres enfoques posibles de escribir c&#x00f3;digo de aplicaci&#x00f3;n que use concurrencia optimista. Los casos de uso que hemos mostrado est&#x00e1;n en el contexto de transacciones de aplicaci&#x00f3;n largas pero el chequeo de versiones tiene adem&#x00e1;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&#x00f3;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&#x00f3;n sin mucha ayuda de Hibernate, cada interacci&#x00f3;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&#x00f3;n a realizar su propio chequeo de versiones para asegurar el aislamiento de transacciones de base de datos. Es el enfoque m&#x00e1;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>&lt;version&gt;</literal>, e Hibernate la incrementar&#x00e1; autom&#x00e1;ticamente durante la limpieza si la entidad est&#x00e1; 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&#x00e1;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 &#x00fa;ltimo compromiso (commit) gana</emphasis> ser&#x00e1; la estrategia por defecto para tus transacciones de aplicaci&#x00f3;n largas. Ten en mente que esto podr&#x00ed;a confundir a los usuarios de la aplicaci&#x00f3;n, pues podr&#x00ed;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&#x00e1;ctico para la mayor&#x00ed;a de aplicaciones. Frecuentemente, no s&#x00f3;lo intancias solas, sino grafos completos de objetos modificados tienen que ser chequeados. Hibernate ofrece chequeo de versiones autom&#x00e1;tico con el paradigma de dise&#x00f1;o de <literal>Session</literal> larga o de instancias separadas." + +#: index.docbook:626 +msgid "Optimistic concurrency control" +msgstr "Sesi&#x00f3;n larga y versionado autom&#x00e1;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&#x00f3;n de aplicaci&#x00f3;n. Hibernate chequea las versiones de instancia en el momento de limpieza (flush), lanzando una excepci&#x00f3;n si se detecta una modificaci&#x00f3;n concurrente. Concierne al desarrollador capturar y manejar esta excepci&#x00f3;n (las opciones comunes son la oportunidad del usuario de fusionar los cambios, o recomenzar el proceso de negocio sin datos a&#x00f1;ejos)." + +#: index.docbook:639 +msgid "Application version checking" +msgstr "La <literal>Session</literal> se desconecta de cualquier conexi&#x00f3;n JDBC subyacente al esperar por una interacci&#x00f3;n del usuario. Este enfoque es el m&#x00e1;s eficiente en t&#x00e9;rminos de acceso a base de datos. La aplicaci&#x00f3;n no necesita tratar por s&#x00ed; misma con el chequeo de versiones, ni re-uniendo instancias separadas, ni tiene que recargar instancias en cada transacci&#x00f3;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&#x00ed;a conoce en qu&#x00e9; <literal>Session</literal> fue cargado. <literal>Session.reconnect()</literal> obtiene una nueva conexi&#x00f3;n (o puedes proveer una) y reasume la sesi&#x00f3;n. El m&#x00e9;todo <literal>Session.disconnect()</literal> desconectar&#x00e1; la sesi&#x00f3;n de la conexi&#x00f3;n JDBC y la devolver&#x00e1; la conexi&#x00f3;n al pool (a menos que hayas provisto la conexi&#x00f3;n). Despu&#x00e9;s de la reconexi&#x00f3;n, para forzar un chequeo de versi&#x00f3;n en datos que no est&#x00e9;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&#x00f3;n. No necesitas bloquear ning&#x00fa;n dato que <emphasis>s&#x00ed; est&#x00e9;s</emphasis> actualizando." + +#: index.docbook:652 +msgid "The <literal>version</literal> property is mapped using <literal>&lt;version&gt;</literal>, and Hibernate will automatically increment it during flush if the entity is dirty." +msgstr "Si las llamadas expl&#x00ed;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&#x00f3;n es problem&#x00e1;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&#x00f1;a como sea posible. Ya que la <literal>Session</literal> es tambi&#x00e9;n el cach&#x00e9; (obligatorio) de primer nivel y contiene todos los objetos cargados, podemos probablemente cargar esta estrategia s&#x00f3;lo para unos pocos ciclos petici&#x00f3;n/respuesta. Esto est&#x00e1; de hecho recomendado, ya que la <literal>Session</literal> tendr&#x00e1; pronto tambi&#x00e9;n datos a&#x00f1;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&#x00e9;n que debes mantener la <literal>Session</literal> desconectada pr&#x00f3;xima a la capa de persistencia. En otras palabras, usa una sesi&#x00f3;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&#x00e1;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&#x00f3;n con el almac&#x00e9;n persistente ocurre en una nueva <literal>Session</literal>. Sin embargo, las mismas instancias persistentes son reusadas para cada interacci&#x00f3;n con la base de datos. La aplicaci&#x00f3;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&#x00e1; las versiones de instancia durante la limpieza (flush), lanzando una excepci&#x00f3;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&#x00e9;n llamar a <literal>lock()</literal> en vez de <literal>update()</literal> y usar <literal>LockMode.READ</literal> (realizando un chequeo de versi&#x00f3;n, puenteando todos los cach&#x00e9;s) si est&#x00e1;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&#x00e1;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&#x00f3;n autom&#x00e1;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&#x00e1; ya m&#x00e1;s las versiones si la propiedad est&#x00e1; 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&#x00e1;ticos y no pueden ser modificados. U otras aplicaciones podr&#x00ed;an tambi&#x00e9;n acceder la misma base de datos y no saber c&#x00f3;mo manejar los n&#x00fa;meros de versi&#x00f3;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&#x00f3;n o timestamp, con una comparaci&#x00f3;n del estado de todos los campos en una fila, activa <literal>optimistic-lock=\"all\"</literal> en el mapeo de <literal>&lt;class&gt;</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&#x00f3;n-por-petici&#x00f3;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>&lt;class&gt;</literal>, Hibernate s&#x00f3;lo comparar&#x00e1; los campos sucios durante la limpieza." + +#: index.docbook:747 +msgid "Detached objects and automatic versioning" +msgstr "En ambos casos, con columnas de versi&#x00f3;n/timestamp dedicadas o con comparaci&#x00f3;n de campos completa/sucios, Hibernate usa una sola sentencia <literal>UPDATE</literal> (con una cl&#x00e1;usula <literal>WHERE</literal> apropiada) por entidad para ejecutar el chequeo de versiones y actualizar la informaci&#x00f3;n. Si usas persistencia transitiva para la re-uni&#x00f3;n en cascada de entidades asociadas, Hibernate podr&#x00ed;a ejecutar actualizaciones innecesarias. Esto usualmente no es un problema, pero podr&#x00ed;an ejecutarse disparadores (triggers) <emphasis>on update</emphasis> en la base de datos incluso cuando no se haya hecho ning&#x00fa;n cambio a las instancias separadas. Puedes personalizar este comportamiento estableciendo <literal>select-before-update=\"true\"</literal> en el mapeo de <literal>&lt;class&gt;</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&#x00e1;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&#x00f3;n." + +#: index.docbook:759 +msgid "Again, Hibernate will check instance versions during flush, throwing an exception if conflicting updates occured." +msgstr "&#x00a1;Hibernate siempre usar&#x00e1; 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&#x00e1;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&#x00f3;n expl&#x00ed;cita del usuario usando <literal>SELECT ... FOR UPDATE</literal> en base de datos que soporten esa sint&#x00e1;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>&lt;class&gt;</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&#x00f3;n expl&#x00ed;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>&lt;class&gt;</literal>, Hibernate will only compare dirty fields during flush." +msgstr "<literal>LockMode.READ</literal> es adquirido autom&#x00e1;ticamente cuando Hibernate lee datos bajo los niveles de aislamiento Repeatable Read o Serializable. Puede ser readquirido por pedido expl&#x00ed;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>&lt;class&gt;</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&#x00f3;n v&#x00ed;a una llamada a <literal>update()</literal> o <literal>saveOrUpdate()</literal> tambi&#x00e9;n comienzan en este modo de bloqueo." + +#: index.docbook:817 +msgid "Pessimistic Locking" +msgstr "La \"petici&#x00f3;n expl&#x00ed;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&#x00fa;n cargado por la sesi&#x00f3;n, el objeto es cargado usando <literal>SELECT ... FOR UPDATE</literal>. Si se llama a <literal>load()</literal> para un objeto que ya est&#x00e9; 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&#x00fa;mero de versi&#x00f3;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&#x00e1; un modo alternativo apropiado (en vez de lanzar una excepci&#x00f3;n). Esto asegura que las aplicaciones ser&#x00e1;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@ADDRESS>\n" +"Content-Type: text/plain; charset=utf-8\n" +#: index.docbook:7 +msgid "Introduction to Hibernate" +msgstr "Introducci&#x00f3;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&#x00ed;tulo es un tutorial introductorio de Hibernate. Comenzamos con una aplicaci&#x00f3;n simple de l&#x00ed;nea de comandos usando un base de datos en-memoria y desarroll&#x00e1;ndola en f&#x00e1;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&#x00e1; concebido para usuarios nuevos de Hibernate pero requiere conocimiento en Java y SQL. Est&#x00e1; basado en un tutorial de Michael Gloegl. Las bibliotecas de terceros que mencionamos son para JDK 1.4 y 5.0. Podr&#x00ed;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&#x00f3;n Hibernate" + +#: index.docbook:32 +msgid "Part 1 - The first Hibernate Application" +msgstr "Primero, crearemos una aplicaci&#x00f3;n simple de Hibenate basada en consola. Usamos usamos una base de datos en-memoria (HSQL DB), de modo que no necesitamos instalar ning&#x00fa;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&#x00f3;n peque&#x00f1;a de base de datos que pueda almacenar eventos que queremos atender, e informaci&#x00f3;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 &#x00e9;l todas las bibliotecas Java que necesitamos. Descarga la distribuci&#x00f3;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&#x00ed;nimo de bibliotecas requeridas para Hibernate (observa que tambi&#x00e9;n hemos copiado hibernate3.jar, el fichero principal). Ver el fichero <literal>README.txt</literal> en el directorio <literal>lib/</literal> de la distribuci&#x00f3;n de Hibernate para m&#x00e1;s informaci&#x00f3;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&#x00e1;ndar de JavaBean para m&#x00e9;todos getter y setter de propiedad, as&#x00ed; como visibilidad privada para los campos. Esto es un dise&#x00f1;o recomendado, aunque no requerido. Hibernate tambi&#x00e9;n puede acceder a los campos directamente; el beneficio de los m&#x00e9;todos de acceso es la robustez para la refactorizaci&#x00f3;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 &#x00fa;nico de identificador para un evento en particular. Todas las clase de entidad persistentes ( tambi&#x00e9;n hay clases dependientes menos importantes) necesitar&#x00e1;n una propiedad identificadora similar si queremos usar el conjunto completo de funcionalidades de Hibernate. De hecho, la mayor&#x00ed;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&#x00f3;n. Sin embargo, usualmente no manipulamos la identidad de un objeto, por lo tanto el m&#x00e9;todo setter debe ser privado. S&#x00f3;lo Hibernate asignar&#x00e1; identificadores cuando un objeto sea salvado. Puedes ver que Hibernate puede acceder a m&#x00e9;todos de acceso p&#x00fa;blicos, privados y protegidos, tanto como directamente a campos (p&#x00fa;blicos, privados y protegidos). La elecci&#x00f3;n est&#x00e1; en ti, y puedes ajustar! la a tu dise&#x00f1;o de aplicaci&#x00f3;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&#x00f3;n Java. El constructor puede ser privado, sin embargo, la visibilidad de paquete es requerida para la generaci&#x00f3;n de proxies en tiempo de ejecuci&#x00f3;n y la recuperaci&#x00f3;n de datos sin instrumentaci&#x00f3;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&#x00f3;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&#x00f3;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&#x00f3;mo cargar y almacenar objetos de la clase persistente. Aqu&#x00ed; es donde el fichero de mapeo de Hibernate entra en juego. El fichero de mapeo le dice a Hibernate a qu&#x00e9; tabla en la base de datos tiene que acceder, y qu&#x00e9; 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&#x00e1;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&#x00f3;n de los elementos y atributos XML de mapeo en tu editor o IDE. Debes tambi&#x00e9;n abrir el fichero DTD en tu editor de texto. Es la forma m&#x00e1;s f&#x00e1;cil para tener un panorama de todos los elementos y atributos y ver los valores por defectos, as&#x00ed; como algunos comentarios. Nota que Hibernate no cargar&#x00e1; el fichero DTD de la web, sino que primero buscar&#x00e1; en el classpath de la aplicaci&#x00f3;n. El fichero DTD est&#x00e1; inclu&#x00ed;do en <literal>hibernate3.jar</literal> as&#x00ed; como tambi&#x00e9;n en el directorio <literal>src/</literal> de la distribuci&#x00f3;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&#x00f3;n de DTD en futuros ejemplos para acortar el c&#x00f3;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&#x00ed;a haber m&#x00e1;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&#x00f3;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 &#x00fa;nico a la clave primaria de la tabla. Adem&#x00e1;s, como no queremos cuidar del manejo de este identificador, configuramos la estrategia de generaci&#x00f3;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&#x00f3;n de la propiedad identificadora, <literal>name=\"id\"</literal> declara el nombre de la propiedad Java. Hibernate usar&#x00e1; los m&#x00e9;todos getter y setter para acceder a la propiedad. El attributo de columna dice a Hibernate cu&#x00e1;l columna de la tabla <literal>EVENTS</literal> usamos para esta clave primaria. El elemento anidado <literal>generator</literal> especifica la estrategia de generaci&#x00f3;n de identificadores, en este caso usamos <literal>increment</literal>, que es un m&#x00e9;todo muy simple de incremento de n&#x00fa;mero en-memoria &#x00fa;til mayormente para testeo (y tutoriales). Hibernate tambi&#x0e9;n soporta identificadores generados por base de datos, globalmente &#x00fa;nicos, as&#x00ed; como tambi&#x00e9;n asignados por aplicaci&#x00f3;n (o cualquier estrategia para la que hayas escrito una extensi&#x00f3;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&#x00ed;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&#x00e1;les m&#x00e9;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&#x00e9; 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&#x00ed;a de las bases de datos, as&#x00ed; 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&#x00f3;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&#x00ed;as esperar, tipos de datos Java. Tampoco son tipos de base de datos SQL. Estos tipos son los llamados as&#x00ed; <emphasis>Tipos de mapeo de Hibernate</emphasis>, convertidores que pueden traducir de tipos Java a SQL y vice versa. De nuevo, Hibernate intentar&#x00e1; determinar la conversi&#x00f3;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&#x00f3;n autom&#x00e1;tica (usando reflecci&#x00f3;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&#x00e1; a una columna <literal>date</literal>, <literal>timestamp</literal> o <literal>time</literal>. Declaramos ! que queremos preservar la informaci&#x00f3;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&#x00f3;ximo al fichero de c&#x00f3;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&#x00f3;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&#x00f3;n principal de Hibernate." + +#: index.docbook:230 +msgid "We continue with the main configuration of Hibernate." +msgstr "Configuraci&#x00f3;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&#x00f3;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&#x00ed;z del directorio de desarrollo. All&#x00ed; es donde HSQL DB almacenar&#x00e1; 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&#x00f3;n que se conecta a esta base de datos, de modo que necesita informaci&#x00f3;n de conexi&#x00f3;n. Las conexiones se hacen a trav&#x00e9;s de un pool de conexiones JDBC, que tamb&#x00e9;n tenemos que configurar. La distribuci&#x00f3;n de Hibernate contiene muchas herramientas de pooling de conexiones JDBC de c&#x00f3;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&#x00f3;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&#x00f3;n de Hibernate, podemos usar un fichero <literal>hibernate.properties</literal> simple, un fichero <literal>hibernate.cfg.xml</literal> ligeramente m&#x00e1;s sofisticado, o incluso una configuraci&#x00f3;n completamente program&#x00e1;tica. La mayor&#x00ed;a de los usuarios prefieren el fichero de configuraci&#x00f3;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&#x00f3;n XML usa un DTD diferente. Configuramos la <literal>SessionFactory</literal> de Hibernate, una f&#x00e1;brica global responsable de una base de datos en particular. Si tienes varias bases de datos, usa varias configuraciones <literal>&lt;session-factory&gt;</literal> , usualmente en varios ficheros de configuraci&#x00f3;n (para un arranque m&#x00e1;s f&#x00e1;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>&lt;session-factory&gt;</literal> configurations, usually in several configuration files (for easier startup)." +msgstr "Los primeros cuatro elementos <literal>property</literal> contienen la configuraci&#x00f3;n necesaria para la conexi&#x00f3;n JDBC. El elemento de dialecto <literal>property</literal> especifica la variante de SQL en particular que genera Hibernate. La opci&#x00f3;n <literal>hbm2ddl.auto</literal> activa la generaci&#x00f3;n autom&#x00e1;tica de esquemas de base de datos, directamente en la base de datos. Esto, por supuesto, puede desactivarse (quitando la opci&#x00f3;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&#x00f3;digo fuente, de modo que termine ubicado en la rai&#x00ed;z del classpath. Hibernate busca autom&#x00e1;ticamente un fichero llamado <literal>hibernate.cfg.xml</literal> en la ra&#x00ed;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&#x00e1;s tener Ant instalado. Obt&#x00e9;nlo de <ulink url=\"http://ant.apache.org/bindownload.cgi\">P&#x00e1;gina de descarga de Ant</ulink>. No se cubrir&#x00e1; aqu&#x00ed; c&#x00f3;mo instalar Ant. Por favor refi&#x00e9;rete al <ulink url=\"http://ant.apache.org/manual/index.html\"> Manual de Ant</ulink>. Despu&#x00e9;s que hayas instalado Ant, podemos comenzar a crear el buildfile. Ser&#x00e1; 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&#x00f3;n de Ant est&#x00e1; 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&#x00f3;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&#x00f3;n b&#x00e1;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&#x00e1; a Ant que agregue todos los ficheros en el directorio lib que terminen con <literal>.jar</literal> al classpath usado para la compilaci&#x00f3;n. Tambi&#x00e9;n copiar&#x00e1; todos los ficheros que no sean c&#x00f3;digo Java al directorio objetivo, por ejemplo, ficheros de configuraci&#x00f3;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&#x00f3;n de alg&#x00fa;n c&#x00f3;digo de infraestructura. Tenemos que arrancar Hibernate. Este arranque incluye construir un objeto <literal>SessionFactory</literal> global y almacenarlo en alg&#x00fa;n sitio de f&#x00e1;cil acceso en el c&#x00f3;digo de aplicaci&#x00f3;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&#x00ed; llamado patr&#x00f3;n <emphasis>Sesi&#x00f3;n de Hebra Local (ThreadLocal Session)</emphasis> es &#x00fa;til aqu&#x00ed;; mantenemos la unidad de trabajo actual asociada a la hebra actual. Echemos una mirada a la implementaci&#x00f3;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 &#x00f3;lo produce la <literal>SessionFactory</literal> global en su inicializador static (llamado s&#x00f3;lo una vez por la JVM al cargar la clase), sino que tambi&#x00e9;n tiene una variable <literal>ThreadLocal</literal> para tener la <literal>Session</literal> para la hebra actual. No importa cu&#x00e1;ndo llames a <literal>HibernateUtil.currentSession()</literal>, siempre devolver&#x00e1; 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&#x00fa;rate de entender el concepto Java de una variable local a una hebra antes de usar esta ayuda. Una clase <literal>HibernateUtil</literal> m&#x00e1;s potente puede encontrarse en <literal>CaveatEmptor</literal>, http://caveatemptor.hibernate.org/, as&#x00ed; 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&#x00e1; autom&#x00e1;ticamente ligada a la transacci&#x00f3;n JTA actual, y puedes buscar la <literal>SessionFactory</literal> a trav&#x00e9;s de JNDI. Si usas JBoss AS, Hibernate puede ser desplegado como un servicio de sistema manejado y autom&#x00e1;ticamente ligar&#x00e1; 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&#x00e9;n debe compilar sin problemas. Finalmente necesitamos configurar un sistema de logging (registro). Hibernate usa commons logging y te deja la elecci&#x00f3;n entre Log4J y logging de JDK 1.4. La mayor&#x00ed;a de los desarrolladores prefieren Log4J: copia <literal>log4j.properties</literal> de la distribuci&#x00f3;n de Hibernate (est&#x00e1; 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&#x00f3;n de ejemplo y cambia los ajustes si te gusta tener una salida m&#x00e1;s verborr&#x00e1;gica. Por defecto, s&#x00f3;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&#x00e1; completa, y estamos listos para hacer alg&#x00fa;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&#x00e9;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&#x00ed;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&#x00f3;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&#x00ed;a sorprenderte que tengamos una API adicional, <literal>Transaction</literal>. Esto implica que una unidad de trabajo puede ser \"m&#x00e1;s larga\" que una sola transacci&#x00f3;n de base de datos; imagina una unidad de trabajo que se abarca varios ciclos petici&#x00f3;n/respuesta HTTP (por ejemplo, un di&#x00e1;logo asistente) en una aplicaci&#x00f3;n web. Separar las transacciones de base de datos de \"las unidades de trabajo de la aplicaci&#x00f3;n desde el punto de vista del usuario\" es uno de los conceptos b&#x00e1;sicos de dise&#x00f1;o de Hibernate. Llamamos una unidad de trabajo larga <emphasis>Transacci&#x00f3;n de Aplicaci&#x00f3;n</emphasis>, usualmente encapsulando varias transacciones de base de datos m&#x00e1;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&#x00e9; es lo que hacen <literal>Transaction.begin()</literal> y <literal>commit()</literal>? ¿D&#x00f3;nde est&#x00e1; 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&#x00f3;n de base de datos por ti mismo (por ejemplo, llamando a <literal>session.connection.commit()</literal>), ligar&#x00ed;as el c&#x00f3;digo a un entorno de despliegue particular, en este JDBC directo no manejado. Estableciendo la f&#x00e1;brica de <literal>Transaction</literal> en tu configuraci&#x00f3;n de Hibernate puedes desplegar tu capa de persistencia en cualquier sitio. Echa una mirada al <xref linkend=\"transactions\"/> para m&#x00e1;s informaci&#x00f3;n sobre manejo y demarcaci&#x00f3;n de transacciones. Hemos saltado tambi&#x00e9;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&#x00f3;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&#x00ed;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&#x00e9;s de la compilaci&#x00f3;n, a Hibernate arrancando y, dependiendo de tu configuraci&#x00f3;n mucha salida de registro (log). Al final encontrar&#x00e1;s la siguiente l&#x00ed;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&#x00e1;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&#x00e9;ramos listar acontecimientos almacenados tambi&#x00e9;n, as&#x00ed; que agregamos una opci&#x00f3;n al m&#x00e9;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&#x00e9;n un nuevo m&#x00e9;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&#x00ed; 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&#x00e1; el SQL apropiado, lo enviar&#x00e1; a la base de datosy poblar&#x00e1; los objetos <literal>Event</literal> con datos. Puedes, por supuesto, crear consultas m&#x00e1;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&#x00e1; vac&#x00ed;o. La razon de esto es la opci&#x00f3;n <literal>hbm2ddl.auto</literal> en la configuraci&#x00f3;n de Hibernate: Hibernate recrear&#x00e1; la base de datos en cada ejecuci&#x00f3;n. Deshabil&#x00ed;tala quitando la opci&#x00f3;n, y ver&#x00e1;s resultados en tu listado despu&#x00e9;s que llames a la acci&#x00f3;n <literal>store</literal> unas cuantas veces. La generaci&#x00f3;n y exportaci&#x00f3;n de esquema es &#x00fa;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&#x00f3;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&#x00f3;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&#x00f3;n entre estas dos entidades. Obviamente, las personas pueden participar en eventos, y los eventos tienen participantes. Las cuestiones de dise&#x00f1;o con que tenemos que tratar son: direccionalidad, multiplicidad y comportamiento de colecci&#x00f3;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&#x00f3;n unidireccional basada en Set" + +#: index.docbook:567 +msgid "Finally, add the new mapping to Hibernate's configuration:" +msgstr "Agregaremos una colecci&#x00f3;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&#x00ed;cita, llamando a <literal>aPerson.getEvents()</literal>. Usamos una colecci&#x00f3;n Java, un <literal>Set</literal>, porque la colecci&#x00f3;n no contendr&#x00e1; 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&#x00f1;ado asociaciones unidireccionales multivaluadas, implementadas con un <literal>Set</literal>. Escribamos el c&#x00f3;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&#x00f3;n, piensa sobre el otro lado. Claramente, podemos mantener esto solamente unidireccional. O podemos crear otra colecci&#x00f3;n en el <literal>Event</literal>, si queremos ser capaces de navegarlos bidireccionalmente; por ejemplo, <literal>anEvent.getParticipants()</literal>. Esta es una elecci&#x00f3;n de dise&#x00f1;o que recae en ti, pero lo que est&#x00e1; claro de esta discusi&#x00f3;n es la multiplicidad de la asociaci&#x00f3;n: \"multi\" valuada a ambos lados, llamamos a esto una asociaci&#x00f3;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&#x00f3;n, siendo el m&#x00e1;s com&#x00fa;n un <literal>&lt;set&gt;</literal>. Para una asociaci&#x00f3;n muchos-a-muchos (o relaci&#x00f3;n de entidad <emphasis>n:m</emphasis>), se necesita una tabla de asociaci&#x00f3;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&#x00f3;n, para el lado de la persona, se define con el elemento <literal>&lt;key&gt;</literal>. El nombre de columna para el lado del evento se define con el atributo <literal>column</literal> del <literal>&lt;many-to-many&gt;</literal>. Tambi&#x00e9;n tienes que decirle a Hibernate la clase de los objetos en tu colecci&#x00f3;n (correcto: la clase del otro lado de la colecci&#x00f3;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&#x00f3;n" + +#: index.docbook:612 +msgid "Hibernate supports all kinds of collection mappings, a <literal>&lt;set&gt;</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>&lt;key&gt;</literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal>&lt;many-to-many&gt;</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&#x00e9;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&#x00e9;s de cargar una <literal>Person</literal> y un <literal>Event</literal>, simplemente modifica la colecci&#x00f3;n usando sus m&#x00e9;todos normales. Como puedes ver, no hay una llamada expl&#x00ed;cita a <literal>update()</literal> o <literal>save()</literal>. Hibernate detecta autom&#x00e1;ticamente que la colecci&#x00f3;n ha sido modificada y necesita ser salvada. Esto es llamado <emphasis>chequeo sucio autom&#x00f3;tico (automatic dirty checking)</emphasis>, y tambi&#x00e9;n puedes intentarlo modificando el nombre de la propiedad de fecha de cualquiera de tus objetos. Mientras est&#x00e9;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&#x00e1;s. El proceso de sincronizaci&#x00f3;n del estado de memoria con la base de datos, usu! almente s&#x00f3;lo al final de una unidad de trabajo, es llamado <emphasis>limpieza (flushing)</emphasis>." + +#: index.docbook:633 +msgid "Working the association" +msgstr "Podr&#x00ed;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&#x00e1; en estado persistente (si antes era persistente llamamos a este estado <emphasis>separado (detached) </emphasis>). En c&#x00f3;digo (no muy realista), esto se ver&#x00ed;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&#x00ed;as decir que la liga a una nueva unidad de trabajo, de modo que cualquier modificaci&#x00f3;n que le hagas mientras est&#x00e9; 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&#x00f3;n actual, pero es un concepto importante que puedes dise&#x00f1;ar en tu propia aplicaci&#x00f3;n. Por ahora, completa este ejercicio agregando una nueva acci&#x00f3;n al m&#x00e9;todo main de <literal>EventManager</literal> y ll&#x00e1;mala desde la l&#x00ed;nea de comandos. Si necesitas los identificadores de una persona o evento, el m&#x00e9;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&#x00f3;n entre dos clases igualmente importantes, dos entidades. Como se ha mencionado anteriormente, hay otras clases y tipos en un modelo t&#x00ed;pico, usualmente \"menos importantes\". Algunos ya los habr&#x00e1;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&#x00f3;lo pueden encontrarse en el JDK (de hecho, en una aplicaci&#x00f3;n Hibernate todas las clases del JDK son consideradas tipos de valor), sino que adem&#x00e1;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&#x00e9;n puedes dise&#x00f1;ar una colecci&#x00f3;n de tipos de valor. Esto es conceptualmente muy diferente de una colecci&#x00f3;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&#x00f3;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&#x00f3;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&#x00f3;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&#x00f3;n no contiene referencias a otra entidad, sino una colecci&#x00f3;n de elementos de tipo <literal>String</literal> (el nombre en min&#x00fa;sculas te dice que es un tipo/conversor de mapeo de Hibernate). Una vez m&#x00e1;s, el atributo <literal>table</literal> del elemento <literal>set</literal> determina el nombre de la tabla para la colecci&#x00f3;n. El elemento <literal>key</literal> define el nombre de la columna clave for&#x00e1;nea en la tabla de colecci&#x00f3;n. El atributo <literal>column</literal> en el elemento <literal>element</literal> define el nombre de columna donde realmente ser&#x00e1;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&#x00f3;n es de hecho una clave compuesta, usando ambas columnas. Esto implica tambi&#x00e9;n que no pueden haber direcciones de email duplicadas por persona, que es exactamente la sem&#x00e1;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&#x00f3;n, al igual que hicimos antes enlazando personas y eventos. Es el mismo c&#x00f3;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&#x00f3;n bidireccional, haciendo que la asociaci&#x00f3;n entre persona y evento funcione desde ambos lados en Java. Por supuesto, el esquema de base de datos no cambia; todav&#x00ed;a necesitamos multiplicidad muchos-a-muchos. Una base de datos relacional es m&#x00e1;s flexible que un lenguaje de programaci&#x00f3;n de red, as&#x00ed; que no necesita nada parecido a una direcci&#x00f3;n de navegaci&#x00f3;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&#x00f3;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&#x00f3;n tambi&#x00e9;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&#x00ed; la adici&#x00f3;n m&#x00e1;s importante es el atributo <literal>inverse=\"true\"</literal> en el elemento <literal>set</literal> del mapeo de colecci&#x00f3;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&#x00f3;n sobre el enlace entre las dos. Esto ser&#x00e1; mucho m&#x00e1;s f&#x00e1;cil de entender una vez que veas c&#x00f3;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&#x00e1;ntica normal de Java. ¿C&#x00f3;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&#x00f3;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&#x00f3;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&#x00e9;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&#x00e9;todos get y set para esta colecci&#x00f3;n son ahora protegidos. Esto le permite a clases en el mismo paquete y a subclases acceder a&#x00fa;n a los m&#x00e9;todos, pero previene a cualquier otro de ensuciarse con la colecci&#x00f3;n directamente (bueno, casi). Probablemente debas hacer lo mismo con la colecci&#x00f3;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&#x00e9; del atributo de mapeo <literal>inverse</literal>? Para ti, y para Java, un enlace bidireccional es simplemente cuesti&#x00f3;n de establecer correctamente las referencias a ambos lados. Hibernate, sin embargo, no tiene suficiente informaci&#x00f3;n para arreglar correctamente sentencias <literal>INSERT</literal> y <literal>UPDATE</literal> de SQL (para evitar violaci&#x00f3;n de restricciones), y necesita alguna ayuda para manejar asociaciones bidireccionales apropiadamente. El hacer un lado de la asociaci&#x00f3;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&#x00f3;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&#x00f3;n uno-a-muchos debe ser el lado-de-muchos. En una asociaci&#x00f3;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&#x00f3; los fundamentos de escribir una simple aplicaci&#x00f3;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&#x00fa;a navegando a trav&#x00e9;s de la tabla de contenidos de la documentaci&#x00f3;n de referencia para los temas que encuentres interesantes. Los m&#x00e1;s consultados son procesamiento transaccional (<xref linkend=\"transactions\"/>), rendimiento de recuperaci&#x00f3;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&#x00e1;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&mdash;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>&mdash;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&mdash;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@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>&lt;one-to-many&gt;</literal> mapping, the data might look more like this:" +msgstr "Si estableces <literal>embed-xml=\"true\"</literal> en el mapeo <literal>&lt;one-to-many&gt;</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@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.openc... +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.openc... + +#: 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(a)redhat.com key is:" +msgstr "The GPG fingerprint of the security(a)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@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 "&copyrightHolder;" +msgstr "&copyrightHolder;" + +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@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@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>&lt;key&gt;</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>&lt;column&gt;</literal> element, but on the <literal>&lt;key&gt;</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@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>&lt;class&gt;</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>&lt;class&gt;</literal> mappings, as shown above. It is however good practice (and expected by some tools) to map only a single persistent class (or a single class hierarchy) in one mapping file and name it after the persistent superclass, 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>&lt;hibernate-mapping&gt;</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>&lt;hibernate-mapping&gt;</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>&lt;hibernate-mapping&gt;</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>&lt;hibernate-mapping&gt;</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>&lt;union-subclass&gt;</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>&lt;subclass&gt;</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>&lt;subclass&gt;</literal> ou <literal>&lt;joined-subclass&gt;</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>&lt;union-subclass&gt;</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>&lt;subclass&gt;</literal> ou <literal>&lt;joined-subclass&gt;</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>&lt;subclass&gt;</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>&lt;class&gt;</literal> declaration as a <literal>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</literal>. For most purposes the default, <literal>polymorphism=\"implicit\"</literal>, is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table (this allows a \"lightweight\" class that contains a subset of the table columns)." +msgstr "<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>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</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>&lt;subselect&gt;</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>&lt;id&gt;</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>&lt;subselect&gt;</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>&lt;id&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "\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>&lt;composite-id&gt;</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>&lt;generator&gt;</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>&lt;param&gt;</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>&lt;composite-id&gt;</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>&lt;generator&gt;</literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal>&lt;param&gt;</literal> element." +msgstr "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>&lt;generator&gt;</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>&lt;one-to-one&gt;</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>&lt;generator&gt;</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>&lt;one-to-one&gt;</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>&lt;generator&gt;</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>&lt;generator&gt;</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>&lt;composite-id&gt;</literal> accepte les mappings de propriétés <literal>&lt;key-property&gt;</literal> et les mappings <literal>&lt;key-many-to-one&gt;</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>&lt;composite-id&gt;</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>&lt;discriminator&gt;</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>&lt;class&gt;</literal> et <literal>&lt;subclass&gt;</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>&lt;version&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" + +#: 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>&lt;composite-id&gt;</literal> element accepts <literal>&lt;key-property&gt;</literal> property mappings and <literal>&lt;key-many-to-one&gt;</literal> mappings as child elements." +msgstr "<literal>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>&lt;composite-id&gt;</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&mdash;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>&lt;timestamp&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" + +#: 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>&lt;discriminator&gt;</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>&lt;timestamp&gt;</literal> est équivalent à <literal>&lt;version type=\"timestamp\"&gt;</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>&lt;property&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;column&gt;</literal>." + +#: index.docbook:1096 +msgid "Actual values of the discriminator column are specified by the <literal>discriminator-value</literal> attribute of the <literal>&lt;class&gt;</literal> and <literal>&lt;subclass&gt;</literal> elements." +msgstr "<literal>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>&lt;version&gt;</literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis> (see below)." +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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" +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>&lt;timestamp&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" +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>&lt;formula&gt;</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>&lt;column&gt;</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>&lt;timestamp&gt;</literal> is equivalent to <literal>&lt;version type=\"timestamp\"&gt;</literal>. And <literal>&lt;timestamp source=\"db\"&gt;</literal> is equivalent to <literal>&lt;version type=\"dbtimestamp\"&gt;</literal>" +msgstr "<literal>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>&lt;property&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;column&gt;</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>&lt;properties&gt;</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>&lt;formula&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;column&gt;</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>&lt;natural-id&gt;</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>&lt;properties&gt;</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>&lt;component&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;property&gt;</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>&lt;dynamic-component&gt;</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>&lt;properties&gt;</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>&lt;properties&gt;</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>&lt;subclass&gt;</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>&lt;natural-id&gt;</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>&lt;component&gt;</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>&lt;version&gt;</literal> et <literal>&lt;id&gt;</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>&lt;joined-subclass&gt;</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>&lt;property&gt;</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>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity." +msgstr "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>&lt;key&gt;</literal>. Le mapping au début de ce chapitre serait ré-écrit ainsi :" + +#: index.docbook:1919 +msgid "The <literal>&lt;dynamic-component&gt;</literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map, see <xref linkend=\"components-dynamic\"/>." +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>&lt;properties&gt;</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>&lt;class&gt;</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>&lt;union-subclass&gt;</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>&lt;properties&gt;</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>&lt;join&gt;</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>&lt;subclass&gt;</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>&lt;hibernate-mapping&gt;</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>&lt;hibernate-mapping&gt;</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>&lt;jointure&gt;</literal> définie par une sous-classe. Si positionné à <literal>select</literal> alors Hibernate utilisera un select séquentiel pour une <literal>&lt;jointure&gt;</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>&lt;jointure&gt;</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>&lt;version&gt;</literal> and <literal>&lt;id&gt;</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>&lt;joined-subclass&gt;</literal> element." +msgstr "Nous avons rencontré l'élément <literal>&lt;key&gt;</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>&lt;key&gt;</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>&lt;key not-null=\"true\"&gt;</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>&lt;class&gt;</literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal>&lt;union-subclass&gt;</literal> mapping." +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>&lt;column&gt;</literal>. De façon identique, <literal>&lt;formula&gt;</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>&lt;join&gt;</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>&lt;join&gt;</literal> defined by a class or its superclasses and an outer join for a <literal>&lt;join&gt;</literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal>&lt;join&gt;</literal> defined on a subclass, 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>&lt;join&gt;</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>&lt;key&gt;</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>&lt;key not-null=\"true\"&gt;</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>&lt;class&gt;</literal>, <literal>&lt;subclass&gt;</literal> et ainsi de suite. Pour les types valeurs nous utilisons <literal>&lt;property&gt;</literal>, <literal>&lt;component&gt;</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>&lt;column&gt;</literal> subelement. Likewise, <literal>&lt;formula&gt;</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>&lt;any&gt;</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>&lt;class&gt;</literal>, <literal>&lt;subclass&gt;</literal> and so on. For value types we use <literal>&lt;property&gt;</literal>, <literal>&lt;component&gt;</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>&lt;column&gt;</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>&lt;type&gt;</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>&lt;typedef&gt;</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&gt;(a)hibernate.tags&lt;/literal&gt;. 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>&lt;column&gt;</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>&lt;type&gt;</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>&lt;typedef&gt;</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&gt;(a)hibernate.tags&lt;/literal&gt;. 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@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@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>&lt;component&gt;</literal>." +msgstr "Découpez finement vos classes et mappez les en utilisant <literal>&lt;component&gt;</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>&lt;natural-id&gt;</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>&lt;natural-id&gt;</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@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>&lt;set&gt;</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>&lt;set&gt;</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>&lt;set&gt;</literal>, there is also <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal>, <literal>&lt;array&gt;</literal> and <literal>&lt;primitive-array&gt;</literal> mapping elements. The <literal>&lt;map&gt;</literal> element is representative:" +msgstr "À part <literal>&lt;set&gt;</literal>, il y aussi les éléments de mapping <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal>, <literal>&lt;array&gt;</literal> et <literal>&lt;primitive-array&gt;</literal>. L'élément <literal>&lt;map&gt;</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>&lt;key&gt;</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>&lt;key&gt;</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>&lt;key&gt;</literal> element." +msgstr "Voir le chapitre précédent pour une définition complète de l'élément <literal>&lt;key&gt;</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>&lt;element&gt;</literal> or <literal>&lt;composite-element&gt;</literal>, or in the case of entity references, with <literal>&lt;one-to-many&gt;</literal> or <literal>&lt;many-to-many&gt;</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>&lt;element&gt;</literal> ou <literal>&lt;composite-element&gt;</literal>, ou dans le cas des références d'entité, avec <literal>&lt;one-to-many&gt;</literal> ou <literal>&lt;many-to-many&gt;</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>&lt;map-key&gt;</literal>, it may be an entity reference mapped with <literal>&lt;map-key-many-to-many&gt;</literal>, or it may be a composite type, mapped with <literal>&lt;composite-map-key&gt;</literal>. The index of an array or list is always of type <literal>integer</literal> and is mapped using the <literal>&lt;list-index&gt;</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>&lt;map-key&gt;</literal>, ça peut être une référence d'entité mappée avec <literal>&lt;map-key-many-to-many&gt;</literal>, ou ça peut être un type composé, mappé avec <literal>&lt;composite-map-key&gt;</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>&lt;list-index&gt;</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>&lt;bag&gt;</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>&lt;bag&gt;</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>&lt;element&gt;</literal> tag." +msgstr "Pour une collection de valeurs, nous utilisons la balise <literal>&lt;element&gt;</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>&lt;many-to-many&gt;</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>&lt;many-to-many&gt;</literal! 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>&lt;many-to-many&gt;</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! 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>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</literal> association is declared <literal>NOT NULL</literal>, you must declare the <literal>&lt;key&gt;</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>&lt;one-to-many&gt;</literal> est déclarée <literal>NOT NULL</literal>, vous devez déclarer le mapping de <literal>&lt;key&gt;</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>&lt;list&gt;</literal> or <literal>&lt;map&gt;</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>&lt;list&gt;</literal> ou une <literal>&lt;map&gt;</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 &lt;idbag&gt;" +msgstr "Utiliser un <literal>&lt;idbag&gt;</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>&lt;idbag&gt;</literal> element lets you map a <literal>List</literal> (or <literal>Collection</literal>) with bag semantics." +msgstr "L'élément <literal>&lt;idbag&gt;</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>&lt;idbag&gt;</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>&lt;idbag&gt;</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>&lt;idbag&gt;</literal> is <emphasis>much</emphasis> better than a regular <literal>&lt;bag&gt;</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>&lt;idbag&gt;</literal> sont <emphasis>bien</emphasis> meilleures qu'un <literal>&lt;bag&gt;</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>&lt;idbag&gt;</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>&lt;idbag&gt;</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>&lt;key&gt;</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>&lt;key&gt;</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@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>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity." +msgstr "Le <literal>&lt;component&gt;</literal> peut inclure dans la liste de ses propriétés une référence au <literal>&lt;parent&gt;</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>&lt;element&gt;</literal> tag with a <literal>&lt;composite-element&gt;</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>&lt;element&gt;</literal> par le tag <literal>&lt;composite-element&gt;</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>&lt;nested-composite-element&gt;</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>&lt;nested-composite-element&gt;</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>&lt;set&gt;</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>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal> or <literal>&lt;idbag&gt;</literal>." +msgstr "Remarque, le mapping d'éléments composites ne supporte pas la nullité des propriétés lorsqu'on utilise un <literal>&lt;set&gt;</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>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal> ou <literal>&lt;idbag&gt;</literal>." + +#: index.docbook:113 +msgid "A special case of a composite element is a composite element with a nested <literal>&lt;many-to-one&gt;</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>&lt;many-to-one&gt;</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>&lt;composite-map-key&gt;</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>&lt;composite-map-key&gt;</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>&lt;composite-id&gt;</literal> tag (with nested <literal>&lt;key-property&gt;</literal> elements) in place of the usual <literal>&lt;id&gt;</literal> declaration. For example, the <literal>OrderLine</literal> class has a primary key that depends upon the (composite) primary key of <literal>Order</literal>." +msgstr "Utiliser l'élément <literal>&lt;composite-id&gt;</literal> (en incluant l'élément <literal>&lt;key-property&gt;</literal>) à la place de l'habituel déclaration <literal>&lt;id&gt;</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>&lt;column&gt;</literal> tag is an alternative to the <literal>column</literal> attribute everywhere.)" +msgstr "(Remarque: l'élément <literal>&lt;column&gt;</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>&lt;one-to-many&gt;</literal> element, as usual, declares no columns.)" +msgstr "(L'élément <literal>&lt;one-to-many&gt;</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>&lt;dynamic-component&gt;</literal> mapping are identical to <literal>&lt;component&gt;</literal>. The advantage of this kind of mapping is the ability to determine the actual properties of the bean at deployment time, just by editing the mapping document. Runtime manipulation of the mapping document is also possible, using a DOM parser. 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>&lt;dynamic-component&gt;</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@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>&lt;property&gt;</literal> elements in <literal>hibernate.cfg.xml</literal> (discussed later)." +msgstr "Inclure des éléments <literal>&lt;property&gt;</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>&lt;propertyName&gt;</emphasis>" + +#: index.docbook:698 +msgid "hibernate.connection.<emphasis>&lt;propertyName&gt;</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>&lt;propertyName&gt;</emphasis>" + +#: index.docbook:707 +msgid "hibernate.jndi.<emphasis>&lt;propertyName&gt;</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>&lt;cache&gt;</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>&lt;cache&gt;</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&mdash;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&mdash;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@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>&lt;listener/&gt;</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>&lt;listener/&gt;</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>&lt;listener type=\"...\" class=\"...\"/&gt;</literal> est juste un raccourci pour <literal>&lt;event type=\"...\"&gt;&lt;listener class=\"...\"/&gt;&lt;/event&gt;</literal> quand il y a exactement un listener pour un type d'événement particulier." + +#: index.docbook:146 +msgid "Note that <literal>&lt;listener type=\"...\" class=\"...\"/&gt;</literal> is just a shorthand for <literal>&lt;event type=\"...\"&gt;&lt;listener class=\"...\"/&gt;&lt;/event&gt;</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@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@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>&lt;one-to-many&gt;</literal> association from <literal>Parent</literal> to <literal>Child</literal>. (The alternative approach is to declare the <literal>Child</literal> as a <literal>&lt;composite-element&gt;</literal>.) 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>&lt;one-to-many&gt;</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>&lt;composite-element&gt;</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>&lt;one-to-many&gt;</literal> association from <literal>Parent</literal> to <literal>Child</literal>." +msgstr "Supposons que nous ayons une simple association <literal>&lt;one-to-many&gt;</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>&lt;composite-element&gt;</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>&lt;composite-element&gt;</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@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@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>&lt;filter-def/&gt;</literal> element within a <literal>&lt;hibernate-mapping/&gt;</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>&lt;filter-def/&gt;</literal> dans un élément <literal>&lt;hibernate-mapping/&gt;</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>&lt;filter-def/&gt;</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@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>&lt;subclass&gt;</literal>, and <literal>&lt;joined-subclass&gt;</literal> and <literal>&lt;union-subclass&gt;</literal> mappings under the same root <literal>&lt;class&gt;</literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies, under the the same <literal>&lt;class&gt;</literal> element, by combining the <literal>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</literal> elements (see below)." +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>&lt;subclass&gt;</literal> et <literal>&lt;joined-subclass&gt;</literal> et <literal>&lt;union-subclass&gt;</literal> pour le même élément <literal>&lt;class&gt;</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>&lt;class&gt;</literal>, en combinant les éléments <literal>&lt;subclass&gt;</literal> et <literal>&lt;join&gt;</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>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</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>&lt;subclass&gt;</literal> et <literal>&lt;join&gt;</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>&lt;many-to-one&gt;</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>&lt;many-to-one&gt;</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>&lt;union-subclass&gt;</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>&lt;union-subclass&gt;</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>[ &lt;!ENTITY allproperties SYSTEM \"allproperties.xml\"&gt; ]</literal> in the <literal>DOCTYPE</literal> declartion and <literal>&amp;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>[ &lt;!ENTITY allproperties SYSTEM \"allproperties.xml\"&gt; ]</literal> dans la déclaration du <literal>DOCTYPE</literal> et <literal>&amp;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>&lt;any&gt;</literal>." +msgstr "Pour cette stratégie de mapping, une association polymorphique pour <literal>Payment</literal> est habituellement mappée en utilisant <literal>&lt;any&gt;</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>&lt;class&gt;</literal> element (and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy! (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>&lt;class&gt;</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>&lt;union-subclass&gt;</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>&lt;union-subclass&gt;</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 "&lt;many-to-one&gt;" +msgstr "&lt;many-to-one&gt;" + +#: index.docbook:291, index.docbook:302, index.docbook:313 +msgid "&lt;one-to-one&gt;" +msgstr "&lt;one-to-one&gt;" + +#: index.docbook:292, index.docbook:303 +msgid "&lt;one-to-many&gt;" +msgstr "&lt;one-to-many&gt;" + +#: index.docbook:293, index.docbook:304, index.docbook:315 +msgid "&lt;many-to-many&gt;" +msgstr "&lt;many-to-many&gt;" + +#: 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>&lt;one-to-many&gt;</literal> (for <literal>inverse=\"true\"</literal> only)" +msgstr "<literal>&lt;one-to-many&gt;</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 "&lt;any&gt;" +msgstr "&lt;any&gt;" + +#: index.docbook:324, index.docbook:325, index.docbook:329, index.docbook:330 +msgid "not supported" +msgstr "non supporté" + +#: index.docbook:326 +msgid "&lt;many-to-any&gt;" +msgstr "&lt;many-to-any&gt;" + +#: 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@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>&lt;cache&gt;</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>&lt;cache&gt;</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>&lt;class-cache&gt;</literal> and <literal>&lt;collection-cache&gt;</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>&lt;class-cache&gt;</literal> et <literal>&lt;collection-cache&gt;</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>&lt;key&gt;</literal> and <literal>&lt;index&gt;</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>&lt;key&gt;</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>&lt;set&gt;</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>&lt;key&gt;</literal>) et <literal>&lt;index&gt;</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>&lt;idbag&gt;</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>&lt;key&gt;</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>&lt;set&gt;</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>&lt;idbag&gt;</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@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@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@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>&lt;natural-id&gt;</literal>, and enable use of the second-level cache." +msgstr "D'abord vous devriez mapper la clef naturelle de votre entité en utilisant <literal>&lt;natural-id&gt;</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@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>&lt;any&gt;</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>&lt;any&gt;</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>=, &gt;=, &lt;=, &lt;&gt;, !=, 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>=, &gt;=, &lt;=, &lt;&gt;, !=, 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 &amp; 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 &amp; 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@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 "" + "&lt;sql-query name=\"persons\"&gt;\n" + " &lt;return alias=\"person\" class=\"eg.Person\"/&gt;\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" + "&lt;/sql-query&gt;" + +#: 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>&lt;return-join&gt;</literal> et <literal>&lt;load-collection&gt;</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 "" + "&lt;sql-query name=\"personsWith\"&gt;\n" + " &lt;return alias=\"person\" class=\"eg.Person\"/&gt;\n" + " &lt;return-join alias=\"address\" property=\"person.mailingAddress\"/&gt;\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" + "&lt;/sql-query&gt;" + +#: 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>&lt;return-scalar&gt;</literal> :" + +#: index.docbook:266 +msgid "ORGID as {coll.key}" +msgstr "" + "&lt;sql-query name=\"mySqlQuery\"&gt;\n" + " &lt;return-scalar column=\"name\" type=\"string\"/&gt;\n" + " &lt;return-scalar column=\"age\" type=\"long\"/&gt;\n" + " SELECT p.NAME AS name,\n" + " p.AGE AS age,\n" + " FROM PERSON p WHERE p.NAME LIKE 'Hiber%'\n" + "&lt;/sql-query&gt;" + +#: 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>&lt;resultset&gt;</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 "" + "&lt;resultset name=\"personAddress\"&gt;\n" + " &lt;return alias=\"person\" class=\"eg.Person\"/&gt;\n" + " &lt;return-join alias=\"address\" property=\"person.mailingAddress\"/&gt;\n" + "&lt;/resultset&gt;\n" + "\n" + "&lt;sql-query name=\"personsWith\" resultset-ref=\"personAddress\"&gt;\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" + "&lt;/sql-query&gt;" + +#: 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>&lt;return-property&gt;</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 "" + "&lt;sql-query name=\"mySqlQuery\"&gt;\n" + " &lt;return alias=\"person\" class=\"eg.Person\"&gt;\n" + " &lt;return-property name=\"name\" column=\"myName\"/&gt;\n" + " &lt;return-property name=\"age\" column=\"myAge\"/&gt;\n" + " &lt;return-property name=\"sex\" column=\"mySex\"/&gt;\n" + " &lt;/return&gt;\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" + "&lt;/sql-query&gt;" + +#: index.docbook:282 +msgid "XID as {coll.element}" +msgstr "<literal>&lt;return-property&gt;</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 "" + "&lt;sql-query name=\"organizationCurrentEmployments\"&gt;\n" + " &lt;return alias=\"emp\" class=\"Employment\"&gt;\n" + " &lt;return-property name=\"salary\"&gt;\n" + " &lt;return-column name=\"VALUE\"/&gt;\n" + " &lt;return-column name=\"CURRENCY\"/&gt;\n" + " &lt;/return-property&gt;\n" + " &lt;return-property name=\"endDate\" column=\"myEndDate\"/&gt;\n" + " &lt;/return&gt;\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" + "&lt;/sql-query&gt;" + +#: index.docbook:288 +msgid "{[aliasname].element.[propertyname]}" +msgstr "Notez que dans cet exemple nous avons utilisé <literal>&lt;return-property&gt;</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>&lt;return-discriminator&gt;</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>&lt;return-join&gt;</literal> et <literal>&lt;load-collection&gt;</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>&lt;sql-insert&gt;</literal>, <literal>&lt;sql-delete&gt;</literal>, et <literal>&lt;sql-update&gt;</literal> surchargent ces chaînes de caractères :" + +#: index.docbook:350 +msgid "Native sql queries support positional as well as named parameters:" +msgstr "" + "&lt;class name=\"Person\"&gt;\n" + " &lt;id name=\"id\"&gt;\n" + " &lt;generator class=\"increment\"/&gt;\n" + " &lt;/id&gt;\n" + " &lt;property name=\"name\" not-null=\"true\"/&gt;\n" + " &lt;sql-insert&gt;INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )&lt;/sql-insert&gt;\n" + " &lt;sql-update&gt;UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?&lt;/sql-update&gt;\n" + " &lt;sql-delete&gt;DELETE FROM PERSON WHERE ID=?&lt;/sql-delete&gt;\n" + "&lt;/class&gt;" + +#: 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 "" + "&lt;class name=\"Person\"&gt;\n" + " &lt;id name=\"id\"&gt;\n" + " &lt;generator class=\"increment\"/&gt;\n" + " &lt;/id&gt;\n" + " &lt;property name=\"name\" not-null=\"true\"/&gt;\n" + " &lt;sql-insert callable=\"true\"&gt;{call createPerson (?, ?)}&lt;/sql-insert&gt;\n" + " &lt;sql-delete callable=\"true\"&gt;{? = call deletePerson (?)}&lt;/sql-delete&gt;\n" + " &lt;sql-update callable=\"true\"&gt;{? = call updatePerson (?, ?)}&lt;/sql-update&gt;\n" + "&lt;/class&gt;" + +#: 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>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</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>&lt;return-scalar&gt;</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>&lt;resultset&gt;</literal> element to either reuse them accross several named queries or through the <literal>setResultSetMapping()</literal> API." +msgstr "" + "&lt;sql-query name=\"person\"&gt;\n" + " &lt;return alias=\"pers\" class=\"Person\" lock-mode=\"upgrade\"/&gt;\n" + " SELECT NAME AS {pers.name}, ID AS {pers.id}\n" + " FROM PERSON\n" + " WHERE ID=?\n" + " FOR UPDATE\n" + "&lt;/sql-query&gt;" + +#: 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 "" + "&lt;class name=\"Person\"&gt;\n" + " &lt;id name=\"id\"&gt;\n" + " &lt;generator class=\"increment\"/&gt;\n" + " &lt;/id&gt;\n" + " &lt;property name=\"name\" not-null=\"true\"/&gt;\n" + " &lt;loader query-ref=\"person\"/&gt;\n" + "&lt;/class&gt;" + +#: 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>&lt;return-property&gt;</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 "" + "&lt;set name=\"employments\" inverse=\"true\"&gt;\n" + " &lt;key/&gt;\n" + " &lt;one-to-many class=\"Employment\"/&gt;\n" + " &lt;loader query-ref=\"employments\"/&gt;\n" + "&lt;/set&gt;" + +#: 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 "" + "&lt;sql-query name=\"employments\"&gt;\n" + " &lt;load-collection alias=\"emp\" role=\"Person.employments\"/&gt;\n" + " SELECT {emp.*}\n" + " FROM EMPLOYMENT emp\n" + " WHERE EMPLOYER = :id\n" + " ORDER BY STARTDATE ASC, EMPLOYEE ASC\n" + "&lt;/sql-query&gt;" + +#: index.docbook:408 +msgid "<literal>&lt;return-property&gt;</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 "" + "&lt;sql-query name=\"person\"&gt;\n" + " &lt;return alias=\"pers\" class=\"Person\"/&gt;\n" + " &lt;return-join alias=\"emp\" property=\"pers.employments\"/&gt;\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" + "&lt;/sql-query&gt;" + +#: index.docbook:415 +msgid "Notice that in this example we used <literal>&lt;return-property&gt;</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>&lt;return-discriminator&gt;</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>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</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(&lt;parameters&gt;) }</literal> or <literal>{ ? = call procedureName(&lt;parameters&gt;}</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>&lt;sql-insert&gt;</literal>, <literal>&lt;sql-delete&gt;</literal>, and <literal>&lt;sql-update&gt;</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@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@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>&lt;hibernate-mapping&gt;</literal> element requires a global unique name for the query, while a query declaration inside a <literal>&lt;class&gt;</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>&lt;version&gt;</literal> ou <literal>&lt;timestamp&gt;</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>&lt;version&gt;</literal> or <literal>&lt;timestamp&gt;</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>&lt;many-to-one&gt;</literal> ou <literal>&lt;many-to-many&gt;</literal>. Les cascades sont souvent utiles pour des associations <literal>&lt;one-to-one&gt;</literal> et <literal>&lt;one-to-many&gt;</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>&lt;many-to-one&gt;</literal> or <literal>&lt;many-to-many&gt;</literal> association. Cascade is often useful for <literal>&lt;one-to-one&gt;</literal> and <literal>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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@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>&lt;column&gt;</literal> element. This is particularly useful for mapping multi-column types:" +msgstr "Plusieurs éléments de mapping acceptent aussi un élément fils <literal>&lt;column&gt;</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>&lt;one-to-one&gt;</literal>, <literal>&lt;many-to-one&gt;</literal>, <literal>&lt;key&gt;</literal>, or <literal>&lt;many-to-many&gt;</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 &lt;one-to-one&gt;, &lt;many-to-one&gt;, &lt;key&gt;, et &lt;many-to-many&gt; 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>&lt;column&gt;</literal> element only)" +msgstr "surcharge le type par défaut (attribut de l'élément <literal>&lt;column&gt;</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>&lt;comment&gt;</literal> element allows you to specify comments for the generated schema." +msgstr "L'élément <literal>&lt;comment&gt;</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>&lt;property&gt;</emphasis>" +msgstr "comme propriétés système avec <literal>-D</literal><emphasis>&lt;property&gt;</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@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>&lt;version&gt;</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>&lt;version&gt;</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>&lt;class&gt;</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>&lt;class&gt;</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>&lt;class&gt;</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>&lt;class&gt;</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>&lt;class&gt;</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>&lt;class&gt;</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@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>&lt;session-factory&gt;</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>&lt;session-factory&gt;</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>&lt;set&gt;</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>&lt;key&gt;</literal>, et le nom de la colonne pour l'événement dans l'attribut <literal>column</literal> de <literal>&lt;many-to-many&gt;</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>&lt;set&gt;</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>&lt;key&gt;</literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal>&lt;many-to-many&gt;</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&mdash; 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>&mdash; 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&mdash;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>&mdash;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&mdash;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&mdash;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@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>&lt;one-to-many&gt;</literal> mapping, the data might look more like this:" +msgstr "Si vous positionnez <literal>embed-xml=\"true\"</literal> sur le mapping <literal>&lt;one-to-many&gt;</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@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.openc... +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.openc... + +#: 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(a)redhat.com key is:" +msgstr "The GPG fingerprint of the security(a)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@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 "&copyrightHolder;" +msgstr "&copyrightHolder;" + +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@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@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>&lt;key&gt;</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>&lt;column&gt;</literal> element, but on the <literal>&lt;key&gt;</literal> element." +msgstr "もし外部キーカラムが <literal>NOT NULL</literal> であるならば、 コレクションマッピングの <literal>&lt;key&gt;</literal> 要素を <literal>not-null=\"true\"</literal> にすることは重要です。 入れ子になった <literal>&lt;column&gt;</literal> 要素だけではなく、 <literal>&lt;key&gt;</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@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>&lt;class&gt;</literal> mappings, as shown above. It is however good practice (and expected by some tools) to map only a single persistent class (or a single class hierarchy) in one mapping file and name it after the persistent superclass, 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>&lt;class&gt;</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>&lt;hibernate-mapping&gt;</literal> element." +msgstr "<literal>schema</literal> （オプション）： ルートの <literal>&lt;hibernate-mapping&gt;</literal> 要素で指定されたスキーマ名をオーバーライドします。" + +#: index.docbook:246, index.docbook:2210 +msgid "<literal>catalog</literal> (optional): Override the catalog name specified by the root <literal>&lt;hibernate-mapping&gt;</literal> element." +msgstr "<literal>catalog</literal> （オプション）：ルートの <literal>&lt;hibernate-mapping&gt;</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>&lt;union-subclass&gt;</literal> hierarchies." +msgstr "<literal>abstract</literal> （オプション）： <literal>&lt;union-subclass&gt;</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>&lt;subclass&gt;</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>&lt;subclass&gt;</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>&lt;class&gt;</literal> declaration as a <literal>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</literal>. For most purposes the default, <literal>polymorphism=\"implicit\"</literal>, is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table (this allows a \"lightweight\" class that contains a subset of the table columns)." +msgstr "<emphasis>暗黙的</emphasis> ポリモーフィズムとは、次の二つを意味しています。 一つはクラスのインスタンスが、スーパークラスや実装したインターフェイス、またそのクラスを指定するクエリによって返されることで、 もう一つはそのクラスのサブクラスのインスタンスが、そのクラス自身を指定したクエリによって返されることです。 また、<emphasis>明示的</emphasis> ポリモーフィズムとは、次の二つを意味しています。 一つはクラスのインスタンスが、そのクラスを明示的に指定したクエリによってのみ返されることで、 もう一つはクラスを指定したクエリが、<literal>&lt;class&gt;</literal> 要素の中で <literal>&lt;subclass&gt;</literal> や <literal>&lt;joined-subclass&gt;</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>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</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>&lt;subclass&gt;</literal> や <literal>&lt;joined-subclass&gt;</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>&lt;subselect&gt;</literal> is available as both as an attribute and a nested mapping element." +msgstr "テーブルをこのエンティティと同期するように定義してください。 オートフラッシュが確実に起こるように、また導出エンティティに対するクエリが古いデータを 返さないようにするためです。 <literal>&lt;subselect&gt;</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>&lt;id&gt;</literal> element defines the mapping from that property to the primary key column." +msgstr "マップされたクラスはデータベーステーブルの主キーカラムを定義 <emphasis>しなければなりません</emphasis> 。 ほとんどのクラスにはインスタンスのユニークな識別子を保持するJavaBeansスタイルのプロパティもあります。 <literal>&lt;id&gt;</literal> 要素は、そのプロパティから主キーカラムへのマッピングを定義します。" + +#: 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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "\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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot; +\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>&lt;composite-id&gt;</literal> declaration to allow access to legacy data with composite keys. We strongly discourage its use for anything else." +msgstr "複合キーを持つレガシーデータにアクセスできるように、 <literal>&lt;composite-id&gt;</literal> という代替のマッピング定義があります。 しかし他の用途への使用は全くおすすめできません。" + +#: index.docbook:532 +msgid "Generator" +msgstr "ジェネレータ" + +#: index.docbook:534 +msgid "The optional <literal>&lt;generator&gt;</literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal>&lt;param&gt;</literal> element." +msgstr "オプションの <literal>&lt;generator&gt;</literal> 子要素は、 永続クラスのインスタンスのユニークな識別子を生成するために使う、Javaクラスを指定します。 ジェネレータインスタンスの設定、もしくは初期化にパラメータが必要であれば、<literal>&lt;param&gt;</literal> 要素を使って渡すことができます。" + +#: 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>&lt;generator&gt;</literal> element is specified." +msgstr "<literal>save()</literal> が呼ばれる前に、 アプリケーションがオブジェクトに識別子を代入できるようにします。 <literal>&lt;generator&gt;</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>&lt;one-to-one&gt;</literal> primary key association." +msgstr "他の関連オブジェクトの識別子を使います。 普通は、<literal>&lt;one-to-one&gt;</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>&lt;generator&gt;</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>&lt;generator&gt;</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>&lt;composite-id&gt;</literal> 要素は、子要素として <literal>&lt;key-property&gt;</literal> プロパティマッピングと <literal>&lt;key-many-to-one&gt;</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>&lt;composite-id&gt;</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>&lt;discriminator&gt;</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>&lt;class&gt;</literal> と <literal>&lt;subclass&gt;</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>&lt;composite-id&gt;</literal> element accepts <literal>&lt;key-property&gt;</literal> property mappings and <literal>&lt;key-many-to-one&gt;</literal> mappings as child elements." +msgstr "<literal>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>&lt;version&gt;</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>&lt;composite-id&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot; +\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&mdash;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>&lt;timestamp&gt;</literal> 要素は、 テーブルがタイムスタンプデータを含むことを示します。 これはバージョン付けの代わりの方法として用意されています。 タイムスタンプはもともと楽観的ロックにおける安全性の低い実装です。 しかしアプリケーションは異なる用途で使うこともあるかもしれません。" + +#: index.docbook:1040 +msgid "The <literal>&lt;discriminator&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot; +\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>&lt;class&gt;</literal> and <literal>&lt;subclass&gt;</literal> elements." +msgstr "<literal>&lt;timestamp&gt;</literal> は <literal>&lt;version type=\"timestamp\"&gt;</literal> と等価であることに注意してください。 <literal>&lt;timestamp source=\"db\"&gt;</literal> は <literal>&lt;version type=\"dbtimestamp\"&gt;</literal> と等価であることに注意してください。" + +#: 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>&lt;property&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot; +\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>&lt;version&gt;</literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis> (see below)." +msgstr "<literal>column</literal>（オプション - デフォルトはプロパティ名）： マッピングされたデータベーステーブルのカラムの名前。 ネストした <literal>&lt;column&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" +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>&lt;timestamp&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" +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>&lt;formula&gt;</literal> マッピング要素を使えることにも注意してください。" + +#: index.docbook:1274 +msgid "Note that <literal>&lt;timestamp&gt;</literal> is equivalent to <literal>&lt;version type=\"timestamp\"&gt;</literal>. And <literal>&lt;timestamp source=\"db\"&gt;</literal> is equivalent to <literal>&lt;version type=\"dbtimestamp\"&gt;</literal>" +msgstr "many-to-one" + +#: index.docbook:1284 +msgid "property" +msgstr "他の永続クラスへの通常の関連は <literal>many-to-one</literal> 要素を使って定義します。 リレーショナルモデルは多対一関連です。 つまりあるテーブルの外部キーは、ターゲットとなるテーブルの主キーカラムを参照しています。" + +#: index.docbook:1286 +msgid "The <literal>&lt;property&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot; +\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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;column&gt;</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>&lt;column&gt;</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>&lt;formula&gt;</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>&lt;properties&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;column&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot; +\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>&lt;properties&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;property&gt;</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>&lt;component&gt;</literal> 要素は、親エンティティへ戻る参照として、 コンポーネントのクラスのプロパティをマッピングする <literal>&lt;parent&gt;</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>&lt;dynamic-component&gt;</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>&lt;properties&gt;</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>&lt;natural-id&gt;</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>&lt;properties&gt;</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>&lt;component&gt;</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>&lt;version&gt;</literal> と <literal>&lt;id&gt;</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>&lt;property&gt;</literal> tags map properties of the child class to table columns." +msgstr "joined-subclass" + +#: index.docbook:1913 +msgid "The <literal>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity." +msgstr "もう1つの方法として、各サブクラスを自身のテーブルへマッピングすることができます (table-per-subclass mapping strategy)。 継承した状態はスーパークラスのテーブルを使った結合で検索します。 <literal>&lt;joined-subclass&gt;</literal> 要素を使用します。" + +#: index.docbook:1919 +msgid "The <literal>&lt;dynamic-component&gt;</literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map, see <xref linkend=\"components-dynamic\"/>." +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>&lt;properties&gt;</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>&lt;properties&gt;</literal> mapping:" +msgstr "3つ目の選択肢は、継承階層の具象クラスのみをテーブルにマッピングすることです (the table-per-concrete-class戦略)。 それぞれのテーブルは継承の状態を含めすべてのクラスの永続状態を定義します。 Hibernateではその様な継承階層が必ずしも必要ではありません。 単純にそれぞれのクラスを、 別々の <literal>&lt;class&gt;</literal> 宣言を使ってマッピングすることができます。 しかしポリモーフィックな関連(例えば 階層のスーパークラスへの関連)を使いたいなら、 <literal>&lt;union-subclass&gt;</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>&lt;subclass&gt;</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>&lt;join&gt;</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>&lt;version&gt;</literal> and <literal>&lt;id&gt;</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>&lt;hibernate-mapping&gt;</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>&lt;hibernate-mapping&gt;</literal> 要素で指定したカタログ名を オーバーライドします。" + +#: index.docbook:2063 +msgid "joined-subclass" +msgstr "<literal>fetch</literal> (オプション - デフォルトは <literal>join</literal> ): <literal>join</literal> を設定した場合、 Hibernateはデフォルトで、クラスやスーパークラスで定義された <literal>&lt;join&gt;</literal> を検索するのに内部結合を使い、サブクラスで定義された <literal>&lt;join&gt;</literal> を検索するのに外部結合を使います。 <literal>select</literal> を設定した場合には、 Hibernateはサブクラスで定義された <literal>&lt;join&gt;</literal> の選択に順次選択を使います。この場合、 行がサブクラスのインスタンスを代表することがわかった場合にのみ発行されます。 内部結合はクラスやそのスーパークラスで定義された <literal>&lt;join&gt;</literal> を検索 するために使用します。" + +#: 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>&lt;joined-subclass&gt;</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>&lt;key&gt;</literal> element. The mapping at the start of the chapter would be re-written as:" +msgstr "今まで何度か <literal>&lt;key&gt;</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>&lt;class&gt;</literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal>&lt;union-subclass&gt;</literal> mapping." +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>&lt;join&gt;</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>&lt;join&gt;</literal> defined by a class or its superclasses and an outer join for a <literal>&lt;join&gt;</literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal>&lt;join&gt;</literal> defined on a subclass, 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>&lt;join&gt;</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>&lt;any&gt;</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>&lt;key&gt;</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>&lt;key not-null=\"true\"&gt;</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>&lt;column&gt;</literal> subelement. Likewise, <literal>&lt;formula&gt;</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>&lt;class&gt;</literal> や <literal>&lt;subclass&gt;</literal> などを使用します。 値型に対しては <literal>&lt;property&gt;</literal> や <literal>&lt;component&gt;</literal> などを、通常 <literal>type</literal> とともに使います。 この属性の値はHibernateの <emphasis>マッピング型</emphasis> の名前です。 Hibernateは(標準JDKの値型に対して)多くの自由なマッピングを提供します。 後で見るように、自身のマッピング型を記述し、同様にカスタムの変換戦略を実装することができます。" + +#: 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>&lt;any&gt;</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>&lt;class&gt;</literal>, <literal>&lt;subclass&gt;</literal> and so on. For value types we use <literal>&lt;property&gt;</literal>, <literal>&lt;component&gt;</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>&lt;column&gt;</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>&lt;type&gt;</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>&lt;typedef&gt;</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&gt;(a)hibernate.tags&lt;/literal&gt; を使って、 ソースコード内に直接マッピング情報を埋め込むことを好みます。 これは厳密に言えば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>&lt;column&gt;</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>&lt;type&gt;</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>&lt;typedef&gt;</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&gt;(a)hibernate.tags&lt;/literal&gt;. 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@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@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>&lt;component&gt;</literal>." +msgstr "クラスは細かい粒度で書き <literal>&lt;component&gt;</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>&lt;natural-id&gt;</literal>. Implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the properties that make up the natural key." +msgstr "すべてのエンティティに対して自然キーを見つけて、 <literal>&lt;natural-id&gt;</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@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>&lt;set&gt;</literal> element is used for mapping properties of type <literal>Set</literal>." +msgstr "コレクションをマッピングするためのマッピング要素は、インターフェイスの型に依存します。 例えば、<literal>&lt;set&gt;</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>&lt;set&gt;</literal>, there is also <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal>, <literal>&lt;array&gt;</literal> and <literal>&lt;primitive-array&gt;</literal> mapping elements. The <literal>&lt;map&gt;</literal> element is representative:" +msgstr "マッピング要素には <literal>&lt;set&gt;</literal> の他に <literal>&lt;list&gt;</literal>、 <literal>&lt;map&gt;</literal>、<literal>&lt;bag&gt;</literal>、 <literal>&lt;array&gt;</literal>、<literal>&lt;primitive-array&gt;</literal> があります。 代表として、<literal>&lt;map&gt;</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>&lt;key&gt;</literal> element." +msgstr "コレクションのインスタンスは、データベース内では、 そのコレクションを所有するエンティティの外部キーによって識別されます。 この外部キーはコレクションテーブルの <emphasis>コレクションキーカラム</emphasis> と呼ばれます。 コレクションキーカラムは <literal>&lt;key&gt;</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>&lt;key&gt;</literal> element." +msgstr "<literal>&lt;key&gt;</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>&lt;element&gt;</literal> or <literal>&lt;composite-element&gt;</literal>, or in the case of entity references, with <literal>&lt;one-to-many&gt;</literal> or <literal>&lt;many-to-many&gt;</literal>. The first two map elements with value semantics, the next two are used to map entity associations." +msgstr "格納される型は <emphasis>コレクション要素型</emphasis> と呼ばれます。 コレクション要素は、<literal>&lt;element&gt;</literal> または <literal>&lt;composite-element&gt;</literal> によりマッピングされ、エンティティへの参照の場合には <literal>&lt;one-to-many&gt;</literal> または <literal>&lt;many-to-many&gt;</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>&lt;map-key&gt;</literal>, it may be an entity reference mapped with <literal>&lt;map-key-many-to-many&gt;</literal>, or it may be a composite type, mapped with <literal>&lt;composite-map-key&gt;</literal>. The index of an array or list is always of type <literal>integer</literal> and is mapped using the <literal>&lt;list-index&gt;</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>&lt;map-key&gt;</literal> によりマッピングされた基本型か、 <literal>&lt;map-key-many-to-many&gt;</literal> によりマッピングされたエンティティの関連か、 あるいは <literal>&lt;composite-map-key&gt;</literal> によりマッピングされたコンポジット型になります。 配列かリストのインデックスは、常に <literal>integer</literal> 型で、 <literal>&lt;list-index&gt;</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>&lt;bag&gt;</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>&lt;bag&gt;</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>&lt;element&gt;</literal> tag." +msgstr "値のコレクションのために、<literal>&lt;element&gt;</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>&lt;many-to-many&gt;</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>&lt;many-to-many&gt;</literal! 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>&lt;many-to-many&gt;</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>&lt;many-to-many&gt;</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>&lt;one-to-many&gt;</literal> tag indicates that this is a one to many association." +msgstr "<literal>Product</literal> から <literal>Part</literal> への関連は、 <literal>Part</literal> テーブルへの外部キーカラムと、場合によってはインデックスカラムが必要です。 <literal>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</literal> element does not need to declare any columns. Nor is it necessary to specify the <literal>table</literal> name anywhere." +msgstr "<literal>&lt;one-to-many&gt;</literal> 要素はカラムを宣言する必要がないことに注意してください。 同様に <literal>テーブル</literal> 名を指定する必要もありません。" + +#: index.docbook:579 +msgid "<emphasis>Very important note:</emphasis> If the foreign key column of a <literal>&lt;one-to-many&gt;</literal> association is declared <literal>NOT NULL</literal>, you must declare the <literal>&lt;key&gt;</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>&lt;one-to-many&gt;</literal> 関連の外部キーカラムが <literal>NOT NULL</literal>と宣言された場合、 <literal>&lt;key&gt;</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>&lt;list&gt;</literal> or <literal>&lt;map&gt;</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>&lt;list&gt;</literal> や <literal>&lt;map&gt;</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 &lt;idbag&gt;" +msgstr "<literal>&lt;idbag&gt;</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>&lt;idbag&gt;</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>&lt;idbag&gt;</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>&lt;idbag&gt;</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>&lt;idbag&gt;</literal> はエンティティ･クラスのように 人工的なidジェネレータを持っています！ 異なる代理キーをそれぞれのコレクションの列に割り当てます。 しかしながら、Hibernateはある行の代理キーの値を見つけ出す機構を持っていません。" + +#: index.docbook:798 +msgid "Note that the update performance of an <literal>&lt;idbag&gt;</literal> is <emphasis>much</emphasis> better than a regular <literal>&lt;bag&gt;</literal>! Hibernate can locate individual rows efficiently and update or delete them individually, just like a list, map or set." +msgstr "<literal>&lt;idbag&gt;</literal> を更新するパフォーマンスは 通常の <literal>&lt;bag&gt;</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>&lt;idbag&gt;</literal> collection identifiers." +msgstr "現在の実装では、<literal>native</literal> というid生成戦略を <literal>&lt;idbag&gt;</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>&lt;key&gt;</literal> mapping:" +msgstr "あるいは、もしこの関連は単方向であるべきと強く主張するのであれば、 <literal>&lt;key&gt;</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@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>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity." +msgstr "<literal>&lt;component&gt;</literal> 要素は親エンティティへの逆参照として、コンポーネントクラスの 属性をマッピングする <literal>&lt;parent&gt;</literal> サブ要素を使用できます。" + +#: 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>&lt;element&gt;</literal> tag with a <literal>&lt;composite-element&gt;</literal> tag." +msgstr "Hibernateはコンポーネントのコレクションをサポートしています（例えば <literal>Name</literal> 型の配列）。 <literal>&lt;element&gt;</literal> タグを <literal>&lt;composite-element&gt;</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>&lt;nested-composite-element&gt;</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>&lt;nested-composite-element&gt;</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>&lt;set&gt;</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>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal> or <literal>&lt;idbag&gt;</literal>." +msgstr "もし <literal>&lt;set&gt;</literal> を使用するのであれば、コンポジットエレメントのマッピングがnull値が可能な 属性をサポートしていないことに注意してください。Hibernateはオブジェクトを削除するとき、 レコードを識別するためにそれぞれのカラムの値を使用する必要があるため、null値を持つことが出来ません （コンポジットエレメントテーブルには別の主キーカラムはありません）。 コンポジットエレメントにnot-nullの属性のみを使用するか、または <literal>&lt;list&gt;</literal>、<literal>&lt;map&gt;</literal>、 <literal>&lt;bag&gt;</literal>、<literal>&lt;idbag&gt;</literal> を選択する必要があります。" + +#: index.docbook:113 +msgid "A special case of a composite element is a composite element with a nested <literal>&lt;many-to-one&gt;</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>&lt;many-to-one&gt;</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>&lt;composite-map-key&gt;</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>&lt;composite-map-key&gt;</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>&lt;composite-id&gt;</literal> tag (with nested <literal>&lt;key-property&gt;</literal> elements) in place of the usual <literal>&lt;id&gt;</literal> declaration. For example, the <literal>OrderLine</literal> class has a primary key that depends upon the (composite) primary key of <literal>Order</literal>." +msgstr "通常の <literal>&lt;id&gt;</literal> 宣言の代わりに <literal>&lt;composite-id&gt;</literal> タグを （ネストされた <literal>&lt;key-property&gt;</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>&lt;column&gt;</literal> tag is an alternative to the <literal>column</literal> attribute everywhere.)" +msgstr "（<literal>&lt;column&gt;</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>&lt;one-to-many&gt;</literal> element, as usual, declares no columns.)" +msgstr "（<literal>&lt;one-to-many&gt;</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>&lt;dynamic-component&gt;</literal> mapping are identical to <literal>&lt;component&gt;</literal>. The advantage of this kind of mapping is the ability to determine the actual properties of the bean at deployment time, just by editing the mapping document. Runtime manipulation of the mapping document is also possible, using a DOM parser. Even better, you can access (and change) Hibernate's configuration-time metamodel via the <literal>Configuration</literal> object." +msgstr "<literal>&lt;dynamic-component&gt;</literal> マッピングのセマンティクスは <literal>&lt;component&gt;</literal> と同一のものです。この種のマッピングの利点は、マッピングドキュメントの編集により、配置時に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@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>&lt;property&gt;</literal> elements in <literal>hibernate.cfg.xml</literal> (discussed later)." +msgstr "<literal>&lt;property&gt;</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>&lt;propertyName&gt;</emphasis>" +msgstr "hibernate.connection.<emphasis>&lt;propertyName&gt;</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>&lt;propertyName&gt;</emphasis>" +msgstr "hibernate.jndi.<emphasis>&lt;propertyName&gt;</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>&lt;cache&gt;</literal> mapping." +msgstr "二次キャッシュを完全に無効にする場合に使います。 デフォルトでは有効で、クラスの <literal>&lt;cache&gt;</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&mdash;see chapter 1." +msgstr "管理された環境では <literal>SessionFactory</literal> をJNDIにバインドし、 そうでなければ <literal>static</literal> シングルトンを使うことを推奨します。 こういった詳細からアプリケーションコードを保護するために、 <literal>HibernateUtil.getSessionFactory()</literal> のようなヘルパークラスの中に、 <literal>SessionFactory</literal> をルックアップするコードを隠すことを推奨します。 このようなヘルパークラスはHibernateを開始する便利な手段でもあります。 &mdash;１章を参照してください。" + +#: 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@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>&lt;listener/&gt;</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>&lt;listener/&gt;</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>&lt;listener type=\"...\" class=\"...\"/&gt;</literal> is just a shorthand for <literal>&lt;event type=\"...\"&gt;&lt;listener class=\"...\"/&gt;&lt;/event&gt;</literal> when there is exactly one listener for a particular event type." +msgstr "特定のイベント型に対してちょうど一つのリスナがあるとき、 <literal>&lt;listener type=\"...\" class=\"...\"/&gt;</literal> は <literal>&lt;event type=\"...\"&gt;&lt;listener class=\"...\"/&gt;&lt;/event&gt;</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@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@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>&lt;one-to-many&gt;</literal> association from <literal>Parent</literal> to <literal>Child</literal>. (The alternative approach is to declare the <literal>Child</literal> as a <literal>&lt;composite-element&gt;</literal>.) 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>&lt;one-to-many&gt;</literal> 関連により <literal>親</literal> と <literal>子供</literal> の両方をエンティティクラスとしてモデリングする方法です （もう一つの方法は、<literal>子供</literal> を <literal>&lt;composite-element&gt;</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>&lt;one-to-many&gt;</literal> association from <literal>Parent</literal> to <literal>Child</literal>." +msgstr "<literal>Parent</literal> から <literal>Child</literal> への単純な <literal>&lt;one-to-many&gt;</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>&lt;composite-element&gt;</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>&lt;composite-element&gt;</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@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@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>&lt;filter-def/&gt;</literal> element within a <literal>&lt;hibernate-mapping/&gt;</literal> element:" +msgstr "フィルタを使うためにはまず、適切なマッピング要素に定義、追加しなくてはなりません。 フィルタを定義するためには、 <literal>&lt;hibernate-mapping/&gt;</literal> 要素内で <literal>&lt;filter-def/&gt;</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>&lt;filter-def/&gt;</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@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>&lt;subclass&gt;</literal>, and <literal>&lt;joined-subclass&gt;</literal> and <literal>&lt;union-subclass&gt;</literal> mappings under the same root <literal>&lt;class&gt;</literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies, under the the same <literal>&lt;class&gt;</literal> element, by combining the <literal>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</literal> elements (see below)." +msgstr "同一の継承階層の異なるブランチに対して異なるマッピング戦略を使うことができます。 その場合には全体の階層に渡るポリモーフィズムを実現するために暗黙的ポリモーフィズムを使用します。 しかし、Hibernateは同じルート <literal>&lt;class&gt;</literal> 要素内で <literal>&lt;subclass&gt;</literal> マッピング、<literal>&lt;joined-subclass&gt;</literal> マッピング、 <literal>&lt;union-subclass&gt;</literal> マッピングの同時使用をサポートしていません。 <literal>&lt;subclass&gt;</literal> 要素と <literal>&lt;join&gt;</literal> 要素を組み合わせることで、 同一 <literal>&lt;class&gt;</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>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</literal>, as follow:" +msgstr "Hibernateの table-per-subclass 実装は、discriminatorカラムを必要としないことを覚えておいてください。 Hibernate以外のO/Rマッパーは、table-per-subclass に異なる実装を用います。 それは、スーパークラスのテーブルにタイプdiscriminatorカラムを必要とします。 このアプローチは実装が困難になりますが、関係の視点から見ると、より正確なものです。 table-per-subclass 戦略でdiscriminatorカラムを使いたければ、 <literal>&lt;subclass&gt;</literal> と <literal>&lt;join&gt;</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>&lt;many-to-one&gt;</literal>." +msgstr "いずれのマッピング戦略であっても、ルートである <literal>Payment</literal> クラスへの ポリモーフィックな関連は <literal>&lt;many-to-one&gt;</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>&lt;union-subclass&gt;</literal>." +msgstr "table-per-concrete-class 戦略のマッピングに対するアプローチは、2つあります。 1つ目は <literal>&lt;union-subclass&gt;</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の今後のリリースで緩和されるかもしれません）。 &lt;union-subclass&gt; を使った 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>[ &lt;!ENTITY allproperties SYSTEM \"allproperties.xml\"&gt; ]</literal> in the <literal>DOCTYPE</literal> declartion and <literal>&amp;allproperties;</literal> in the mapping)." +msgstr "<literal>Payment</literal> インターフェイスがどこにも明示的に示されていないことに注意してください。 そして、<literal>Payment</literal> プロパティがそれぞれのサブクラスにマッピングされていることにも注意してください。 もし重複を避けたいのであれば、XMLエンティティの利用を考えてください。 （例： <literal>DOCTYPE</literal> 宣言における <literal>[ &lt;!ENTITY allproperties SYSTEM \"allproperties.xml\"&gt; ]</literal> と、マッピングにおける <literal>&amp;allproperties;</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>&lt;any&gt;</literal>." +msgstr "このマッピング戦略に対しては、<literal>Payment</literal> へのポリモーフィックな関連は 通常、<literal>&lt;any&gt;</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>&lt;class&gt;</literal> element (and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy! (And you can still use polymorphic queries against the <literal>Payment</literal> interface.)" +msgstr "このマッピングについての更なる注意点があります。 サブクラスが自身を <literal>&lt;class&gt;</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>&lt;union-subclass&gt;</literal> mappings." +msgstr "table-per-concrete-class マッピング戦略への「暗黙的ポリモーフィズム」アプローチには いくつかの制限があります。<literal>&lt;union-subclass&gt;</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 "&lt;many-to-one&gt;" +msgstr "&lt;many-to-one&gt;" + +#: index.docbook:291, index.docbook:302, index.docbook:313 +msgid "&lt;one-to-one&gt;" +msgstr "&lt;one-to-one&gt;" + +#: index.docbook:292, index.docbook:303 +msgid "&lt;one-to-many&gt;" +msgstr "&lt;one-to-many&gt;" + +#: index.docbook:293, index.docbook:304, index.docbook:315 +msgid "&lt;many-to-many&gt;" +msgstr "&lt;many-to-many&gt;" + +#: 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>&lt;one-to-many&gt;</literal> (for <literal>inverse=\"true\"</literal> only)" +msgstr "<literal>&lt;one-to-many&gt;</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 "&lt;any&gt;" +msgstr "&lt;any&gt;" + +#: index.docbook:324, index.docbook:325, index.docbook:329, index.docbook:330 +msgid "not supported" +msgstr "サポートしていません" + +#: index.docbook:326 +msgid "&lt;many-to-any&gt;" +msgstr "&lt;many-to-any&gt;" + +#: 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@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>&lt;cache&gt;</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>&lt;cache&gt;</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>&lt;class-cache&gt;</literal> and <literal>&lt;collection-cache&gt;</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>&lt;class-cache&gt;</literal> と <literal>&lt;collection-cache&gt;</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>&lt;key&gt;</literal> and <literal>&lt;index&gt;</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>&lt;key&gt;</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>&lt;set&gt;</literal> for you, you must declare all columns as <literal>not-null=\"true\"</literal>.)" +msgstr "<para>bag</para>" + +#: index.docbook:1020 +msgid "<literal>&lt;idbag&gt;</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>&lt;key&gt;</literal> と <literal>&lt;index&gt;</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>&lt;key&gt;</literal> からなる主キーと要素のカラムを持っています。 これはコレクション要素のいくつかの型については効率的ではないかもしれません。 特に複合要素、大きなテキスト、バイナリフィールドでは非効率です。データベースは 複合主キーに効率的にインデックスを付けることができないからです。一方、1対多や多対多関連において、 特に人工識別子の場合は同じぐらい効率的です。（余談： <literal>SchemaExport</literal> で実際に <literal>&lt;set&gt;</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>&lt;idbag&gt;</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@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! + +#: 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@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@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>&lt;natural-id&gt;</literal>, and enable use of the second-level cache." +msgstr "最初に、<literal>&lt;natural-id&gt;</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@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>&lt;any&gt;</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>&lt;any&gt;</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>=, &gt;=, &lt;=, &lt;&gt;, !=, 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>=, &gt;=, &lt;=, &lt;&gt;, !=, 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 &amp; 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 &amp; 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@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>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</literal> elements are used to join associations and define queries which initialize collections, respectively." +msgstr "関連を結合するためとコレクションを初期化するクエリを定義するために、それぞれ <literal>&lt;return-join&gt;</literal> と <literal>&lt;load-collection&gt;</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>&lt;return-scalar&gt;</literal> element:" +msgstr "名前付きSQLクエリはスカラ値を返すこともできます。 <literal>&lt;return-scalar&gt;</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>&lt;resultset&gt;</literal> element to either reuse them accross several named queries or through the <literal>setResultSetMapping()</literal> API." +msgstr "リザルトセットのマッピング情報を <literal>&lt;resultset&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</literal> を使っていることに注意してください。 列とプロパティをどのように参照するかを選べます。" + +#: index.docbook:420 +msgid "If your mapping has a discriminator you must use <literal>&lt;return-discriminator&gt;</literal> to specify the discriminator column." +msgstr "マッピングに discriminator が含まれている場合、 discriminator の列を指定するために、&lt;return-discriminator&gt; を使わなければなりません。" + +#: 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>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</literal> are not supported." +msgstr "注意：今のところ、ストアドプロシージャはスカラとエンティティを返すのみです。 <literal>&lt;return-join&gt;</literal> と <literal>&lt;load-collection&gt;</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(&lt;parameters&gt;) }</literal> or <literal>{ ? = call procedureName(&lt;parameters&gt;}</literal>. Native call syntax is not supported." +msgstr "推奨する呼び出し方は、標準であるSQL92に従うことです。 <literal>{ ? = call functionName(&lt;parameters&gt;) }</literal> や <literal>{ ? = call procedureName(&lt;parameters&gt;) }</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>&lt;sql-insert&gt;</literal>, <literal>&lt;sql-delete&gt;</literal>, and <literal>&lt;sql-update&gt;</literal> override these strings:" +msgstr "Hibernate3は作成、更新、削除処理のためのカスタムSQL文を使用できます。 クラスとコレクションの永続化機構は、コンフィグレーション時に生成された文字列 （insertsql、deletesql、updatesqlなど）のセットをすでに保持しています。 これらの文字列より、 <literal>&lt;sql-insert&gt;</literal>、 <literal>&lt;sql-delete&gt;</literal>、 <literal>&lt;sql-update&gt;</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@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@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>&lt;hibernate-mapping&gt;</literal> の中のクエリ定義は、クエリに対する ユニークな名前が必要なことにも注意してください。それに対して、 <literal>&lt;class&gt;</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>&lt;hibernate-mapping&gt;</literal> element requires a global unique name for the query, while a query declaration inside a <literal>&lt;class&gt;</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>&lt;version&gt;</literal> や <literal>&lt;timestamp&gt;</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>&lt;version&gt;</literal> or <literal>&lt;timestamp&gt;</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>&lt;many-to-one&gt;</literal> や <literal>&lt;many-to-many&gt;</literal> 関連に対しては、 カスケードを設定する意味はありません。 <literal>&lt;one-to-one&gt;</literal> と <literal>&lt;one-to-many&gt;</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>&lt;many-to-one&gt;</literal> or <literal>&lt;many-to-many&gt;</literal> association. Cascade is often useful for <literal>&lt;one-to-one&gt;</literal> and <literal>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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@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>&lt;column&gt;</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>&lt;column&gt;</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 "&lt;one-to-one&gt;、&lt;many-to-one&gt;、&lt;many-to-many&gt;マッピング要素を使って、 関連に対し生成された外部キー制約の名前を指定します。 <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>&lt;one-to-one&gt;</literal>, <literal>&lt;many-to-one&gt;</literal>, <literal>&lt;key&gt;</literal>, or <literal>&lt;many-to-many&gt;</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>&lt;column&gt;</literal> 要素の属性のみ)" + +#: index.docbook:218 +msgid "SQL column type" +msgstr "default" + +#: index.docbook:219 +msgid "overrides the default column type (attribute of <literal>&lt;column&gt;</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>&lt;comment&gt;</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>&lt;property&gt;</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>&lt;property&gt;</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@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>&lt;version&gt;</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>&lt;version&gt;</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>&lt;class&gt;</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>&lt;class&gt;</literal>, Hibernate will only compare dirty fields during flush." +msgstr "レガシーのデータベーススキーマは、しばしば固定的であり、変更できません。 または、他のアプリケーションが同じデータベースにアクセスしなければならず、 そのアプリケーションはバージョン番号やタイムスタンプさえ操作する方法を知りません。 どちらの場合も、テーブルの特定のカラムを当てにして、バージョニングを行えません。 バージョンやタイムスタンプのプロパティをマッピングせずに、バージョンチェックさせるために、 <literal>&lt;class&gt;</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>&lt;class&gt;</literal> mapping, forcing Hibernate to <literal>SELECT</literal> the instance to ensure that changes did actually occur, before updating the row." +msgstr "ときどき、行われた変更が重ならない限り、同時に行われた変更を受け入れることができます。 <literal>&lt;class&gt;</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>&lt;class&gt;</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@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>&lt;session-factory&gt;</literal> configurations, usually in several configuration files (for easier startup)." +msgstr "このXMLの設定が異なるDTDを使うことに注意してください。 特定のデータベースを受け持つグローバルファクトリであるHibernateの <literal>SessionFactory</literal> を設定します。 もし複数のデータベースがある場合には、 （スタートアップを簡単にするため）通常いくつかの設定ファイル内で、 いくつかの <literal>&lt;session-factory&gt;</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ダウンロードページ&l... からダウンロードしてください。 Antのインストール方法はここでは説明しませんので、 <ulink url=\"http://ant.apache.org/manual/index.html\">Antマニュアル<... を参照してください。 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>&lt;set&gt;</literal> です。 多対多関連（または <emphasis>n:m</emphasis> エンティティリレーションシップ）には、 関連テーブルが必要です。 このテーブルのそれぞれの行は、人とイベント間のリンクを表現します。 テーブル名は <literal>set</literal> 要素の <literal>table</literal> 属性で設定します。 人側の関連の識別子カラム名は <literal>&lt;key&gt;</literal> 要素で、 イベント側のカラム名は <literal>&lt;many-to-many&gt;</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>&lt;set&gt;</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>&lt;key&gt;</literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal>&lt;many-to-many&gt;</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&mdash;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>&mdash;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&mdash;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@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>&lt;one-to-many&gt;</literal> mapping, the data might look more like this:" +msgstr "<literal>&lt;one-to-many&gt;</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@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.openc... +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.openc... + +#: 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(a)redhat.com key is:" +msgstr "The GPG fingerprint of the security(a)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@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 "&copyrightHolder;" +msgstr "&copyrightHolder;" + +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@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@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>&lt;key&gt;</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>&lt;column&gt;</literal> element, but on the <literal>&lt;key&gt;</literal> element." +msgstr "만일 기본 외래 키 컬럼이 <literal>NOT NULL</literal>일 경우 콜렉션 매핑의 <literal>&lt;key&gt;</literal> 요소 상에 <literal>not-null=\"true\"</literal>를 정의하는 것이 중요하다. 내포된 <literal>&lt;column&gt;</literal> 요소 상에 <literal>not-null=\"true\"</literal>를 선언하지 말고, <literal>&lt;key&gt;</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@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>&lt;class&gt;</literal> mappings, as shown above. It is however good practice (and expected by some tools) to map only a single persistent class (or a single class hierarchy) in one mapping file and name it after the persistent superclass, 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>&lt;class&gt;</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>&lt;hibernate-mapping&gt;</literal> element." +msgstr "<literal>schema</literal> (옵션): 루트 <literal>&lt;hibernate-mapping&gt;</literal> 요소에 의해 지정된 스키마 이름을 오버라이드 시킨다." + +#: index.docbook:246, index.docbook:2210 +msgid "<literal>catalog</literal> (optional): Override the catalog name specified by the root <literal>&lt;hibernate-mapping&gt;</literal> element." +msgstr "<literal>catalog</literal> (옵션): 루트 <literal>&lt;hibernate-mapping&gt;</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>&lt;union-subclass&gt;</literal> hierarchies." +msgstr "<literal>abstract</literal> (옵션): <literal>&lt;union-subclass&gt;</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>&lt;subclass&gt;</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>&lt;subclass&gt;</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>&lt;class&gt;</literal> declaration as a <literal>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</literal>. For most purposes the default, <literal>polymorphism=\"implicit\"</literal>, is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table (this allows a \"lightweight\" class that contains a subset of the table columns)." +msgstr "<emphasis>Implicit</emphasis> 다형성은 클래스의 인스턴스들이 어떤 서브클래스나 구현된 인터페이스 또는 클래스를 명명하는 질의에 의해 반환될 것임을 의미하고 그 클래스의 어떤 서브클래스에 대한 인스턴스들이 그 클래스 자체를 명명하는 질의에 의해 반환될 것임을 의미한다. <emphasis>Explicit</emphasis> 다형성은 클래스 인스턴스들이 그 클래스를 명시적으로 명명하는 질의들에 의해서만 반환될 것임을 의미고 그 클래스를 명명하는 질의들이 이 <literal>&lt;class&gt;</literal> 선언 내부에서 <literal>&lt;subclass&gt;</literal> 또는 <literal>&lt;joined-subclass&gt;</literal>로 매핑된 서브 클래스들의 인스턴스들 만을 반환하게 될 것임을 의미한다. 대부분의 용도로, 디폴트인 <literal>polymorphism=\"implicit\"</literal>가 적절하다.두 개의 다른 클래스들이 동일한 테이블�! � 매핑될 때 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>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</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>&lt;subclass&gt;</literal> 또는 <literal>&lt;joined-subclass&gt;</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>&lt;subselect&gt;</literal> is available as both as an attribute and a nested mapping element." +msgstr "auto-flush가 정확하게 발생하도록 하고, 그리고 파생된 엔티티에 대한 질의들이 쓸효성 없는 데이터를 반환하지 않도록 함으로써, 이 엔티티와 동기화 될 테이블을 선언하라. <literal>&lt;subselect&gt;</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>&lt;id&gt;</literal> element defines the mapping from that property to the primary key column." +msgstr "매핑된 클래스들은 데이터베이스 테이블의 프라이머리 키 컬럼을 선언<emphasis>해야 한다</emphasis>. 대부분의 클래스들은 또한 인스턴스의 유일 식별자를 소유하는 자바빈즈-스타일 프로퍼티를 가질 것이다. <literal>&lt;id&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "\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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "\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>&lt;composite-id&gt;</literal> declaration to allow access to legacy data with composite keys. We strongly discourage its use for anything else." +msgstr "composite 키들로서 리거시 데이터에 액세스하는 것을 허용해주는 대체적인 <literal>&lt;composite-id&gt;</literal> 선언이 존재한다. 우리는 그 밖의 어떤것에 대한 그것의 사용에 대해 강력하게 반대한다." + +#: index.docbook:532 +msgid "Generator" +msgstr "Generator" + +#: index.docbook:534 +msgid "The optional <literal>&lt;generator&gt;</literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal>&lt;param&gt;</literal> element." +msgstr "선택적인 <literal>&lt;generator&gt;</literal> 자식 요소는 영속 클래스의 인스턴스들에 대한 유일 식별자들을 생성시키는데 사용되는 자바 클래스를 명명한다. 만일 임의의 파라미터들이 생성기 인스턴스를 구성하거나 초기화 시키는데 필요할 경우, 그것들은 <literal>&lt;param&gt;</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>&lt;generator&gt;</literal> element is specified." +msgstr "어플리케이션으로 하여금 <literal>save()</literal>가 호출되기 전에 식별자를 객체에 할당하도록 한다. <literal>&lt;generator&gt;</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>&lt;one-to-one&gt;</literal> primary key association." +msgstr "또 다른 연관된 객체의 식별자를 사용한다. 대개 <literal>&lt;one-to-one&gt;</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>&lt;generator&gt;</literal> element." +msgstr "(Hibernate로 하여금 식별자들을 생성시키도록 하는 것과는 반대로) 당신이 어플리케이션으로 하여금 식별자들을 할당하도록 원할 경우, 당신은 <literal>assigned</literal> 생성기를 사용할 수 있다. 이 특별한 생성기는 객체의 identifier 프로퍼티에 이미 할당된 식별자 값을 사용할 것이다. 이 생성기(generator)는 프라이머리 키가 대용(surrogate ) 키 대신에 natural 키일 때 사용된다. 당신이 <literal>&lt;generator&gt;</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>&lt;composite-id&gt;</literal> 요소는 자식 요소들로서 <literal>&lt;key-property&gt;</literal> 프로퍼티 매핑과 <literal>&lt;key-many-to-one&gt;</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>&lt;composite-id&gt;</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>을 구현해야 한다. 이 접근법의 단점은 아주 명백한&mdash;코드 중복이다." + +#: 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>&lt;discriminator&gt;</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>&lt;composite-id&gt;</literal> element accepts <literal>&lt;key-property&gt;</literal> property mappings and <literal>&lt;key-many-to-one&gt;</literal> mappings as child elements." +msgstr "discriminator 컬럼의 실제 값들은 <literal>&lt;class&gt;</literal> 요소와 <literal>&lt;subclass&gt;</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>&lt;composite-id&gt;</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>&lt;version&gt;</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&mdash;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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" + +#: 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>&lt;discriminator&gt;</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>&lt;timestamp&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" + +#: 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>&lt;class&gt;</literal> and <literal>&lt;subclass&gt;</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>&lt;timestamp&gt;</literal>는 <literal>&lt;version type=\"timestamp\"&gt;</literal>과 같음을 노트하라. 그리고 <literal>&lt;timestamp use-db=\"true\"&gt;</literal>는 <literal>&lt;version type=\"dbtimestamp\"&gt;</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>&lt;property&gt;</literal> 요소는 클래스의 자바빈즈 스타일의 영속 프로퍼티를 선언한다." + +#: index.docbook:1120 +msgid "The <literal>&lt;version&gt;</literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis> (see below)." +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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" +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>&lt;column&gt;</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>&lt;timestamp&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" +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>&lt;timestamp&gt;</literal> is equivalent to <literal>&lt;version type=\"timestamp\"&gt;</literal>. And <literal>&lt;timestamp source=\"db\"&gt;</literal> is equivalent to <literal>&lt;version type=\"dbtimestamp\"&gt;</literal>" +msgstr "" + "<![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>&lt;formula&gt;</literal> 매핑 요소를 사용할 수 있음을 노트하라." + +#: index.docbook:1286 +msgid "The <literal>&lt;property&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;column&gt;</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>&lt;column&gt;</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>&lt;formula&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;properties&gt;</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>&lt;column&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;properties&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;natural-id&gt;</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>&lt;component&gt;</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>&lt;property&gt;</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>&lt;component&gt;</literal> 요소는 컴포넌트 클래스의 프로퍼티를 포함하는 엔티티에 대한 참조로서 매핑시키는 <literal>&lt;parent&gt;</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>&lt;dynamic-component&gt;</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>&lt;properties&gt;</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>&lt;natural-id&gt;</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>&lt;properties&gt;</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>&lt;component&gt;</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>&lt;subclass&gt;</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>&lt;property&gt;</literal> tags map properties of the child class to table columns." +msgstr "각각의 서브클래스는 그것 자신의 영속 프로퍼티들과 서브클래스들을 선언할 것이다. <literal>&lt;version&gt;</literal> 프로퍼티와 <literal>&lt;id&gt;</literal> 프로퍼티는 루트 클래스로부터 상속된다고 가정된다. 계층구조 내에서 각각의 서브클래스는 유일한 <literal>discriminator-value</literal>를 정의해야 한다. none이 지정될 경우, 전체 수식어가 붙은 자바 클래스 이름이 사용된다." + +#: index.docbook:1913 +msgid "The <literal>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity." +msgstr "상속 매핑들에 대한 정보는 <xref linkend=\"inheritance\"/>을 보라." + +#: index.docbook:1919 +msgid "The <literal>&lt;dynamic-component&gt;</literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map, see <xref linkend=\"components-dynamic\"/>." +msgstr "joined-subclass" + +#: index.docbook:1928 +msgid "properties" +msgstr "다른 방법으로 각각의 서브클래스는 그것 자신이 테이블로 매핑될 수 있다(table-per-subclass 매핑 방도). 상속된 상태는 슈퍼클래스의 테이블과 조인함으로써 검색된다. 우리는 <literal>&lt;joined-subclass&gt;</literal> 요소를 사용한다." + +#: index.docbook:1930 +msgid "The <literal>&lt;properties&gt;</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>&lt;key&gt;</literal> 요소를 사용하여 객체 식별자를 보관하는 테이블 컬럼을 선언해야 한다. 이 장의 시작 부분에 있는 매핑은 다음과 같이 다시 작성될 것이다:" + +#: index.docbook:1984 +msgid "For example, if we have the following <literal>&lt;properties&gt;</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>&lt;class&gt;</literal> 선언을 가진 각각의 클래스를 간단히 매핑시킬 수 있다. 하지만 당신이 다형성 연관관계들(예를 들면 당신의 계층구조의 슈퍼클래스에 대한 연관)을 사용하고자 원할 경우, 당신은 <literal>&lt;union-subclass&gt;</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>&lt;subclass&gt;</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>&lt;join&gt;</literal>요소를 사용하면, 테이블들 사이에 1대일 관계가 존재할 때, 하나의 클래스에 속한 프로퍼티들을 여러 테이블들로 매핑시키는 것이 가능하다." + +#: index.docbook:2048 +msgid "Each subclass should declare its own persistent properties and subclasses. <literal>&lt;version&gt;</literal> and <literal>&lt;id&gt;</literal> properties are assumed to be inherited from the root class. Each subclass in a 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>&lt;hibernate-mapping&gt;</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>&lt;joined-subclass&gt;</literal> element." +msgstr "<literal>catalog</literal> (옵션): 루트 <literal>&lt;hibernate-mapping&gt;</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>&lt;join&gt;</literal>을 검색하는데 inner join을 사용하고 서브클래스에 의해 정의된 <literal>&lt;join&gt;</literal>을 검색하는데 outer join을 사용할 것이다. 만일 <literal>select</literal>로 설정할 경우, Hibernate는 서브클래스 상에 정의된 <literal>&lt;join&gt;</literal>에 대해 sequential select를 사용할 것이고, 그것은 한 행이 서브클래스의 인스턴스를 표현하는 것으로 판명되는 경우에만 명령이 내려질 것이다. inner join들은 여전히 클래스와 그것의 슈퍼클래스들에 의해 정의된 <literal>&lt;join&gt;</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>&lt;key&gt;</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>&lt;class&gt;</literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal>&lt;union-subclass&gt;</literal> mapping." +msgstr "<literal>column</literal> (옵션): foreign key 컬럼의 이름. 이것은 또한 내포된 <literal>&lt;column&gt;</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>&lt;join&gt;</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>&lt;column&gt;</literal> 서브요소를 수용할 것이다. 비슷하게 <literal>&lt;formula&gt;</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>&lt;join&gt;</literal> defined by a class or its superclasses and an outer join for a <literal>&lt;join&gt;</literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal>&lt;join&gt;</literal> defined on a subclass, 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>&lt;join&gt;</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>&lt;key&gt;</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>&lt;any&gt;</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>&lt;key not-null=\"true\"&gt;</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>&lt;column&gt;</literal> subelement. Likewise, <literal>&lt;formula&gt;</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>&lt;class&gt;</literal>, <literal>&lt;subclass&gt;</literal> 등을 사용한다.value 타입들의 경우 우리는 대개<literal>type</literal> 속성을 가진 <literal>&lt;property&gt;</literal>, <literal>&lt;component&gt;</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>&lt;any&gt;</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>&lt;class&gt;</literal>, <literal>&lt;subclass&gt;</literal> and so on. For value types we use <literal>&lt;property&gt;</literal>, <literal>&lt;component&gt;</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>&lt;column&gt;</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>&lt;type&gt;</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>&lt;typedef&gt;</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&gt;(a)hibernate.xn--tags&lt;/literal&gt;-g352f 사용하여 소스 코드 속에 직접 매핑 정보를 삽입시키는 것을 선호한다. 우리는 이 문서에서 이 접근법을 다루지 않을 것이다. 왜냐하면 그것은 엄격하게는 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>&lt;column&gt;</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>&lt;type&gt;</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>&lt;typedef&gt;</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&gt;(a)hibernate.tags&lt;/literal&gt;. 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@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@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>&lt;component&gt;</literal>." +msgstr "fine-grained 클래스들을 작성하고 <literal>&lt;component&gt;</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>&lt;natural-id&gt;</literal>. Implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the properties that make up the natural key." +msgstr "모든 엔티티들에 대해 고유 키들을 식별하고, <literal>&lt;natural-id&gt;</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@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>&lt;set&gt;</literal> element is used for mapping properties of type <literal>Set</literal>." +msgstr "콜렉션을 매핑하는데 사용되는 Hiberante 매핑 요소는 인터페이스의 타입에 의존한다. 예를 들어<literal>&lt;set&gt;</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>&lt;set&gt;</literal>, there is also <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal>, <literal>&lt;array&gt;</literal> and <literal>&lt;primitive-array&gt;</literal> mapping elements. The <literal>&lt;map&gt;</literal> element is representative:" +msgstr "<literal>&lt;set&gt;</literal>과는 별도로, 또한 <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal>, <literal>&lt;array&gt;</literal>, 그리고 <literal>&lt;map&gt;</literal> 매핑 요소들이 존재한다. <literal>&lt;map&gt;</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>&lt;key&gt;</literal> element." +msgstr "콜렉션 인스턴스들은 그 콜렉션을 소유하는 엔티티의 foreign 키에 의해 데이터베이스 내에서 구별지워진다. 이 foreign 키는 그 콜렉션 테이블의 <emphasis>콜렉션 키 컬럼</emphasis> (또는 컬럼들)로서 참조된다. 그 콜렉션 키 컬럼은 <literal>&lt;key&gt;</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>&lt;key&gt;</literal> element." +msgstr "<literal>&lt;key&gt;</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>&lt;element&gt;</literal> or <literal>&lt;composite-element&gt;</literal>, or in the case of entity references, with <literal>&lt;one-to-many&gt;</literal> or <literal>&lt;many-to-many&gt;</literal>. The first two map elements with value semantics, the next two are used to map entity associations." +msgstr "포함된 타입은 콜렉션 요소 타입으로서 불려진다. 콜렉션 요소들은 <literal>&lt;element&gt;</literal> 또는 <literal>&lt;composite-element&gt;</literal>에 의해 매핑되거나, 엔티티 참조들의 경우에 <literal>&lt;one-to-many&gt;</literal> 또는 <literal>&lt;many-to-many&gt;</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>&lt;map-key&gt;</literal>, it may be an entity reference mapped with <literal>&lt;map-key-many-to-many&gt;</literal>, or it may be a composite type, mapped with <literal>&lt;composite-map-key&gt;</literal>. The index of an array or list is always of type <literal>integer</literal> and is mapped using the <literal>&lt;list-index&gt;</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>&lt;map-key&gt;</literal>로 매핑된, 어떤 기본 타입일 수 있고, 그것은 <literal>&lt;map-key-many-to-many&gt;</literal>로 매핑된 엔티티 참조일 수 있거나, 그것은 <literal>&lt;composite-map-key&gt;</literal>로 매핑된 composite 타입일 수 있다. 배열 또는 리스트의 인덱스는 항상 <literal>integer</literal> 타입이고 <literal>&lt;list-index&gt;</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>&lt;bag&gt;</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>&lt;bag&gt;</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>&lt;element&gt;</literal> tag." +msgstr "값들을 가진 콜렉션의 경우, 우리는 <literal>&lt;element&gt;</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>&lt;many-to-many&gt;</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>&lt;many-to-many&gt;</literal! 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>&lt;many-to-many&gt;</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>&lt;ma! ny-to-many&gt;</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>&lt;one-to-many&gt;</literal> tag indicates that this is a one to many association." +msgstr "<literal>Product</literal>로부터 <literal>Part</literal>로의 연관은 foreign 키 컬럼과 <literal>Part</literal> 테이블에 대한 인덱스 컬럼의 존재를 필요로 한다. <literal>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</literal> element does not need to declare any columns. Nor is it necessary to specify the <literal>table</literal> name anywhere." +msgstr "<literal>&lt;one-to-many&gt;</literal> 요소는 어떤 컬럼들을 선언하는데 필요하지 않음을 주목하라. 어딘가에 <literal>table</literal> 이름을 지정하는 것도 필수적이지 않다." + +#: index.docbook:579 +msgid "<emphasis>Very important note:</emphasis> If the foreign key column of a <literal>&lt;one-to-many&gt;</literal> association is declared <literal>NOT NULL</literal>, you must declare the <literal>&lt;key&gt;</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>&lt;one-to-many&gt;</literal> 연관의 foreign 키 컬럼이 <literal>NOT NULL</literal>로 선언될 경우, 당신은 <literal>&lt;key&gt;</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>&lt;list&gt;</literal> or <literal>&lt;map&gt;</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>&lt;list&gt;</literal> 또는 <literal>&lt;map&gt;</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 &lt;idbag&gt;" +msgstr "<literal>&lt;idbag&gt;</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>&lt;idbag&gt;</literal> element lets you map a <literal>List</literal> (or <literal>Collection</literal>) with bag semantics." +msgstr "<literal>&lt;idbag&gt;</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>&lt;idbag&gt;</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>&lt;idbag&gt;</literal>은 마치 엔티티 클래스인양 synthetic id generator(합성 id 생성기)를 갖는다! 다른 대용 키는 각각의 콜렉션 행에 할당된다. 하지만 Hibernate는 특정 행의 대용 키 값을 발견하는 메커니즘을 제공하지 않는다." + +#: index.docbook:798 +msgid "Note that the update performance of an <literal>&lt;idbag&gt;</literal> is <emphasis>much</emphasis> better than a regular <literal>&lt;bag&gt;</literal>! Hibernate can locate individual rows efficiently and update or delete them individually, just like a list, map or set." +msgstr "<literal>&lt;idbag&gt;</literal>의 업데이트 퍼포먼스는 정규 <literal>&lt;bag&gt;</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>&lt;idbag&gt;</literal> collection identifiers." +msgstr "현재 구현에서, <literal>native</literal> 식별자 생성 방도는 <literal>&lt;idbag&gt;</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>&lt;key&gt;</literal> mapping:" +msgstr "대안적으로, 만일 당신이 이 연관관계가 단방향이어야 함을 절대적으로 역설할 경우, 당신은 <literal>&lt;key&gt;</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@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>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity." +msgstr "<literal>&lt;component&gt;</literal> 요소는 컴포넌트 클래스의 프로퍼티를 포함되는 엔티티에 대한 역 참조로서 매핑시키는 <literal>&lt;parent&gt;</literal> 서브요소를 허용한다." + +#: 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>&lt;element&gt;</literal> tag with a <literal>&lt;composite-element&gt;</literal> tag." +msgstr "컴포넌트들을 가진 콜렉션들이 지원된다(예를 들면 <literal>Name</literal> 타입을 가진 배열). <literal>&lt;element&gt;</literal> 태그를 <literal>&lt;composite-element&gt;</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>&lt;nested-composite-element&gt;</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>&lt;nested-composite-element&gt;</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>&lt;set&gt;</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>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal> or <literal>&lt;idbag&gt;</literal>." +msgstr "당신이 하나의 <literal>&lt;set&gt;</literal>을 사용 중이라면, 하나의 composite 요소 매핑은 null 가능한 프로퍼티들을 지원하지 않음을 노트하길 바란다. Hibernate는 객체들을 삭제할 때 하나의 레코드를 식별하는데 각각의 컬럼들 값을 사용해야 하며 (composite 요소 테이블 내에 별도의 프라이머리 키 컬럼이 존재하지 않는다), 그것은 null 값들에 대해서는 불가능하다. 당신은 하나의 composite-요소 내에 not-null 프로퍼티들 만을 사용해야 하거나 하나의 <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal> 또는 <literal>&lt;idbag&gt;</literal>을 선택해야 한다." + +#: index.docbook:113 +msgid "A special case of a composite element is a composite element with a nested <literal>&lt;many-to-one&gt;</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>&lt;many-to-one&gt;</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>&lt;composite-map-key&gt;</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>&lt;composite-map-key&gt;</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>&lt;composite-id&gt;</literal> tag (with nested <literal>&lt;key-property&gt;</literal> elements) in place of the usual <literal>&lt;id&gt;</literal> declaration. For example, the <literal>OrderLine</literal> class has a primary key that depends upon the (composite) primary key of <literal>Order</literal>." +msgstr "통상의 <literal>&lt;id&gt;</literal> 선언 위치에 (내포된 <literal>&lt;key-property&gt;</literal> 요소들을 가진) <literal>&lt;composite-id&gt;</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>&lt;column&gt;</literal> tag is an alternative to the <literal>column</literal> attribute everywhere.)" +msgstr "(<literal>&lt;column&gt;</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>&lt;one-to-many&gt;</literal> element, as usual, declares no columns.)" +msgstr "(통상적으로 <literal>&lt;one-to-many&gt;</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>&lt;dynamic-component&gt;</literal> mapping are identical to <literal>&lt;component&gt;</literal>. The advantage of this kind of mapping is the ability to determine the actual properties of the bean at deployment time, just by editing the mapping document. Runtime manipulation of the mapping document is also possible, using a DOM parser. Even better, you can access (and change) Hibernate's configuration-time metamodel via the <literal>Configuration</literal> object." +msgstr "<literal>&lt;dynamic-component&gt;</literal> 매핑의 의미는 <literal>&lt;component&gt;</literal>와 동일하다. 이런 종류의 매핑의 장점은 배치 시에 단지 매핑 문서를 편집함으로써 그 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@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>&lt;property&gt;</literal> elements in <literal>hibernate.cfg.xml</literal> (discussed later)." +msgstr "<literal>hibernate.cfg.xml</literal>에 <literal>&lt;property&gt;</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>&lt;propertyName&gt;</emphasis>" +msgstr "hibernate.connection.<emphasis>&lt;propertyName&gt;</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>&lt;propertyName&gt;</emphasis>" +msgstr "hibernate.jndi.<emphasis>&lt;propertyName&gt;</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>&lt;cache&gt;</literal> mapping." +msgstr "second-level 캐시를 완전히 사용 불가능하게 하는데 사용될 수 있고, 그것은 <literal>&lt;cache&gt;</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&mdash;see chapter 1." +msgstr "우리는 관리되는 환경들에서 <literal>SessionFactory</literal>를 JNDI에 바인드 시키고 그 밖의 경우에는 하나의 <literal>static</literal> 싱글톤을 사용하는 것을 권장한다. 이들 상세로부터 당신의 어플리케이션 코드를 은폐시키기 위해, 우리는 또한 <literal>HibernateUtil.getSessionFactory()</literal>과 같은 하나의 helper 클래스 내에서 <literal>SessionFactory</literal>에 대한 실제 룩업 코드를 은폐시키기를 권장한다. 그런 클래스는 또한 Hibernate를 시작하는 편리한 방법임을 노트하라&mdash; 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@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>&lt;listener/&gt;</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>&lt;listener/&gt;</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>&lt;listener type=\"...\" class=\"...\"/&gt;</literal> is just a shorthand for <literal>&lt;event type=\"...\"&gt;&lt;listener class=\"...\"/&gt;&lt;/event&gt;</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>&lt;listener type=\"...\" class=\"...\"/&gt;</literal>는 특정 이벤트 타입에 대해 정확히 한 개의 리스너가 존재할 때 단지 <literal>&lt;event type=\"...\"&gt;&lt;listener class=\"...\"/&gt;&lt;/event&gt;</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@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@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>&lt;one-to-many&gt;</literal> association from <literal>Parent</literal> to <literal>Child</literal>. (The alternative approach is to declare the <literal>Child</literal> as a <literal>&lt;composite-element&gt;</literal>.) 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>&lt;one-to-many&gt;</literal> 연관을 가진 엔티티 클래스들로서 <literal>Parent</literal>와 <literal>Child</literal> 양자를 모형화 시키는 것이다. (다른 접근법은 <literal>Child</literal>를 <literal>&lt;composite-element&gt;</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>&lt;one-to-many&gt;</literal> association from <literal>Parent</literal> to <literal>Child</literal>." +msgstr "<literal>Parent</literal>로부터 <literal>Child</literal>로의 간단한 <literal>&lt;one-to-many&gt;</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>&lt;composite-element&gt;</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>&lt;composite-element&gt;</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@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@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>&lt;filter-def/&gt;</literal> element within a <literal>&lt;hibernate-mapping/&gt;</literal> element:" +msgstr "필터들을 사용하기 위해서, 그것들은 먼저 정의되고 나서 적절한 매핑 요소들에 첨가되어야 한다. 필터를 정의하기 위해, <literal>&lt;hibernate-mapping/&gt;</literal> 요소 내부에 <literal>&lt;filter-def/&gt;</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>&lt;filter-def/&gt;</literal> allows defining a default condition, either as an attribute or CDATA:" +msgstr "필터가 정의된 후에는 그것 자신의 조건에 대해 각각 여러 개의 엔티티들 그리고/또는 콜렉션들에 첨가될 수 있다. 조건들이 매번 동일할 때 그것은 지루할 수 있다. 따라서 <literal>&lt;filter-def/&gt;</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@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>&lt;subclass&gt;</literal>, and <literal>&lt;joined-subclass&gt;</literal> and <literal>&lt;union-subclass&gt;</literal> mappings under the same root <literal>&lt;class&gt;</literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies, under the the same <literal>&lt;class&gt;</literal> element, by combining the <literal>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</literal> elements (see below)." +msgstr "동일한 상속 계층구조의 다른 가지들에 대해 다른 매핑 방도들을 사용하는 것이 가능하고, 그런 다음 전체 계층 구조를 가로질러 다형성을 성취하는데 함축적인 다형성을 사용하라. 하지만 Hibernate는 동일한 루트 <literal>&lt;class&gt;</literal> 요소 하에서 <literal>&lt;subclass&gt;</literal> 그리고 <literal>&lt;joined-subclass&gt;</literal> 그리고 <literal>&lt;union-subclass&gt;</literal> 매핑들을 혼합하는 것을 지원하지 않는다. 동일한 <literal>&lt;class&gt;</literal> 요소 하에서 <literal>&lt;subclass&gt;</literal> 요소와 <literal>&lt;join&gt;</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>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</literal>, as follow:" +msgstr "table-per-subclass에 대한 Hibernate의 구현은 discriminator(판별자) 컬럼을 필요로 하지 않음을 노트하라. 다른 객체/관계형 매핑기들은 슈퍼클래스 테이블 속에 하나의 타입 판별자 컬럼을 필요로 하는 table-per-subclass에 대한 다른 구현을 사용한다. Hibernate에 의해 채택된 접근법은 구현하기가 훨씬 더 어렵지만 관계형 관점에서는 아마 틀림없이 보다 더 정확하다. 만일 당신이 table per subclass 방도에 대해 하나의 판별자 컬럼을 사용하고 싶다면, 당신은 다음과 같이 <literal>&lt;subclass&gt;</literal>와 <literal>&lt;join&gt;</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>&lt;many-to-one&gt;</literal>." +msgstr "이들 매핑 방도들 중 어떤 것에 대해, 루트 <literal>Payment</literal> 클래스에 대한 하나의 다형성 연관은 <literal>&lt;many-to-one&gt;</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>&lt;union-subclass&gt;</literal>." +msgstr "우리가 table per concrete class 방도 매핑에 대해 취할 수 있는 두 가지 방법들이 존재한다. 첫 번째는 <literal>&lt;union-subclass&gt;</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>[ &lt;!ENTITY allproperties SYSTEM \"allproperties.xml\"&gt; ]</literal> in the <literal>DOCTYPE</literal> declartion and <literal>&amp;allproperties;</literal> in the mapping)." +msgstr "어느 곳에서도 우리가 명시적으로 <literal>Payment</literal> 인터페이스를 언급하지 않음을 주목하라. 또한 <literal>Payment</literal>의 프로퍼티들이 서브클래스들 각각에서 매핑된다는 점을 주목하라. 만일 당신이 중복을 피하고자 원한다면, XML 엔티티들을 사용하는 것을 고려하라(예를 들어 매핑에서 <literal>DOCTYPE</literal> 선언과 <literal>&amp;allproperties;</literal>에서 <literal>[ &lt;!ENTITY allproperties SYSTEM \"allproperties.xml\"&gt; ]</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>&lt;any&gt;</literal>." +msgstr "이 매핑 방도의 경우, <literal>Payment</literal>에 대한 하나의 다형성 연관은 대개 <literal>&lt;any&gt;</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>&lt;class&gt;</literal> element (and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy! (And you can still use polymorphic queries against the <literal>Payment</literal> interface.)" +msgstr "이 매핑에 대해 주목할 하나 이상의 것이 존재한다. 서브클래스들이 그것들 자신의<literal>&lt;class&gt;</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>&lt;union-subclass&gt;</literal> mappings." +msgstr "table per concrete-class 매핑 방도에 대한 \"함축적인 다형성\" 접근법에는 어떤 제약들이 존재한다. <literal>&lt;union-subclass&gt;</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 "&lt;many-to-one&gt;" +msgstr "&lt;many-to-one&gt;" + +#: index.docbook:291, index.docbook:302, index.docbook:313 +msgid "&lt;one-to-one&gt;" +msgstr "&lt;one-to-one&gt;" + +#: index.docbook:292, index.docbook:303 +msgid "&lt;one-to-many&gt;" +msgstr "&lt;one-to-many&gt;" + +#: index.docbook:293, index.docbook:304, index.docbook:315 +msgid "&lt;many-to-many&gt;" +msgstr "&lt;many-to-many&gt;" + +#: 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>&lt;one-to-many&gt;</literal> (for <literal>inverse=\"true\"</literal> only)" +msgstr "<literal>&lt;one-to-many&gt;</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 "&lt;any&gt;" +msgstr "&lt;any&gt;" + +#: index.docbook:324, index.docbook:325, index.docbook:329, index.docbook:330 +msgid "not supported" +msgstr "지원되지 않음" + +#: index.docbook:326 +msgid "&lt;many-to-any&gt;" +msgstr "&lt;many-to-any&gt;" + +#: 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@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>&lt;cache&gt;</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>&lt;cache&gt;</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>&lt;class-cache&gt;</literal> and <literal>&lt;collection-cache&gt;</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>&lt;class-cache&gt;</literal>와 <literal>&lt;collection-cache&gt;</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>&lt;key&gt;</literal> and <literal>&lt;index&gt;</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>&lt;key&gt;</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>&lt;set&gt;</literal> for you, you must declare all columns as <literal>not-null=\"true\"</literal>.)" +msgstr "모든 인덱싱된 콜렉션들(map들, list들, array들)은 <literal>&lt;key&gt;</literal>와 <literal>&lt;index&gt;</literal> 컬럼들로 이루어진 프라이머리 키를 갖는다. 이 경우에 콜렉션 업데이트들은 대개 극히 효율적이다 - Hibernate가 그것을 업데이트나 삭제를 시도할 때 프라이머리 키는 효율적으로 인덱싱될 수 있고 특정 행은 효율적으로 위치지워질 수 있다." + +#: index.docbook:1020 +msgid "<literal>&lt;idbag&gt;</literal> mappings define a surrogate key, so they are always very efficient to update. In fact, they are the best case." +msgstr "Set들은 <literal>&lt;key&gt;</literal>와 요소 컬럼들로 구성된 프라이머리 키를 갖는다. 이것은 몇몇 유형의 콜렉션 요소, 특히 composite 요소들 또는 대형 텍스트 또는 바이너리 필드들에 대해 덜 효율적일 수 있다; 데이터베이스는 복잡한 프라이머리 키를 효율적으로 인덱싱하는 것이 불가능할 수도 있다. 반면에 one to many 또는 many to many 연관들의 경우, 특히 합성 식별자들의 경우에는 효율적일 수 있을 것 같다.(부수-노트: 만일 당신이 당신을 위한 <literal>&lt;set&gt;</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>&lt;idbag&gt;</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@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@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@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>&lt;natural-id&gt;</literal>, and enable use of the second-level cache." +msgstr "첫번째로 당신은 <literal>&lt;natural-id&gt;</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@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>&lt;any&gt;</literal>)." +msgstr "\"임의의\" 타입은 다음 방법으로 join을 표현하는 것을 우리에게 허용해주는, 특별한 프로퍼티들 <literal>id</literal>와 <literal>class</literal>를 갖는다(여기서 <literal>AuditLog.item</literal>은 <literal>&lt;any&gt;</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>=, &gt;=, &lt;=, &lt;&gt;, !=, like</literal>" +msgstr "바이너리 비교 연산자들 <literal>=, &gt;=, &lt;=, &lt;&gt;, !=, 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 &amp; Tricks" +msgstr "팁들 &amp; 트릭들" + +#: 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@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>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</literal> elements are used to join associations and define queries which initialize collections, respectively." +msgstr "<literal>&lt;return-join&gt;</literal> 요소와 <literal>&lt;load-collection&gt;</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>&lt;return-scalar&gt;</literal> element:" +msgstr "명명된 SQL 질의는 스칼라 값을 반환할수도 있다. 당신은 <literal>&lt;return-scalar&gt;</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>&lt;resultset&gt;</literal> element to either reuse them accross several named queries or through the <literal>setResultSetMapping()</literal> API." +msgstr "당신은 여러 개의 명명된 질의들을 가로질러 재사용하거나 <literal>setResultSetMapping()</literal> API를 통해 결과셋 매핑정보들을 재사용하기 위해 <literal>&lt;resultset&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</literal>를 사용했음을 주목하라. 사용자들이 컬럼과 프로퍼티들을 참조하고자 원하는 방법을 선택하는 것을 사용자들에게 허용해줌으로써." + +#: index.docbook:420 +msgid "If your mapping has a discriminator you must use <literal>&lt;return-discriminator&gt;</literal> to specify the discriminator column." +msgstr "만일 당신의 매핑이 한 개의 판별자(discriminator )를 가질 경우 당신은 판별자 컬럼을 지정하는데 <literal>&lt;return-discriminator&gt;</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>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</literal> are not supported." +msgstr "내장 프로시저들은 현재 스칼라들과 엔티티들 만을 반환함을 주목하라. <literal>&lt;return-join&gt;</literal>과 <literal>&lt;load-collection&gt;</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(&lt;parameters&gt;) }</literal> or <literal>{ ? = call procedureName(&lt;parameters&gt;}</literal>. Native call syntax is not supported." +msgstr "권장되는 호출 형식은 표준 SQL92이다: <literal>{ ? = call functionName(&lt;parameters&gt;) }</literal> 또는 <literal>{ ? = call procedureName(&lt;parameters&gt;}</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>&lt;sql-insert&gt;</literal>, <literal>&lt;sql-delete&gt;</literal>, and <literal>&lt;sql-update&gt;</literal> override these strings:" +msgstr "Hibernate3는 create, update, delete 오퍼레이션들을 위한 맞춤형 문장들을 사용할 수 있다. Hibernate에서 클래스와 콜렉션 영속자들은 구성 시에 생성된 문자열들의 집합(insertsql, deletesql, updatesql 등)을 이미 포함하고 있다. <literal>&lt;sql-insert&gt;</literal>, <literal>&lt;sql-delete&gt;</literal>, <literal>&lt;sql-update&gt;</literal> 매핑 태그들은 이들 문자열들을 오버라이드 시킨다:" + +#: 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@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 &amp; 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@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>&lt;hibernate-mapping&gt;</literal> 요소 내에서 하나의 질의 선언은 그 질의에 대한 전역 유일 이름을 필요로 하고, 반면에 <literal>&lt;class&gt;</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>&lt;hibernate-mapping&gt;</literal> element requires a global unique name for the query, while a query declaration inside a <literal>&lt;class&gt;</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>&lt;version&gt;</literal> 또는 <literal>&lt;timestamp&gt;</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>&lt;version&gt;</literal> or <literal>&lt;timestamp&gt;</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>&lt;many-to-one&gt;</literal> 또는 <literal>&lt;many-to-many&gt;</literal> 연관에 대해 케스케이드를 가능하게 하는 것은 대개 의미가 없다. 케스케이드는 <literal>&lt;one-to-one&gt;</literal> 연관과 <literal>&lt;one-to-many&gt;</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>&lt;many-to-one&gt;</literal> or <literal>&lt;many-to-many&gt;</literal> association. Cascade is often useful for <literal>&lt;one-to-one&gt;</literal> and <literal>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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@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>&lt;column&gt;</literal> element. This is particularly useful for mapping multi-column types:" +msgstr "많은 매핑 요소들은 또한 하나의 자식 <literal>&lt;column&gt;</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>&lt;column&gt;</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>&lt;one-to-one&gt;</literal>, <literal>&lt;many-to-one&gt;</literal>, <literal>&lt;key&gt;</literal>, or <literal>&lt;many-to-many&gt;</literal> mapping element. Note that <literal>inverse=\"true\"</literal> sides will not be considered by <literal>SchemaExport</literal>." +msgstr "하나의 연관에 대해, <literal>&lt;one-to-one&gt;</literal>, <literal>&lt;many-to-one&gt;</literal>, <literal>&lt;key&gt;</literal>, 또는 <literal>&lt;many-to-many&gt;</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>&lt;column&gt;</literal> element only)" +msgstr "디폴트 컬럼 타입을 오버라이드 시킨다 (<literal>&lt;column&gt;</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>&lt;comment&gt;</literal> element allows you to specify comments for the generated schema." +msgstr "<literal>&lt;comment&gt;</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>&lt;property&gt;</emphasis>" +msgstr "<literal>-D</literal><emphasis>&lt;property&gt;</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@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>&lt;version&gt;</literal>, and Hibernate will automatically increment it during flush if the entity is dirty." +msgstr "version 프로퍼티는 <literal>&lt;version&gt;</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>&lt;class&gt;</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>&lt;class&gt;</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>&lt;class&gt;</literal>, Hibernate will only compare dirty fields during flush." +msgstr "때때로 행해졌던 변경들이 중첩되지 않는 한 동시적인 변경이 허용될 수 있다. 만일 <literal>&lt;class&gt;</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>&lt;class&gt;</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>&lt;class&gt;</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@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>&lt;session-factory&gt;</literal> configurations, usually in several configuration files (for easier startup)." +msgstr "이 XML 구성이 다른 DTD를 사용함을 노트하라. 우리는 Hibernate의 <literal>SessionFactory</literal> -특정 데이터베이스에 대해 책임이 있는 전역 팩토리-를 구성한다. 만일 당신이 여러 데이터베이스들을 갖고 있다면, (보다 쉬운 시작을 위해) 몇 개의 구성 파일들 속에 여러 개의 <literal>&lt;session-factory&gt;</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>&lt;set&gt;</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>&lt;key&gt;</literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal>&lt;many-to-many&gt;</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>&lt;set&gt;</literal>을 지원한다. many-to-many 연관 (또는 <emphasis>n:m</emphasis> 엔티티 관계)의 경우, 한 개의 연관 테이블이 필요하다. 이 테이블 내에 있는 각각의 행은 한 명의 개인과 한 개의 이벤트 사이의 링크를 표현한다. 테이블 이름은 <literal>set</literal> 요소의 <literal>table</literal> 속성으로 구성된다. 연관 내의 식별자 컬럼 이름은 개인 측에 대해 <literal>&lt;key&gt;</literal> 요소로 정의되고 이벤트 측에 대한 컬럼 이름은 <literal>&lt;many-to-many&gt;</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&mdash;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>&mdash;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&mdash;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@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>&lt;one-to-many&gt;</literal> mapping, the data might look more like this:" +msgstr "만일 당신이 <literal>&lt;one-to-many&gt;</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@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.openc... +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.openc... + +#: 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(a)redhat.com key is:" +msgstr "The GPG fingerprint of the security(a)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@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 "&copyrightHolder;" +msgstr "&copyrightHolder;" + +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@ADDRESS>\n" +"Content-Type: text/plain; charset=utf-8\n" +#: index.docbook:21 +msgid "Architecture" +msgstr "Arquitetura" + +#: index.docbook:24 +msgid "Overview" +msgstr "Vis&#x00E3;o Geral" + +#: index.docbook:26 +msgid "A (very) high-level view of the Hibernate architecture:" +msgstr "Uma vis&#x00E3;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&#x00E1;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@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>&lt;key&gt;</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>&lt;column&gt;</literal> element, but on the <literal>&lt;key&gt;</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@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>&lt;class&gt;</literal> mappings, as shown above. It is however good practice (and expected by some tools) to map only a single persistent class (or a single class hierarchy) in one mapping file and name it after the persistent superclass, 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>&lt;hibernate-mapping&gt;</literal> element." +msgstr "" + +#: index.docbook:246, index.docbook:2210 +msgid "<literal>catalog</literal> (optional): Override the catalog name specified by the root <literal>&lt;hibernate-mapping&gt;</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>&lt;union-subclass&gt;</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>&lt;subclass&gt;</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>&lt;class&gt;</literal> declaration as a <literal>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</literal>. For most purposes the default, <literal>polymorphism=\"implicit\"</literal>, is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table (this allows a \"lightweight\" class that contains a subset of the table columns)." +msgstr "" + +#: 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>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</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>&lt;subselect&gt;</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>&lt;id&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "\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>&lt;composite-id&gt;</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>&lt;generator&gt;</literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal>&lt;param&gt;</literal> element." +msgstr "" + +#: 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>&lt;generator&gt;</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>&lt;one-to-one&gt;</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>&lt;generator&gt;</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>&lt;composite-id&gt;</literal> element accepts <literal>&lt;key-property&gt;</literal> property mappings and <literal>&lt;key-many-to-one&gt;</literal> mappings as child elements." +msgstr "" + +#: 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>&lt;composite-id&gt;</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&mdash;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>&lt;discriminator&gt;</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>&lt;class&gt;</literal> and <literal>&lt;subclass&gt;</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>&lt;version&gt;</literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis> (see below)." +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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" +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>&lt;timestamp&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" +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>&lt;timestamp&gt;</literal> is equivalent to <literal>&lt;version type=\"timestamp\"&gt;</literal>. And <literal>&lt;timestamp source=\"db\"&gt;</literal> is equivalent to <literal>&lt;version type=\"dbtimestamp\"&gt;</literal>" +msgstr "" + +#: index.docbook:1284 +msgid "property" +msgstr "" + +#: index.docbook:1286 +msgid "The <literal>&lt;property&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;column&gt;</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>&lt;formula&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;column&gt;</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>&lt;properties&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;natural-id&gt;</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>&lt;component&gt;</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>&lt;property&gt;</literal> tags map properties of the child class to table columns." +msgstr "" + +#: index.docbook:1913 +msgid "The <literal>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity." +msgstr "" + +#: index.docbook:1919 +msgid "The <literal>&lt;dynamic-component&gt;</literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map, see <xref linkend=\"components-dynamic\"/>." +msgstr "" + +#: index.docbook:1928 +msgid "properties" +msgstr "" + +#: index.docbook:1930 +msgid "The <literal>&lt;properties&gt;</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>&lt;properties&gt;</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>&lt;subclass&gt;</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>&lt;version&gt;</literal> and <literal>&lt;id&gt;</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>&lt;joined-subclass&gt;</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>&lt;key&gt;</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>&lt;class&gt;</literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal>&lt;union-subclass&gt;</literal> mapping." +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>&lt;join&gt;</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>&lt;join&gt;</literal> defined by a class or its superclasses and an outer join for a <literal>&lt;join&gt;</literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal>&lt;join&gt;</literal> defined on a subclass, 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>&lt;join&gt;</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>&lt;key&gt;</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>&lt;key not-null=\"true\"&gt;</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>&lt;column&gt;</literal> subelement. Likewise, <literal>&lt;formula&gt;</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>&lt;any&gt;</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>&lt;class&gt;</literal>, <literal>&lt;subclass&gt;</literal> and so on. For value types we use <literal>&lt;property&gt;</literal>, <literal>&lt;component&gt;</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>&lt;column&gt;</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>&lt;type&gt;</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>&lt;typedef&gt;</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&gt;(a)hibernate.tags&lt;/literal&gt;. 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@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@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>&lt;component&gt;</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>&lt;natural-id&gt;</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@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>&lt;set&gt;</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>&lt;set&gt;</literal>, there is also <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal>, <literal>&lt;array&gt;</literal> and <literal>&lt;primitive-array&gt;</literal> mapping elements. The <literal>&lt;map&gt;</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>&lt;key&gt;</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>&lt;key&gt;</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>&lt;element&gt;</literal> or <literal>&lt;composite-element&gt;</literal>, or in the case of entity references, with <literal>&lt;one-to-many&gt;</literal> or <literal>&lt;many-to-many&gt;</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>&lt;map-key&gt;</literal>, it may be an entity reference mapped with <literal>&lt;map-key-many-to-many&gt;</literal>, or it may be a composite type, mapped with <literal>&lt;composite-map-key&gt;</literal>. The index of an array or list is always of type <literal>integer</literal> and is mapped using the <literal>&lt;list-index&gt;</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>&lt;bag&gt;</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>&lt;element&gt;</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>&lt;many-to-many&gt;</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>&lt;many-to-many&gt;</literal! 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>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</literal> association is declared <literal>NOT NULL</literal>, you must declare the <literal>&lt;key&gt;</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>&lt;list&gt;</literal> or <literal>&lt;map&gt;</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 &lt;idbag&gt;" +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>&lt;idbag&gt;</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>&lt;idbag&gt;</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>&lt;idbag&gt;</literal> is <emphasis>much</emphasis> better than a regular <literal>&lt;bag&gt;</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>&lt;idbag&gt;</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>&lt;key&gt;</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@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>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity." +msgstr "" + +#: 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>&lt;element&gt;</literal> tag with a <literal>&lt;composite-element&gt;</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>&lt;nested-composite-element&gt;</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>&lt;set&gt;</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>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal> or <literal>&lt;idbag&gt;</literal>." +msgstr "" + +#: index.docbook:113 +msgid "A special case of a composite element is a composite element with a nested <literal>&lt;many-to-one&gt;</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>&lt;composite-map-key&gt;</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>&lt;composite-id&gt;</literal> tag (with nested <literal>&lt;key-property&gt;</literal> elements) in place of the usual <literal>&lt;id&gt;</literal> declaration. For example, the <literal>OrderLine</literal> class has a primary key that depends upon the (composite) primary key of <literal>Order</literal>." +msgstr "" + +#: 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>&lt;column&gt;</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>&lt;one-to-many&gt;</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>&lt;dynamic-component&gt;</literal> mapping are identical to <literal>&lt;component&gt;</literal>. The advantage of this kind of mapping is the ability to determine the actual properties of the bean at deployment time, just by editing the mapping document. Runtime manipulation of the mapping document is also possible, using a DOM parser. 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@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>&lt;property&gt;</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>&lt;propertyName&gt;</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>&lt;propertyName&gt;</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>&lt;cache&gt;</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&mdash;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@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>&lt;listener/&gt;</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>&lt;listener type=\"...\" class=\"...\"/&gt;</literal> is just a shorthand for <literal>&lt;event type=\"...\"&gt;&lt;listener class=\"...\"/&gt;&lt;/event&gt;</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@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@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>&lt;one-to-many&gt;</literal> association from <literal>Parent</literal> to <literal>Child</literal>. (The alternative approach is to declare the <literal>Child</literal> as a <literal>&lt;composite-element&gt;</literal>.) 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>&lt;one-to-many&gt;</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>&lt;composite-element&gt;</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@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@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>&lt;filter-def/&gt;</literal> element within a <literal>&lt;hibernate-mapping/&gt;</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>&lt;filter-def/&gt;</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@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>&lt;subclass&gt;</literal>, and <literal>&lt;joined-subclass&gt;</literal> and <literal>&lt;union-subclass&gt;</literal> mappings under the same root <literal>&lt;class&gt;</literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies, under the the same <literal>&lt;class&gt;</literal> element, by combining the <literal>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</literal> elements (see below)." +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>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</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>&lt;many-to-one&gt;</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>&lt;union-subclass&gt;</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>[ &lt;!ENTITY allproperties SYSTEM \"allproperties.xml\"&gt; ]</literal> in the <literal>DOCTYPE</literal> declartion and <literal>&amp;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>&lt;any&gt;</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>&lt;class&gt;</literal> element (and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy! (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>&lt;union-subclass&gt;</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 "&lt;many-to-one&gt;" +msgstr "" + +#: index.docbook:291, index.docbook:302, index.docbook:313 +msgid "&lt;one-to-one&gt;" +msgstr "" + +#: index.docbook:292, index.docbook:303 +msgid "&lt;one-to-many&gt;" +msgstr "" + +#: index.docbook:293, index.docbook:304, index.docbook:315 +msgid "&lt;many-to-many&gt;" +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>&lt;one-to-many&gt;</literal> (for <literal>inverse=\"true\"</literal> only)" +msgstr "" + +#: index.docbook:322 +msgid "table per concrete class (implicit polymorphism)" +msgstr "" + +#: index.docbook:323 +msgid "&lt;any&gt;" +msgstr "" + +#: index.docbook:324, index.docbook:325, index.docbook:329, index.docbook:330 +msgid "not supported" +msgstr "" + +#: index.docbook:326 +msgid "&lt;many-to-any&gt;" +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@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>&lt;cache&gt;</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>&lt;class-cache&gt;</literal> and <literal>&lt;collection-cache&gt;</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>&lt;key&gt;</literal> and <literal>&lt;index&gt;</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>&lt;key&gt;</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>&lt;set&gt;</literal> for you, you must declare all columns as <literal>not-null=\"true\"</literal>.)" +msgstr "" + +#: index.docbook:1020 +msgid "<literal>&lt;idbag&gt;</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@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@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@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>&lt;natural-id&gt;</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@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>&lt;any&gt;</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>=, &gt;=, &lt;=, &lt;&gt;, !=, 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 &amp; 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@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>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</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>&lt;return-scalar&gt;</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>&lt;resultset&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-discriminator&gt;</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>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</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(&lt;parameters&gt;) }</literal> or <literal>{ ? = call procedureName(&lt;parameters&gt;}</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>&lt;sql-insert&gt;</literal>, <literal>&lt;sql-delete&gt;</literal>, and <literal>&lt;sql-update&gt;</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@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@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>&lt;hibernate-mapping&gt;</literal> element requires a global unique name for the query, while a query declaration inside a <literal>&lt;class&gt;</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>&lt;version&gt;</literal> or <literal>&lt;timestamp&gt;</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>&lt;many-to-one&gt;</literal> or <literal>&lt;many-to-many&gt;</literal> association. Cascade is often useful for <literal>&lt;one-to-one&gt;</literal> and <literal>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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@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>&lt;column&gt;</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>&lt;one-to-one&gt;</literal>, <literal>&lt;many-to-one&gt;</literal>, <literal>&lt;key&gt;</literal>, or <literal>&lt;many-to-many&gt;</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>&lt;column&gt;</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>&lt;comment&gt;</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>&lt;property&gt;</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@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>&lt;version&gt;</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>&lt;class&gt;</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>&lt;class&gt;</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>&lt;class&gt;</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@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>&lt;session-factory&gt;</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>&lt;set&gt;</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>&lt;key&gt;</literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal>&lt;many-to-many&gt;</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&mdash;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>&mdash;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&mdash;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@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>&lt;one-to-many&gt;</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@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.openc... +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.openc... + +#: 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(a)redhat.com key is:" +msgstr "The GPG fingerprint of the security(a)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@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 "&copyrightHolder;" +msgstr "&copyrightHolder;" + +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@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@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>&lt;key&gt;</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>&lt;column&gt;</literal> element, but on the <literal>&lt;key&gt;</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@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>&lt;class&gt;</literal> mappings, as shown above. It is however good practice (and expected by some tools) to map only a single persistent class (or a single class hierarchy) in one mapping file and name it after the persistent superclass, 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>&lt;hibernate-mapping&gt;</literal> element." +msgstr "" + +#: index.docbook:246, index.docbook:2210 +msgid "<literal>catalog</literal> (optional): Override the catalog name specified by the root <literal>&lt;hibernate-mapping&gt;</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>&lt;union-subclass&gt;</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>&lt;subclass&gt;</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>&lt;class&gt;</literal> declaration as a <literal>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</literal>. For most purposes the default, <literal>polymorphism=\"implicit\"</literal>, is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table (this allows a \"lightweight\" class that contains a subset of the table columns)." +msgstr "" + +#: 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>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</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>&lt;subselect&gt;</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>&lt;id&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "\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>&lt;composite-id&gt;</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>&lt;generator&gt;</literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal>&lt;param&gt;</literal> element." +msgstr "" + +#: 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>&lt;generator&gt;</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>&lt;one-to-one&gt;</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>&lt;generator&gt;</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>&lt;composite-id&gt;</literal> element accepts <literal>&lt;key-property&gt;</literal> property mappings and <literal>&lt;key-many-to-one&gt;</literal> mappings as child elements." +msgstr "" + +#: 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>&lt;composite-id&gt;</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&mdash;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>&lt;discriminator&gt;</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>&lt;class&gt;</literal> and <literal>&lt;subclass&gt;</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>&lt;version&gt;</literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis> (see below)." +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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" +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>&lt;timestamp&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + "/>]]>" +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>&lt;timestamp&gt;</literal> is equivalent to <literal>&lt;version type=\"timestamp\"&gt;</literal>. And <literal>&lt;timestamp source=\"db\"&gt;</literal> is equivalent to <literal>&lt;version type=\"dbtimestamp\"&gt;</literal>" +msgstr "" + +#: index.docbook:1284 +msgid "property" +msgstr "" + +#: index.docbook:1286 +msgid "The <literal>&lt;property&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;column&gt;</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>&lt;formula&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;column&gt;</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>&lt;properties&gt;</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=\&quot;element-name|@attribute-name|element/(a)attribute|.\&quot;\n&quot; + " 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>&lt;natural-id&gt;</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>&lt;component&gt;</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>&lt;property&gt;</literal> tags map properties of the child class to table columns." +msgstr "" + +#: index.docbook:1913 +msgid "The <literal>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity." +msgstr "" + +#: index.docbook:1919 +msgid "The <literal>&lt;dynamic-component&gt;</literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map, see <xref linkend=\"components-dynamic\"/>." +msgstr "" + +#: index.docbook:1928 +msgid "properties" +msgstr "" + +#: index.docbook:1930 +msgid "The <literal>&lt;properties&gt;</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>&lt;properties&gt;</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>&lt;subclass&gt;</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>&lt;version&gt;</literal> and <literal>&lt;id&gt;</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>&lt;joined-subclass&gt;</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>&lt;key&gt;</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>&lt;class&gt;</literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal>&lt;union-subclass&gt;</literal> mapping." +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>&lt;join&gt;</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>&lt;join&gt;</literal> defined by a class or its superclasses and an outer join for a <literal>&lt;join&gt;</literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal>&lt;join&gt;</literal> defined on a subclass, 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>&lt;join&gt;</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>&lt;key&gt;</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>&lt;key not-null=\"true\"&gt;</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>&lt;column&gt;</literal> subelement. Likewise, <literal>&lt;formula&gt;</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>&lt;any&gt;</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>&lt;class&gt;</literal>, <literal>&lt;subclass&gt;</literal> and so on. For value types we use <literal>&lt;property&gt;</literal>, <literal>&lt;component&gt;</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>&lt;column&gt;</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>&lt;type&gt;</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>&lt;typedef&gt;</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&gt;(a)hibernate.tags&lt;/literal&gt;. 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@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@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>&lt;component&gt;</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>&lt;natural-id&gt;</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@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>&lt;set&gt;</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>&lt;set&gt;</literal>, there is also <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal>, <literal>&lt;array&gt;</literal> and <literal>&lt;primitive-array&gt;</literal> mapping elements. The <literal>&lt;map&gt;</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>&lt;key&gt;</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>&lt;key&gt;</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>&lt;element&gt;</literal> or <literal>&lt;composite-element&gt;</literal>, or in the case of entity references, with <literal>&lt;one-to-many&gt;</literal> or <literal>&lt;many-to-many&gt;</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>&lt;map-key&gt;</literal>, it may be an entity reference mapped with <literal>&lt;map-key-many-to-many&gt;</literal>, or it may be a composite type, mapped with <literal>&lt;composite-map-key&gt;</literal>. The index of an array or list is always of type <literal>integer</literal> and is mapped using the <literal>&lt;list-index&gt;</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>&lt;bag&gt;</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>&lt;element&gt;</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>&lt;many-to-many&gt;</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>&lt;many-to-many&gt;</literal! 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>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</literal> association is declared <literal>NOT NULL</literal>, you must declare the <literal>&lt;key&gt;</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>&lt;list&gt;</literal> or <literal>&lt;map&gt;</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 &lt;idbag&gt;" +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>&lt;idbag&gt;</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>&lt;idbag&gt;</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>&lt;idbag&gt;</literal> is <emphasis>much</emphasis> better than a regular <literal>&lt;bag&gt;</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>&lt;idbag&gt;</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>&lt;key&gt;</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@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>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity." +msgstr "" + +#: 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>&lt;element&gt;</literal> tag with a <literal>&lt;composite-element&gt;</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>&lt;nested-composite-element&gt;</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>&lt;set&gt;</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>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal> or <literal>&lt;idbag&gt;</literal>." +msgstr "" + +#: index.docbook:113 +msgid "A special case of a composite element is a composite element with a nested <literal>&lt;many-to-one&gt;</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>&lt;composite-map-key&gt;</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>&lt;composite-id&gt;</literal> tag (with nested <literal>&lt;key-property&gt;</literal> elements) in place of the usual <literal>&lt;id&gt;</literal> declaration. For example, the <literal>OrderLine</literal> class has a primary key that depends upon the (composite) primary key of <literal>Order</literal>." +msgstr "" + +#: 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>&lt;column&gt;</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>&lt;one-to-many&gt;</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>&lt;dynamic-component&gt;</literal> mapping are identical to <literal>&lt;component&gt;</literal>. The advantage of this kind of mapping is the ability to determine the actual properties of the bean at deployment time, just by editing the mapping document. Runtime manipulation of the mapping document is also possible, using a DOM parser. 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@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>&lt;property&gt;</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>&lt;propertyName&gt;</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>&lt;propertyName&gt;</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>&lt;cache&gt;</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&mdash;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@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>&lt;listener/&gt;</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>&lt;listener type=\"...\" class=\"...\"/&gt;</literal> is just a shorthand for <literal>&lt;event type=\"...\"&gt;&lt;listener class=\"...\"/&gt;&lt;/event&gt;</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@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@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>&lt;one-to-many&gt;</literal> association from <literal>Parent</literal> to <literal>Child</literal>. (The alternative approach is to declare the <literal>Child</literal> as a <literal>&lt;composite-element&gt;</literal>.) 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>&lt;one-to-many&gt;</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>&lt;composite-element&gt;</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@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@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>&lt;filter-def/&gt;</literal> element within a <literal>&lt;hibernate-mapping/&gt;</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>&lt;filter-def/&gt;</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@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>&lt;subclass&gt;</literal>, and <literal>&lt;joined-subclass&gt;</literal> and <literal>&lt;union-subclass&gt;</literal> mappings under the same root <literal>&lt;class&gt;</literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies, under the the same <literal>&lt;class&gt;</literal> element, by combining the <literal>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</literal> elements (see below)." +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>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</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>&lt;many-to-one&gt;</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>&lt;union-subclass&gt;</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>[ &lt;!ENTITY allproperties SYSTEM \"allproperties.xml\"&gt; ]</literal> in the <literal>DOCTYPE</literal> declartion and <literal>&amp;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>&lt;any&gt;</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>&lt;class&gt;</literal> element (and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy! (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>&lt;union-subclass&gt;</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 "&lt;many-to-one&gt;" +msgstr "" + +#: index.docbook:291, index.docbook:302, index.docbook:313 +msgid "&lt;one-to-one&gt;" +msgstr "" + +#: index.docbook:292, index.docbook:303 +msgid "&lt;one-to-many&gt;" +msgstr "" + +#: index.docbook:293, index.docbook:304, index.docbook:315 +msgid "&lt;many-to-many&gt;" +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>&lt;one-to-many&gt;</literal> (for <literal>inverse=\"true\"</literal> only)" +msgstr "" + +#: index.docbook:322 +msgid "table per concrete class (implicit polymorphism)" +msgstr "" + +#: index.docbook:323 +msgid "&lt;any&gt;" +msgstr "" + +#: index.docbook:324, index.docbook:325, index.docbook:329, index.docbook:330 +msgid "not supported" +msgstr "" + +#: index.docbook:326 +msgid "&lt;many-to-any&gt;" +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@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>&lt;cache&gt;</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>&lt;class-cache&gt;</literal> and <literal>&lt;collection-cache&gt;</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>&lt;key&gt;</literal> and <literal>&lt;index&gt;</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>&lt;key&gt;</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>&lt;set&gt;</literal> for you, you must declare all columns as <literal>not-null=\"true\"</literal>.)" +msgstr "" + +#: index.docbook:1020 +msgid "<literal>&lt;idbag&gt;</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@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@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@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>&lt;natural-id&gt;</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@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>&lt;any&gt;</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>=, &gt;=, &lt;=, &lt;&gt;, !=, 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 &amp; 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@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>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</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>&lt;return-scalar&gt;</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>&lt;resultset&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-property&gt;</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>&lt;return-discriminator&gt;</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>&lt;return-join&gt;</literal> and <literal>&lt;load-collection&gt;</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(&lt;parameters&gt;) }</literal> or <literal>{ ? = call procedureName(&lt;parameters&gt;}</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>&lt;sql-insert&gt;</literal>, <literal>&lt;sql-delete&gt;</literal>, and <literal>&lt;sql-update&gt;</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@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@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>&lt;hibernate-mapping&gt;</literal> element requires a global unique name for the query, while a query declaration inside a <literal>&lt;class&gt;</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>&lt;version&gt;</literal> or <literal>&lt;timestamp&gt;</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>&lt;many-to-one&gt;</literal> or <literal>&lt;many-to-many&gt;</literal> association. Cascade is often useful for <literal>&lt;one-to-one&gt;</literal> and <literal>&lt;one-to-many&gt;</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>&lt;one-to-many&gt;</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@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>&lt;column&gt;</literal> element. This is particularly useful for mapping multi-column types:" +msgstr "很多映射元素还接受<literal>&lt;column&gt;</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>&lt;one-to-one&gt;</literal>, <literal>&lt;many-to-one&gt;</literal>, <literal>&lt;key&gt;</literal>, or <literal>&lt;many-to-many&gt;</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>&lt;one-to-one&gt;</literal>, <literal>&lt;many-to-one&gt;</literal>, <literal>&lt;key&gt;</literal>, or <literal>&lt;many-to-many&gt;</literal> mapping element. Note that <literal>inverse=\"true\"</literal> sides will not be considered by <literal>SchemaExport</literal>. 指明一个外键的名字，它是为关联生成的，或者<literal>&lt;one-to-one&gt;</literal>，<literal>&lt;many-to-one&gt;</literal>, <literal>&lt;key&gt;</literal>, 或者<literal>&lt;many-to-many&gt;</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>&lt;column&gt;</literal> element only)" +msgstr "覆盖默认的字段类型(只能用于<literal>&lt;column&gt;</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>&lt;comment&gt;</literal> element allows you to specify comments for the generated schema." +msgstr "<literal>&lt;comment&gt;</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>&lt;property&gt;</emphasis>" +msgstr "通过<literal>-D</literal><emphasis>&lt;property&gt;</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@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>&lt;version&gt;</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>&lt;class&gt;</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>&lt;class&gt;</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>&lt;class&gt;</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@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>&lt;session-factory&gt;</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>&lt;set&gt;</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>&lt;key&gt;</literal> element, the column name for the event's side with the <literal>column</literal> attribute of the <literal>&lt;many-to-many&gt;</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&mdash;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>&mdash;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&mdash;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@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>&lt;one-to-many&gt;</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@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.openc... +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.openc... + +#: 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(a)redhat.com key is:" +msgstr "The GPG fingerprint of the security(a)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-->" +