repo_zf1/documentation/manual/fr/module_specs/Zend_Db_Adapter.xml

<!-- EN-Revision: 13946 -->
<sect1 id="zend.db.adapter">
    <title>Zend_Db_Adapter</title>

    <para><classname>Zend_Db</classname> et ses autres sous classes proposent une interface de connexion aux bases de données avec
    Zend Framework. <classname>Zend_Db_Adapter</classname> est la classe de base que vous utilisez pour vous connecter aux bases
    de données (SGBDs). Il y a différentes classes d'adaptateur par SGBD.</para>

    <para>Les classes <code>Adapters</code> de <classname>Zend_Db</classname> créent un pont entre les extensions PHP et une
    interface commune. Ceci vous aide à écrire des applications déployables avec de multiples SGBDs, demandant peu
    d'efforts.</para>

    <para>L'interface de la classe d'adaptateur est semblable à celle de l'extension <ulink
    url="http://www.php.net/pdo">PHP Data Objects</ulink>. <classname>Zend_Db</classname> propose des classes d'adaptateurs vers
    les drivers PDO pour les SGBDs suivants :</para>

    <itemizedlist>
        <listitem>
            <para>IBM DB2 et Informix Dynamic Server (IDS), en utilisant l'extension PHP <ulink
            url="http://www.php.net/pdo-ibm">pdo_ibm</ulink>.</para>
        </listitem>

        <listitem>
            <para>MySQL, utilisant l'extension PHP <ulink url="http://www.php.net/pdo-mysql">pdo_mysql</ulink>.</para>
        </listitem>

        <listitem>
            <para>Microsoft SQL Server, utilisant l'extension PHP <ulink
            url="http://www.php.net/pdo-mssql">pdo_mssql</ulink>.</para>
        </listitem>

        <listitem>
            <para>Oracle, utilisant l'extension PHP <ulink url="http://www.php.net/pdo-oci">pdo_oci</ulink>.</para>
        </listitem>

        <listitem>
            <para>PostgreSQL, grâce à l'extension PHP <ulink
            url="http://www.php.net/pdo-pgsql">pdo_pgsql</ulink>.</para>
        </listitem>

        <listitem>
            <para>SQLite, avec l'extension PHP <ulink url="http://www.php.net/pdo-sqlite">pdo_sqlite</ulink>.</para>
        </listitem>
    </itemizedlist>

    <para>De plus, <classname>Zend_Db</classname> fournit aussi des classes se connectant avec les extensions PHP propres aux
    SGBDs (hors PDO donc), pour les SGBDs suivants :</para>

    <itemizedlist>
        <listitem>
            <para>MySQL, utilisant l'extension PHP <ulink url="http://www.php.net/mysqli">mysqli</ulink>.</para>
        </listitem>

        <listitem>
            <para>Oracle, utilisant l'extension PHP <ulink url="http://www.php.net/oci8">oci8</ulink>.</para>
        </listitem>

        <listitem>
            <para>IBM DB2, utilisant l'extension PHP <ulink url="http://www.php.net/ibm_db2">ibm_db2</ulink>.</para>
        </listitem>

        <listitem>
            <para>Firebird/Interbase, utilisant l'extension PHP <ulink
            url="http://www.php.net/ibase">php_interbase</ulink></para>
        </listitem>
    </itemizedlist>

    <note>
        <para>Chaque <classname>Zend_Db_Adapter</classname> utilise une extension PHP. Vous devez donc les avoir activées pour
        utiliser les classes en question. Par exemple, si vous voulez utiliser une classe <classname>Zend_Db_Adapter</classname>
        basée sur PDO, vous devrez alors avoir l'extension PDO d'installée, ainsi que l'extension représentant le driver
        spécifique à votre SGBD.</para>
    </note>

    <sect2 id="zend.db.adapter.connecting">
        <title>Se connecter à un SGBD en utilisant un adaptateur</title>

        <para>Cette section décrit comment créer une instance d'un adaptateur <classname>Zend_Db</classname> de base de
        données.</para>

        <sect3 id="zend.db.adapter.connecting.constructor">
            <title>Utilisation du constructeur du Zend_Db Adapter</title>

            <para>Vous pouvez créer une instance d'un adaptateur en utilisant son constructeur. Celui-ci accepte un
            paramètre représentant un tableau d'options.</para>

            <example id="zend.db.adapter.connecting.constructor.example">
                <title>Utiliser le constructeur de l'adaptateur</title>

                <programlisting role="php"><![CDATA[
$db = new Zend_Db_Adapter_Pdo_Mysql(array(
    'host'     => '127.0.0.1',
    'username' => 'webuser',
    'password' => 'xxxxxxxx',
    'dbname'   => 'test'
));
]]></programlisting>
            </example>
        </sect3>

        <sect3 id="zend.db.adapter.connecting.factory">
            <title>Utiliser la fabrique (Factory) de <classname>Zend_Db</classname></title>

            <para>Alternativement, il est possible d'utiliser la méthode statique <classname>Zend_Db::factory()</classname>.
            Celle-ci charge dynamiquement la classe d'adaptateur correspondant en utilisant <link
            linkend="zend.loader.load.class">Zend_Loader::loadClass()</link>.</para>

            <para>Le premier argument est une chaîne désignant l'adaptateur souhaité. Par exemple,
            "<code>Pdo_Mysql</code>" va correspondre à la classe <classname>Zend_Db_Adapter_Pdo_Mysql</classname>. Le second
            paramètre est un tableau d'options. C'est le même que celui que vous auriez passé au constructeur de la
            classe directement.</para>

            <example id="zend.db.adapter.connecting.factory.example">
                <title>Utilisation de la méthode statique de fabrique de <classname>Zend_Db</classname></title>

                <programlisting role="php"><![CDATA[
// Nous n'avons pas besoin de la ligne suivante car Zend_Db_Adapter_Pdo_Mysql
// sera automatiquement chargé par la fabrique Zend_Db.

// require_once 'Zend/Db/Adapter/Pdo/Mysql.php';

// Charge automatiquement la classe Zend_Db_Adapter_Pdo_Mysql
// et en créer une instance.
$db = Zend_Db::factory('Pdo_Mysql', array(
    'host'     => '127.0.0.1',
    'username' => 'webuser',
    'password' => 'xxxxxxxx',
    'dbname'   => 'test'
));
]]></programlisting>
            </example>

            <para>Si vous créez votre propre classe d'adaptateur qui étend <classname>Zend_Db_Adapter_Abstract</classname> et que
            celle-ci ne respecte pas la syntaxe du préfixe package "<classname>Zend_Db_Adapter</classname>", utilisez alors la clé
            "<code>adapterNamespace</code>" dans le tableau de configuration passé à la méthode <code>factory()</code>
            afin de charger votre adaptateur.</para>

            <example id="zend.db.adapter.connecting.factory.example2">
                <title>Utilisation de la fabrique avec une classe personnalisée</title>

                <programlisting role="php"><![CDATA[
// Charge automatiquement la classe MyProject_Db_Adapter_Pdo_Mysql
// et l'instantie.
$db = Zend_Db::factory('Pdo_Mysql', array(
    'host'             => '127.0.0.1',
    'username'         => 'webuser',
    'password'         => 'xxxxxxxx',
    'dbname'           => 'test',
    'adapterNamespace' => 'MyProject_Db_Adapter'
));
]]></programlisting>
            </example>
        </sect3>

        <sect3 id="zend.db.adapter.connecting.factory-config">
            <title>Utiliser <classname>Zend_Config</classname> avec la fabrique <classname>Zend_Db</classname></title>

            <para>Optionnellement, vous pouvez passer un objet de type <link linkend="zend.config">Zend_Config</link> en
            tant qu'argument de la méthode <code>factory()</code>, concernant la configuration.</para>

            <para>Il est alors nécessaire que l'objet de configuration contienne une propriété <code>adapter</code>, qui
            représente une chaîne de caractères décrivant l'adaptateur à utiliser. De plus, l'objet peut aussi contenir
            une propriété nommée <code>params</code>, avec toutes les sous propriétés requises pour la configuration de
            l'adaptateur.</para>

            <example id="zend.db.adapter.connecting.factory.example1">
                <title>Utilisation de la fabrique avec un objet de type <classname>Zend_Config</classname></title>

                <para>Dans l'exemple qui va suivre, l'objet <classname>Zend_Config</classname> est crée à partir d'un tableau. Il
                eut été possible de le créer à partir de fichiers externes, grâce à <link
                linkend="zend.config.adapters.ini">Zend_Config_Ini</link> ou <link
                linkend="zend.config.adapters.xml">Zend_Config_Xml</link>.</para>

                <programlisting role="php"><![CDATA[
$config = new Zend_Config(
    array(
        'database' => array(
            'adapter' => 'Mysqli',
            'params' => array(
                'host'     => '127.0.0.1',
                'dbname'   => 'test',
                'username' => 'webuser',
                'password' => 'secret',
            )
        )
    )
);

$db = Zend_Db::factory($config->database);
]]></programlisting>
            </example>

            <para>Le second paramètre de la méthode <code>factory()</code> doit être un tableau associatif décrivant les
            paramètres de l'adaptateur à utiliser. Cet argument est optionnel, si un objet de type
            <classname>Zend_Config</classname> est utilisé en premier paramètre, alors il est supposé contenir les paramètres, et
            le second paramètre de <code>factory()</code> est alors ignoré.</para>
        </sect3>

        <sect3 id="zend.db.adapter.connecting.parameters">
            <title>Paramètres de l'adaptateur (Adapter)</title>

            <para>La liste ci dessous explique les différents paramètres acceptés par les classes d'adaptateur
            <classname>Zend_Db</classname>.</para>

            <itemizedlist>
                <listitem>
                    <para><emphasis role="strong">host</emphasis> : le nom de l'hôte hébergeant le SGBD. Vous pouvez
                    aussi spécifier une adresse IP. Si le SGBD se situe sur la même machine que l'application PHP,
                    "localhost" ou "127.0.0.1" devraient alors être utilisés.</para>
                </listitem>

                <listitem>
                    <para><emphasis role="strong">username </emphasis>: nom d'utilisateur du compte de connexion au
                    SGBD.</para>
                </listitem>

                <listitem>
                    <para><emphasis role="strong">password</emphasis> : mot de passe de l'utilisateur du compte de
                    connexion au SGBD.</para>
                </listitem>

                <listitem>
                    <para><emphasis role="strong">dbname</emphasis> : nom de la base de données située dans le
                    SGBD.</para>
                </listitem>

                <listitem>
                    <para><emphasis role="strong">port</emphasis> : Certains SGBDs acceptent que l'on spécifie un port
                    pour d'y connecter. Indiquez le alors ici.</para>
                </listitem>

                <listitem>
                    <para><emphasis role="strong">options</emphasis> : Ce paramètre est un tableau associatif d'options
                    génériques à toutes les classes <classname>Zend_Db_Adapter</classname>.</para>
                </listitem>

                <listitem>
                    <para><emphasis role="strong">driver_options</emphasis> : Ce paramètre est un tableau associatif
                    d'options spécifiques à une extension de SGBD spécifique. Typiquement, il est possible avec ce
                    paramètre de passer des options (attributs) au driver PDO.</para>
                </listitem>

                <listitem>
                    <para><emphasis role="strong">adapterNamespace</emphasis> : fournit le commencement du nom de la
                    classe d'adaptateur, à utiliser la place de "<classname>Zend_Db_Adapter</classname>". Utilisez ceci si vous
                    désirez que <code>factory()</code> charge une classe non Zend.</para>
                </listitem>
            </itemizedlist>

            <example id="zend.db.adapter.connecting.parameters.example1">
                <title>Passer l'option de gestion de la casse à la fabrique</title>

                <para>Vous pouvez spécifier cette option avec la constante <classname>Zend_Db::CASE_FOLDING</classname>. Ceci
                correspond à l'attribut <code>ATTR_CASE</code> dans les drivers PDO et IBM DB2, ce qui ajuste la casse
                des clés dans les jeux de résultats. Les valeurs possibles possibles sont
                <classname>Zend_Db::CASE_NATURAL</classname> (défaut), <classname>Zend_Db::CASE_UPPER</classname>, et
                <classname>Zend_Db::CASE_LOWER</classname>.</para>

                <programlisting role="php"><![CDATA[
$options = array(
    Zend_Db::CASE_FOLDING => Zend_Db::CASE_UPPER
);

$params = array(
    'host'           => '127.0.0.1',
    'username'       => 'webuser',
    'password'       => 'xxxxxxxx',
    'dbname'         => 'test',
    'options'        => $options
);

$db = Zend_Db::factory('Db2', $params);
]]></programlisting>
            </example>

            <example id="zend.db.adapter.connecting.parameters.example2">
                <title>Passer l'option d'auto-échappement à la fabrique</title>

                <para>Vous pouvez spécifier cette option avec le paramètre <classname>Zend_Db::AUTO_QUOTE_IDENTIFIERS</classname>.
                Si la valeur passée est <code>true</code> (par défaut), alors les identifiants tels que les noms de
                tables, de colonnes, ou encore les alias SQL, sont échappés (délimités) dans la syntaxe de la requête
                SQL générée par l'objet d'adaptateur. Ceci rend l'utilisation de mots SQL contenant des identifiant
                spéciaux plus simple. Dans le cas de <code>false</code>, vous devrez vous-même délimiter ces identifiant
                avec la méthode <code>quoteIdentifier()</code>.</para>

                <programlisting role="php"><![CDATA[
$options = array(
    Zend_Db::AUTO_QUOTE_IDENTIFIERS => false
);

$params = array(
    'host'           => '127.0.0.1',
    'username'       => 'webuser',
    'password'       => 'xxxxxxxx',
    'dbname'         => 'test',
    'options'        => $options
);

$db = Zend_Db::factory('Pdo_Mysql', $params);
]]></programlisting>
            </example>

            <example id="zend.db.adapter.connecting.parameters.example3">
                <title>Passer des options de driver PDO à la fabrique</title>

                <programlisting role="php"><![CDATA[
$pdoParams = array(
    PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true
);

$params = array(
    'host'           => '127.0.0.1',
    'username'       => 'webuser',
    'password'       => 'xxxxxxxx',
    'dbname'         => 'test',
    'driver_options' => $pdoParams
);

$db = Zend_Db::factory('Pdo_Mysql', $params);

echo $db->getConnection()
        ->getAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY);
]]></programlisting>
            </example>

            <example id="zend.db.adapter.connecting.parameters.example4">
                <title>Passer des options de sérialisation à la fabrique</title>

                <programlisting role="php"><![CDATA[
$options = array(
    Zend_Db::ALLOW_SERIALIZATION => false
);

$params = array(
    'host'           => '127.0.0.1',
    'username'       => 'webuser',
    'password'       => 'xxxxxxxx',
    'dbname'         => 'test',
    'options'        => $options
);

$db = Zend_Db::factory('Pdo_Mysql', $params);

                ]]></programlisting>
            </example>
        </sect3>

        <sect3 id="zend.db.adapter.connecting.getconnection">
            <title>Gestion des connexions dites paresseuses</title>

            <para>La création d'une instance d'une classe d'adaptateur ne crée pas physiquement une connexion au SGBD.
            L'adaptateur sauvegarde les paramètres et se connectera physiquement à la demande, la première fois que vous
            aurez besoin d'exécuter une requête. Ceci permet d'assurer que la création de l'instance elle-même est
            rapide, et ne coûte rien en performances. Vous pouvez donc créer une instance de l'adaptateur, même si vous
            ne savez pas si vous allez l'utiliser. Ainsi, si vos paramètres sont incorrects, il faudra attendre la
            tentative de connexion au SGBD pour le vérifier réellement.</para>

            <para>Si vous voulez forcer l'adaptateur à se connecter au SGBD, utilisez sa méthode
            <code>getConnection()</code>. Elle retournera alors un objet représentant la connexion, en fonction de
            l'extension PHP utilisée, ou une exception si la connexion n'a pas été réalisée. Par exemple, si votre
            adaptateur utilise PDO, le retour sera un objet PDO. La connexion physique au SGBD est alors
            réalisée.</para>

            <para>Afin de vérifier si les paramètres de connexion au SGBD sont corrects, surveillez les exceptions
            envoyées par la méthode <code>getConnection()</code>.</para>

            <para>De plus, un adaptateur peut être sérialisé pour être stocké, par exemple, dans une variable de
            session. Ceci peut être utile non seulement pour l'adaptateur lui-même, mais aussi pour les autres objets
            qui l'agrègent, comme un objet <classname>Zend_Db_Select</classname>. Par défaut, les adaptateurs sont autorisés à
            être sérialisés, si vous ne le voulez pas, vous devez passer l'option
            <classname>Zend_Db::ALLOW_SERIALIZATION=false</classname>, regardez l'exemple ci-dessus. Afin de respecter le principe
            de connexions paresseuses, l'adaptateur ne se reconnectera pas après la désérialisation. Vous devez appeler
            vous-même <code>getConnection()</code>. Vous pouvez permettre à l'adaptateur de se reconnecter
            automatiquement en utilisant l'option d'adaptateur
            <classname>Zend_Db::AUTO_RECONNECT_ON_UNSERIALIZE=true</classname>.</para>

            <example id="zend.db.adapter.connecting.getconnection.example">
                <title>Gérer les exceptions de connexion</title>

                <programlisting role="php"><![CDATA[
try {
    $db = Zend_Db::factory('Pdo_Mysql', $parameters);
    $db->getConnection();
} catch (Zend_Db_Adapter_Exception $e) {
    // probablement mauvais identifiants,
    // ou alors le SGBD n'est pas joignable
} catch (Zend_Exception $e) {
    // probablement que factory() n'a pas réussi à charger
    // la classe de l'adaptateur demandé
}
]]></programlisting>
            </example>
        </sect3>
    </sect2>

    <sect2 id="zend.db.adapter.example-database">
        <title>La base de données d'exemple</title>

        <para>Dans cette documentation concernant <classname>Zend_Db</classname>, nous utilisons un exemple simple de tables pour
        illustrer nos exemples. Ces tables peuvent servir à stocker des informations sur la gestion des bugs dans une
        application. La base de données contient quatre tables :</para>

        <itemizedlist>
            <listitem>
                <para><emphasis role="strong">accounts</emphasis> correspond aux informations sur les utilisateurs qui
                gèrent les bugs.</para>
            </listitem>

            <listitem>
                <para><emphasis role="strong">products</emphasis> enregistre les produits pour lesquels des bugs vont
                être relevés.</para>
            </listitem>

            <listitem>
                <para><emphasis role="strong">bugs</emphasis> est la table qui contient les bugs, à savoir leur état
                actuel, la personne ayant relevé le bug, la personne en charge de le corriger, et la personne chargée de
                vérifier le correctif.</para>
            </listitem>

            <listitem>
                <para><emphasis role="strong">bugs_products</emphasis> enregistre les relations entre les bugs, et les
                produits. C'est une relation plusieurs à plusieurs car un même bug peut faire partie de plusieurs
                produits, et un produit peut évidemment posséder plusieurs bugs.</para>
            </listitem>
        </itemizedlist>

        <para>Le pseudo-code SQL suivant représente les tables de notre base de données d'exemple. Ces tables sont
        utilisées aussi pour les tests unitaires automatisés de <classname>Zend_Db</classname>.</para>

        <programlisting role="sql"><![CDATA[
CREATE TABLE accounts (
  account_name      VARCHAR(100) NOT NULL PRIMARY KEY
);

CREATE TABLE products (
  product_id        INTEGER NOT NULL PRIMARY KEY,
  product_name      VARCHAR(100)
);

CREATE TABLE bugs (
  bug_id            INTEGER NOT NULL PRIMARY KEY,
  bug_description   VARCHAR(100),
  bug_status        VARCHAR(20),
  reported_by       VARCHAR(100) REFERENCES accounts(account_name),
  assigned_to       VARCHAR(100) REFERENCES accounts(account_name),
  verified_by       VARCHAR(100) REFERENCES accounts(account_name)
);

CREATE TABLE bugs_products (
  bug_id            INTEGER NOT NULL REFERENCES bugs,
  product_id        INTEGER NOT NULL REFERENCES products,
  PRIMARY KEY       (bug_id, product_id)
);
]]></programlisting>

        <para>Notez aussi que la table <code>bugs</code> contient plusieurs référence (clés étrangères) vers la table
        <code>accounts</code>. Chacune de ces clés peut référencer un enregistrement différent de la table
        <code>accounts</code>, pour un bug donné.</para>

        <para>Le diagramme qui suit illustre le modèle physique des données.</para>

        <para><inlinegraphic align="center" fileref="figures/zend.db.adapter.example-database.png" format="PNG"
        scale="100" valign="middle" width="387" /></para>
    </sect2>

    <sect2 id="zend.db.adapter.select">
        <title>Lecture de résultats de requête</title>

        <para>Cette section décrit des méthodes de la classe d'adaptateur permettant l'obtention de résultats suivants
        une requête SELECT.</para>

        <sect3 id="zend.db.adapter.select.fetchall">
            <title>Récupérer tous les résultats</title>

            <para>Vous pouvez à la fois exécuter une requête SELECT et récupérer tous ses résultats en une seule
            manipulation, grâce à la méthode <code>fetchAll()</code>.</para>

            <para>Le premier paramètre de cette méthode est une chaîne représentant la requête SELECT à exécuter. Aussi,
            ce premier paramètre peut être un objet <link linkend="zend.db.select">Zend_Db_Select</link>, qui sera alors
            converti en une chaîne automatiquement.</para>

            <para>Le second paramètre de de <code>fetchAll()</code> est un tableau de substitutions des éventuels jokers
            présents dans la syntaxe SQL.</para>

            <example id="zend.db.adapter.select.fetchall.example">
                <title>Utiliser <code>fetchAll()</code></title>

                <programlisting role="php"><![CDATA[
$sql = 'SELECT * FROM bugs WHERE bug_id = ?';

$result = $db->fetchAll($sql, 2);
]]></programlisting>
            </example>
        </sect3>

        <sect3 id="zend.db.adapter.select.fetch-mode">
            <title>Changer le mode de récupération (Fetch Mode)</title>

            <para>Par défaut, <code>fetchAll()</code> retourne un tableau d'enregistrements. Chaque enregistrement étant
            un tableau associatif dont les clés sont les noms des colonnes SQL désirées, ou leurs alias.</para>

            <para>Vous pouvez spécifier un mode de récupération de résultats différent, ceci par la méthode
            <code>setFetchMode()</code>. Les modes supportés sont identifiés par des constantes :</para>

            <itemizedlist>
                <listitem>
                    <para><emphasis role="strong">Zend_Db::FETCH_ASSOC</emphasis>: Retourne un tableau
                    d'enregistrements. Chaque enregistrement étant un tableau associatif dont les clés sont les noms des
                    colonnes SQL désirées, ou leurs alias. Il s'agit du mode par défaut utilisé par les classes
                    Zend_Db_Adapter.</para>

                    <para>Notez que si votre résultat comporte plusieurs colonnes avec le même nom, par exemple lors
                    d'une jointure, il ne peut y avoir qu'un clé avec un nom définit dans le tableau de résultat. Vous
                    devriez toujours utiliser des alias avec le mode FETCH_ASSOC.</para>

                    <para>Les noms des clés des tableaux correspondants aux noms des colonnes SQL telles que retournées
                    par le SGBD, vous pouvez spécifier la casse pour ces noms, grâce à l'option
                    <classname>Zend_Db::CASE_FOLDING</classname>. Spécifiez ceci lors de l'instanciation de votre adaptateur.
                    Voyez <xref linkend="zend.db.adapter.connecting.parameters.example1" />.</para>
                </listitem>

                <listitem>
                    <para><emphasis role="strong">Zend_Db::FETCH_NUM</emphasis>: Retourne les enregistrements dans un
                    tableau de tableaux. Les tableaux nichés sont indexés par des entiers correspondants à la position
                    du champ dans la syntaxe SQL SELECT.</para>
                </listitem>

                <listitem>
                    <para><emphasis role="strong">Zend_Db::FETCH_BOTH</emphasis>: Retourne les enregistrements dans un
                    tableau de tableaux. Les tableaux nichés sont indexés à la fois numériquement et lexicalement. C'est
                    un mode qui réunit FETCH_ASSOC et FETCH_NUM. Ainsi, vous avez deux fois plus d'enregistrements,
                    chacun d'entre eux étant doublé.</para>
                </listitem>

                <listitem>
                    <para><emphasis role="strong">Zend_Db::FETCH_COLUMN</emphasis>: Retourne les enregistrements dans un
                    tableau de valeurs. Les valeurs correspondent à une des colonnes utilisées dans la requête SQL
                    SELECT. Par défaut, il s'agit de la colonne à l'index 0.</para>
                </listitem>

                <listitem>
                    <para><emphasis role="strong">Zend_Db::FETCH_OBJ</emphasis>: Retourne les enregistrements dans un
                    tableau d'objets. La classe de ces objets par défaut est la classe intégrée à PHP :
                    <code>stdClass</code>. Les colonnes des enregistrements sont représentées par les propriétés
                    publiques des objets.</para>
                </listitem>
            </itemizedlist>

            <example id="zend.db.adapter.select.fetch-mode.example">
                <title>Utiliser <code>setFetchMode()</code></title>

                <programlisting role="php"><![CDATA[
$db->setFetchMode(Zend_Db::FETCH_OBJ);

$result = $db->fetchAll('SELECT * FROM bugs WHERE bug_id = ?', 2);

// $result est un tableau d'objets
echo $result[0]->bug_description;
]]></programlisting>
            </example>
        </sect3>

        <sect3 id="zend.db.adapter.select.fetchassoc">
            <title>Récupérer un enregistrement comme tableau associatif</title>

            <para>La méthode <code>fetchAssoc()</code> retourne des enregistrements sous forme de tableau de tableaux
            associatifs, quelque soit la valeur de "fetch mode".</para>

            <example id="zend.db.adapter.select.fetchassoc.example">
                <title>Utiliser f<code>etchAssoc()</code></title>

                <programlisting role="php"><![CDATA[
$db->setFetchMode(Zend_Db::FETCH_OBJ);

$result = $db->fetchAssoc('SELECT * FROM bugs WHERE bug_id = ?', 2);

// $result est un tableau de tableaux associatifs
echo $result[0]['bug_description'];
]]></programlisting>
            </example>
        </sect3>

        <sect3 id="zend.db.adapter.select.fetchcol">
            <title>Récupérer une seule colonne d'un enregistrement</title>

            <para>La méthode <code>fetchCol()</code> retourne les enregistrements dans un tableau de valeurs. Les
            valeurs correspondent à une des colonnes utilisées dans la requête SQL SELECT, par défaut : la première.
            Toute autre colonne sera ignorée. Si vous avez besoin de retourner une autre colonne, voyez <xref
            linkend="zend.db.statement.fetching.fetchcolumn" />. Cette méthode est indépendante de la valeur de "fetch
            mode".</para>

            <example id="zend.db.adapter.select.fetchcol.example">
                <title>Utiliser <code>fetchCol()</code></title>

                <programlisting role="php"><![CDATA[
$db->setFetchMode(Zend_Db::FETCH_OBJ);

$sql = 'SELECT bug_description, bug_id FROM bugs WHERE bug_id = ?';
$result = $db->fetchCol($sql, 2);

// Contient bug_description ; bug_id n'est pas retourné
echo $result[0];
]]></programlisting>
            </example>
        </sect3>

        <sect3 id="zend.db.adapter.select.fetchpairs">
            <title>Récupérer des paires Clé-Valeur d'enregistrements</title>

            <para>La méthode <code>fetchPairs()</code> retourne un tableau de paires clés/valeurs. La clé est le
            résultat de la première colonne sélectionnée dans la requête, la valeur est le résultat de la deuxième
            colonne sélectionnée dans la requête. Il est donc inutile de sélectionner plus de deux colonnes avec cette
            méthode. De même, vous devez sélectionner exactement deux colonnes avec cette méthode, pas moins. Si des
            clés ont des doublons, alors ils seront écrasés.</para>

            <para>Vous devriez réfléchir votre requête SELECT de manière à ce que la première colonne sélectionnée,
            correspondant à la clé du tableau de résultat, soit unique (une clé primaire par exemple). Cette méthode est
            indépendante de "fetch mode" éventuellement précédemment défini.</para>

            <example id="zend.db.adapter.select.fetchpairs.example">
                <title>Utilisation de <code>fetchPairs()</code></title>

                <programlisting role="php"><![CDATA[
$db->setFetchMode(Zend_Db::FETCH_OBJ);

$result = $db->fetchPairs('SELECT bug_id, bug_status FROM bugs');

echo $result[2]; // le bug_status correspondant au bug_id numéro 2
]]></programlisting>
            </example>
        </sect3>

        <sect3 id="zend.db.adapter.select.fetchrow">
            <title>Récupérer un seul enregistrement complet</title>

            <para>La méthode <code>fetchRow()</code> retourne un et un seul enregistrement (le premier si plusieurs
            correspondent), en fonction de "fetch mode" que vous aurez précédemment défini. Cette méthode ressemble donc
            à <code>fetchAll()</code> si ce n'est qu'elle ne retournera jamais plus d'un seul enregistrement. Arrangez
            vous donc pour que votre SELECT possède une clause WHERE sur une clé primaire.</para>

            <example id="zend.db.adapter.select.fetchrow.example">
                <title>Utiliser <code>fetchRow()</code></title>

                <programlisting role="php"><![CDATA[
$db->setFetchMode(Zend_Db::FETCH_OBJ);

$result = $db->fetchRow('SELECT * FROM bugs WHERE bug_id = 2');

// Ce résultat sera un objet, car le fetch mode en a décidé ainsi
echo $result->bug_description;
]]></programlisting>
            </example>
        </sect3>

        <sect3 id="zend.db.adapter.select.fetchone">
            <title>Récupérer une colonne d'un enregistrement</title>

            <para>La méthode <code>fetchOne()</code> est une combinaison des méthodes <code>fetchRow()</code> et
            <code>fetchCol()</code>, ainsi elle ne retourne que la première colonne, du premier enregistrement retourné.
            La valeur de retour est donc une chaîne de caractères. Toute requête retournant plusieurs colonnes et/ou
            plusieurs résultats est donc inutile avec cette méthode.</para>

            <example id="zend.db.adapter.select.fetchone.example">
                <title>Utiliser <code>fetchOne()</code></title>

                <programlisting role="php"><![CDATA[
$result = $db->fetchOne('SELECT bug_status FROM bugs WHERE bug_id = 2');

// ceci est une chaine
echo $result;
]]></programlisting>
            </example>
        </sect3>
    </sect2>

    <sect2 id="zend.db.adapter.write">
        <title>Effectuer des changements dans la base de données</title>

        <para>Il est bien entendu possible d'utiliser la classe d'adaptateur pour effectuer des changements dans vos
        données. Cette section décrit les manières de procéder.</para>

        <sect3 id="zend.db.adapter.write.insert">
            <title>Insérer des données</title>

            <para>Vous pouvez ajouter de nouveaux enregistrements dans une table, grâce à la méthode
            <code>insert()</code>. Son premier paramètre est une chaîne qui représente le nom de la table ciblée, le
            second paramètre est un tableau associatif liant les noms des colonnes de la table, aux valeurs
            souhaitées.</para>

            <example id="zend.db.adapter.write.insert.example">
                <title>Insertion dans une table</title>

                <programlisting role="php"><![CDATA[
$data = array(
    'created_on'      => '2007-03-22',
    'bug_description' => 'Something wrong',
    'bug_status'      => 'NEW'
);

$db->insert('bugs', $data);
]]></programlisting>
            </example>

            <para>Les colonnes non citées dans le tableau associatif sont laissées telles quelles. Ainsi, si le SGBD
            possède une valeur DEFAULT pour les colonnes concernées, celle-ci sera utilisée, autrement, NULL sera
            utilisé.</para>

            <para>Par défaut, les valeurs insérées avec cette méthode sont automatiquement échappées. Ceci pour des
            raisons de sécurité, vous n'avez donc pas besoin de vous occuper de ce point là.</para>

            <para>Si vous avez besoin d'écrire de la syntaxe SQL, comme des mots réservés, des noms de fonctions SQL,
            vous voulez que ceux-ci ne soient pas échappés, et ne soient pas traités comme de vulgaires chaînes de
            caractères, mais plutôt comme des expressions. Pour ceci, vous devriez passer ces valeurs dans votre tableau
            de données, en tant qu'objets de type <classname>Zend_Db_Expr</classname> au lieu de chaînes de caractères
            banales.</para>

            <example id="zend.db.adapter.write.insert.example2">
                <title>Insérer des expressions dans une table</title>

                <programlisting role="php"><![CDATA[
$data = array(
    'created_on'      => new Zend_Db_Expr('CURDATE()'),
    'bug_description' => 'Something wrong',
    'bug_status'      => 'NEW'
);

$db->insert('bugs', $data);
]]></programlisting>
            </example>
        </sect3>

        <sect3 id="zend.db.adapter.write.lastinsertid">
            <title>Récupérer une valeur générée</title>

            <para>Certains SGBDs supportent les clé primaires auto-incrémentées. Une table qui utilise un tel procédé
            génère la valeur de la clé automatiquement lors d'une insertion (INSERT). La valeur de retour de la méthode
            <code>insert()</code> <emphasis>n'est pas</emphasis> le dernier ID inséré car la table peut ne pas avoir de
            clé auto-incrémentée. La valeur de retour est le nombres d'enregistrements affectés (théoriquement
            1).</para>

            <para>Si votre table a été définie avec une clé auto-incrémentée, alors vous pouvez appeler la méthode
            <code>lastInsertId()</code> après une opération d'insertion. Cette méthode retourne la valeur
            auto-incrémentée, générée dans le cadre de la connexion au SGBD.</para>

            <example id="zend.db.adapter.write.lastinsertid.example-1">
                <title>Utiliser l<code>astInsertId()</code> pour les clés auto-incrémentées</title>

                <programlisting role="php"><![CDATA[
$db->insert('bugs', $data);

// retourne la dernière valeur générée par la clé auto-incrémentée
$id = $db->lastInsertId();
]]></programlisting>
            </example>

            <para>Certains SGBD supporte un objet de séquence, qui sert à générer des valeurs uniques qui vont servir
            pour les clé primaires. Pour supporter ce procédé, la méthode <code>lastInsertId()</code> accepte deux
            paramètres optionnels (chaînes de caractères). Ces paramètres nomment la table et la colonne en supposant
            que vous ayez respecté la convention qui définit que la séquence est nommée en utilisant le nom de la table
            et des colonnes utilisées, avec le suffixe "_seq". Ces conventions sont celles de PostgreSQL pour les
            colonnes de type SERIAL. Par exemple, une table "bugs" avec une clé primaire "bug_id" utilisera une séquence
            nommée "bugs_bug_id_seq".</para>

            <example id="zend.db.adapter.write.lastinsertid.example-2">
                <title>Utiliser <code>lastInsertId()</code> avec une séquence</title>

                <programlisting role="php"><![CDATA[
$db->insert('bugs', $data);

// retourne la dernière valeur générée par la séquence 'bugs_bug_id_seq'.
$id = $db->lastInsertId('bugs', 'bug_id');

// ceci retourne la dernière valeur générée par la séquence 'bugs_seq'.
$id = $db->lastInsertId('bugs');
]]></programlisting>
            </example>

            <para>Si le nom de votre objet de séquence ne suit pas ces conventions de nommage, utilisez alors
            <code>lastSequenceId()</code>. Cette méthode prend un paramètre qui nomme la séquence explicitement.</para>

            <example id="zend.db.adapter.write.lastinsertid.example-3">
                <title>Utilisation de <code>lastSequenceId()</code></title>

                <programlisting role="php"><![CDATA[
$db->insert('bugs', $data);

// retourne la dernière valeur générée par la séquence 'bugs_id_gen'.
$id = $db->lastSequenceId('bugs_id_gen');
]]></programlisting>
            </example>

            <para>Pour les SGBDs ne supportant pas les séquences, comme MySQL, Microsoft SQL Server, et SQLite, les
            arguments passés à la méthode <code>lastInsertId()</code> sont ignorés. La valeur retournée est la dernière
            valeur générée pour la dernière requête INSERT, quelque soit la table concernée (pour cette connexion).
            Aussi, pour ces SGBDs, la méthode <code>lastSequenceId()</code> retournera toujours
            <code>null</code>.</para>

            <note>
                <title>Pourquoi ne pas utiliser "SELECT MAX(id) FROM table"?</title>

                <para>Quelques fois, cette requête retourne la valeur la plus récente de clé primaire insérée dans la
                table en question. Cependant, cette technique n'est pas pertinente dans un environnement où beaucoup de
                clients insèrent beaucoup de données dans une même table. Il est donc possible qu'un client insère une
                donnée entre le moment où la dernière insertion est effectuée, et l'appel de MAX(id), aboutissant ainsi
                à un résultat erroné. Il est très difficile de se rendre compte d'un tel comportement.</para>

                <para>Utiliser un mode d'isolation transactionnelle très élevé, comme "repeatable read" peut mitiger
                plus ou moins les risques, mais certains SGBDs ne supportent pas ce mode de transactions.</para>

                <para>De plus, utiliser une requête du type "MAX(id)+1" pour générer une nouvelle valeur de clé primaire
                n'est pas sécurisé non plus, car deux client peuvent se connecter simultanément et créer des effets
                indésirables.</para>

                <para>Tous les SGBDs fournissent un mécanisme de génération de valeurs uniques, et une méthode pour les
                récupérer. Ces mécanismes travaillent en dehors du mode transactionnel, et empêchent ainsi deux clients
                de générer la même valeur, ou de "se marcher dessus".</para>
            </note>
        </sect3>

        <sect3 id="zend.db.adapter.write.update">
            <title>Mettre à jour des données</title>

            <para>Vous pouvez mettre à jour des données dans une table en utilisant la méthode <code>update()</code> de
            l'adaptateur. Cette méthode accepte trois arguments : le premier est le nom de la table, le deuxième est un
            tableau faisant correspondre les noms des colonnes SQL à leurs valeurs désirées.</para>

            <para>Les valeurs dans ce tableau sont traitées comme des chaînes. Voyez <xref
            linkend="zend.db.adapter.write.insert" /> pour plus d'informations sur la gestion des expressions SQL dans
            ce tableau.</para>

            <para>Le troisième argument est une chaîne contenant l'expression SQL utilisée comme critère pour la mise à
            jour des données dans la table. Les valeurs et les arguments dans ce paramètre ne sont pas échappés pour
            vous. Vous devez donc vous assurer de l'éventuel bon échappement des caractères. Voyez <xref
            linkend="zend.db.adapter.quoting" /> pour plus d'informations.</para>

            <para>La valeur de retour de cette méthode est le nombre d'enregistrements affectés par l'opération de mise
            à jour (UPDATE).</para>

            <example id="zend.db.adapter.write.update.example">
                <title>Mettre à jour des enregistrements</title>

                <programlisting role="php"><![CDATA[
$data = array(
    'updated_on'      => '2007-03-23',
    'bug_status'      => 'FIXED'
);

$n = $db->update('bugs', $data, 'bug_id = 2');
]]></programlisting>
            </example>

            <para>Si vous oubliez le troisième paramètre, alors tous les enregistrements de la table sont mis à jour
            avec les valeurs spécifiées dans le tableau de données.</para>

            <para>Si vous spécifiez un tableau de chaîne en tant que troisième paramètre, alors ces chaînes sont jointes
            entre elles avec une opération <code>AND</code>.</para>

            <example id="zend.db.adapter.write.update.example-array">
                <title>Mettre à jour des enregistrements avec un tableau de données</title>

                <programlisting role="php"><![CDATA[
$data = array(
    'updated_on'      => '2007-03-23',
    'bug_status'      => 'FIXED'
);

$where[] = "reported_by = 'goofy'";
$where[] = "bug_status = 'OPEN'";

$n = $db->update('bugs', $data, $where);

// la requête SQL executée est:
//  UPDATE "bugs" SET "update_on" = '2007-03-23', "bug_status" = 'FIXED'
//  WHERE ("reported_by" = 'goofy') AND ("bug_status" = 'OPEN')
]]></programlisting>
            </example>
        </sect3>

        <sect3 id="zend.db.adapter.write.delete">
            <title>Supprimer des enregistrements</title>

            <para>Il est possible de supprimer des enregistrements dans une table. La méthode <code>delete()</code> est
            faite pour cela. Elle accepte deux paramètres, le premier est une chaîne désignant la table.</para>

            <para>Le second paramètre est une chaîne contenant l'expression SQL utilisée comme critère pour effacer les
            enregistrements. Les valeurs de cette expression de sont pas échappées automatiquement, vous devez donc vous
            en occuper le cas échéant. Voyez <xref linkend="zend.db.adapter.quoting" /> pour les méthodes concernant
            l'échappement.</para>

            <para>La valeur retournée par la méthode <code>delete()</code> est le nombre d'enregistrements affectés
            (effacés).</para>

            <example id="zend.db.adapter.write.delete.example">
                <title>Supprimer des enregistrements</title>

                <programlisting role="php"><![CDATA[
$n = $db->delete('bugs', 'bug_id = 3');
]]></programlisting>
            </example>

            <para>Si vous ne spécifiez pas le second paramètres, tous les enregistrements de la table seront alors
            supprimés.</para>

            <para>Si le second paramètre est un tableau de chaînes, alors celles ci seront jointe en une expression SQL,
            séparées par l'opération <code>AND</code>.</para>
        </sect3>
    </sect2>

    <sect2 id="zend.db.adapter.quoting">
        <title>Échapper des valeurs ou des identifiants</title>

        <para>Lorsque vous envoyez des requêtes SQL au SGBD, il est souvent nécessaire d'y inclure des paramètres
        dynamiques, PHP. Ceci est risqué car si un des paramètres contient certains caractères, comme l'apostrophe ('),
        alors la requête résultante risque d'être mal formée. Par exemple, notez le caractère indésirable dans la
        requête suivante : <programlisting role="php"><![CDATA[
$name = "O'Reilly";
$sql = "SELECT * FROM bugs WHERE reported_by = '$name'";

echo $sql;
// SELECT * FROM bugs WHERE reported_by = 'O'Reilly'
]]></programlisting></para>

        <para>Pire encore est le cas où de telles erreurs SQL peuvent être utilisées délibérément par une personne afin
        de manipuler la logique de votre requête. Si une personne peut manipuler un paramètre de votre requête, par
        exemple via un paramètre HTTP ou une autre méthode, alors il peut y avoir une fuite de données, voire même une
        corruption totale de votre base de données. Cette technique très préoccupante de violation de la sécurité d'un
        SGBD, est appelée "injection SQL" (voyez <ulink
        url="http://en.wikipedia.org/wiki/SQL_Injection">http://en.wikipedia.org/wiki/SQL_Injection</ulink>).</para>

        <para>La classe Zend_Db Adapter possède des méthodes adaptées pour vous aider à faire face à de telles
        vulnérabilités. La solution proposée est l'échappement de tels caractères (comme la "quote" = ') dans les
        valeurs PHP avant leur passage dans la chaîne de requête. Ceci vous protège de l'insertion malveillante ou
        involontaires, de caractères spéciaux dans les variables PHP faisant partie d'une requête SQL.</para>

        <sect3 id="zend.db.adapter.quoting.quote">
            <title>Utilisation de <code>quote()</code></title>

            <para>La méthode <code>quote()</code> accepte un seul paramètre, une chaîne de caractère. Elle retourne une
            chaîne dont les caractères spéciaux ont été échappés d'une manière convenable en fonction du SGBD
            sous-jacent. De plus, la chaîne échappée est entourée d'apostrophes ("<code>'</code>").C'est la valeur
            standard de délimitations des chaînes en SQL.</para>

            <example id="zend.db.adapter.quoting.quote.example">
                <title>Utiliser <code>quote()</code></title>

                <programlisting role="php"><![CDATA[
$name = $db->quote("O'Reilly");
echo $name;
// 'O\'Reilly'

$sql = "SELECT * FROM bugs WHERE reported_by = $name";

echo $sql;
// SELECT * FROM bugs WHERE reported_by = 'O\'Reilly'
]]></programlisting>
            </example>

            <para>Notez que la valeur de retour contient les apostrophes de délimitation autour de la chaîne. Ceci est
            différent de certaines fonctions qui se contentent juste d'échapper les caractères spéciaux, telle que
            <ulink url="http://www.php.net/mysqli_real_escape_string">mysql_real_escape_string()</ulink>.</para>

            <para>Certaines valeurs en revanche n'ont pas besoin d'être délimitées. Certains SGBDs n'acceptent pas que
            les valeurs correspondant à des champs de type entier, soient délimitées. Autrement dit, l'exemple suivant
            est erroné dans certaines implémentations de SQL. Nous supposons <code>intColumn</code> ayant un type SQL
            <code>INTEGER</code> : <programlisting role="php"><![CDATA[
SELECT * FROM atable WHERE intColumn = '123'
]]></programlisting></para>

            <para>Le second paramètre optionnel de <code>quote()</code> permet de spécifier un type SQL.</para>

            <example id="zend.db.adapter.quoting.quote.example-2">
                <title>Utiliser <code>quote()</code> avec un type SQL</title>

                <programlisting role="php"><![CDATA[
$value = '1234';
$sql = 'SELECT * FROM atable WHERE intColumn = '
     . $db->quote($value, 'INTEGER');
]]></programlisting>
            </example>

            <para>De plus, chaque classe Zend_Db_Adapter possèdent des constantes représentant les différents type SQL
            des SGBDs respectifs qu'elles représentent. Ainsi, les constantes <classname>Zend_Db::INT_TYPE</classname>,
            <classname>Zend_Db::BIGINT_TYPE</classname>, et <classname>Zend_Db::FLOAT_TYPE</classname> peuvent vous permettre d'écrire un
            code portable entre différents SGBDs.</para>

            <para>Zend_Db_Table fournit les types SQL à <code>quote()</code> automatiquement en fonction des colonnes
            utilisées par la table référencée.</para>
        </sect3>

        <sect3 id="zend.db.adapter.quoting.quote-into">
            <title>Utilisation de <code>quoteInto()</code></title>

            <para>Une autre manière est d'échapper une expression SQL contenant une variable PHP. Vous pouvez utiliser
            <code>quoteInto()</code> pour cela. Cette méthode accepte trois arguments. Le premier est la chaîne
            représentant l'expression SQL dont les paramètres variables sont remplacés par un joker(<code>?</code>), et
            le second argument est la variable PHP à utiliser pour le remplacement du joker.</para>

            <para>Le joker est le même symbole que celui utilisé par beaucoup de SGBDs pour la substitution de paramètre
            dans une requête préparée.<code>quoteInto()</code> ne fait qu'émuler ce comportement : la méthode ne fait
            que remplacer le joker par la valeur PHP, en lui appliquant la méthode <code>quote</code>. De vrais
            paramètres de requêtes préparées conservent une réelle isolation entre la requête et ses paramètres.</para>

            <example id="zend.db.adapter.quoting.quote-into.example">
                <title>Utiliser <code>quoteInto()</code></title>

                <programlisting role="php"><![CDATA[
$sql = $db->quoteInto("SELECT * FROM bugs WHERE reported_by = ?",
                      "O'Reilly");

echo $sql;
// SELECT * FROM bugs WHERE reported_by = 'O\'Reilly'
]]></programlisting>
            </example>

            <para>Le troisième paramètre optionnel s'utilise comme avec la méthode <code>quote</code>. Il sert à
            spécifier un type SQL, les types numériques ne sont pas délimités.</para>

            <example id="zend.db.adapter.quoting.quote-into.example-2">
                <title>Utiliser <code>quoteInto()</code> avec un type SQL</title>

                <programlisting role="php"><![CDATA[
$sql = $db->quoteInto("SELECT * FROM bugs WHERE bug_id = ?",
                      '1234',
                      'INTEGER');

echo $sql;
// SELECT * FROM bugs WHERE reported_by = 1234
]]></programlisting>
            </example>
        </sect3>

        <sect3 id="zend.db.adapter.quoting.quote-identifier">
            <title>Utilisation de <code>quoteIdentifier()</code></title>

            <para>Les valeurs ne sont pas les seuls données qui peuvent être dynamiques dans une requête SQL,et donc
            passées par des variables PHP. Les noms des tables, des colonnes, ou tout autre identifiant SQL spécial de
            la requête peuvent aussi être dynamiques. En général, les identifiant spéciaux d'une requête ont une syntaxe
            identique à celle des variables PHP : pas d'espaces dans les noms, certains autres caractères interdits, la
            ponctuation est interdite, etc... Aussi, les identifiant ne peuvent valoir certaines valeurs de mots
            réservés : une table ne peut s'appeler "FROM". Il se peut donc que vous ayez besoin aussi d'échapper des
            paramètres voués à être substitués à des identifiant dans la requête SQL, et non plus à des valeurs.</para>

            <para>Le langage SQL possède une caractéristique appelée <emphasis>identifiant délimités</emphasis>. Si vous
            entourez un identifiant SQL dans un type spécial de délimiteurs, alors vous pouvez écrire des requêtes qui
            auraient été invalides autrement. Ainsi, vous pouvez inclure des espaces, de la ponctuation ou des
            caractères internationaux dans vos identifiant, et aussi utiliser des mots réservés.</para>

            <para>La méthode <code>quoteIdentifier()</code> fonctionne comme <code>quote()</code>, mais elle utilise un
            caractère de délimitation spécial, en fonction du SGBD sous-jacent. Par exemple, le standard SQL spécifie
            des doubles quotes (<code>"</code>) et beaucoup de SGBDs utilisent ceci. MySQL utilise les apostrophes
            inverses (back-quotes) (<code>`</code>) par défaut. Les caractères spéciaux sont aussi échappés.</para>

            <example id="zend.db.adapter.quoting.quote-identifier.example">
                <title>Utiliser quoteIdentifier()</title>

                <programlisting role="php"><![CDATA[
// nous possédons une table ayant un nom correspondant
// à un mot reservé en SQL
$tableName = $db->quoteIdentifier("order");

$sql = "SELECT * FROM $tableName";

echo $sql
// SELECT * FROM "order"
]]></programlisting>
            </example>

            <para>Les identifiant SQL délimités sont sensibles à la casse. Vous devriez toujours utiliser la casse telle
            qu'elle est utilisée dans votre base de données (nom des tables, des colonnes ...).</para>

            <para>Dans les cas où le SQL est généré à l'intérieur des classes <classname>Zend_Db</classname>, alors les
            identifiant SQL seront automatiquement échappés. Vous pouvez changer ce comportement avec l'option
            <classname>Zend_Db::AUTO_QUOTE_IDENTIFIERS</classname>.Spécifiez la lors de l'instanciation de l'adaptateur. Voyez
            <xref linkend="zend.db.adapter.connecting.parameters.example2" />.</para>
        </sect3>
    </sect2>

    <sect2 id="zend.db.adapter.transactions">
        <title>Gérer les transactions dans une base de données</title>

        <para>Les bases de données définissent les transactions comme étant des unités logiques de travail qui peuvent
        êtres validées ("commit") ou annulées ("rollback") en tant qu'une seule opération, même sur de multiples tables.
        Toutes les requêtes aux bases de données sont considérées comme faisant partie d'une transaction, même si le
        driver de base de données fait ceci implicitement. Ceci s'appelle le mode <emphasis>auto-commit</emphasis>, dans
        lequel le driver de base de données créer une transaction pour chaque requête exécutée et la valide. Par défaut
        toutes les classes <classname>Zend_Db_Adapter</classname> fonctionnent en mode auto-commit.</para>

        <para>Vous pouvez manuellement spécifier lorsque vous voulez démarrer une transaction. Vous contrôler ainsi
        combien de requêtes doivent y être exécutées, et valider ou annuler ce groupe de requêtes. Utilisez
        <code>beginTransaction()</code> pour démarrer une transaction. Toutes les requêtes suivantes seront alors
        exécutées dans cette transaction avant que vous ne l'annuliez, ou validiez.</para>

        <para>Pour terminer une transaction, utilisez les méthodes <code>commit()</code> ou <code>rollBack()</code>.
        <code>commit()</code> validera et appliquera les changements de la transaction au SGBD, ils deviendront alors
        visibles dans les autres transactions.</para>

        <para><code>rollBack()</code> fait le contraire : elle annule les changements qu'ont générés les requêtes dans
        la transaction. L'annulation n'a aucun effet sur les changements qui ont été opérés par d'autres transactions
        parallèles.</para>

        <para>Après qu'une transaction soit terminées, <classname>Zend_Db_Adapter</classname> retourne en mode auto-commit jusqu'à
        un nouvel appel à <code>beginTransaction()</code>.</para>

        <example id="zend.db.adapter.transactions.example">
            <title>Manipuler les transactions pour assurer l'intégrité de la logique</title>

            <programlisting role="php"><![CDATA[
// Démarre explicitement une transaction.
$db->beginTransaction();

try {
    // Essaye d'executer une ou plusieurs requêtes :
    $db->query(...);
    $db->query(...);
    $db->query(...);

    // Si toutes ont réussi, valide les changements en une seule passe.
    $db->commit();

} catch (Exception $e) {
    // Si une des requête s'est mal déroulée, alors nous voulons
    // annuler les changements de toutes les requêtes faisant partie
    // de la transaction, même celles qui se sont bien déroulées.
    // Tous les changements sont annulés d'un seul coup.
    $db->rollBack();
    echo $e->getMessage();
}
]]></programlisting>
        </example>
    </sect2>

    <sect2 id="zend.db.adapter.list-describe">
        <title>Lister et décrire les tables</title>

        <para>La méthode <code>listTables()</code> retourne un tableau de chaînes décrivant les tables de la base de
        données courante.</para>

        <para>La méthode <code>describeTable()</code> retourne un tableau associatif de métadonnées sur une table.
        Spécifiez en le nom en paramètre. Le second paramètre est optionnel et définit la base de données à utiliser,
        comme par exemple si aucune n'a été sélectionnée précédemment.</para>

        <para>Les clés de ce tableau représentent les noms des colonnes, les valeurs sont un tableau avec les clés
        suivantes :</para>

        <table cellpadding="5" frame="all" id="zend.db.adapter.list-describe.metadata">
            <title>Champs de métadonnées retournés par <code>describeTable()</code></title>

            <tgroup align="left" cols="3" colsep="1" rowsep="1">
                <thead>
                    <row>
                        <entry>clé</entry>

                        <entry>type</entry>

                        <entry>description</entry>
                    </row>
                </thead>

                <tbody>
                    <row>
                        <entry>SCHEMA_NAME</entry>

                        <entry>(chaîne)</entry>

                        <entry>Nom de la base de données dans laquelle la table existe.</entry>
                    </row>

                    <row>
                        <entry>TABLE_NAME</entry>

                        <entry>(chaîne)</entry>

                        <entry>Nom de la table dans laquelle la colonne existe.</entry>
                    </row>

                    <row>
                        <entry>COLUMN_NAME</entry>

                        <entry>(chaîne)</entry>

                        <entry>Nom de la colonne.</entry>
                    </row>

                    <row>
                        <entry>COLUMN_POSITION</entry>

                        <entry>(entier)</entry>

                        <entry>Position de la colonne dans la table.</entry>
                    </row>

                    <row>
                        <entry>DATA_TYPE</entry>

                        <entry>(chaîne)</entry>

                        <entry>Nom du type de données tel que renvoyé par le SGBD.</entry>
                    </row>

                    <row>
                        <entry>DEFAULT</entry>

                        <entry>(chaîne)</entry>

                        <entry>Valeur par défaut de la colonne, si une existe.</entry>
                    </row>

                    <row>
                        <entry>NULLABLE</entry>

                        <entry>(booléen)</entry>

                        <entry><code>true</code> si la colonne accepte la valeur SQL '<code>NULL</code>',
                        <code>false</code> sinon.</entry>
                    </row>

                    <row>
                        <entry>LENGTH</entry>

                        <entry>(entier)</entry>

                        <entry>Longueur ou taille de la colonne telle que reportée par le SGBD.</entry>
                    </row>

                    <row>
                        <entry>SCALE</entry>

                        <entry>(entier)</entry>

                        <entry>Échelle du type SQL NUMERIC ou DECIMAL.</entry>
                    </row>

                    <row>
                        <entry>PRECISION</entry>

                        <entry>(entier)</entry>

                        <entry>Précision du type SQL NUMERIC ou DECIMAL.</entry>
                    </row>

                    <row>
                        <entry>UNSIGNED</entry>

                        <entry>(booléen)</entry>

                        <entry><code>true</code> si le type est un entier non signé, défini par UNSIGNED.</entry>
                    </row>

                    <row>
                        <entry>PRIMARY</entry>

                        <entry>(booléen)</entry>

                        <entry><code>true</code> si la colonne fait partie d'une clé primaire.</entry>
                    </row>

                    <row>
                        <entry>PRIMARY_POSITION</entry>

                        <entry>(entier)</entry>

                        <entry>Position de la colonne dans la clé primaire.</entry>
                    </row>

                    <row>
                        <entry>IDENTITY</entry>

                        <entry>(booléen)</entry>

                        <entry><code>true</code> si la colonne utilise une valeur auto-générée.</entry>
                    </row>
                </tbody>
            </tgroup>
        </table>

        <note>
            <title>A quoi correspond le champs de métadonnées "IDENTITY" en fonction du SGBD ?</title>

            <para>Le champs de métadonnées "IDENTITY" a été choisi en tant que terme idiomatique pour représenter une
            relation de substitution de clés. Ce champ est généralement connu par les valeurs suivantes :</para>

            <itemizedlist>
                <listitem>
                    <para><code>IDENTITY</code> - DB2, MSSQL</para>
                </listitem>

                <listitem>
                    <para><code>AUTO_INCREMENT</code> - MySQL</para>
                </listitem>

                <listitem>
                    <para><code>SERIAL</code> - PostgreSQL</para>
                </listitem>

                <listitem>
                    <para><code>SEQUENCE</code> - Oracle</para>
                </listitem>
            </itemizedlist>
        </note>

        <para>Si aucune table ne correspond à votre demande, alors <code>describeTable()</code> retourne un tableau
        vide.</para>
    </sect2>

    <sect2 id="zend.db.adapter.closing">
        <title>Fermer une connexion</title>

        <para>Normalement, il n'est pas nécessaire de fermer explicitement sa connexion. PHP nettoie automatiquement les
        ressources laissées ouvertes en fin de traitement. Les extensions des SGBDs ferment alors les connexions
        respectives pour les ressources détruites par PHP.</para>

        <para>Cependant, il se peut que vous trouviez utile de fermer la connexion manuellement. Vous pouvez alors
        utiliser la méthode de l'adaptateur <code>closeConnection()</code> afin de fermer explicitement la connexion
        vers le SGBD.</para>

        <para>A partir de la version 1.7.2, vous pouvez vérifier si vous êtes actuellement connecté au serveur SGBD
        grâce à la méthode <code>isConnected()</code>. Ceci correspond à une ressource de connexion qui a été initiée et
        qui n'est pas close. Cette fonction ne permet pas actuellement de tester la fermeture de la connexion au niveau
        du SGBD par exemple. Cette fonction est utilisée en interne pour fermer la connexion. Elle vous permet entre
        autres de fermer plusieurs fois une connexion sans erreurs. C'était déjà le cas avant la version 1.7.2 pour les
        adaptateurs de type PDO mais pas pour les autres.</para>

        <example id="zend.db.adapter.closing.example">
            <title>Fermer une connexion à un SGBD</title>

            <programlisting role="php"><![CDATA[
$db->closeConnection();
]]></programlisting>
        </example>

        <note>
            <title>Zend_Db supporte-t-il les connexions persistantes ?</title>

            <para>L'utilisation de connexions persistantes n'est pas supporté, ni conseillé, par le composant
            <classname>Zend_Db</classname>.</para>

            <para>Utiliser des connexions persistantes peut mener à un trop grand nombre de connexions en attente
            (idle), ce qui causera plus de problème que cela n'est sensé en résoudre.</para>

            <para>Les connexions aux bases de données possède un état. Dans cet état sont mémorisés des objets propres
            au SGBD. Par exemples des verrous, des variables utilisateur, des tables temporaires, des informations sur
            les requêtes récentes, les derniers enregistrements affectés, les dernières valeurs auto-générées, etc. Avec
            des connexions persistantes, il se peut que vous accédiez à des données ne faisant pas partie de votre
            session de travail avec le SGBD, ce qui peut s'avérer dangereux.</para>
        </note>
    </sect2>

    <sect2 id="zend.db.adapter.other-statements">
        <title>Exécuter des requêtes sur le driver directement</title>

        <para>Il peut y avoir des cas où vous souhaitez accéder directement à la connexion 'bas niveau', sous
        <classname>Zend_Db_Adapter</classname>.</para>

        <para>Par exemple, toute requête effectuée par <classname>Zend_Db</classname> est préparée, et exécutée. Cependant,
        certaines caractéristiques des bases de données ne sont pas compatibles avec les requêtes préparées. Par
        exemple, des requêtes du type CREATE ou ALTER ne peuvent pas être préparées sous MySQL. De même, les requêtes
        préparées ne bénéficient pas du <ulink url="http://dev.mysql.com/doc/refman/5.1/en/query-cache-how.html"> cache
        de requêtes</ulink>, avant MySQL 5.1.17.</para>

        <para>La plupart des extensions PHP pour les bases de données proposent une méthode permettant d'envoyer une
        requête directe, sans préparation. Par exemple, PDO propose pour ceci la méthode <code>exec()</code>. Vous
        pouvez récupérer l'objet de connexion "bas niveau" grâce à la méthode de l'adaptateur
        <code>getConnection()</code>.</para>

        <example id="zend.db.adapter.other-statements.example">
            <title>Envoyer une requête directe dans un adaptateur PDO</title>

            <programlisting role="php"><![CDATA[
$result = $db->getConnection()->exec('DROP TABLE bugs');
]]></programlisting>
        </example>

        <para>De la même manière, vous pouvez accéder à toutes les propriétés ou méthodes de l'objet "bas niveau",
        utilisé par <classname>Zend_Db</classname>. Attention toutefois en utilisant ce procédé, vous risquez de rendre votre
        application dépendante du SGBD qu'elle utilise, en manipulant des méthodes propres à l'extension
        utilisée.</para>

        <para>Dans de futures versions de <classname>Zend_Db</classname>, il sera possible d'ajouter des méthodes pour des
        fonctionnalités communes aux extensions de bases de données de PHP. Ceci ne rompra pas la compatibilité.</para>
    </sect2>

    <sect2 id="zend.db.adapter.server-version">
        <title>Récupérer la version du serveur SGBD</title>

        <para>A partir de la version 1.7.2, vous pouvez récupérer la version du serveur avec le style de syntaxe PHP ce
        qui permet d'utiliser <code>version_compare()</code>. Si cette information n'est pas disponible, vous recevrez
        un <code>null</code>.</para>

        <example id="zend.db.adapter.server-version.example">
            <title>Vérifier la version du serveur avant de lancer une requête</title>

            <programlisting role="php"><![CDATA[
$version = $db->getServerVersion();
if (!is_null($version)) {
    if (version_compare($version, '5.0.0', '>=')) {
        // faire quelquechose
    } else {
        // faire autre chose
    }
} else {
    // impossible de lire la version du serveur
}
]]></programlisting>
        </example>
    </sect2>

    <sect2 id="zend.db.adapter.adapter-notes">
        <title>Notes sur des adaptateur spécifiques</title>

        <para>Cette section liste des différences entre les adaptateurs, que vous devriez considérer.</para>

        <sect3 id="zend.db.adapter.adapter-notes.ibm-db2">
            <title>IBM DB2</title>

            <itemizedlist>
                <listitem>
                    <para>Passez le paramètre 'Db2' à la méthode <code>factory()</code>.</para>
                </listitem>

                <listitem>
                    <para>Cet adaptateur utilise l'extension PHP ibm_db2.</para>
                </listitem>

                <listitem>
                    <para>IBM DB2 supporte les séquences et les clés auto-incrémentées. Les arguments de
                    <code>lastInsertId()</code> sont donc optionnels. Si vous ne passez pas de paramètres, alors
                    l'adaptateur retourne la dernière valeur de clé auto- incrémentée. Sinon, il retourne la dernière
                    valeur de la séquence passée en paramètre, en se référant à la convention
                    '<emphasis>table</emphasis>_<emphasis>colonne</emphasis>_seq'.</para>
                </listitem>
            </itemizedlist>
        </sect3>

        <sect3 id="zend.db.adapter.adapter-notes.mysqli">
            <title>MySQLi</title>

            <itemizedlist>
                <listitem>
                    <para>Passez le paramètre 'Mysqli' à la méthode <code>factory()</code>.</para>
                </listitem>

                <listitem>
                    <para>Cet adaptateur utilise l'extension PHP mysqli.</para>
                </listitem>

                <listitem>
                    <para>MySQL ne supporte pas les séquences, donc <code>lastInsertId()</code> ignore tout paramètre
                    qu'on lui passe. Elle retourne toujours la valeur de la dernière clé auto-incrémentée.
                    <code>lastSequenceId()</code>, elle, retourne toujours <code>null</code>.</para>
                </listitem>
            </itemizedlist>
        </sect3>

        <sect3 id="zend.db.adapter.adapter-notes.oracle">
            <title>Oracle</title>

            <itemizedlist>
                <listitem>
                    <para>Passez le paramètre 'Oracle' à la méthode <code>factory()</code>.</para>
                </listitem>

                <listitem>
                    <para>Cet adaptateur utilise l'extension PHP oci8.</para>
                </listitem>

                <listitem>
                    <para>Oracle ne supporte pas les clé auto-incrémentées, donc vous devriez spécifier un paramètre de
                    séquence à <code>lastInsertId()</code> ou <code>lastSequenceId()</code>.</para>
                </listitem>

                <listitem>
                    <para>L'extension Oracle ne supporte pas les paramètres positionnés (?). Vous devez utiliser des
                    paramètres nommés (:name).</para>
                </listitem>

                <listitem>
                    <para>Actuellement l'option <classname>Zend_Db::CASE_FOLDING</classname> n'est pas supportée par l'adaptateur
                    Oracle. Pour l'utiliser, vous devez utiliser l'adaptateur basé sur PDO et OCI.</para>
                </listitem>

                <listitem>
                    <para>Par défaut les champs LOB ("Large Objet Binaire") sont retournés sous la forme d'objets
                    OCI-Lob. Vous pouvez les récupérer sous forme de chaînes pour toutes les requêtes en utilisant
                    l'option de driver <code>'lob_as_string'</code> ou pour une requête en particulier en utilisant la
                    méthode <code>setLobAsString(boolean)</code> de l'adaptateur ou de l'objet statement.</para>
                </listitem>
            </itemizedlist>
        </sect3>

        <sect3 id="zend.db.adapter.adapter-notes.pdo-ibm">
            <title>PDO pour IBM DB2 et Informix Dynamic Server (IDS)</title>

            <itemizedlist>
                <listitem>
                    <para>Passez le paramètre 'PDO_Ibm' à la méthode <code>factory()</code>.</para>
                </listitem>

                <listitem>
                    <para>Cet adaptateur utilise les extensions PHP pdo et pdo_ibm.</para>
                </listitem>

                <listitem>
                    <para>Vous devez possédez l'extension PDO_IBM en version 1.2.2 minimum. Si ce n'est pas le cas, vous
                    devrez la mettre à jour via PECL.</para>
                </listitem>
            </itemizedlist>
        </sect3>

        <sect3 id="zend.db.adapter.adapter-notes.pdo-mssql">
            <title>PDO Microsoft SQL Server</title>

            <itemizedlist>
                <listitem>
                    <para>Passez le paramètre 'PDO_Mssql' à la méthode <code>factory()</code>.</para>
                </listitem>

                <listitem>
                    <para>Cet adaptateur utilise les extensions PHP pdo et pdo_mssql.</para>
                </listitem>

                <listitem>
                    <para>Microsoft SQL Server ne supporte pas les séquences, ainsi <code>lastInsertId()</code> ignore
                    les paramètres qu'on lui passe et retourne toujours la valeur de la dernière clé auto-incrémentée.
                    <code>lastSequenceId()</code> retourne toujours <code>null</code>.</para>
                </listitem>

                <listitem>
                    <para>Si vous travaillez avec des chaînes Unicode avec un encodage autre que UCS-2 (comme UTF-8),
                    vous devrez peut-être réaliser une conversion dans votre code d'application ou stocker les données
                    dans un champs binaire. Reportez vous à la <ulink url="http://support.microsoft.com/kb/232580"> base
                    de connaissance Microsoft</ulink> pour plus d'informations.</para>
                </listitem>

                <listitem>
                    <para>Zend_Db_Adapter_Pdo_Mssql met <code>QUOTED_IDENTIFIER</code> à ON dès que la connexion a été
                    effectuée. Le driver utilise donc le délimiteur d'identifiant SQL <code>"</code> au lieu de son
                    délimiteur habituel.</para>
                </listitem>

                <listitem>
                    <para>Vous pouvez spécifier la clé <code>pdoType</code> dans le tableau d'options de construction de
                    l'adaptateur. La valeur peut être "mssql" (défaut), "dblib", "freetds", ou "sybase". Cette option
                    affecte la syntaxe du préfixe DSN que l'adaptateur utilisera. "freetds" et "sybase" impliquent un
                    préfixe "sybase:", qui est utilisé par les librairies <ulink
                    url="http://www.freetds.org/">FreeTDS</ulink>.Voyez aussi <ulink
                    url="http://www.php.net/manual/en/ref.pdo-dblib.connection.php">
                    http://www.php.net/manual/en/ref.pdo-dblib.connection.php</ulink> pour plus d'informations sur les
                    DSN pour ce driver.</para>
                </listitem>
            </itemizedlist>
        </sect3>

        <sect3 id="zend.db.adapter.adapter-notes.pdo-mysql">
            <title>PDO MySQL</title>

            <itemizedlist>
                <listitem>
                    <para>Passez le paramètre 'PDO_Mysql' à la méthode <code>factory()</code>.</para>
                </listitem>

                <listitem>
                    <para>Cet adaptateur utilise les extensions PHP pdo et pdo_mysql.</para>
                </listitem>

                <listitem>
                    <para>MySQL ne supporte pas les séquences, ainsi <code>lastInsertId()</code> ignore les paramètres
                    qu'on lui passe et retourne toujours la valeur de la dernière clé auto-incrémentée.
                    <code>lastSequenceId()</code> retourne toujours <code>null</code>.</para>
                </listitem>
            </itemizedlist>
        </sect3>

        <sect3 id="zend.db.adapter.adapter-notes.pdo-oci">
            <title>PDO Oracle</title>

            <itemizedlist>
                <listitem>
                    <para>Passez le paramètre 'PDO_Oci' à la méthode <code>factory()</code>.</para>
                </listitem>

                <listitem>
                    <para>Cet adaptateur utilise les extensions PHP pdo et pdo_oci.</para>
                </listitem>

                <listitem>
                    <para>Oracle ne supporte pas les clé auto-incrémentées, donc vous devriez spécifier un paramètre de
                    séquence à <code>lastInsertId()</code> ou <code>lastSequenceId()</code>.</para>
                </listitem>
            </itemizedlist>
        </sect3>

        <sect3 id="zend.db.adapter.adapter-notes.pdo-pgsql">
            <title>PDO PostgreSQL</title>

            <itemizedlist>
                <listitem>
                    <para>Passez le paramètre 'PDO_Pgsql' à la méthode <code>factory()</code>.</para>
                </listitem>

                <listitem>
                    <para>Cet adaptateur utilise les extensions PHP pdo et pdo_pgsql.</para>
                </listitem>

                <listitem>
                    <para>PostgreSQL supporte les séquences et les clés auto-incrémentées. Les arguments de
                    <code>lastInsertId()</code> sont donc optionnels. Si vous ne passez pas de paramètres, alors
                    l'adaptateur retourne la dernière valeur de clé auto- incrémentée. Sinon, il retourne la dernière
                    valeur de la séquence passée en paramètre, en se référant à la convention
                    '<emphasis>table</emphasis>_<emphasis>colonne</emphasis>_seq'.</para>
                </listitem>
            </itemizedlist>
        </sect3>

        <sect3 id="zend.db.adapter.adapter-notes.pdo-sqlite">
            <title>PDO SQLite</title>

            <itemizedlist>
                <listitem>
                    <para>Passez le paramètre 'PDO_Sqlite' à la méthode <code>factory()</code>.</para>
                </listitem>

                <listitem>
                    <para>Cet adaptateur utilise les extensions PHP pdo et pdo_sqlite.</para>
                </listitem>

                <listitem>
                    <para>SQLite ne supporte pas les séquences, ainsi <code>lastInsertId()</code> ignore les paramètres
                    qu'on lui passe et retourne toujours la valeur de la dernière clé auto-incrémentée.
                    <code>lastSequenceId()</code> retourne toujours <code>null</code>.</para>
                </listitem>

                <listitem>
                    <para>Pour vous connecter à une base de données SQLite2, spécifiez le paramètre
                    <code>'sqlite2'=&gt;true</code> dans le tableau d'options passé à l'adaptateur, lors de la création
                    de l'instance de Pdo_Sqlite Adapter.</para>
                </listitem>

                <listitem>
                    <para>Pour vous connecter à une base de données SQLite en mémoire, spécifiez le paramètre
                    <code>'dsnprefix'=&gt;':memory:'</code> dans le tableau d'options passé à l'adaptateur, lors de la
                    création de l'instance de Pdo_Sqlite Adapter.</para>
                </listitem>

                <listitem>
                    <para>Les anciennes versions du driver SQLite pour PHP ne semblent pas supporter les commandes
                    PRAGMA nécessaires pour s'assurer que les colonnes ayant un nom court soient utilisées dans les
                    résultats. Si vous avez des problèmes, tels que vos enregistrements sont retournés avec une forme
                    "nomtable.nomcolonne" lors de vos jointures, vous devriez alors mettre à jour votre version de
                    PHP.</para>
                </listitem>
            </itemizedlist>
        </sect3>

        <sect3 id="zend.db.adapter.adapter-notes.firebird">
            <title>Firebird/Interbase</title>

            <itemizedlist>
                <listitem>
                    <para>Cet adaptateur utilise l'extension PHP php_interbase.</para>
                </listitem>

                <listitem>
                    <para>Firebird/interbase ne supporte pas les clé auto-incrémentées, donc vous devez spécifier un
                    paramètre de séquence à <code>lastInsertId()</code> ou <code>lastSequenceId()</code>.</para>
                </listitem>

                <listitem>
                    <para>Pour l'instant l'option <classname>Zend_Db::CASE_FOLDING</classname> n'est pas supportée par
                    l'adaptateur Firebird/interbase. Tout identificateur non échappé sera automatiquement retourné en
                    majuscules.</para>
                </listitem>
            </itemizedlist>
        </sect3>
    </sect2>
</sect1>