component_mapping.po

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

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