component_mapping.po

hibernate 开源框架的代码 jar包希望大家能喜欢

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