component_mapping.po

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

msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2008-08-14 15:28+0000\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <[e-mail]>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#. Tag: title
#: component_mapping.xml:29
#, no-c-format
msgid "Component Mapping"
msgstr "Mapping de composants"

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

#. Tag: title
#: component_mapping.xml:37
#, no-c-format
msgid "Dependent objects"
msgstr "Objects dépendants"

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

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

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

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

#. Tag: para
#: component_mapping.xml:56
#, no-c-format
msgid "Our Hibernate mapping would look like:"
msgstr "Nous serions alors amené à mapper ce composant de cette façon:"

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

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

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

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

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

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

#. Tag: title
#: component_mapping.xml:97
#, no-c-format
msgid "Collections of dependent objects"
msgstr "Collection d'objets dépendants"

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

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

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

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

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

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

#. Tag: programlisting
#: component_mapping.xml:147
#, no-c-format
msgid ""