DOCUMENTATION French: sync and clean manual

git-svn-id: http://framework.zend.com/svn/framework/standard/trunk@15425 44c647ce-9c0f-0410-b52a-842ac1e357ba

documentation/manual/fr/module_specs/Zend_Db_Table-Relationships.xml

@@ -1,5 +1,5 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- EN-Revision: 13846 -->
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- EN-Revision: 15346 -->
 <!-- Reviewed: no -->
 <sect1 id="zend.db.table.relationships">
     <title>Relations Zend_Db_Table</title>
@@ -7,22 +7,30 @@
     <sect2 id="zend.db.table.relationships.introduction">
         <title>Introduction</title>
 
-        <para>Les tables possèdent des relations entre elles, dans une base de données relationnelle. Une entité d'une
-        table peut être liée à une autre entité d'une autre table, via un procédé appelé contrainte d'intégrité
-        référentielle</para>
+        <para>
+            Les tables possèdent des relations entre elles, dans une base de données
+            relationnelle. Une entité d'une table peut être liée à une autre entité d'une autre
+            table, via un procédé appelé contrainte d'intégrité référentielle
+        </para>
 
-        <para>La classe <classname>Zend_Db_Table_Row</classname> possède des méthodes pour récupérer des enregistrement dans
-        d'autres tables, liées à celle en cours.</para>
+        <para>
+            La classe <classname>Zend_Db_Table_Row</classname> possède des méthodes pour
+            récupérer des enregistrement dans d'autres tables, liées à celle en cours.
+        </para>
     </sect2>
 
     <sect2 id="zend.db.table.relationships.defining">
         <title>Définir ses relations</title>
 
-        <para>Chaque table doit avoir sa classe étendant <classname>Zend_Db_Table_Abstract</classname>, comme décrit dans <xref
-        linkend="zend.db.table.defining" />. Voyez aussi <xref linkend="zend.db.adapter.example-database" /> pour une
-        description de la base de donnée qui servira d'exemple pour la suite de ce chapitre.</para>
+        <para>
+            Chaque table doit avoir sa classe étendant
+            <classname>Zend_Db_Table_Abstract</classname>, comme décrit dans <xref
+            linkend="zend.db.table.defining" />. Voyez aussi <xref
+            linkend="zend.db.adapter.example-database" /> pour une description de la base de donnée
+            qui servira d'exemple pour la suite de ce chapitre.
+        </para>
 
-        <para>Voici les classes correspondantes à ces tables :</para>
+        <para>Voici les classes correspondantes à ces tables&#160;:</para>
 
         <programlisting role="php"><![CDATA[
 class Accounts extends Zend_Db_Table_Abstract
@@ -82,73 +90,115 @@ class BugsProducts extends Zend_Db_Table_Abstract
 }
 ]]></programlisting>
 
-        <para>Si vous utilisez <classname>Zend_Db_Table</classname> pour émuler les cascades <code>UPDATE</code> et
-        <code>DELETE</code>, alors déclarez <code>$_dependentTables</code> en tant que tableau dans la classe des tables
-        parentes. Listez ainsi le nom de chaque table dépendante. Utilisez bien le nom des classes, et non les noms
-        physiques des tables.</para>
+        <para>
+            Si vous utilisez <classname>Zend_Db_Table</classname> pour émuler les cascades
+            <code>UPDATE</code> et <code>DELETE</code>, alors déclarez
+            <code>$_dependentTables</code> en tant que tableau dans la classe des tables parentes.
+            Listez ainsi le nom de chaque table dépendante. Utilisez bien le nom des classes, et non
+            les noms physiques des tables.
+        </para>
 
         <note>
-            <para>Si votre SGBD implémente le mécanisme des cascades, alors vous n'avez pas besoin de déclarer
-            <code>$_dependentTables</code>. Voyez <xref linkend="zend.db.table.relationships.cascading" /> pour plus
-            d'informations.</para>
+            <para>
+                Si votre SGBD implémente le mécanisme des cascades, alors vous n'avez pas
+                besoin de déclarer <code>$_dependentTables</code>. Voyez <xref
+                linkend="zend.db.table.relationships.cascading" /> pour plus d'informations.
+            </para>
         </note>
 
