component_mapping.po

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

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

#. Tag: para
#: component_mapping.xml:149
#, no-c-format
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."

#. Tag: para
#: component_mapping.xml:157
#, no-c-format
msgid "Even ternary (or quaternary, etc) associations are possible:"
msgstr "Même les associations ternaires ou quaternaires sont possibles:"

#. Tag: programlisting
#: component_mapping.xml:159
#, no-c-format
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 ""

#. Tag: para
#: component_mapping.xml:161
#, no-c-format
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"

#. Tag: title
#: component_mapping.xml:169
#, no-c-format
msgid "Components as Map indices"
msgstr "Utiliser les composants comme index de map"

#. Tag: para
#: component_mapping.xml:171
#, no-c-format
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."

#. Tag: title
#: component_mapping.xml:180
#, no-c-format
msgid "Components as composite identifiers"
msgstr "Utiliser un composant comme identifiant"

#. Tag: para
#: component_mapping.xml:182
#, no-c-format
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."

#. Tag: para
#: component_mapping.xml:189
#, no-c-format
msgid "It must implement <literal>java.io.Serializable</literal>."
msgstr "Elle doit implémenter <literal>java.io.Serializable</literal>."

#. Tag: para
#: component_mapping.xml:194
#, no-c-format
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."

#. Tag: emphasis
#: component_mapping.xml:203
#, no-c-format
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."

#. Tag: para
#: component_mapping.xml:207
#, no-c-format
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."

#. Tag: para
#: component_mapping.xml:212
#, no-c-format
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>."

#. Tag: programlisting
#: component_mapping.xml:220
#, no-c-format
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 ""

#. Tag: para
#: component_mapping.xml:222
#, no-c-format
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 :"

#. Tag: programlisting
#: component_mapping.xml:228
#, no-c-format
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 ""

#. Tag: para
#: component_mapping.xml:230
#, no-c-format
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.)"

#. Tag: para
#: component_mapping.xml:235
#, no-c-format
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:"

#. Tag: programlisting
#: component_mapping.xml:240
#, no-c-format
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 ""

#. Tag: para
#: component_mapping.xml:242
#, no-c-format
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:"

#. Tag: programlisting
#: component_mapping.xml:247
#, no-c-format
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 ""

#. Tag: para
#: component_mapping.xml:249
#, no-c-format
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.)"

#. Tag: para
#: component_mapping.xml:253
#, no-c-format
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."

#. Tag: programlisting
#: component_mapping.xml:258
#, no-c-format
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 ""

#. Tag: title
#: component_mapping.xml:263
#, no-c-format
msgid "Dynamic components"
msgstr "Composant Dynamique"

#. Tag: para
#: component_mapping.xml:265
#, no-c-format
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>:"

#. Tag: programlisting
#: component_mapping.xml:269
#, no-c-format
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 ""

#. Tag: para
#: component_mapping.xml:271
#, no-c-format
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>"