persistent_classes.po

hibernate-distribution-3.3.1.GA-dist.zip源码

"    <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 "UNTRANSLATED!!! 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>ComponentTuplizer</literal>s do the same for components."
msgstr ""
"<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>ComponentTuplizer</literal>s do the same for components."

#: 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 ""
"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:"

#: 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 ""
"PORHACER: Documentar el framework de extensiones del usuario en los paquetes "
"de propiedad y proxies."

msgid "ROLES_OF_TRANSLATORS"
msgstr "<!--TRANS:ROLES_OF_TRANSLATORS-->"

msgid "CREDIT_FOR_TRANSLATORS"
msgstr "<!--TRANS:CREDIT_FOR_TRANSLATORS-->"