-        <para>Déclarez un tableau <code>$_referenceMap</code> dans les classes de chaque table dépendante (qui "reçoit
-        une clé"). C'est un tableau associatif, dit de "rôles". Un rôle définit quelle table est parente dans la
-        relation, et quelle est sa colonne de parenté.</para>
-
-        <para>Le rôle est utilisé comme index du tableau <code>$_referenceMap</code>. Il est utilisé pour définir la
-        relation, et pourra faire partie du nom de certaines méthodes, comme nous le verrons plus tard. Choisissez ainsi
-        un nom de rôle de manière intelligente.</para>
-
-        <para>Dans l'exemple du dessus, les rôles dans la classe Bugs sont : <code>"Reporter"</code>,
-        <code>"Engineer"</code>, <code>"Verifier"</code> et <code>"Product"</code>.</para>
-
-        <para>La valeur de chaque rôle dans le tableau <code>$_referenceMap</code> est aussi un tableau associatif. Les
-        éléments de chaque rôle sont décrits ci-après.</para>
+        <para>
+            Déclarez un tableau <code>$_referenceMap</code> dans les classes de chaque table
+            dépendante (qui "reçoit une clé"). C'est un tableau associatif, dit de "rôles". Un rôle
+            définit quelle table est parente dans la relation, et quelle est sa colonne de
+            parenté.
+        </para>
+
+        <para>
+            Le rôle est utilisé comme index du tableau <code>$_referenceMap</code>. Il est
+            utilisé pour définir la relation, et pourra faire partie du nom de certaines méthodes,
+            comme nous le verrons plus tard. Choisissez ainsi un nom de rôle de manière
+            intelligente.
+        </para>
+
+        <para>
+            Dans l'exemple du dessus, les rôles dans la classe Bugs sont :
+            <code>"Reporter"</code>, <code>"Engineer"</code>, <code>"Verifier"</code> et
+            <code>"Product"</code>.
+        </para>
+
+        <para>
+            La valeur de chaque rôle dans le tableau <code>$_referenceMap</code> est aussi un
+            tableau associatif. Les éléments de chaque rôle sont décrits ci-après.
+        </para>
 
         <itemizedlist>
             <listitem>
-                <para><emphasis>columns</emphasis> =&gt; une chaîne de caractères ou un tableau de chaînes
-                désignant le(s) nom(s) des clés étrangères dans la table dépendante (la table actuelle donc).</para>
-
-                <para>Il est courant qu'il s'agisse d'une seule colonne, mais on peut rencontrer le cas de clés
-                composées de multiples colonnes.</para>
+                <para>
+                    <emphasis>columns</emphasis> =&gt; une chaîne de caractères ou un tableau
+                    de chaînes désignant le(s) nom(s) des clés étrangères dans la table dépendante
+                    (la table actuelle donc).
+                </para>
+
+                <para>
+                    Il est courant qu'il s'agisse d'une seule colonne, mais on peut rencontrer
+                    le cas de clés composées de multiples colonnes.
+                </para>
             </listitem>
 
             <listitem>
-                <para><emphasis>refTableClass</emphasis> =&gt; désigne la classe de la table parente, liée
-                à cette colonne. Utilisez le nom de la classe et non le nom de la table physique.</para>
-
-                <para>Il est courant qu'une table dépendante n'ait qu'une seule référence d'une même table parente.
-                Cependant certaines tables peuvent avoir plusieurs références vers une même table parente. Dans notre
-                base de données d'exemple, c'est le cas avec la table <code>bugs</code>. Elle possède soit une et une
-                seule colonne référençant la table parente <code>products</code>, mais elle possède trois références
-                (donc trois colonnes) vers la table parente <code>accounts</code>. Chaque référence doit être
-                matérialisée par un rôle unique dans le tableau <code>$_referenceMap</code>.</para>
+                <para>
+                    <emphasis>refTableClass</emphasis> =&gt; désigne la classe de la table
+                    parente, liée à cette colonne. Utilisez le nom de la classe et non le nom de la
+                    table physique.
+                </para>
+
+                <para>
+                    Il est courant qu'une table dépendante n'ait qu'une seule référence d'une
+                    même table parente. Cependant certaines tables peuvent avoir plusieurs
+                    références vers une même table parente. Dans notre base de données d'exemple,
+                    c'est le cas avec la table <code>bugs</code>. Elle possède soit une et une seule
+                    colonne référençant la table parente <code>products</code>, mais elle possède
+                    trois références (donc trois colonnes) vers la table parente
+                    <code>accounts</code>. Chaque référence doit être matérialisée par un rôle
+                    unique dans le tableau <code>$_referenceMap</code>.
+                </para>
             </listitem>
 
             <listitem>
-                <para><emphasis>refColumns</emphasis> =&gt; c'est une chaîne de caractères ou un tableau
-                de chaînes nommant la(es) colonne(s) (clé primaire) de la table parente.</para>
-
-                <para>Si vous devez utiliser de multiples colonnes parentes pour une seule clé, alors veillez à bien les
-                entrer dans <code>'columns'</code> dans le même ordre que dans <code>'refColumns'</code>.</para>
-
-                <para>Il est optionnel de spécifier la <code>refColumns</code>. La clé primaire est utilisée par défaut
-                comme colonne parente dans une relation.</para>
+                <para>
+                    <emphasis>refColumns</emphasis> =&gt; c'est une chaîne de caractères ou un
+                    tableau de chaînes nommant la(es) colonne(s) (clé primaire) de la table
+                    parente.
+                </para>
+
+                <para>
+                    Si vous devez utiliser de multiples colonnes parentes pour une seule clé,
+                    alors veillez à bien les entrer dans <code>'columns'</code> dans le même ordre
+                    que dans <code>'refColumns'</code>.
+                </para>
+
+                <para>
+                    Il est optionnel de spécifier la <code>refColumns</code>. La clé primaire
+                    est utilisée par défaut comme colonne parente dans une relation.
+                </para>
             </listitem>
 
             <listitem>
-                <para><emphasis>onDelete</emphasis> =&gt; le nom de l'action à exécuter si un
-                enregistrement est supprimé de la table parente. Voyez <xref
-                linkend="zend.db.table.relationships.cascading" /> pour plus d'informations.</para>
+                <para>
+                    <emphasis>onDelete</emphasis> =&gt; le nom de l'action à exécuter si un
+                    enregistrement est supprimé de la table parente. Voyez <xref
+                    linkend="zend.db.table.relationships.cascading" /> pour plus
+                    d'informations.
+                </para>
             </listitem>
 
             <listitem>
-                <para><emphasis>onUpdate</emphasis> =&gt; le nom de l'action à exécuter si un
-                enregistrement est mis à jour dans la table parente. Voyez<xref
-                linkend="zend.db.table.relationships.cascading" /> pour plus d'informations.</para>
+                <para>
+                    <emphasis>onUpdate</emphasis> =&gt; le nom de l'action à exécuter si un
+                    enregistrement est mis à jour dans la table parente. Voyez<xref
+                    linkend="zend.db.table.relationships.cascading" /> pour plus
+                    d'informations.
+                </para>
             </listitem>
         </itemizedlist>
     </sect2>
@@ -156,26 +206,37 @@ class BugsProducts extends Zend_Db_Table_Abstract
     <sect2 id="zend.db.table.relationships.fetching.dependent">
         <title>Récupérer des enregistrements dépendants (enfants)</title>
 
-        <para>Si vous possédez un enregistrement actif (<code>Row</code>), il est possible de récupérer ses enfants
-        dépendants, si les dépendances ont été déclarées suivant la procédure ci-dessus. Utilisez la méthode :</para>
+        <para>
+            Si vous possédez un enregistrement actif (<code>Row</code>), il est possible de
+            récupérer ses enfants dépendants, si les dépendances ont été déclarées suivant la
+            procédure ci-dessus. Utilisez la méthode&#160;:
+        </para>
 
         <programlisting role="php"><![CDATA[
 $row->findDependentRowset($table, [$rule]);
 ]]></programlisting>
 
-        <para>Cette méthode retourne un objet instance de <classname>Zend_Db_Table_Rowset_Abstract</classname>, qui contient tous
-        les enregistrements (<code>Row</code>) de la table dépendante <code>$table</code> faisant référence à
-        l'enregistrement actif actuel <code>$row</code>.</para>
+        <para>
+            Cette méthode retourne un objet instance de
+            <classname>Zend_Db_Table_Rowset_Abstract</classname>, qui contient tous les
+            enregistrements (<code>Row</code>) de la table dépendante <code>$table</code> faisant
+            référence à l'enregistrement actif actuel <code>$row</code>.
+        </para>
 
-        <para>Le paramètre <code>$table</code> désigne la table dépendante à utiliser. Ceci peut être une chaîne de
-        caractères aussi bien qu'un objet de la classe de cette table.</para>
+        <para>
+            Le paramètre <code>$table</code> désigne la table dépendante à utiliser. Ceci peut
+            être une chaîne de caractères aussi bien qu'un objet de la classe de cette table.
+        </para>
 
         <example id="zend.db.table.relationships.fetching.dependent.example">
             <title>Récupérer des enregistrements dépendants</title>
 
-            <para>Cet exemple montre comment obtenir un enregistrement actif (objet <code>Row</code>) de la table
-            <code>Accounts</code>, et comment en récupérer les enfants dépendants de la table <code>Bugs</code>. (les
-            bugs reportés par ce compte)</para>
+            <para>
+                Cet exemple montre comment obtenir un enregistrement actif (objet
+                <code>Row</code>) de la table <code>Accounts</code>, et comment en récupérer les
+                enfants dépendants de la table <code>Bugs</code>. (les bugs reportés par ce
+                compte)
+            </para>
 
             <programlisting role="php"><![CDATA[
 $accountsTable      = new Accounts();
@@ -186,19 +247,27 @@ $bugsReportedByUser = $user1234->findDependentRowset('Bugs');
 ]]></programlisting>
         </example>
 
-        <para>Le second paramètre <code>$rule</code> est optionnel. Il s'agit du nom du rôle à utiliser depuis le
-        tableau <code>$_referenceMap</code> de la classe de la table dépendante. Si vous ne le spécifiez pas, le premier
-        rôle sera utilisé. Il n'y a dans la majorité des cas qu'un seul rôle.</para>
+        <para>
+            Le second paramètre <code>$rule</code> est optionnel. Il s'agit du nom du rôle à
+            utiliser depuis le tableau <code>$_referenceMap</code> de la classe de la table
+            dépendante. Si vous ne le spécifiez pas, le premier rôle sera utilisé. Il n'y a dans la
+            majorité des cas qu'un seul rôle.
+        </para>
 
-        <para>Dans l'exemple ci dessus, nous ne fournissons pas de nom de rôle, le premier est donc pris en
-        considération, et il s'agit de <code>"Reporter"</code>.</para>
+        <para>
+            Dans l'exemple ci dessus, nous ne fournissons pas de nom de rôle, le premier est
+            donc pris en considération, et il s'agit de <code>"Reporter"</code>.
+        </para>
 
         <example id="zend.db.table.relationships.fetching.dependent.example-by">
             <title>Récupérer des enregistrements dépendants avec un rôle spécifique</title>
 
-            <para>Dans cet exemple nous montrons comment obtenir un enregistrement (<code>Row</code>) depuis la table
-            <code>Accounts</code>, et comment trouver les <code>Bugs</code> assignés à ce compte (<code>Account</code>).
-            Nous devrons alors nommer le rôle <code>"Engineer"</code>.</para>
+            <para>
+                Dans cet exemple nous montrons comment obtenir un enregistrement
+                (<code>Row</code>) depuis la table <code>Accounts</code>, et comment trouver les
+                <code>Bugs</code> assignés à ce compte (<code>Account</code>). Nous devrons alors
+                nommer le rôle <code>"Engineer"</code>.
+            </para>
 
             <programlisting role="php"><![CDATA[
 $accountsTable      = new Accounts();
@@ -210,17 +279,25 @@ $bugsAssignedToUser = $user1234->findDependentRowset('Bugs',
 ]]></programlisting>
         </example>
 
-        <para>Vous pouvez rajouter des critères à vos relations, comme l'ordre ou la limite, ceci en utilisant l'objet
-        <code>select</code> de l'enregistrement parent.</para>
-
-        <para><example id="zend.db.table.relationships.fetching.dependent.example-by-select">
-                <title>Récupérer des enregistrements dépendants en utilisant un objet
-                <classname>Zend_Db_Table_Select</classname></title>
-
-                <para>Dans cet exemple nous montrons comment obtenir un enregistrement (<code>Row</code>) depuis la
-                table <code>Accounts</code>, et comment trouver les <code>Bugs</code> assignés à ce compte
-                (<code>Account</code>), mais limités seulement à trois enregistrements, et ordonnés par nom. Nous
-                devrons nommer le rôle <code>"Engineer"</code>.</para>
+        <para>
+            Vous pouvez rajouter des critères à vos relations, comme l'ordre ou la limite,
+            ceci en utilisant l'objet <code>select</code> de l'enregistrement parent.
+        </para>
+
+        <para>
+            <example id="zend.db.table.relationships.fetching.dependent.example-by-select">
+                    <title>
+                        Récupérer des enregistrements dépendants en utilisant un objet
+                        Zend_Db_Table_Select
+                    </title>
+
+                <para>
+                    Dans cet exemple nous montrons comment obtenir un enregistrement
+                    (<code>Row</code>) depuis la table <code>Accounts</code>, et comment trouver les
+                    <code>Bugs</code> assignés à ce compte (<code>Account</code>), mais limités
+                    seulement à trois enregistrements, et ordonnés par nom. Nous devrons nommer le
+                    rôle <code>"Engineer"</code>.
+                </para>
 
                 <programlisting role="php"><![CDATA[
 $accountsTable      = new Accounts();
@@ -233,10 +310,12 @@ $bugsAssignedToUser = $user1234->findDependentRowset('Bugs',
                                                      'Engineer',
                                                      $select);
 ]]></programlisting>
-            </example>Vous pouvez récupérer les enregistrements dépendants d'une autre manière. En utilisant les
-        "méthodes magiques". En effet, <classname>Zend_Db_Table_Row_Abstract</classname> va utiliser la méthode
-        <code>findDependentRowset('&lt;TableClass&gt;', '&lt;Rule&gt;')</code> si vous appelez sur l'enregistrement une
-        méthode correspondante à un de ces motifs :</para>
+            </example>Vous pouvez récupérer les enregistrements dépendants d'une autre manière.
+        En utilisant les "méthodes magiques". En effet,
+        <classname>Zend_Db_Table_Row_Abstract</classname> va utiliser la méthode
+        <code>findDependentRowset('&lt;TableClass&gt;', '&lt;Rule&gt;')</code> si vous appelez
+            sur l'enregistrement une méthode correspondante à un de ces motifs&#160;:
+        </para>
 
         <itemizedlist>
             <listitem>
@@ -248,21 +327,32 @@ $bugsAssignedToUser = $user1234->findDependentRowset('Bugs',
             </listitem>
         </itemizedlist>
 
-        <para>Dans les motifs ci-dessus, <code>&lt;TableClass&gt;</code> et <code>&lt;Rule&gt;</code> désignent
-        respectivement le nom de la table dépendante et le rôle à utiliser.</para>
+        <para>
+            Dans les motifs ci-dessus, <code>&lt;TableClass&gt;</code> et
+            <code>&lt;Rule&gt;</code> désignent respectivement le nom de la table dépendante et le
+            rôle à utiliser.
+        </para>
 
         <note>
-            <para>Certains frameworks tels que Rails pour Ruby, utilise un mécanisme dit d'inflexion, qui permet de
-            transformer les noms des identifiants (nom de table, de rôle...) d'une certaine manière bien spécifique dans
-            les méthodes appelées. Cela n'est pas le cas de Zend Framework : vous devez, dans vos méthodes magiques,
-            utiliser l'orthographe exacte des noms des rôles et classes, tels que vous les définissez.</para>
+            <para>
+                Certains frameworks tels que Rails pour Ruby, utilise un mécanisme dit
+                d'inflexion, qui permet de transformer les noms des identifiants (nom de table, de
+                rôle...) d'une certaine manière bien spécifique dans les méthodes appelées. Cela
+                n'est pas le cas de Zend Framework : vous devez, dans vos méthodes magiques,
+                utiliser l'orthographe exacte des noms des rôles et classes, tels que vous les
+                définissez.
+            </para>
         </note>
 
         <example id="zend.db.table.relationships.fetching.dependent.example-magic">
-            <title>Récupérer des enregistrements dépendants en utilisant les méthodes magiques</title>
+            <title>
+                Récupérer des enregistrements dépendants en utilisant les méthodes magiques
+            </title>
 
-            <para>Cet exemple a le même effet que le précédent. Il utilise simplement les méthodes magiques pour
-            récupérer les enregistrements dépendants.</para>
+            <para>
+                Cet exemple a le même effet que le précédent. Il utilise simplement les
+                méthodes magiques pour récupérer les enregistrements dépendants.
+            </para>
 
             <programlisting role="php"><![CDATA[
 $accountsTable    = new Accounts();
@@ -281,25 +371,36 @@ $bugsAssignedTo   = $user1234->findBugsByEngineer();
     <sect2 id="zend.db.table.relationships.fetching.parent">
         <title>Récupérer l'enregistrement parent</title>
 
-        <para>Si vous possédez un enregistrement (<code>Row</code>) dont la table possède une table parente, il est
-        possible alors de récupérer l'enregistrement parent. Utilisez pour cela la méthode :</para>
+        <para>
+            Si vous possédez un enregistrement (<code>Row</code>) dont la table possède une
+            table parente, il est possible alors de récupérer l'enregistrement parent. Utilisez pour
+            cela la méthode&#160;:
+        </para>
 
         <programlisting role="php"><![CDATA[
 $row->findParentRow($table, [$rule]);
 ]]></programlisting>
 
-        <para>La logique veut qu'il ne puisse y avoir qu'un et un seul parent par enregistrement. Ainsi, cette méthode
-        retourne un objet <code>Row</code> et non un objet <code>Rowset</code></para>
+        <para>
+            La logique veut qu'il ne puisse y avoir qu'un et un seul parent par
+            enregistrement. Ainsi, cette méthode retourne un objet <code>Row</code> et non un objet
+            <code>Rowset</code>
+        </para>
 
-        <para>Le premier paramètre <code>$table</code> désigne la table parente. Ceci peut être une chaîne de
-        caractères, ou un objet instance de la classe de la table parente.</para>
+        <para>
+            Le premier paramètre <code>$table</code> désigne la table parente. Ceci peut être
+            une chaîne de caractères, ou un objet instance de la classe de la table parente.
+        </para>
 
         <example id="zend.db.table.relationships.fetching.parent.example">
             <title>Récupérer l'enregistrement parent</title>
 
-            <para>Cet exemple illustre la récupération d'un enregistrement <code>Bugs</code> ( disons par exemple ceux
-            avec le statut "NEW"), et l'obtention de l'enregistrement parent correspondant à <code>Accounts</code> (la
-            personne ayant reporté le bug)</para>
+            <para>
+                Cet exemple illustre la récupération d'un enregistrement <code>Bugs</code> (disons
+                par exemple ceux avec le statut "NEW"), et l'obtention de l'enregistrement
+                parent correspondant à <code>Accounts</code> (la personne ayant reporté le
+                bug)
+            </para>
 
             <programlisting role="php"><![CDATA[
 $bugsTable   = new Bugs();
@@ -310,18 +411,26 @@ $reporter    = $bug1->findParentRow('Accounts');
 ]]></programlisting>
         </example>
 
-        <para>Le second paramètre <code>$rule</code> est optionnel. Il s'agit du nom du rôle à utiliser depuis le
-        tableau <code>$_referenceMap</code> de la classe de la table dépendante. Si vous ne le spécifiez pas, le premier
-        rôle sera utilisé. Il n'y a dans la majorité des cas qu'un seul rôle.</para>
+        <para>
+            Le second paramètre <code>$rule</code> est optionnel. Il s'agit du nom du rôle à
+            utiliser depuis le tableau <code>$_referenceMap</code> de la classe de la table
+            dépendante. Si vous ne le spécifiez pas, le premier rôle sera utilisé. Il n'y a dans la
+            majorité des cas qu'un seul rôle.
+        </para>
 
-        <para>Dans l'exemple ci dessus, nous ne fournissons pas de nom de rôle, le premier est donc pris en
-        considération, et il s'agit de <code>"Reporter"</code>.</para>
+        <para>
+            Dans l'exemple ci dessus, nous ne fournissons pas de nom de rôle, le premier est
+            donc pris en considération, et il s'agit de <code>"Reporter"</code>.
+        </para>
 
         <example id="zend.db.table.relationships.fetching.parent.example-by">
             <title>Récupérer un enregistrement parent avec un rôle spécifique</title>
 
-            <para>Cet exemple va démontrer comment, à partir d'un enregistrement de <code>Bugs</code>, récupérer la
-            personne en étant assignée. Il va falloir utiliser le rôle <code>"Engineer"</code>.</para>
+            <para>
+                Cet exemple va démontrer comment, à partir d'un enregistrement de
+                <code>Bugs</code>, récupérer la personne en étant assignée. Il va falloir utiliser
+                le rôle <code>"Engineer"</code>.
+            </para>
 
             <programlisting role="php"><![CDATA[
 $bugsTable   = new Bugs();
@@ -332,35 +441,49 @@ $engineer    = $bug1->findParentRow('Accounts', 'Engineer');
 ]]></programlisting>
         </example>
 
-        <para>Vous pouvez récupérer l'enregistrement parent d'une autre manière. En utilisant les "méthodes magiques".
-        En effet, Zend_Db_Table_Row_Abstract va utiliser la méthode<code>findParentRow('&lt;TableClass&gt;',
-        '&lt;Rule&gt;')</code> si vous appelez sur l'enregistrement une méthode correspondante à un de ces motifs
-        :</para>
+        <para>
+            Vous pouvez récupérer l'enregistrement parent d'une autre manière. En utilisant
+            les "méthodes magiques". En effet, Zend_Db_Table_Row_Abstract va utiliser la
+            méthode<code>findParentRow('&lt;TableClass&gt;', '&lt;Rule&gt;')</code> si vous appelez
+            sur l'enregistrement une méthode correspondante à un de ces motifs :
+        </para>
 
         <itemizedlist>
             <listitem>
-                <para><code>$row-&gt;findParent&lt;TableClass&gt;([Zend_Db_Table_Select $select])</code></para>
+                <para>
+                    <code>$row-&gt;findParent&lt;TableClass&gt;([Zend_Db_Table_Select
+                    $select])</code>
+                </para>
             </listitem>
 
             <listitem>
-                <para><code>$row-&gt;findParent&lt;TableClass&gt;By&lt;Rule&gt;([Zend_Db_Table_Select
-                $select])</code></para>
+                <para>
+                    <code>$row-&gt;findParent&lt;TableClass&gt;By&lt;Rule&gt;([Zend_Db_Table_Select
+                    $select])</code>
+                </para>
             </listitem>
         </itemizedlist>
 
-        <para>Dans les motifs ci-dessus, <code>&lt;TableClass&gt;</code> et <code>&lt;Rule&gt;</code> représentent
-        respectivement le nom de la classe de la table parente, et le rôle à utiliser éventuellement.</para>
+        <para>
+            Dans les motifs ci-dessus, <code>&lt;TableClass&gt;</code> et
+            <code>&lt;Rule&gt;</code> représentent respectivement le nom de la classe de la table
+            parente, et le rôle à utiliser éventuellement.
+        </para>
 
         <note>
-            <para>Les noms de la table et du rôle doivent être orthographiés de la même manière qu'ils ne le sont lors
-            de leur définition dans la table.</para>
+            <para>
+                Les noms de la table et du rôle doivent être orthographiés de la même manière
+                qu'ils ne le sont lors de leur définition dans la table.
+            </para>
         </note>
 
         <example id="zend.db.table.relationships.fetching.parent.example-magic">
             <title>Récupérer un enregistrement parent en utilisant les méthodes magiques</title>
 
-            <para>Cet exemple a le même effet que le précédent. Il utilise simplement les méthodes magiques pour
-            récupérer l'enregistrement parent.</para>
+            <para>
+                Cet exemple a le même effet que le précédent. Il utilise simplement les
+                méthodes magiques pour récupérer l'enregistrement parent.
+            </para>
 
             <programlisting role="php"><![CDATA[
 $bugsTable   = new Bugs();
@@ -377,11 +500,17 @@ $engineer    = $bug1->findParentAccountsByEngineer();
     </sect2>
 
     <sect2 id="zend.db.table.relationships.fetching.many-to-many">
-        <title>Récupérer des enregistrements dans une relation N-N (plusieurs-à-plusieurs ou "many-to-many")</title>
-
-        <para>Si vous possédez un enregistrement sur une table (appelons la "table d'origine") ayant une relation
-        plusieurs à plusieurs vers une autre table (appelons la "table de destination"), vous pouvez alors accéder aux
-        enregistrements de la table de destination, via une table dite "d'intersection". Utilisez la méthode :</para>
+        <title>
+            Récupérer des enregistrements dans une relation N-N (plusieurs-à-plusieurs ou
+            "many-to-many")
+        </title>
+
+        <para>
+            Si vous possédez un enregistrement sur une table (appelons la "table d'origine")
+            ayant une relation plusieurs à plusieurs vers une autre table (appelons la "table de
+            destination"), vous pouvez alors accéder aux enregistrements de la table de destination,
+            via une table dite "d'intersection". Utilisez la méthode :
+        </para>
 
         <programlisting role="php"><![CDATA[
 $row->findManyToManyRowset($table,
@@ -391,23 +520,36 @@ $row->findManyToManyRowset($table,
                            [Zend_Db_Table_Select $select]]]);
 ]]></programlisting>
 
-        <para>Cette méthode retourne un objet instance de <classname>Zend_Db_Table_Rowset_Abstract</classname> qui contient les
-        enregistrements de la table <code>$table</code> qui correspondent à la relation plusieurs à plusieurs.
-        L'enregistrement courant de la table courante, <code>$row</code>, est utilisé comme point de départ pour
-        effectuer une jointure vers la table de destination, via la table d'intersection.</para>
-
-        <para>Le premier paramètre <code>$table</code> peut être soit une chaîne soit un objet instance de la classe de
-        la table de destination dans la relation plusieurs à plusieurs.</para>
-
-        <para>Le second paramètre <code>$intersectionTable</code> peut être soit une chaîne soit un objet instance de la
-        classe de la table d'intersection dans la relation plusieurs à plusieurs.</para>
+        <para>
+            Cette méthode retourne un objet instance de
+            <classname>Zend_Db_Table_Rowset_Abstract</classname> qui contient les enregistrements de
+            la table <code>$table</code> qui correspondent à la relation plusieurs à plusieurs.
+            L'enregistrement courant de la table courante, <code>$row</code>, est utilisé comme
+            point de départ pour effectuer une jointure vers la table de destination, via la table
+            d'intersection.
+        </para>
+
+        <para>
+            Le premier paramètre <code>$table</code> peut être soit une chaîne soit un objet
+            instance de la classe de la table de destination dans la relation plusieurs à
+            plusieurs.
+        </para>
+
+        <para>
+            Le second paramètre <code>$intersectionTable</code> peut être soit une chaîne soit
+            un objet instance de la classe de la table d'intersection dans la relation plusieurs à
+            plusieurs.
+        </para>
 
         <example id="zend.db.table.relationships.fetching.many-to-many.example">
             <title>Récupérer des enregistrements dans une relation plusieurs-à-plusieurs</title>
 
-            <para>Cet exemple montre comment posséder un enregistrement de la table d'origine <code>Bugs</code>, et
-            comment en récupérer les enregistrements de <code>Products</code>, qui représentent les produits qui font
-            référence à ce bug.</para>
+            <para>
+                Cet exemple montre comment posséder un enregistrement de la table d'origine
+                <code>Bugs</code>, et comment en récupérer les enregistrements de
+                <code>Products</code>, qui représentent les produits qui font référence à ce
+                bug.
+            </para>
 
             <programlisting role="php"><![CDATA[
 $bugsTable        = new Bugs();
@@ -419,27 +561,45 @@ $productsRowset   = $bug1234->findManyToManyRowset('Products',
 ]]></programlisting>
         </example>
 
-        <para>Les troisième et quatrième paramètres, <code>$rule1</code> et <code>$rule2</code>, sont optionnels. Ce
-        sont des chaînes de caractères qui désignent les rôles à utiliser dans le tableau <code>$_referenceMap</code> de
-        la table d'intersection.</para>
-
-        <para><code>$rule1</code> nomme le rôle dans la relation entre la table d'origine et la table d'intersection.
-        Dans notre exemple, il s'agit donc de la relation de <code>Bugs</code> à <code>BugsProducts</code>.</para>
-
-        <para><code>$rule2</code>nomme le rôle dans la relation entre la table d'origine et la table d'intersection.
-        Dans notre exemple, il s'agit donc de la relation de <code>BugsProducts</code> à <code>Products</code>.</para>
-
-        <para>Si vous ne spécifiez pas de rôles, alors le premier rôle trouvé pour la table, dans le tableau
-        <code>$_referenceMap</code>, sera utilisé. Dans la grande majorité des cas, il n'y a qu'un rôle.</para>
-
-        <para>Dans l'exemple ci-dessus, les rôles ne sont pas spécifiés. Ainsi <code>$rule1</code> prend la valeur
-        <code>"Reporter"</code> et <code>$rule2</code> prend la valeur <code>"Product"</code>.</para>
+        <para>
+            Les troisième et quatrième paramètres, <code>$rule1</code> et <code>$rule2</code>,
+            sont optionnels. Ce sont des chaînes de caractères qui désignent les rôles à utiliser
+            dans le tableau <code>$_referenceMap</code> de la table d'intersection.
+        </para>
+
+        <para>
+            <code>$rule1</code> nomme le rôle dans la relation entre la table d'origine et la
+            table d'intersection. Dans notre exemple, il s'agit donc de la relation de
+            <code>Bugs</code> à <code>BugsProducts</code>.
+        </para>
+
+        <para>
+            <code>$rule2</code>nomme le rôle dans la relation entre la table d'origine et la
+            table d'intersection. Dans notre exemple, il s'agit donc de la relation de
+            <code>BugsProducts</code> à <code>Products</code>.
+        </para>
+
+        <para>
+            Si vous ne spécifiez pas de rôles, alors le premier rôle trouvé pour la table,
+            dans le tableau <code>$_referenceMap</code>, sera utilisé. Dans la grande majorité des
+            cas, il n'y a qu'un rôle.
+        </para>
+
+        <para>
+            Dans l'exemple ci-dessus, les rôles ne sont pas spécifiés. Ainsi
+            <code>$rule1</code> prend la valeur <code>"Reporter"</code> et <code>$rule2</code> prend
+            la valeur <code>"Product"</code>.
+        </para>
 
         <example id="zend.db.table.relationships.fetching.many-to-many.example-by">
-            <title>Récupérer des enregistrements dans une relation plusieurs-à-plusieurs avec un rôle spécifique</title>
+            <title>Récupérer des enregistrements dans une relation plusieurs-à-plusieurs avec un
+            rôle spécifique</title>
 
-            <para>Cet exemple montre comment à partir d'un enregistrement de <code>Bugs</code>, récupérer les
-            enregistrements de <code>Products</code>, représentant les produits comportant ce bug.</para>
+            <para>
+                Cet exemple montre comment à partir d'un enregistrement de <code>Bugs</code>,
+                récupérer les enregistrements de <code>Products</code>, représentant les produits
+                comportant ce bug.
+            </para>
 
             <programlisting role="php"><![CDATA[
 $bugsTable        = new Bugs();
@@ -452,45 +612,63 @@ $productsRowset   = $bug1234->findManyToManyRowset('Products',
 ]]></programlisting>
         </example>
 
-        <para>Vous pouvez récupérer l'enregistrement de destination d'une autre manière. En utilisant les "méthodes
-        magiques". En effet, <classname>Zend_Db_Table_Row_Abstract</classname> va utiliser la méthode
-        <code>findManyToManyRowset('&lt;TableClass&gt;', '&lt;IntersectionTableClass&gt;', '&lt;Rule1&gt;',
-        '&lt;Rule2&gt;')</code> si vous appelez sur l'enregistrement une méthode correspondante à un de ces motifs
-        :</para>
+        <para>
+            Vous pouvez récupérer l'enregistrement de destination d'une autre manière. En
+            utilisant les "méthodes magiques". En effet,
+            <classname>Zend_Db_Table_Row_Abstract</classname> va utiliser la méthode
+            <code>findManyToManyRowset('&lt;TableClass&gt;', '&lt;IntersectionTableClass&gt;',
+            '&lt;Rule1&gt;', '&lt;Rule2&gt;')</code> si vous appelez sur l'enregistrement une
+            méthode correspondante à un de ces motifs :
+        </para>
 
         <itemizedlist>
             <listitem>
-                <para><code>$row-&gt;find&lt;TableClass&gt;Via&lt;IntersectionTableClass&gt;([Zend_Db_Table_Select
-                $select])</code></para>
+                <para>
+                    <code>$row-&gt;find&lt;TableClass&gt;Via&lt;IntersectionTableClass&gt;([Zend_Db_Table_Select
+                    $select])</code>
+                </para>
             </listitem>
 
             <listitem>
-                <para><code>$row-&gt;find&lt;TableClass&gt;Via&lt;IntersectionTableClass&gt;By&lt;Rule1&gt;([Zend_Db_Table_Select
-                $select])</code></para>
+                <para>
+                    <code>$row-&gt;find&lt;TableClass&gt;Via&lt;IntersectionTableClass&gt;By&lt;Rule1&gt;([Zend_Db_Table_Select
+                    $select])</code>
+                </para>
             </listitem>
 
             <listitem>
-                <para><code>$row-&gt;find&lt;TableClass&gt;Via&lt;IntersectionTableClass&gt;By&lt;Rule1&gt;And&lt;Rule2&gt;([Zend_Db_Table_Select
-                $select])</code></para>
+                <para>
+                    <code>$row-&gt;find&lt;TableClass&gt;Via&lt;IntersectionTableClass&gt;By&lt;Rule1&gt;And&lt;Rule2&gt;([Zend_Db_Table_Select
+                    $select])</code>
+                </para>
             </listitem>
         </itemizedlist>
 
-        <para>Dans les motifs ci dessus, <code>&lt;TableClass&gt;</code> et <code>&lt;IntersectionTableClass&gt;</code>
-        sont des chaînes de caractères correspondantes aux noms des classes des tables de destination et d'intersection
-        (respectivement). <code>&lt;Rule1&gt;</code> et <code>&lt;Rule2&gt;</code> sont respectivement des chaînes
-        désignant les rôles dans la table d'intersection pour la table de référence, et de destination.</para>
+        <para>
+            Dans les motifs ci dessus, <code>&lt;TableClass&gt;</code> et
+            <code>&lt;IntersectionTableClass&gt;</code> sont des chaînes de caractères
+            correspondantes aux noms des classes des tables de destination et d'intersection
+            (respectivement). <code>&lt;Rule1&gt;</code> et <code>&lt;Rule2&gt;</code> sont
+            respectivement des chaînes désignant les rôles dans la table d'intersection pour la
+            table de référence, et de destination.
+        </para>
 
         <note>
-            <para>Les noms de la table et des rôles doivent être orthographiés de manière exacte, tel qu'ils le sont
-            lors de leurs définitions respectives.</para>
+            <para>
+                Les noms de la table et des rôles doivent être orthographiés de manière
+                exacte, tel qu'ils le sont lors de leurs définitions respectives.
+            </para>
         </note>
 
         <example id="zend.db.table.relationships.fetching.many-to-many.example-magic">
-            <title>Récupérer des enregistrements dans une relation plusieurs-à-plusieurs avec les méthodes
-            magiques</title>
+            <title>Récupérer des enregistrements dans une relation plusieurs-à-plusieurs avec
+            les méthodes magiques</title>
 
-            <para>Cet exemple illustre la récupération d'enregistrements dans une table de destination, bugs, depuis un
-            produit, en passant par une table d'intersection, le tout, via des méthodes magiques.</para>
+            <para>
+                Cet exemple illustre la récupération d'enregistrements dans une table de
+                destination, bugs, depuis un produit, en passant par une table d'intersection, le
+                tout, via des méthodes magiques.
+            </para>
 
             <programlisting role="php"><![CDATA[
 $bugsTable   = new Bugs();
@@ -512,32 +690,50 @@ $products    = $bug1234->findProductsViaBugsProductsByBug();
         <note>
             <title>Déclarer l'intégrité référentielle</title>
 
-            <para>Déclarer les opérations de cascades dûes à l'intégrité référentielle dans <classname>Zend_Db_Table</classname>
-            directement, ne doit se faire <emphasis>seulement</emphasis> si votre SGBD ne supporte pas
-            nativement ce genre d'opérations.</para>
-
-            <para>C'est le cas par exemple de MySQL utilisant le stockage de tables MyISAM, ou encore SQLite. Ces
-            solutions là ne supportent pas l'intégrité référentielle. Il peut alors être intéressant d'utiliser
-            <classname>Zend_Db_Table</classname> pour émuler un tel comportement</para>
-
-            <para>Si votre SGBD en revanche supporte les clauses <code>ON DELETE</code> et <code>ON UPDATE</code>, alors
-            vous devriez les déclarer directement dans le SGBD plutôt que de vous fier à l'émulation proposée par
-            <classname>Zend_Db_Table</classname>. Déclarer son intégrité référentielle dans son SGBD directement est tout à fait
-            recommandé pour les performances, l'intégrité (l'atomicité des opérations), et la logique de base de
-            données.</para>
-
-            <para>Il est très important de ne pas déclarer ses règles d'intégrité référentielle à la fois dans son SGBD
-            et dans les classes <classname>Zend_Db_Table</classname>.</para>
+            <para>
+                Déclarer les opérations de cascades dûes à l'intégrité référentielle dans
+                <classname>Zend_Db_Table</classname> directement, ne doit se faire
+                <emphasis>seulement</emphasis> si votre SGBD ne supporte pas nativement ce genre
+                d'opérations.
+            </para>
+
+            <para>
+                C'est le cas par exemple de MySQL utilisant le stockage de tables MyISAM, ou
+                encore SQLite. Ces solutions là ne supportent pas l'intégrité référentielle. Il peut
+                alors être intéressant d'utiliser <classname>Zend_Db_Table</classname> pour émuler
+                un tel comportement
+            </para>
+
+            <para>
+                Si votre SGBD en revanche supporte les clauses <code>ON DELETE</code> et
+                <code>ON UPDATE</code>, alors vous devriez les déclarer directement dans le SGBD
+                plutôt que de vous fier à l'émulation proposée par
+                <classname>Zend_Db_Table</classname>. Déclarer son intégrité référentielle dans son
+                SGBD directement est tout à fait recommandé pour les performances, l'intégrité
+                (l'atomicité des opérations), et la logique de base de données.
+            </para>
+
+            <para>
+                Il est très important de ne pas déclarer ses règles d'intégrité référentielle
+                à la fois dans son SGBD et dans les classes
+                <classname>Zend_Db_Table</classname>.
+            </para>
         </note>
 
-        <para>Vous pouvez déclarer des opérations de cascade sur un <code>UPDATE</code> ou un <code>DELETE</code>, à
-        appliquer sur les enregistrements dépendants à la table en cours.</para>
+        <para>
+            Vous pouvez déclarer des opérations de cascade sur un <code>UPDATE</code> ou un
+            <code>DELETE</code>, à appliquer sur les enregistrements dépendants à la table en
+            cours.
+        </para>
 
         <example id="zend.db.table.relationships.cascading.example-delete">
             <title>Exemple de DELETE cascade</title>
 
-            <para>Cet exemple montre l'effacement d'un enregistrement de <code>Products</code>, qui va propager
-            l'effacement des enregistrements dépendants dans la table <code>Bugs</code>.</para>
+            <para>
+                Cet exemple montre l'effacement d'un enregistrement de <code>Products</code>,
+                qui va propager l'effacement des enregistrements dépendants dans la table
+                <code>Bugs</code>.
+            </para>
 
             <programlisting role="php"><![CDATA[
 $productsTable  = new Products();
@@ -550,30 +746,44 @@ $product1234->delete();
 ]]></programlisting>
         </example>
 
-        <para>De la même manière, si vous utilisez un <code>UPDATE</code> pour changer la valeur de la clé primaire
-        d'une table parente, vous pourriez nécessiter que les clés étrangères des tables dépendantes soient mises à
-        jour.</para>
-
-        <para>En général s'il s'agit d'une séquence, il n'est pas nécessaire de mettre à jour les enregistrements
-        dépendants. En revanche concernant les clé dites <emphasis>naturelles </emphasis>, il peut s'avérer nécessaire
-        de propager un changement de valeur.</para>
-
-        <para>Afin de déclarer une relation de cascades dans <classname>Zend_Db_Table</classname>, éditer les rôles dans
-        <code>$_referenceMap</code>. Ajoutez les clés <code>'onDelete'</code> et <code>'onUpdate'</code> et donnez leur
-        la valeur 'cascade' (ou la constante <code>self::CASCADE</code>). Avant qu'un enregistrement ne soit modifié(sa
-        clé primaire) / supprimé, tous les enregistrements dans les tables dépendantes seront modifiés /
-        supprimés.</para>
+        <para>
+            De la même manière, si vous utilisez un <code>UPDATE</code> pour changer la valeur
+            de la clé primaire d'une table parente, vous pourriez nécessiter que les clés étrangères
+            des tables dépendantes soient mises à jour.
+        </para>
+
+        <para>
+            En général s'il s'agit d'une séquence, il n'est pas nécessaire de mettre à jour
+            les enregistrements dépendants. En revanche concernant les clé dites
+            <emphasis>naturelles </emphasis>, il peut s'avérer nécessaire de propager un changement
+            de valeur.
+        </para>
+
+        <para>
+            Afin de déclarer une relation de cascades dans
+            <classname>Zend_Db_Table</classname>, éditer les rôles dans <code>$_referenceMap</code>.
+            Ajoutez les clés <code>'onDelete'</code> et <code>'onUpdate'</code> et donnez leur la
+            valeur 'cascade' (ou la constante <code>self::CASCADE</code>). Avant qu'un
+            enregistrement ne soit modifié(sa clé primaire) / supprimé, tous les enregistrements
+            dans les tables dépendantes seront modifiés / supprimés.
+        </para>
 
         <example id="zend.db.table.relationships.cascading.example-declaration">
             <title>Exemple de déclaration des opérations de cascade</title>
 
-            <para>Dans l'exemple ci-après, les enregistrements de <code>Bugs</code> sont automatiquement supprimés si
-            l'enregistrement dans la table <code>Products</code> auquel ils font référence est supprimé. L'élément
-            <code>"onDelete"</code> de la <code>$_referenceMap</code> est mis à <code>self::CASCADE</code>.</para>
+            <para>
+                Dans l'exemple ci-après, les enregistrements de <code>Bugs</code> sont
+                automatiquement supprimés si l'enregistrement dans la table <code>Products</code>
+                auquel ils font référence est supprimé. L'élément <code>"onDelete"</code> de la
+                <code>$_referenceMap</code> est mis à <code>self::CASCADE</code>.
+            </para>
 
-            <para>Pas de mise à jour en cascade en revanche pour cette table, si la clé primaire de la table parente est
-            changée. En effet, l'élément <code>"onUpdate"</code> est mis à <code>self::RESTRICT</code>. Vous auriez
-            aussi pu tout simplement ne pas spécifier <code>"onUpdate"</code> .</para>
+            <para>
+                Pas de mise à jour en cascade en revanche pour cette table, si la clé primaire
+                de la table parente est changée. En effet, l'élément <code>"onUpdate"</code> est mis
+                à <code>self::RESTRICT</code>. Vous auriez aussi pu tout simplement ne pas spécifier
+                <code>"onUpdate"</code> .
+            </para>
 
             <programlisting role="php"><![CDATA[
 class BugsProducts extends Zend_Db_Table_Abstract
@@ -596,46 +806,69 @@ class BugsProducts extends Zend_Db_Table_Abstract
         <sect3 id="zend.db.table.relationships.cascading.notes">
             <title>Notes concernant les opérations de cascade</title>
 
-            <para><emphasis>Les opérations de cascades déclenchées par Zend_Db_Table ne sont pas
-            atomiques.</emphasis></para>
-
-            <para>Ceci signifie que si votre SGBD possède un moyen de gérer les cascades, comme l'intégrité
-            référentielle (et les clés étrangères), alors vous ne devriez pas utiliser les cascades INSERT via
-            <classname>Zend_Db_Table</classname>, car elles vont entrer en conflit avec le système d'intégrité référentielle du
-            SGBD qui lui, est atomique.</para>
-
-            <para>Le problème est plus mitigé concernant <code>DELETE</code>. Vous pouvez détruire de manière non
-            atomique un enregistrement dépendant, avant de détruire son parent.</para>
-
-            <para>Cependant, les deux opérations <code>UPDATE</code> et <code>DELETE</code> utilisées de manière non
-            atomique(que), c'est à dire avec le mécanisme de <classname>Zend_Db_Table</classname>, peuvent laisser la base de
-            données dans un état non désiré, ou état intermédiaire. Supposez que vous supprimiez tous les
-            enregistrements dépendants, pour finir par leur parent unique. A un moment donnée, la base de donnée sera
-            dans un état tel que le parent sera sans enfants, mais toujours bel et bien présent. Si un autre client se
-            connecte exactement à ce moment là, il va pouvoir requêter éventuellement le parent, en croyant que celui-ci
-            n'a plus d'enfant, ce qui normalement n'est pas le cas. Il est alors totalement impossible pour ce client là
-            de se rendre compte qu'il a effectuer une lecture au beau milieu d'une plus vaste opération
-            d'effacement.</para>
-
-            <para>Les problèmes de changements non-atomique peuvent être anéantis en utilisant les transactions
-            isolantes, c'est d'ailleurs un de leur rôle clé. Cependant certains SGBDs ne supportent pas encore les
-            transactions, et autorisent leurs clients à lire des changements incomplets pas validés en totalité.</para>
-
-            <para><emphasis>Les opérations de cascades de Zend_Db_Table ne sont utilisées que par
-            Zend_Db_Table.</emphasis></para>
-
-            <para>Les cascades pour <code>DELETE</code> et <code>UPDATE</code> définies dans vos classes
-            <classname>Zend_Db_Table</classname> ne sont utilisées que lors du recours aux méthodes <code>save()</code> ou
-            <code>delete()</code> sur les enregistrements <code>Row</code>. Si vous utilisez une autre interface pour
-            vos <code>UPDATE</code> ou <code>DELETE</code>, comme par exemple un outil de requêtes, ou une autre
-            application, les opérations de cascades ne sont bien sûr pas appliquées. C'est même le cas si vous utilisez
-            les méthodes <code>update()</code> et <code>delete()</code> dans la classe
-            <classname>Zend_Db_Adapter</classname>.</para>
+            <para>
+                <emphasis>Les opérations de cascades déclenchées par Zend_Db_Table ne sont pas
+                atomiques.</emphasis>
+            </para>
+
+            <para>
+                Ceci signifie que si votre SGBD possède un moyen de gérer les cascades, comme
+                l'intégrité référentielle (et les clés étrangères), alors vous ne devriez pas
+                utiliser les cascades INSERT via <classname>Zend_Db_Table</classname>, car elles
+                vont entrer en conflit avec le système d'intégrité référentielle du SGBD qui lui,
+                est atomique.
+            </para>
+
+            <para>
+                Le problème est plus mitigé concernant <code>DELETE</code>. Vous pouvez
+                détruire de manière non atomique un enregistrement dépendant, avant de détruire son
+                parent.
+            </para>
+
+            <para>
+                Cependant, les deux opérations <code>UPDATE</code> et <code>DELETE</code>
+                utilisées de manière non atomique(que), c'est à dire avec le mécanisme de
+                <classname>Zend_Db_Table</classname>, peuvent laisser la base de données dans un
+                état non désiré, ou état intermédiaire. Supposez que vous supprimiez tous les
+                enregistrements dépendants, pour finir par leur parent unique. A un moment donnée,
+                la base de donnée sera dans un état tel que le parent sera sans enfants, mais
+                toujours bel et bien présent. Si un autre client se connecte exactement à ce moment
+                là, il va pouvoir requêter éventuellement le parent, en croyant que celui-ci n'a
+                plus d'enfant, ce qui normalement n'est pas le cas. Il est alors totalement
+                impossible pour ce client là de se rendre compte qu'il a effectuer une lecture au
+                beau milieu d'une plus vaste opération d'effacement.
+            </para>
+
+            <para>
+                Les problèmes de changements non-atomique peuvent être anéantis en utilisant
+                les transactions isolantes, c'est d'ailleurs un de leur rôle clé. Cependant certains
+                SGBDs ne supportent pas encore les transactions, et autorisent leurs clients à lire
+                des changements incomplets pas validés en totalité.
+            </para>
+
+            <para>
+                <emphasis>Les opérations de cascades de Zend_Db_Table ne sont utilisées que
+                par Zend_Db_Table.</emphasis>
+            </para>
+
+            <para>
+                Les cascades pour <code>DELETE</code> et <code>UPDATE</code> définies dans vos
+                classes <classname>Zend_Db_Table</classname> ne sont utilisées que lors du recours
+                aux méthodes <code>save()</code> ou <code>delete()</code> sur les enregistrements
+                <code>Row</code>. Si vous utilisez une autre interface pour vos <code>UPDATE</code>
+                ou <code>DELETE</code>, comme par exemple un outil de requêtes, ou une autre
+                application, les opérations de cascades ne sont bien sûr pas appliquées. C'est même
+                le cas si vous utilisez les méthodes <code>update()</code> et <code>delete()</code>
+                dans la classe <classname>Zend_Db_Adapter</classname>.
+            </para>
 
             <para><emphasis>Pas d'<code>INSERT</code> en cascade</emphasis></para>
 
-            <para>Le support pour les cascades d'<code>INSERT</code> n'est pas assuré. Vous devez explicitement insérer
-            les enregistrements dépendants à un enregistrement parent.</para>
+            <para>
+                Le support pour les cascades d'<code>INSERT</code> n'est pas assuré. Vous
+                devez explicitement insérer les enregistrements dépendants à un enregistrement
+                parent.
+            </para>
         </sect3>
     </sect2>
 </sect1>

documentation/manual/fr/module_specs/Zend_Db_Table_Row.xml

@@ -1,5 +1,5 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- EN-Revision: 13846 -->
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- EN-Revision: 15215 -->
 <!-- Reviewed: no -->
 <sect1 id="zend.db.table.row">
     <title>Zend_Db_Table_Row</title>
@@ -7,21 +7,31 @@
     <sect2 id="zend.db.table.row.introduction">
         <title>Introduction</title>
 
-        <para><classname>Zend_Db_Table_Row</classname> est la classe qui donne accès à chacun des résultats issus d'un objet
-        <classname>Zend_Db_Table</classname>. Lorsque vous exécutez une requête via une classe de Table, alors les résultats sont
-        des objets <classname>Zend_Db_Table_Row</classname>. Vous pouvez aussi utiliser ces objets comme résultats vides : pour
-        créer des nouveaux résultats à ajouter à la base de données.</para>
-
-        <para><classname>Zend_Db_Table_Row</classname> est une implémentation du design pattern <ulink
-        url="http://www.martinfowler.com/eaaCatalog/rowDataGateway.html">Row Data Gateway</ulink></para>
+        <para>
+            <classname>Zend_Db_Table_Row</classname> est la classe qui donne accès à chacun
+            des résultats issus d'un objet <classname>Zend_Db_Table</classname>. Lorsque vous
+            exécutez une requête via une classe de Table, alors les résultats sont des objets
+            <classname>Zend_Db_Table_Row</classname>. Vous pouvez aussi utiliser ces objets comme
+            résultats vides : pour créer des nouveaux résultats à ajouter à la base de
+            données.
+        </para>
+
+        <para>
+            <classname>Zend_Db_Table_Row</classname> est une implémentation du design pattern
+            <ulink url="http://www.martinfowler.com/eaaCatalog/rowDataGateway.html">Row Data
+            Gateway</ulink>
+        </para>
     </sect2>
 
     <sect2 id="zend.db.table.row.read">
         <title>Récupérer un résultat (un "Row")</title>
 
-        <para><classname>Zend_Db_Table_Abstract</classname> possède des méthodes <code>find()</code> et <code>fetchAll()</code>,
-        qui retournent un objet de type <classname>Zend_Db_Table_Rowset</classname>, et une méthode <code>fetchRow()</code>, qui
-        retourne un objet de type <classname>Zend_Db_Table_Row</classname>.</para>
+        <para>
+            <classname>Zend_Db_Table_Abstract</classname> possède des méthodes
+            <code>find()</code> et <code>fetchAll()</code>, qui retournent un objet de type
+            <classname>Zend_Db_Table_Rowset</classname>, et une méthode <code>fetchRow()</code>, qui
+            retourne un objet de type <classname>Zend_Db_Table_Row</classname>.
+        </para>
 
         <example id="zend.db.table.row.read.example">
             <title>Exemple de récupération d'un Row</title>
@@ -33,8 +43,11 @@ $row = $bugs->fetchRow($bugs->select()
 ]]></programlisting>
         </example>
 
-        <para>Un objet <classname>Zend_Db_Table_Rowset</classname> contient une collection d'objets
-        <classname>Zend_Db_Table_Row</classname>. Voyez <xref linkend="zend.db.table.rowset" />.</para>
+        <para>
+            Un objet <classname>Zend_Db_Table_Rowset</classname> contient une collection
+            d'objets <classname>Zend_Db_Table_Row</classname>. Voyez <xref
+            linkend="zend.db.table.rowset" />.
+        </para>
 
         <example id="zend.db.table.row.read.example-rowset">
             <title>Exemple de lecture d'un Row dans un Rowset</title>
@@ -50,8 +63,11 @@ $row = $rowset->current();
         <sect3 id="zend.db.table.row.read.get">
             <title>Lecture des valeurs des colonnes, dans un Row</title>
 
-            <para><classname>Zend_Db_Table_Row_Abstract</classname> possède des accesseurs. Les colonnes SQL du résultat sont
-            disponibles en lecture et écriture, via des propriétés de classe.</para>
+            <para>
+                <classname>Zend_Db_Table_Row_Abstract</classname> possède des accesseurs. Les
+                colonnes SQL du résultat sont disponibles en lecture et écriture, via des propriétés
+                de classe.
+            </para>
 
             <example id="zend.db.table.row.read.get.example">
                 <title>Lecture d'une colonne dans un Row</title>
@@ -67,24 +83,30 @@ echo $row->bug_description;
             </example>
 
             <note>
-                <para>Les versions antérieures de <classname>Zend_Db_Table_Row</classname> utilisaient un processus de
-                transformation nommé <emphasis>inflexion</emphasis> pour récupérer les valeurs des colonnes dans un
-                résultat.</para>
-
-                <para>Actuellement, <classname>Zend_Db_Table_Row</classname> n'utilise pas d'inflexion. Les noms des propriétés de
-                l'objet doivent correspondre à l'orthographe des noms des colonnes dans la base de données
-                sous-jacente</para>
+                <para>
+                    Les versions antérieures de <classname>Zend_Db_Table_Row</classname>
+                    utilisaient un processus de transformation nommé <emphasis>inflexion</emphasis>
+                    pour récupérer les valeurs des colonnes dans un résultat.
+                </para>
+
+                <para>
+                    Actuellement, <classname>Zend_Db_Table_Row</classname> n'utilise pas
+                    d'inflexion. Les noms des propriétés de l'objet doivent correspondre à
+                    l'orthographe des noms des colonnes dans la base de données sous-jacente
+                </para>
             </note>
         </sect3>
 
         <sect3 id="zend.db.table.row.read.to-array">
             <title>Récupérer les valeurs des colonnes comme un tableau</title>
 
-            <para>Vous pouvez accéder aux données d'un row sous forme de tableau grâce à la méthode
-            <code>toArray()</code>. Celle-ci retourne un tableau associatif.</para>
+            <para>
+                Vous pouvez accéder aux données d'un row sous forme de tableau grâce à la
+                méthode <code>toArray()</code>. Celle-ci retourne un tableau associatif.
+            </para>
 
             <example id="zend.db.table.row.read.to-array.example">
-                <title>Exemple avec <code>toArray()</code></title>
+                <title>Exemple avec toArray()</title>
 
                 <programlisting role="php"><![CDATA[
 $bugs = new Bugs();
@@ -102,16 +124,22 @@ foreach ($rowArray as $column => $value) {
 ]]></programlisting>
             </example>
 
-            <para>Le tableau retourné par <code>toArray()</code> n'est pas une référence. Vous pouvez modifier ses
-            valeurs, cela n'aura aucune répercussion dans la base de données.</para>
+            <para>
+                Le tableau retourné par <code>toArray()</code> n'est pas une référence. Vous
+                pouvez modifier ses valeurs, cela n'aura aucune répercussion dans la base de
+                données.
+            </para>
         </sect3>
 
         <sect3 id="zend.db.table.row.read.relationships">
             <title>Récupérer des données des tables liées</title>
 
-            <para><classname>Zend_Db_Table_Row_Abstract</classname> possède des méthodes permettant de récupérer des données des
-            tables liées à la table interrogée. Voyez <xref linkend="zend.db.table.relationships" /> pour plus
-            d'informations sur les relations entre les tables.</para>
+            <para>
+                <classname>Zend_Db_Table_Row_Abstract</classname> possède des méthodes
+                permettant de récupérer des données des tables liées à la table interrogée. Voyez
+                <xref linkend="zend.db.table.relationships" /> pour plus d'informations sur les
+                relations entre les tables.
+            </para>
         </sect3>
     </sect2>
 
@@ -121,12 +149,16 @@ foreach ($rowArray as $column => $value) {
         <sect3 id="zend.db.table.row.write.set">
             <title>Changement des valeurs des colonnes d'un Row</title>
 
-            <para>Vous pouvez changer les valeurs de chaque colonne du résultat Row, simplement avec les accesseurs,
-            comme en lecture. Effectuez une banale affectation.</para>
+            <para>
+                Vous pouvez changer les valeurs de chaque colonne du résultat Row, simplement
+                avec les accesseurs, comme en lecture. Effectuez une banale affectation.
+            </para>
 
-            <para>Utiliser l'accesseur pour spécifier une valeur à une colonne d'un résultat Row ne répercute pas le
-            comportement immédiatement en base de données. Vous devez utiliser explicitement la méthode
-            <code>save()</code> pour ceci.</para>
+            <para>
+                Utiliser l'accesseur pour spécifier une valeur à une colonne d'un résultat Row
+                ne répercute pas le comportement immédiatement en base de données. Vous devez
+                utiliser explicitement la méthode <code>save()</code> pour ceci.
+            </para>
 
             <example id="zend.db.table.row.write.set.example">
                 <title>Exemple de changement de la valeur d'une colonne dans un Row</title>
@@ -148,10 +180,12 @@ $row->save();
         <sect3 id="zend.db.table.row.write.insert">
             <title>Créer un Row vierge</title>
 
-            <para>Vous pouvez créer un nouvel enregistrement vierge (Row) pour une table avec la méthode
-            <code>createRow()</code> issue de la classe de cette Table. Vous pouvez alors affecter des valeurs à ses
-            colonnes grâce aux accesseurs, comme déjà vu, puis enregistrer le Row en base de données avec sa méthode
-            <code>save()</code>.</para>
+            <para>
+                Vous pouvez créer un nouvel enregistrement vierge (Row) pour une table avec la
+                méthode <code>createRow()</code> issue de la classe de cette Table. Vous pouvez
+                alors affecter des valeurs à ses colonnes grâce aux accesseurs, comme déjà vu, puis
+                enregistrer le Row en base de données avec sa méthode <code>save()</code>.
+            </para>
 
             <example id="zend.db.table.row.write.insert.example">
                 <title>Exemple de création d'un Row vierge pour une table</title>
@@ -169,8 +203,10 @@ $newRow->save();
 ]]></programlisting>
             </example>
 
-            <para>L'argument optionnel de <code>createRow()</code> est un tableau associatif qui sert à peupler tout de
-            suite l'objet de valeurs.</para>
+            <para>
+                L'argument optionnel de <code>createRow()</code> est un tableau associatif qui
+                sert à peupler tout de suite l'objet de valeurs.
+            </para>
 
             <example id="zend.db.table.row.write.insert.example2">
                 <title>Exemple de remplissage des valeurs d'un nouveau Row vierge</title>
@@ -190,20 +226,28 @@ $newRow->save();
             </example>
 
             <note>
-                <para>La méthode <code>createRow()</code> était nommée <code>fetchNew()</code> dans les anciennes
-                version de <classname>Zend_Db_Table</classname>. Il est recommandé de ne plus utiliser cette ancienne appellation,
-                même si celle-ci fonctionne toujours actuellement.</para>
+                <para>
+                    La méthode <code>createRow()</code> était nommée <code>fetchNew()</code>
+                    dans les anciennes version de <classname>Zend_Db_Table</classname>. Il est
+                    recommandé de ne plus utiliser cette ancienne appellation, même si celle-ci
+                    fonctionne toujours actuellement.
+                </para>
             </note>
         </sect3>
 
         <sect3 id="zend.db.table.row.write.set-from-array">
             <title>Changement en masse des valeurs dans un Row</title>
 
-            <para><classname>Zend_Db_Table_Row_Abstract</classname> possède une méthode <code>setFromArray()</code> qui permet de
-            lui peupler ses valeurs avec celles issues d'un tableau associatif nom de la colonne / valeur..</para>
+            <para>
+                <classname>Zend_Db_Table_Row_Abstract</classname> possède une méthode
+                <code>setFromArray()</code> qui permet de lui peupler ses valeurs avec celles issues
+                d'un tableau associatif nom de la colonne / valeur.
+            </para>
 
             <example id="zend.db.table.row.write.set-from-array.example">
-                <title>Exemple d'utilisation de <code>setFromArray()</code> avec un enregistrement (Row) vierge</title>
+                <title>
+                    Exemple d'utilisation de setFromArray() avec un enregistrement (Row) vierge
+                </title>
 
                 <programlisting role="php"><![CDATA[
 $bugs = new Bugs();
@@ -227,8 +271,11 @@ $newRow->save();
         <sect3 id="zend.db.table.row.write.delete">
             <title>Supprimer un Row</title>
 
-            <para>Vous pouvez appeler la méthode <code>delete()</code> d'un objet Row. Ceci supprime les lignes dans la
-            base de données qui correspondent à la clé primaire de l'objet Row.</para>
+            <para>
+                Vous pouvez appeler la méthode <code>delete()</code> d'un objet Row. Ceci
+                supprime les lignes dans la base de données qui correspondent à la clé primaire de
+                l'objet Row.
+            </para>
 
             <example id="zend.db.table.row.write.delete.example">
                 <title>Effacer un Row</title>
@@ -242,24 +289,31 @@ $row->delete();
 ]]></programlisting>
             </example>
 
-            <para>Notez qu'il n'est pas nécessaire d'appeler <code>save()</code> pour un effacement. Celui-ci est à
-            effet immédiat.</para>
+            <para>
+                Notez qu'il n'est pas nécessaire d'appeler <code>save()</code> pour un
+                effacement. Celui-ci est à effet immédiat.
+            </para>
         </sect3>
     </sect2>
 
     <sect2 id="zend.db.table.row.serialize">
         <title>Sérialisation et désérialisation d'un Row</title>
 
-        <para>Il peut être utile de sauvegarder le contenu d'un enregistrement (Row) sur un support quelconque, pour une
-        utilisation ultérieure. La <emphasis>sérialisation</emphasis> est le nom de l'opération qui consiste à
-        transformer un objet en une forme facilement stockable (dans un fichier par exemple). Les objets du type
-        <classname>Zend_Db_Table_Row_Abstract</classname> sont sérialisables.</para>
+        <para>
+            Il peut être utile de sauvegarder le contenu d'un enregistrement (Row) sur un
+            support quelconque, pour une utilisation ultérieure. La
+            <emphasis>sérialisation</emphasis> est le nom de l'opération qui consiste à transformer
+            un objet en une forme facilement stockable (dans un fichier par exemple). Les objets du
+            type <classname>Zend_Db_Table_Row_Abstract</classname> sont sérialisables.
+        </para>
 
         <sect3 id="zend.db.table.row.serialize.serializing">
             <title>Sérialiser un Row</title>
 
-            <para>Utilisez simplement la fonction PHP <code>serialize()</code> pour créer une chaîne de caractères
-            représentant votre objet Row.</para>
+            <para>
+                Utilisez simplement la fonction PHP <code>serialize()</code> pour créer une
+                chaîne de caractères représentant votre objet Row.
+            </para>
 
             <example id="zend.db.table.row.serialize.serializing.example">
                 <title>Exemple de sérialisation d'un Row</title>
@@ -280,12 +334,17 @@ $serializedRow = serialize($row);
         <sect3 id="zend.db.table.row.serialize.unserializing">
             <title>Désérialiser les données d'un Row</title>
 
-            <para>Utilisez simplement la fonction PHP <code>unserialize()</code>. L'objet Row originel est alors
-            recréé.</para>
+            <para>
+                Utilisez simplement la fonction PHP <code>unserialize()</code>. L'objet Row
+                originel est alors recréé.
+            </para>
 
-            <para>Notez que l'objet retourné fonctionne alors en mode <emphasis>déconnecté</emphasis>. Vous pouvez lire
-            les valeurs des colonnes, mais pas les modifier ni enregistrer l'objet en base de données
-            (<classname>save()</classname>).</para>
+            <para>
+                Notez que l'objet retourné fonctionne alors en mode
+                <emphasis>déconnecté</emphasis>. Vous pouvez lire les valeurs des colonnes, mais pas
+                les modifier ni enregistrer l'objet en base de données
+                (<classname>save()</classname>).
+            </para>
 
             <example id="zend.db.table.row.serialize.unserializing.example">
                 <title>Exemple de désérialisation d'un objet Row sérialisé</title>
@@ -301,20 +360,27 @@ echo $rowClone->bug_description;
             <note>
                 <title>Pourquoi ce mode déconnecté imposé ?</title>
 
-                <para>Un objet sérialisé est une chaîne de caractère, humainement visible. Il est donc peu sécurisé d'y
-                laisser un mot de passe vers un serveur de base de données. Le lecteur d'un objet Row sérialisé ne
-                devrait pas pouvoir accéder à la base de données. De plus, une connexion à une base de données est un
-                type non sérialisable par PHP (ressource).</para>
+                <para>
+                    Un objet sérialisé est une chaîne de caractère, humainement visible. Il
+                    est donc peu sécurisé d'y laisser un mot de passe vers un serveur de base de
+                    données. Le lecteur d'un objet Row sérialisé ne devrait pas pouvoir accéder à la
+                    base de données. De plus, une connexion à une base de données est un type non
+                    sérialisable par PHP (ressource).
+                </para>
             </note>
         </sect3>
 
         <sect3 id="zend.db.table.row.serialize.set-table">
             <title>Reconnecter l'objet Row à la Table</title>
 
-            <para>Il est bien entendu possible de reconnecter l'objet Row à la base de données, et plus précisément à la
-            Table dont il fut issu. Utilisez la méthode <code>setTable()</code> et passez lui une instance héritant de
-            <classname>Zend_Db_Table_Abstract</classname>. Une fois reconnecté, l'objet Row possède de nouveau un accès à la base
-            de données, et n'est donc plus en mode lecture seule.</para>
+            <para>
+                Il est bien entendu possible de reconnecter l'objet Row à la base de données,
+                et plus précisément à la Table dont il fut issu. Utilisez la méthode
+                <code>setTable()</code> et passez lui une instance héritant de
+                <classname>Zend_Db_Table_Abstract</classname>. Une fois reconnecté, l'objet Row
+                possède de nouveau un accès à la base de données, et n'est donc plus en mode lecture
+                seule.
+            </para>
 
             <example id="zend.db.table.row.serialize.set-table.example">
                 <title>Exemple de réactivation d'un Row</title>
@@ -338,9 +404,12 @@ $rowClone->save();
     <sect2 id="zend.db.table.row.extending">
         <title>Étendre la classe Row</title>
 
-        <para>Vous pouvez utilisez votre propre classe étendant <classname>Zend_Db_Table_Row_Abstract</classname>. Spécifiez votre
-        classe dans la propriété protégée <code>$_rowClass</code> de la classe de votre Table, ou dans le tableau du
-        constructeur de l'objet Table.</para>
+        <para>
+            Vous pouvez utilisez votre propre classe étendant
+            <classname>Zend_Db_Table_Row_Abstract</classname>. Spécifiez votre classe dans la
+            propriété protégée <code>$_rowClass</code> de la classe de votre Table, ou dans le
+            tableau du constructeur de l'objet Table.
+        </para>
 
         <example id="zend.db.table.row.extending.example">
             <title>Spécification d'une classe Row personnalisée</title>
@@ -367,44 +436,59 @@ $bugs = new Bugs(array('rowClass' => 'MyRow'));
         <sect3 id="zend.db.table.row.extending.overriding">
             <title>Initialisation et pré-traitements d'un Row</title>
 
-            <para>Si vous avez un besoin spécifique d'implémenter une logique spéciale après la création d'une instance
-            de Row, vous pouvez utiliser sa méthode <code>init()</code>, qui est appelée dans son constructeur, mais
-            après que les méta données aient été calculées. <example id="zend.db.table.row.init.usage.example">
-                    <title>Exemple d'utilisation de la méthode init()</title>
-
-                    <programlisting role="php"><![CDATA[
-class MyApplicationRow extends Zend_Db_Table_Row_Abstract
-{
-    protected $_role;
+            <para>
+                Si vous avez un besoin spécifique d'implémenter une logique spéciale après la
+                création d'une instance de Row, vous pouvez utiliser sa méthode <code>init()</code>,
+                qui est appelée dans son constructeur, mais après que les méta données aient été
+                calculées. <example id="zend.db.table.row.init.usage.example">
+                        <title>Exemple d'utilisation de la méthode init()</title>
 
-    public function init()
+                        <programlisting role="php"><![CDATA[
+    class MyApplicationRow extends Zend_Db_Table_Row_Abstract
     {
-        $this->_role = new MyRoleClass();
+        protected $_role;
+
+        public function init()
+        {
+            $this->_role = new MyRoleClass();
+        }
     }
-}
-]]></programlisting>
-                </example></para>
+    ]]></programlisting>
+                    </example>
+                </para>
         </sect3>
 
         <sect3 id="zend.db.table.row.extending.insert-update">
-            <title>Définir sa propre logique pour Insert, Update, et Delete dans Zend_Db_Table_Row</title>
-
-            <para>La classe des Rows appelle les méthodes protégées <code>_insert()</code>, <code>_update()</code>, et
-            <code>_delete()</code> avant d'effectuer chacune des opérations respectives <code>INSERT</code>,
-            <code>UPDATE</code>, et <code>DELETE</code>. Il est donc possible de définir sa propre logique dans votre
-            sous-classe de Row.</para>
-
-            <para>Ci-dessous vous trouverez des exemples d'utilisation d'une logique personnalisée dans les classes de
-            Row :</para>
+            <title>
+                Définir sa propre logique pour Insert, Update, et Delete dans Zend_Db_Table_Row
+            </title>
+
+            <para>
+                La classe des Rows appelle les méthodes protégées <code>_insert()</code>,
+                <code>_update()</code>, et <code>_delete()</code> avant d'effectuer chacune des
+                opérations respectives <code>INSERT</code>, <code>UPDATE</code>, et
+                <code>DELETE</code>. Il est donc possible de définir sa propre logique dans votre
+                sous-classe de Row.
+            </para>
+
+            <para>
+                Ci-dessous vous trouverez des exemples d'utilisation d'une logique
+                personnalisée dans les classes de Row :
+            </para>
 
             <example id="zend.db.table.row.extending.overriding-example1">
                 <title>Exemple de logique personnalisée dans une classe de Row</title>
 
-                <para>La logique personnelle peut donc être déportée dans une classe de Row qui ne s'appliquera qu'à
-                certaines tables, et pas à d'autres. Sinon, la classe de Table utilise le Row par défaut.</para>
+                <para>
+                    La logique personnelle peut donc être déportée dans une classe de Row qui
+                    ne s'appliquera qu'à certaines tables, et pas à d'autres. Sinon, la classe de
+                    Table utilise le Row par défaut.
+                </para>
 
-                <para>Par exemple, vous souhaitez historiser toutes les insertions sur une Table spécifique, mais
-                uniquement si la configuration du site le permet :</para>
+                <para>
+                    Par exemple, vous souhaitez historiser toutes les insertions sur une Table
+                    spécifique, mais uniquement si la configuration du site le permet :
+                </para>
 
                 <programlisting role="php"><![CDATA[
 class MyLoggingRow extends Zend_Db_Table_Row_Abstract
@@ -429,13 +513,19 @@ if ($loggingEnabled) {
             </example>
 
             <example id="zend.db.table.row.extending.overriding-example2">
-                <title>Exemple d'une classe de Row qui historise les insertions de plusieurs tables</title>
+                <title>Exemple d'une classe de Row qui historise les insertions de plusieurs
+                tables</title>
 
-                <para>En passant l'objet Row personnalisé à chacune des Tables concernées, alors vous n'aurez pas besoin
-                de définir cette logique dans chacune des classes des Tables.</para>
+                <para>
+                    En passant l'objet Row personnalisé à chacune des Tables concernées, alors
+                    vous n'aurez pas besoin de définir cette logique dans chacune des classes des
+                    Tables.
+                </para>
 
-                <para>Dans cet exemple, le code qui effectue l'historisation est identique à celui de l'exemple
-                précédent.</para>
+                <para>
+                    Dans cet exemple, le code qui effectue l'historisation est identique à
+                    celui de l'exemple précédent.
+                </para>
 
                 <programlisting role="php"><![CDATA[
 class MyLoggingRow extends Zend_Db_Table_Row_Abstract
@@ -467,23 +557,35 @@ class Products extends Zend_Db_Table_Abstract
         <sect3 id="zend.db.table.row.extending.inflection">
             <title>Définir l'inflexion dans Zend_Db_Table_Row</title>
 
-            <para>Il peut être intéressant de personnaliser l'accès aux colonnes de la table représentée par un résultat
-            Row, plutôt que d'utiliser le nom des colonnes telles que définies dans le SGBDR sous-jacent. La
-            transformation de l'un vers l'autre est appelée <emphasis>inflexion</emphasis>.</para>
-
-            <para>Les classes Zend_Db n'utilisent pas l'inflexion par défaut. Voyez <xref
-            linkend="zend.db.table.extending.inflection" /> pour plus de détails sur ce procédé.</para>
-
-            <para>Ainsi si vous voulez utiliser l'inflexion, vous devez implémenter vous-même la transformation à
-            effectuer en redéfinissant la méthode <code>_transformColumn()</code> dans votre classe de Row, et bien
-            entendu utiliser cette classe de Row pour votre Table.</para>
+            <para>
+                Il peut être intéressant de personnaliser l'accès aux colonnes de la table
+                représentée par un résultat Row, plutôt que d'utiliser le nom des colonnes telles
+                que définies dans le SGBDR sous-jacent. La transformation de l'un vers l'autre est
+                appelée <emphasis>inflexion</emphasis>.
+            </para>
+
+            <para>
+                Les classes Zend_Db n'utilisent pas l'inflexion par défaut. Voyez <xref
+                linkend="zend.db.table.extending.inflection" /> pour plus de détails sur ce
+                procédé.
+            </para>
+
+            <para>
+                Ainsi si vous voulez utiliser l'inflexion, vous devez implémenter vous-même la
+                transformation à effectuer en redéfinissant la méthode
+                <code>_transformColumn()</code> dans votre classe de Row, et bien entendu utiliser
+                cette classe de Row pour votre Table.
+            </para>
 
             <example id="zend.db.table.row.extending.inflection.example">
                 <title>Exemple d'utilisation de l'inflexion</title>
 
-                <para>Ceci vous permet d'utiliser les accesseurs de votre Row de manière transformée. La classe de votre
-                Row utilisera <code>_transformColumn()</code> pour changer le nom de la colonne appelée, avant de le
-                faire correspondre à un nom dans la table réelle de la base de données.</para>
+                <para>
+                    Ceci vous permet d'utiliser les accesseurs de votre Row de manière
+                    transformée. La classe de votre Row utilisera <code>_transformColumn()</code>
+                    pour changer le nom de la colonne appelée, avant de le faire correspondre à un
+                    nom dans la table réelle de la base de données.
+                </para>
 
                 <programlisting role="php"><![CDATA[
 class MyInflectedRow extends Zend_Db_Table_Row_Abstract

documentation/manual/fr/module_specs/Zend_Db_Table_Rowset.xml

@@ -1,5 +1,5 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- EN-Revision: 13846 -->
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- EN-Revision: 15341 -->
 <!-- Reviewed: no -->
 <sect1 id="zend.db.table.rowset">
     <title>Zend_Db_Table_Rowset</title>
@@ -7,18 +7,24 @@
     <sect2 id="zend.db.table.rowset.introduction">
         <title>Introduction</title>
 
-        <para>Lorsque vous effectuez une requête avec une classe de Table en utilisant <code>find()</code> ou
-        <code>fetchAll()</code> , le résultat retourné est alors un objet de type
-        <classname>Zend_Db_Table_Rowset_Abstract</classname>. Un Rowset est un conteneur d'objets descendants de
-        <classname>Zend_Db_Table_Row_Abstract</classname>. Vous pouvez itérer à travers ce conteneur et accéder aux objet Row
-        individuellement, en lecture ou écriture bien entendu.</para>
+        <para>
+            Lorsque vous effectuez une requête avec une classe de Table en utilisant
+            <code>find()</code> ou <code>fetchAll()</code> , le résultat retourné est alors un objet
+            de type <classname>Zend_Db_Table_Rowset_Abstract</classname>. Un Rowset est un conteneur
+            d'objets descendants de <classname>Zend_Db_Table_Row_Abstract</classname>. Vous pouvez
+            itérer à travers ce conteneur et accéder aux objet Row individuellement, en lecture ou
+            écriture bien entendu.
+        </para>
     </sect2>
 
     <sect2 id="zend.db.table.rowset.fetch">
         <title>Récupérer un Rowset</title>
 
-        <para><classname>Zend_Db_Table_Abstract</classname> possède des méthodes <code>find()</code> et <code>fetchAll()</code>,
-        chacune retourne un objet de type <classname>Zend_Db_Table_Rowset_Abstract</classname>.</para>
+        <para>
+            <classname>Zend_Db_Table_Abstract</classname> possède des méthodes
+            <code>find()</code> et <code>fetchAll()</code>, chacune retourne un objet de type
+            <classname>Zend_Db_Table_Rowset_Abstract</classname>.
+        </para>
 
         <example id="zend.db.table.rowset.fetch.example">
             <title>Exemple de récupération d'un rowset</title>
@@ -33,13 +39,18 @@ $rowset = $bugs->fetchAll("bug_status = 'NEW'");
     <sect2 id="zend.db.table.rowset.rows">
         <title>Atteindre les Rows depuis un Rowset</title>
 
-        <para>L'objet Rowset en lui-même n'est pas très intéressant au regard des objets Rows qu'il contient, qui eux,
-        le sont bien plus.</para>
+        <para>
+            L'objet Rowset en lui-même n'est pas très intéressant au regard des objets Rows
+            qu'il contient, qui eux, le sont bien plus.
+        </para>
 
-        <para>Un requête légitime peut retourner zéro enregistrement, donc zéro Rows. De ce fait, un objet Rowset peut
-        contenir zéro objet Row. Comme <classname>Zend_Db_Table_Rowset_Abstract</classname> implémente l'interface
-        <code>Countable</code>, vous pouvez utiliser la fonction PHP <code>count()</code> dessus, pour compter les Rows
-        qu'il contient.</para>
+        <para>
+            Un requête légitime peut retourner zéro enregistrement, donc zéro Rows. De ce
+            fait, un objet Rowset peut contenir zéro objet Row. Comme
+            <classname>Zend_Db_Table_Rowset_Abstract</classname> implémente l'interface
+            <code>Countable</code>, vous pouvez utiliser la fonction PHP <code>count()</code>
+            dessus, pour compter les Rows qu'il contient.
+        </para>
 
         <example id="zend.db.table.rowset.rows.counting.example">
             <title>Compter les Rows dans un Rowset</title>
@@ -60,8 +71,11 @@ if ($rowCount > 0) {
         <example id="zend.db.table.rowset.rows.current.example">
             <title>Lecture d'un simple Row depuis un Rowset</title>
 
-            <para>La façon la plus simple d'accéder à un Row depuis l'objet Rowset est d'utiliser la méthode
-            <code>current()</code>. C'est tout à fait adapté lorsque le Rowset ne contient qu'un résultat (Row).</para>
+            <para>
+                La façon la plus simple d'accéder à un Row depuis l'objet Rowset est
+                d'utiliser la méthode <code>current()</code>. C'est tout à fait adapté lorsque le
+                Rowset ne contient qu'un résultat (Row).
+            </para>
 
             <programlisting role="php"><![CDATA[
 $bugs   = new Bugs();
@@ -70,15 +84,21 @@ $row    = $rowset->current();
 ]]></programlisting>
         </example>
 
-        <para>Si le Rowset ne contient aucun Row, <code>current()</code> retourne <code>null</code>.</para>
+        <para>
+            Si le Rowset ne contient aucun Row, <code>current()</code> retourne
+            <code>null</code>.
+        </para>
 
         <example id="zend.db.table.rowset.rows.iterate.example">
             <title>Itération à travers un Rowset</title>
 
-            <para>Les objets descendants de <classname>Zend_Db_Table_Rowset_Abstract</classname> implémentent l'interface
-            <code>Iterator</code>, ce qui veut dire qu'ils peuvent être utilisés dans la structure PHP
-            <code>foreach</code>. Chaque valeur récupérée représente alors un objet de
-            <classname>Zend_Db_Table_Row_Abstract</classname> qui correspond à un enregistrement dans la table.</para>
+            <para>
+                Les objets descendants de <classname>Zend_Db_Table_Rowset_Abstract</classname>
+                implémentent l'interface <code>Iterator</code>, ce qui veut dire qu'ils peuvent être
+                utilisés dans la structure PHP <code>foreach</code>. Chaque valeur récupérée
+                représente alors un objet de <classname>Zend_Db_Table_Row_Abstract</classname> qui
+                correspond à un enregistrement dans la table.
+            </para>
 
             <programlisting role="php"><![CDATA[
 $bugs = new Bugs();
@@ -106,11 +126,15 @@ foreach ($rowset as $row) {
         <example id="zend.db.table.rowset.rows.seek.example">
             <title>Déplacement vers une position précise dans le Rowset</title>
 
-            <para><code>SeekableIterator</code> vous permet de vus déplacer à une position précise dans l'itérateur.
-            Utilisez pour ceci la méthode <code>seek()</code>. Elle prend en paramètre un entier représentant le numéro
-            de la position désirée. N'oubliez pas que le premier enregistrement est stocké à la position zéro. Si vous
-            spécifiez une position qui n'existe pas, une exception sera levée. Vous devriez utiliser
-            <code>count()</code> pour vérifier le nombre d'enregistrements Rows présents.</para>
+            <para>
+                <code>SeekableIterator</code> vous permet de vus déplacer à une position
+                précise dans l'itérateur. Utilisez pour ceci la méthode <code>seek()</code>. Elle
+                prend en paramètre un entier représentant le numéro de la position désirée.
+                N'oubliez pas que le premier enregistrement est stocké à la position zéro. Si vous
+                spécifiez une position qui n'existe pas, une exception sera levée. Vous devriez
+                utiliser <code>count()</code> pour vérifier le nombre d'enregistrements Rows
+                présents.
+            </para>
 
             <programlisting role="php"><![CDATA[
 $bugs = new Bugs();
@@ -130,11 +154,15 @@ $row9->save();
 ]]></programlisting>
         </example>
 
-        <para><code>getRow()</code> permet de retourner directement un enregistrement en fonction de sa position dans
-        l'itérateur Rowset. Le premier paramètre est un entier représentant cette position. Le second paramètre est
-        optionnel, et indique si oui ou non l'itérateur doit rester sur cette position, après avoir retourné le Row
-        correspondant. Par défaut, il est à <code>false</code>. Cette méthode retourne donc un objet
-        <classname>Zend_Db_Table_Row</classname>. Si la position demandée n'existe pas, une exception est levée :</para>
+        <para>
+            <code>getRow()</code> permet de retourner directement un enregistrement en
+            fonction de sa position dans l'itérateur Rowset. Le premier paramètre est un entier
+            représentant cette position. Le second paramètre est optionnel, et indique si oui ou non
+            l'itérateur doit rester sur cette position, après avoir retourné le Row correspondant.
+            Par défaut, il est à <code>false</code>. Cette méthode retourne donc un objet
+            <classname>Zend_Db_Table_Row</classname>. Si la position demandée n'existe pas, une
+            exception est levée :
+        </para>
 
         <programlisting role="php"><![CDATA[
 $bugs = new Bugs();
@@ -150,19 +178,24 @@ $row9->assigned_to = 'mmouse';
 $row9->save();
 ]]></programlisting>
 
-        <para>Dès que vous avez accès à un objet individuel Row, vous pouvez le piloter comme présenté dans la section
-        <xref linkend="zend.db.table.row" />.</para>
+        <para>
+            Dès que vous avez accès à un objet individuel Row, vous pouvez le piloter comme
+            présenté dans la section <xref linkend="zend.db.table.row" />.
+        </para>
     </sect2>
 
     <sect2 id="zend.db.table.rowset.to-array">
         <title>Récupérer un Rowset en tant que tableau (Array)</title>
 
-        <para>Vous pouvez accéder à toutes les données d'un Rowset au moyen d'un tableau PHP avec la méthode
-        <code>toArray()</code>. Ce tableau possède deux dimensions. Chaque entrée du tableau représente un tableau de
-        l'objet Row. Les clés sont les noms des champs, et les valeurs leurs valeurs.</para>
+        <para>
+            Vous pouvez accéder à toutes les données d'un Rowset au moyen d'un tableau PHP
+            avec la méthode <code>toArray()</code>. Ce tableau possède deux dimensions. Chaque
+            entrée du tableau représente un tableau de l'objet Row. Les clés sont les noms des
+            champs, et les valeurs leurs valeurs.
+        </para>
 
         <example id="zend.db.table.rowset.to-array.example">
-            <title>Utiliser <code>toArray()</code></title>
+            <title>Utiliser toArray()</title>
 
             <programlisting role="php"><![CDATA[
 $bugs   = new Bugs();
@@ -182,21 +215,28 @@ foreach ($rowsetArray as $rowArray) {
 ]]></programlisting>
         </example>
 
-        <para>Le tableau retourné par <code>toArray()</code> n'est pas une référence. Le modifier ne modifiera en aucun
-        cas les données réelles dans la base de données.</para>
+        <para>
+            Le tableau retourné par <code>toArray()</code> n'est pas une référence. Le
+            modifier ne modifiera en aucun cas les données réelles dans la base de données.
+        </para>
     </sect2>
 
     <sect2 id="zend.db.table.rowset.serialize">
         <title>Sérialisation et Désérialisation d'un Rowset</title>
 
-        <para>Les objets de type <classname>Zend_Db_Table_Rowset_Abstract</classname> sont sérialisables. De la même manière que
-        vous sérialisez un objet Row individuel, le Rowset est sérialisable et désérialisable.</para>
+        <para>
+            Les objets de type <classname>Zend_Db_Table_Rowset_Abstract</classname> sont
+            sérialisables. De la même manière que vous sérialisez un objet Row individuel, le Rowset
+            est sérialisable et désérialisable.
+        </para>
 
         <example id="zend.db.table.rowset.serialize.example.serialize">
             <title>Sérialiser d'un Rowset</title>
 
-            <para>Utilisez simplement la fonction PHP <code>serialize()</code> pour créer une chaîne de caractères
-            représentant votre objet Rowset.</para>
+            <para>
+                Utilisez simplement la fonction PHP <code>serialize()</code> pour créer une
+                chaîne de caractères représentant votre objet Rowset.
+            </para>
 
             <programlisting role="php"><![CDATA[
 $bugs   = new Bugs();
@@ -215,9 +255,12 @@ $serializedRowset = serialize($rowset);
 
             <para>Utilisez simplement la fonction PHP <code>unserialize()</code>.</para>
 
-            <para>Notez que l'objet retourné fonctionne alors en mode <emphasis>déconnecté</emphasis>. Vous pouvez
-            itérer à travers, et lire les objets Row qu'il contient, mais vous ne pouvez plus faire intervenir la base
-            de données, ni changer de valeurs dans les Rows.</para>
+            <para>
+                Notez que l'objet retourné fonctionne alors en mode
+                <emphasis>déconnecté</emphasis>. Vous pouvez itérer à travers, et lire les objets
+                Row qu'il contient, mais vous ne pouvez plus faire intervenir la base de données, ni
+                changer de valeurs dans les Rows.
+            </para>
 
             <programlisting role="php"><![CDATA[
 $rowsetDisconnected = unserialize($serializedRowset);
@@ -229,18 +272,25 @@ echo $row->bug_description;
         </example>
 
         <note>
-            <title>Pourquoi ce mode déconnecté imposé ?</title>
-
-            <para>Un objet sérialisé est une chaîne de caractère, humainement visible. Il est donc peut sécurisé d'y
-            laisser un mot de passe vers un serveur de base de données. Le lecteur d'un objet Rowset sérialisé ne
-            devrait pas pouvoir accéder à la base de données. De plus, une connexion à une base de données est un type
-            non sérialisable par PHP (ressource).</para>
+            <title>Pourquoi ce mode déconnecté imposé&#160;?</title>
+
+            <para>
+                Un objet sérialisé est une chaîne de caractère, humainement visible. Il est
+                donc peut sécurisé d'y laisser un mot de passe vers un serveur de base de données.
+                Le lecteur d'un objet Rowset sérialisé ne devrait pas pouvoir accéder à la base de
+                données. De plus, une connexion à une base de données est un type non sérialisable
+                par PHP (ressource).
+            </para>
         </note>
 
-        <para>Il est bien entendu possible de reconnecter l'objet Rowset à la base de données, et plus précisément à la
-        Table dont il fut issu. Utilisez la méthode <code>setTable()</code> et passez lui une instance héritant de
-        <classname>Zend_Db_Table_Abstract</classname>. Une fois reconnecté, l'objet Rowset possède de nouveau un accès à la base
-        de données, et n'est donc plus en mode lecture seule.</para>
+        <para>
+            Il est bien entendu possible de reconnecter l'objet Rowset à la base de données,
+            et plus précisément à la Table dont il fut issu. Utilisez la méthode
+            <code>setTable()</code> et passez lui une instance héritant de
+            <classname>Zend_Db_Table_Abstract</classname>. Une fois reconnecté, l'objet Rowset
+            possède de nouveau un accès à la base de données, et n'est donc plus en mode lecture
+            seule.
+        </para>
 
         <example id="zend.db.table.rowset.serialize.example.set-table">
             <title>Réactivation d'un Rowset</title>
@@ -262,15 +312,21 @@ $row->save();
 ]]></programlisting>
         </example>
 
-        <para>Réactiver un Rowset avec <code>setTable()</code> réactive tous les Rows le composant.</para>
+        <para>
+            Réactiver un Rowset avec <code>setTable()</code> réactive tous les Rows le
+            composant.
+        </para>
     </sect2>
 
     <sect2 id="zend.db.table.rowset.extending">
         <title>Étendre la classe Rowset</title>
 
-        <para>Vous pouvez utilisez votre propre classe étendant <classname>Zend_Db_Table_Rowset_Abstract</classname>. Spécifiez
-        votre classe dans la propriété protégée <code>$_rowsetClass</code> de la classe de votre Table, ou dans le
-        tableau du constructeur de l'objet Table.</para>
+        <para>
+            Vous pouvez utilisez votre propre classe étendant
+            <classname>Zend_Db_Table_Rowset_Abstract</classname>. Spécifiez votre classe dans la
+            propriété protégée <code>$_rowsetClass</code> de la classe de votre Table, ou dans le
+            tableau du constructeur de l'objet Table.
+        </para>
 
         <example id="zend.db.table.rowset.extending.example">
             <title>Spécifier sa propre classe de Rowset</title>
@@ -294,9 +350,11 @@ $bugs = new Bugs(array('rowsetClass' => 'MyRowset'));
 ]]></programlisting>
         </example>
 
-        <para>En temps normal, la classe standard Zend_Db_Rowset est suffisante. Cependant, il peut être judicieux de
-        rajouter de la logique dans son Rowset, pour une table précise. Par exemple, une nouvelle méthode pourrait
-        effectuer des calculs.</para>
+        <para>
+            En temps normal, la classe standard Zend_Db_Rowset est suffisante. Cependant, il
+            peut être judicieux de rajouter de la logique dans son Rowset, pour une table précise.
+            Par exemple, une nouvelle méthode pourrait effectuer des calculs.
+        </para>
 
         <example id="zend.db.table.rowset.extending.example-aggregate">
             <title>Exemple d'une classe Rowset personnalisée avec une nouvelle méthode</title>