<?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision: 1.23 $ -->
<reference id="ref.mysql">
 <title>MySQL</title>
 <titleabbrev>MySQL</titleabbrev>
 <partintro>
  <simpara>
   Ces fonctions vous permettent d'acc&eacute;der aux bases de donn&eacute;es
   MySQL. Afin de pouvoir les utiliser, vous devez compiler PHP avec le support
   MySQL, en utilisant l'option <link linkend="install.configure.with-mysql">
   <option role="configure">--with-mysql</option></link>.
   Si vous utilisez cette fonction sans pr&eacute;ciser le chemin
   d'acc&egrave;s &agrave; la base MySQL, PHP utilisera les librairies clientes
   MySQL fournies en standard. Les utilisateurs qui font tourner d'autres
   applications qui utilisent elles-m&ecirc;mes MySQL (par exemple, PHP 3 et
   PHP 4 utilis&eacute;s comme des modules concurrents apache, ou encore
   auth-mysql), devraient toujours sp&eacute;cifier le chemin jusqu'&agrave;
   MySQL :
   <link linkend="install.configure.with-mysql"><option role="configure">--with-mysql=/path/to/mysql</option></link>.
   Cela va forcer PHP &agrave; utiliser les librairies clientes install&eacute;es par
   MySQL et &eacute;vitera les conflits.
  </simpara>
  <simpara>
   Plus d'informations sont disponible &agrave;
   <ulink url="&url.mysql;">&url.mysql;</ulink>.
  </simpara>
  <simpara>
   La documentation de MySQL est disponibles &agrave; <ulink
   url="&url.mysql.docs;">&url.mysql.docs;</ulink>, ainsi qu'en fran&ccedil;ais
   chez <ulink url="&url.mysql.docs.fr;">nexen</ulink>.
  </simpara>
   <para>
    Cet exemple simple montre comment se connecter, ex&eacute;cuter une
    requ&ecirc;te, lire les informations obtenues et se d&eacute;connecter d'une
    base de donn&eacute;es MySQL.
    <example>
     <title>Exemple d'introduction</title>
     <programlisting role="php">
&lt;?php
  $link = mysql_connect("hote_mysql", "login_mysql", "mot_de_passe_mysql")
    or die ("Impossible de se connecter");
  print ("Connexion r&eacute;ussie");
  mysql_select_db ("ma_base")
    or die ("Impossible d'acc&eacute;der &agrave; la base de donn&eacute;es");
  $query = "SELECT * FROM ma_table";
  $result = mysql_query ($query)
    or die ("La requ&ecirc;te a &eacute;chou&eacute;");
// Affichage du r&eacute;sultat au format HTML
  print "&lt;table&gt;\n";
  while($line = mysql_fetch_array($result)){
    print "\t&lt;tr&gt;\n";
    while(list($col_name, $col_value) = each($line)){
      print "\t\t&lt;td&gt;$col_value&lt;/td&gt;\n";
    }
    print "\t&lt;/tr&gt;\n";
  }
  print "&lt;/table&gt;\n";
  mysql_close($link);
?&gt;
     </programlisting>
    </example>
   </para>
 </partintro>
 <refentry id="function.mysql-affected-rows">
  <refnamediv>
   <refname>mysql_affected_rows</refname>
   <refpurpose>
    Retourne le nombre de lignes affect&eacute;es lors de la derni&egrave;re
    requ&ecirc;te SQL.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>mysql_affected_rows</methodname>
     <methodparam choice="opt"><type>resource</type><parameter>
      link_identifier
      </parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>mysql_affected_rows</function> retourne le nombre de lignes
    affect&eacute;es lors de la derni&egrave;re requ&ecirc;te INSERT, UPDATE ou
    DELETE sur le serveur associ&eacute; &agrave; l'identifiant de connexion. Si
    cet identifiant n'est pas pr&eacute;cis&eacute;,
    <function>mysql_affected_rows</function> utilise la derni&egrave;re
    connexion ouverte.
   </para>
   <note>
    <para>
     Si vous utilisez les transactions, vous devez appeler
     <function>mysql_affected_rows</function> apr&egrave;s votre INSERT,
     UPDATE, ou DELETE et non apr&egrave;s la validation.
    </para>
   </note>
   <para>
    Si la derni&egrave;re requ&ecirc;te &eacute;tait un DELETE sans clause WHERE, tous
    les enregistrements ont &eacute;t&eacute; effac&eacute;s, mais
    <function>mysql_affected_rows</function> va retourner 0.
   </para>
   <para>
    <function>mysql_affected_rows</function> n'est pas possible apr&egrave;s un
    SELECT, car elle ne fonctionne qu'apr&egrave;s des commandes qui modifient
    les enregistrements. Pour conna&icirc;tre le nombre de lignes
    retourn&eacute;es par un SELECT, utilisez <function>mysql_num_rows</function>.
   </para>
   <para>
    Si la derni&egrave;re requ&ecirc;te a &eacute;chou&eacute;,
    <function>mysql_affected_rows</function> retourne -1.
   </para>
  </refsect1>
 </refentry>
 <refentry id="function.mysql-change-user">
  <refnamediv>
   <refname>mysql_change_user</refname>
   <refpurpose>
    Change le nom de session de l'utilisateur actif.
   </refpurpose>
  </refnamediv>
  <refsect1>
   <title>Description</title>
    <methodsynopsis>
     <type>int</type><methodname>mysql_change_user</methodname>
     <methodparam><type>string</type><parameter>user</parameter></methodparam>
     <methodparam><type>string</type><parameter>password</parameter></methodparam>
     <methodparam choice="opt"><type>string</type><parameter>
      database
      </parameter></methodparam>
     <methodparam choice="opt"><type>resource</type><parameter>
      link_identifier
      </parameter></methodparam>
    </methodsynopsis>
   <para>
    <function>mysql_change_user</function> change l'utilisateur de la session
    courante, ou sur la connexion sp&eacute;cifi&eacute;e avec l'option
    <parameter>link_identifier</parameter>.
    Si une base est sp&eacute;cifi&eacute;e, elle deviendra la base par
    d&eacute;faut de l'utilisateur. Si une erreur de connexion survient,
    la connexion en cours restera active.
   </para>
   <note>
    <para>
     <function>mysql_change_user</function> a &eacute;t&eacute; introduite
     en PHP 3.0.13 et requiert MySQL 3.23.3 ou plus r&eacute;cent.
    </para></note>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-close">
   <refnamediv>
    <refname>mysql_close</refname>
    <refpurpose>Ferme la connexion MySQL.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>boolean</type><methodname>mysql_close</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>
       link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_close</function> retourne &true; en cas
     de succ&egrave;s et &false; sinon.
    </para>
    <para>
     <function>mysql_close</function> ferme la connexion au serveur MySQL
     associ&eacute;e &agrave; l'identifiant <parameter>link_identifier</parameter>.
     Si cet identifiant n'est pas sp&eacute;cifi&eacute;, cette commande s'applique
     &agrave; la derni&egrave;re connexion ouverte.
    </para>
    <note>
     <para>
      Notez que cette commande n'est pas n&eacute;cessaire, car toutes les connexions non
      persistantes seront automatiquement ferm&eacute;es &agrave; la fin du script.
     </para>
    </note>
    <para>
     <function>mysql_close</function> ne ferme pas les connexions persistantes
     g&eacute;n&eacute;r&eacute;es par <function>mysql_pconnect</function>.
    </para>
    <example>
     <title>Exemple MySQL_close</title>
     <programlisting role="php">
&lt;?php
  $link = mysql_connect("kraemer", "marliesle", "secret") {
    or die("Impossible de se connecter");
  }
  print("Connexion r&eacute;ussie");
  mysql_close($link);
?&gt;
     </programlisting>
    </example>
    <para>
     Voir aussi
     <function>mysql_connect</function> et
     <function>mysql_pconnect</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-connect">
   <refnamediv>
    <refname>mysql_connect</refname>
    <refpurpose>Ouvre une connexion &agrave; un serveur MySQL.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>mysql_connect</methodname>
      <methodparam choice="opt"><type>string</type><parameter>
       server
       </parameter></methodparam>
      <methodparam choice="opt"><type>string</type><parameter>
       username
       </parameter></methodparam>
      <methodparam choice="opt"><type>string</type><parameter>
       password
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_connect</function> retourne un identifiant positif de
     connexion en cas de succ&egrave;s, et sinon &false;.
    </para>
    <para>
     <function>mysql_connect</function> &eacute;tablit une connexion &agrave;
     un serveur MySQL. Tous les arguments sont optionnels, et s'ils manquent,
     les valeurs par d&eacute;faut sont utilis&eacute;es ( ('localhost', nom
     du propri&eacute;taire du processus, mot de passe vide).
    </para>
    <para>
     Le nom d'h&ocirc;te peut aussi inclure un num&eacute;ro de port, sous la forme :
     &quot;hostname:port&quot; ou un chemin jusqu'&agrave; une socket sous la forme
     &quot;:/path/to/socket&quot; pour l'h&ocirc;te localhost.
     <note>
      <para>
       Le support des &quot;:port&quot; a &eacute;t&eacute; ajout&eacute; &agrave; partir de la version 3.0B4.
      </para>
      <para>
       Le support de &quot;:/path/to/socket&quot; a &eacute;t&eacute; ajout&eacute; &agrave; partir de la
       version 3.0.10.
      </para>
      <para>
       Vous pouvez supprimer le message d'erreur de connexion en ajoutant une arobase
       '&#64;' au nom de la fonction.
      </para>
     </note>
    </para>
    <para>
     Si un second appel &agrave; <function>mysql_connect</function> est fait avec
     les m&ecirc;mes arguments, PHP ne va pas ouvrir une nouvelle connexion, mais va
     retourner l'identifiant de la connexion d&eacute;j&agrave; ouverte.
    </para>
    <para>
     Le lien sera ferm&eacute; automatiquement d&egrave;s que l'ex&eacute;cution du script sera termin&eacute;e,
     &agrave; moins d'&ecirc;tre ferm&eacute; explicitement avec <function>mysql_close</function>.
    </para>
    <example>
     <title>Exemple MySQL connect</title>
     <programlisting role="php">
&lt;?php
  $link = mysql_connect("kraemer", "marliesle", "secret") {
    or die("Connexion impossible");
  }
  print("Connexion r&eacute;ussie");
  mysql_close($link);
?&gt;
     </programlisting>
    </example>
    <para>
     Voir aussi
     <function>mysql_pconnect</function> et
     <function>mysql_close</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-create-db">
   <refnamediv>
    <refname>mysql_create_db</refname>
    <refpurpose>Cr&eacute;e une base de donn&eacute;es MySQL.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>mysql_create_db</methodname>
      <methodparam><type>string</type><parameter>database_name</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
       link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_create_db</function> tente de cr&eacute;er une nouvelle
     base de donn&eacute;es nomm&eacute;e <parameter>database_name</parameter>
     sur le serveur associ&eacute; &agrave; l'identifiant
     <parameter>link_identifier</parameter>, ou sur la derni&egrave;re connexion
     ouverte.
    </para>
    <example>
     <title>Exemple de cr&eacute;ation de base MySQL</title>
     <programlisting role="php">
&lt;?php
  $link = mysql_pconnect ("kron", "jutta", "geheim") {
    or die ("Connexion impossible");
  }
  if (mysql_create_db ("my_db")) {
    print ("Base de donn&eacute;es cr&eacute;&eacute;e\n");
  } else {
    echo "Erreur lors de la cr&eacute;ation de la base: ".mysql_error();
  }
?&gt;
     </programlisting>
    </example>
    <para>
     Pour des raisons de compatibilit&eacute; ascendante,  mysql_createdb() est toujours
     utilisable.
    </para>
    <para>
     Voir aussi
     <function>mysql_drop_db</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-data-seek">
   <refnamediv>
    <refname>mysql_data_seek</refname>
    <refpurpose>D&eacute;place le pointeur interne de r&eacute;sultat.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>mysql_data_seek</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
      <methodparam><type>int</type><parameter>row_number</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_data_seek</function> retourne &true;
     en cas de succ&egrave;s et &false; sinon.
    </para>
    <para>
     <function>mysql_data_seek</function> d&eacute;place le pointeur
     interne de r&eacute;sultat, dans le r&eacute;sultat associ&eacute; &agrave;
     l'identifiant de r&eacute;sultat <parameter>result_identifier</parameter>.
     Il le fait pointer &agrave; la ligne <parameter>row_number</parameter>.
     Le prochain appel &agrave; <function>mysql_fetch_row</function>
     retournera cette ligne.
    </para>
    <para>
     <parameter>row_number</parameter> commence &agrave; 0.
    </para>
    <example>
     <title>Exemple <function>mysql_data_seek</function></title>
     <programlisting role="php">
&lt;?php
  $link = mysql_pconnect ("kron", "jutta", "geheim") {
    or die ("Connexion impossible");
  }
  mysql_select_db ("samp_db") {
    or die ("S&eacute;lection de base impossible");
  }
  $query = "SELECT last_name, first_name FROM friends";
  $result = mysql_query ($query) {
    or die ("Requ&ecirc;te impossible");
  }
// r&eacute;cup&egrave;re les lignes dans l'ordre inverse
  for ($i = mysql_num_rows ($result) - 1; $i >=0; $i--) {
    if (!mysql_data_seek ($result, $i)) {
      echo "Impossible d'atteindre la ligne $i\n";
      continue;
    }
    if(!($row = mysql_fetch_object ($result)))
      continue;
    echo "{$row->last_name} {$row->last_name$row->first_name}&lt;br&gt;\n";
  }
  mysql_free_result ($result);
?&gt;
     </programlisting>
    </example>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-db-name">
   <refnamediv>
    <refname>mysql_db_name</refname>
    <refpurpose>Lit les noms des bases de donn&eacute;es</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>mysql_db_name</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
      <methodparam><type>int</type><parameter>row</parameter></methodparam>
      <methodparam choice="opt"><type>mixed</type><parameter>
       field
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_db_name</function> prend comme premier argument
     le pointeur de r&eacute;sultat <parameter>result_identifier</parameter>,
     issu de <function>mysql_list_dbs</function>.
     <parameter>row</parameter> est l'index dans le r&eacute;sultat.
    </para>
    <para>
     Si une erreur survient, &false; est retourn&eacute;. Utilisez
     <function>mysql_errno</function> et
     <function>mysql_error</function> pour conna&icirc;tre la nature de l'erreur.
    </para>
    <example>
     <title>Exemple <function>mysql_db_name</function></title>
     <programlisting role="php">
&lt;?php
  error_reporting(E_ALL);
  mysql_connect('dbhost', 'username', 'password');
  $db_list = mysql_list_dbs();
  $i = 0;
  $cnt = mysql_num_rows($db_list);
  while ($i &lt; $cnt) {
    echo mysql_db_name($db_list, $i) . "\n";
    $i++;
  }
?&gt;
     </programlisting>
    </example>
    <para>
     Pour des raisons de compatibilit&eacute; ascendante, mysql_dbname()
     est aussi accept&eacute;, mais obsol&egrave;te.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-db-query">
   <refnamediv>
    <refname>mysql_db_query</refname>
    <refpurpose>Envoie une requ&ecirc;te MySQL &agrave; un serveur MySQL.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>resource</type><methodname>mysql_db_query</methodname>
      <methodparam><type>string</type><parameter>database</parameter></methodparam>
      <methodparam><type>string</type><parameter>query</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
       link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_db_query</function> retourne un identifiant de
     r&eacute;sultat si la requ&ecirc;te r&eacute;ussit et
     &false; sinon.
    </para>
    <para>
     <function>mysql_db_query</function> s&eacute;lectionne une base de donn&eacute;es
     et ex&eacute;cute une requ&ecirc;te. Si l'identifiant de lien
     <parameter>link_identifier</parameter> n'est pas pr&eacute;cis&eacute;,
     <function>mysql_db_query</function> prendra par d&eacute;faut la derni&egrave;re
     connexion ouverte sur le serveur et si elle n'en trouve pas, elle tentera
     de se connecter, en utilisant la fonction <function>mysql_connect</function>,
     sans arguments.
    </para>
    <para>
     Voir aussi
     <function>mysql_connect</function> et
     <function>mysql_query</function>.
    </para>
    <note>
     <simpara>
      Cette fonction est obsol&egrave;te, et abandonn&eacute;e depuis PHP 4.0.6.
      Ne l'utilisez plus (ou pas!). Alternative recommand&eacute;e :
      <function>mysql_select_db</function> et <function>mysql_query</function>.
     </simpara>
    </note>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-drop-db">
   <refnamediv>
    <refname>mysql_drop_db</refname>
    <refpurpose>Efface une base de donn&eacute;es MySQL.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>boolean</type><methodname>mysql_drop_db</methodname>
      <methodparam><type>string</type><parameter>database_name</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
       link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_drop_db</function> retourne &true;
     en cas de succ&egrave;s et &false; sinon.
    </para>
    <para>
     <function>mysql_drop_db</function> essaie d'effacer une base
     de donn&eacute;es enti&egrave;re sur le serveur associ&eacute;
     &agrave; l'identifiant de connexion <parameter>link_identifier</parameter>.
    </para>
    <para>
     Voir aussi
     <function>mysql_create_db</function>.
    </para>
    <para>
     Pour des raisons de compatibilit&eacute; ascendante, mysql_drop_db() est toujours
     utilisable.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-errno">
   <refnamediv>
    <refname>mysql_errno</refname>
    <refpurpose>
     Retourne le num&eacute;ro de message d'erreur de la derni&egrave;re
     op&eacute;ration MySQL.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>mysql_errno</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>
       link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_errno</function> retourne le num&eacute;ro de message
     d'erreur de la derni&egrave;re op&eacute;ration MySQL sur la connexion courante,
     ou sur la connexion sp&eacute;cifi&eacute;e avec l'option
     <parameter>link_identifier</parameter>. Les erreurs qui
     sont remont&eacute;es depuis le serveur MySQL ne sont plus des alertes.
     A la place, il faut utiliser <function>mysql_errno</function> pour
     obtenir le num&eacute;ro d'erreur.
     <informalexample>
      <programlisting role="php">
&lt;?php
  mysql_connect("marliesle");
  echo mysql_errno().": ".mysql_error()."&lt;br&gt;";
  mysql_select_db("nonexistentdb");
  echo mysql_errno().": ".mysql_error()."&lt;br&gt;";
  $conn = mysql_query("SELECT * FROM nonexistenttable");
  echo mysql_errno().": ".mysql_error()."&lt;br&gt;";
?&gt;
      </programlisting>
     </informalexample>
    </para>
    <para>
     Voir aussi
     <function>mysql_error</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-error">
   <refnamediv>
    <refname>mysql_error</refname>
    <refpurpose>
     Retourne le texte associ&eacute; avec l'erreur g&eacute;n&eacute;r&eacute;e
     lors de la derni&egrave;re requ&ecirc;te.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>mysql_error</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>
       link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_error</function> retourne le dernier message
     d'erreur MySQL sur la connexion courante, ou sur la connexion
     sp&eacute;cifi&eacute;e avec <parameter>link_identifier</parameter>.
    </para>
    <para>
     Les erreurs g&eacute;n&eacute;r&eacute;es par mySQL ne se
     transforment plus en alerte. A la place, elles sont accessibles
     via ces fonctions :
     <informalexample>
      <programlisting role="php">
&lt;?php
  mysql_connect("marliesle");
  echo mysql_errno().": ".mysql_error()."&lt;br&gt;";
  mysql_select_db("nonexistentdb");
  echo mysql_errno().": ".mysql_error()."&lt;br&gt;";
  $conn = mysql_query("SELECT * FROM nonexistenttable");
  echo mysql_errno().": ".mysql_error()."&lt;br&gt;";
?&gt;
      </programlisting>
     </informalexample>
    </para>
    <para>
     Voir aussi
     <function>mysql_errno</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-escape-string">
   <refnamediv>
    <refname>mysql_escape_string</refname>
    <refpurpose>
     Prot&egrave;ge une cha&icirc;ne pour la passer &agrave; mysql_query.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>mysql_escape_string</methodname>
      <methodparam><type>string</type><parameter>unescaped_string</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_escape_string</function> va prot&eacute;ger tous les caract&egrave;res de
     la cha&icirc;ne <parameter>unescaped_string</parameter>, pour pouvoir l'utiliser
     directement dans une requ&ecirc;te <function>mysql_query</function>. Elle retourne
     la cha&icirc;ne modifi&eacute;e.
    </para>
    <note>
     <simpara>
      <function>mysql_escape_string</function> n'&eacute;chappe pas les caract&egrave;res
      pourcentage <literal>%</literal> ou  <literal>_</literal>.
     </simpara>
    </note>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-fetch-array">
   <refnamediv>
    <refname>mysql_fetch_array</refname>
    <refpurpose>
     Retourne une ligne de r&eacute;sultat sous la forme d'un tableau
     associatif.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>array</type><methodname>mysql_fetch_array</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>
       result_type
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_fetch_array</function> retourne un tableau qui
     contient la ligne demand&eacute;e, ou &false;
     si il ne reste plus de ligne.
    </para>
    <para>
     <function>mysql_fetch_array</function> est une version &eacute;tendue de
     <function>mysql_fetch_row</function>. En plus d'enregistrer les
     donn&eacute;es
     sous forme d'un tableau &agrave; indice num&eacute;rique, elle peut aussi
     les enregistrer dans un tableau associatif, en utilisant les noms des
     champs comme indices.
    </para>
    <para>
     Si plusieurs colonnes portent le m&ecirc;me nom, la derni&egrave;re colonne
     aura la priorit&eacute;. Pour acc&eacute;der aux autres colonnes du
     m&ecirc;me nom, vous devez utiliser l'index num&eacute;rique, ou
     faire un alias pour chaque colonne.
     <informalexample>
      <programlisting role="sql">
select t1.f1 as foo t2.f1 as bar from t1, t2
      </programlisting>
     </informalexample>
    </para>
    <para>
     Il est important de souligner que <function>mysql_fetch_array</function> N'est PAS
     plus lente que <function>mysql_fetch_row</function>, tandis qu'elle ajoute un
     confort d'utilisation notable.
    </para>
    <para>
     L'option <parameter>result_type</parameter> de
     <function>mysql_fetch_array</function> est une constante qui peut prendre les
     valeurs suivantes  : MYSQL_ASSOC, MYSQL_NUM et MYSQL_BOTH.
    </para>
    <para>
     Voir aussi
     <function>mysql_fetch_row</function>.
    </para>
    <example>
     <title>mysql fetch array</title>
     <programlisting role="php">
&lt;?php
  mysql_connect($host,$user,$password);
  $result = mysql_db_query("database","select * from table");
  while($row = mysql_fetch_array($result)) {
    echo $row["user_id"];
    echo $row["fullname"];
  }
  mysql_free_result($result);
?&gt;
     </programlisting>
    </example>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-fetch-assoc">
   <refnamediv>
    <refname>mysql_fetch_assoc</refname>
    <refpurpose>
     Lit une ligne de r&eacute;sultats dans un tableau associatif
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>array</type><methodname>mysql_fetch_assoc</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_fetch_assoc</function> retourne un tableau associatif
     qui contient la ligne lue, ou bien &false;,
     si il ne reste plus de lignes.
    </para>
    <para>
     <function>mysql_fetch_assoc</function> est &eacute;quivalente &agrave;
     <function>mysql_fetch_array</function> utilis&eacute;e avec l'option
     MYSQL_ASSOC.
     Elle ne retourne qu'un tableau associatif. C'est le fonctionnement
     original de <function>mysql_fetch_array</function>. Si vous avez besoin
     d'indices num&eacute;riques, utilisez <function>mysql_fetch_array</function>.
    </para>
    <para>
     Si plusieurs colonnes portent le m&ecirc;me nom, la derni&egrave;re aura la priorit&eacute;.
     Pour acc&eacute;der aux autres colonnes du m&ecirc;me nom, vous devez utiliser
     <function>mysql_fetch_array</function> et les indices num&eacute;riques.
    </para>
    <para>
     Une chose importante &agrave; noter est que <function>mysql_fetch_assoc</function>
     n'est PAS significativement plus lente que
     <function>mysql_fetch_row</function>, alors qu'elle apporte un confort
     d'utilisation important.
    </para>
    <para>
     Pour plus de d&eacute;tails, reportez-vous &agrave;
     <function>mysql_fetch_row</function> et <function>mysql_fetch_array</function>.
    </para>
    <example>
     <title><function>mysql_fetch_assoc</function></title>
     <programlisting role="php">
&lt;?php
  mysql_connect($host, $user, $password);
  $result = mysql_db_query("database","select * from table");
  while ($row = mysql_fetch_assoc ($result)) {
    echo $row["user_id"];
    echo $row["fullname"];
  }
  mysql_free_result ($result);
?&gt;
     </programlisting>
    </example>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-fetch-field">
   <refnamediv>
    <refname>mysql_fetch_field</refname>
    <refpurpose>
     Retourne les donn&eacute;es enregistr&eacute;es dans une colonne
     sous forme d'objet.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>object</type><methodname>mysql_fetch_field</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>
       field_offset
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_fetch_field</function> retourne un objet contenant
     les donn&eacute;es, lu dans le r&eacute;sultat <parameter>result_identifier</parameter>.
    </para>
    <para>
     <function>mysql_fetch_field</function> sert &agrave; obtenir des
     informations &agrave; propos des champs, dans certaines requ&ecirc;tes.
     Si l'offset du champs n'est pas sp&eacute;cifi&eacute;, le champs
     suivant le dernier champs retourn&eacute;, est retourn&eacute;.
    </para>
    <para>
     Les propri&eacute;t&eacute;s de l'objet sont :
     <itemizedlist>
      <listitem>
       <simpara>
        name - nom de la colonne
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        table - nom de la table de la colonne
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        max_length - taille maximale de la colonne
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	not_null - 1 si la colonne ne peut pas &ecirc;tre &null; (attribut NOT
	&null;)
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        primary_key - 1 si la colonne est une cl&eacute; primaire (attribut PRIMARY KEY)
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        unique_key - 1 si la colonne est une cl&eacute; unique (attribut UNIQUE)
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        multiple_key - 1 si la colonne est une cl&eacute; non-unique
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        numeric - 1 si la colonne est num&eacute;rique
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        blob - 1 si la colonne est BLOB
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        type - le type de la colonne
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        unsigned - 1 si la colonne est non sign&eacute;e
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        zerofill - 1 si la colonne est compl&eacute;t&eacute;e par des z&eacute;ros.
       </simpara>
      </listitem>
     </itemizedlist>
    </para>
    <para>
     Voir aussi
     <function>mysql_field_seek</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-fetch-lengths">
   <refnamediv>
    <refname>mysql_fetch_lengths</refname>
    <refpurpose>
     Retourne la taille de chaque colonne d'une ligne de r&eacute;sultat.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>array</type><methodname>mysql_fetch_lengths</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_fetch_lengths</function> retourne un tableau avec
     la taille de chaque colonne de la derni&egrave;re ligne retourn&eacute;e
     par <function>mysql_fetch_row</function>, sinon &false;.
    </para>
    <para>
     <function>mysql_fetch_lengths</function> stocke les tailles de chaque colonne
     de la derni&egrave;re ligne retourn&eacute;e par <function>mysql_fetch_row</function>,
     <function>mysql_fetch_array</function> et
     <function>mysql_fetch_object</function> dans un tableau, en commen&ccedil;ant &agrave; la
     position.
    </para>
    <para>
     Voir aussi
     <function>mysql_fetch_row</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-fetch-object">
   <refnamediv>
    <refname>mysql_fetch_object</refname>
    <refpurpose>Retourne les lignes r&eacute;sultats sous la forme d'un objet.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>object</type><methodname>mysql_fetch_object</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>
       result_type
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_fetch_object</function> retourne un objet dont les
     propri&eacute;t&eacute;s correspondent &agrave; une ligne d'un
     r&eacute;sultat, ou &false; si il n'y a plus
     d'autres lignes.
    </para>
    <para>
     <function>mysql_fetch_object</function> est identique &agrave;
     <function>mysql_fetch_array</function>, &agrave; la
     diff&eacute;rence qu'elle retourne un objet &agrave; la place
     d'un tableau. Vous pourrez ainsi acc&eacute;der aux valeurs
     des champs par leur nom, mais plus par leur offset (les
     nombres ne sont pas des noms MySQL).
    </para>
    <para>
     L'argument optionnel <parameter>result_type</parameter> est une constante qui
     peut prendre les valeurs suivantes : MYSQL_ASSOC, MYSQL_NUM et MYSQL_BOTH.
    </para>
    <para>
     Concernant la vitesse, <function>mysql_fetch_object</function> est
     aussi rapide que <function>mysql_fetch_array</function> et presque
     aussi rapide que <function>mysql_fetch_row</function> (la
     diff&eacute;rence est insignifiante)
     <example>
      <title>mysql fetch object</title>
      <programlisting role="php">
&lt;?php
  mysql_connect($host,$user,$password);
  $result = mysql_db_query("database","select * from table");
  while($row = mysql_fetch_object($result)) {
    echo $row->user_id;
    echo $row->fullname;
  }
  mysql_free_result($result);
?&gt;
      </programlisting>
     </example>
    </para>
    <para>
     Voir aussi
     <function>mysql_fetch_array</function> et
     <function>mysql_fetch_row</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-fetch-row">
   <refnamediv>
    <refname>mysql_fetch_row</refname>
    <refpurpose>Retourne une ligne de r&eacute;sultat sous la forme d'un tableau.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>array</type><methodname>mysql_fetch_row</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
     </methodsynopsis>
    <para>
      <function>mysql_fetch_row</function> retourne un tableau
      &eacute;num&eacute;r&eacute; qui correspond &agrave; la ligne
      demand&eacute;e, ou &false; s'il ne reste plus de ligne.
    </para>
    <para>
     <function>mysql_fetch_row</function> va rechercher une ligne dans le
     r&eacute;sultat associ&eacute; &agrave; l'identifiant de r&eacute;sultat
     sp&eacute;cifi&eacute;. La ligne est retourn&eacute;e sous la forme d'un
     tableau. Chaque colonne est enregistr&eacute;e sous la forme d'un tableau
     commen&ccedil;ant &agrave; la position <literal>0</literal>.
    </para>
    <para>
     Les appels suivants &agrave; <function>mysql_fetch_row</function>
     retourneront la ligne suivante dans le r&eacute;sultat, ou &false; si il
     n'y a plus de ligne disponible.
    </para>
    <para>
     Voir aussi
     <function>mysql_fetch_array</function>,
     <function>mysql_fetch_object</function>,
     <function>mysql_data_seek</function>,
     <function>mysql_fetch_lengths</function> et
     <function>mysql_result</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-field-flags">
   <refnamediv>
    <refname>mysql_field_flags</refname>
    <refpurpose>
     Retourne le s&eacute;maphore associ&eacute; &agrave; la colonne
     sp&eacute;cifi&eacute;e dans le r&eacute;sultat courant.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>mysql_field_flags</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_offset</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_field_flags</function> retourne le s&eacute;maphore
     associ&eacute; au champs sp&eacute;cifi&eacute; par
     <parameter>field_offset</parameter>. Les s&eacute;maphores sont retourn&eacute;s
     comme des mots, s&eacute;par&eacute;s par des espaces, ce qui les
     rend faciles &agrave; s&eacute;parer, avec la commande <function>explode</function>.
    </para>
    <para>
     Les valeurs suivantes (pour une version suffisamment r&eacute;cente de MySQL) sont
     disponibles : "not_null", "primary_key", "unique_key", "multiple_key", "blob",
     "unsigned", "zerofill", "binary", "enum", "auto_increment", "timestamp".
    </para>
    <para>
     Pour des raisons de compatibilit&eacute; ascendante, mysql_fieldflags()
     peut encore &ecirc;tre utilis&eacute;.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-field-name">
   <refnamediv>
    <refname>mysql_field_name</refname>
    <refpurpose>
     Retourne le nom d'une colonne
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>mysql_field_name</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_index</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_field_name</function> retourne le nom d'une colonne.
     Les arguments de la fonction sont un identifiant de r&eacute;sultat
     <parameter>result_identifier</parameter> et l'index du champs,
     ie.<literal>mysql_field_name($result,2);</literal>.
    </para>
    <para>
     <function>mysql_field_name</function> retournera le nom du
     deuxi&egrave;me champs dans le r&eacute;sultat associ&eacute;
     &agrave; $result.
    </para>
    <para>
     Pour des raisons de compatibilit&eacute; ascendante, mysql_fieldname()
     peut encore &ecirc;tre utilis&eacute;.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-field-len">
   <refnamediv>
    <refname>mysql_field_len</refname>
    <refpurpose>
     Retourne la longueur du champs sp&eacute;cifi&eacute;.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>mysql_field_len</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_offset</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_field_len</function> retourne la taille du champs
     sp&eacute;cifi&eacute; par son offset <parameter>field_offset</parameter>.
    </para>
    <para>
     Pour des raisons de compatibilit&eacute; ascendante, mysql_fieldlen()
     peut encore &ecirc;tre utilis&eacute;.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-field-seek">
   <refnamediv>
    <refname>mysql_field_seek</refname>
    <refpurpose>
     D&eacute;place le pointeur de r&eacute;sultat
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>mysql_field_seek</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_offset</parameter></methodparam>
     </methodsynopsis>
    <para>
     Place le pointeur de r&eacute;sultat sur le champs sp&eacute;cifi&eacute;. Lors du prochain appel &agrave;
     <function>mysql_fetch_field</function> qui n'aura pas d'argument d'index de
     champs, le champs d&eacute;sormais point&eacute; sera retourn&eacute;.
    </para>
    <para>
     Voir aussi
     <function>mysql_fetch_field</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-field-table">
   <refnamediv>
    <refname>mysql_field_table</refname>
    <refpurpose>
     Retourne le nom de la table o&ugrave; se trouve une colonne
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>mysql_field_table</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_offset</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_field_table</function> retourne le nom de la table
     o&ugrave; se trouve une colonne. Pour des raisons de compatibilit&eacute;
     ascendante, mysql_fieldtable() peut encore &ecirc;tre utilis&eacute;.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-field-type">
   <refnamediv>
    <refname>mysql_field_type</refname>
    <refpurpose>
     Retourne le type de la colonne sp&eacute;cifi&eacute;e dans le r&eacute;sultat courant.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>mysql_field_type</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
      <methodparam><type>int</type><parameter>field_offset</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_field_type</function> est similaire &agrave; la fonction
     <function>mysql_field_name</function>. Les arguments sont identiques, mais c'est
     le type du champs qui est retourn&eacute;. Il vaudra "int", "real", "string", "blob", ou
     d'autres, comme d&eacute;taill&eacute; dans la documentation MySQL.
     <example>
      <title>Types mysql field</title>
      <programlisting role="php">
&lt;?php
  mysql_connect("localhost:3306");
  mysql_select_db("wisconsin");
  $result = mysql_query("SELECT * FROM onek");
  $fields = mysql_num_fields($result);
  $rows   = mysql_num_rows($result);
  $i = 0;
  $table = mysql_field_table($result, $i);
  echo "Your '".$table."' table has ".$fields." fields et ".$rows." records &lt;br&gt;";
  echo "The table has the following fields &lt;br&gt;";
  while ($i &lt; $fields) {
    $type  = mysql_field_type($result, $i);
    $name  = mysql_field_name($result, $i);
    $len   = mysql_field_len($result, $i);
    $flags = mysql_field_flags($result, $i);
    echo $type." ".$name." ".$len." ".$flags."&lt;br&gt;";
    $i++;
  }
  mysql_close();
?&gt;
      </programlisting>
     </example>
    </para>
    <para>
     Pour des raisons de compatibilit&eacute; ascendante, mysql_fieldtype()
     peut encore &ecirc;tre utilis&eacute;.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-free-result">
   <refnamediv>
    <refname>mysql_free_result</refname>
    <refpurpose>Efface le r&eacute;sultat de la m&eacute;moire.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>mysql_free_result</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_free_result</function> n'est &agrave; appeler que si
     vous avez peur d'utiliser trop de m&eacute;moire durant l'ex&eacute;cution
     de votre script. Toute la m&eacute;moire associ&eacute;e &agrave;
     l'identifiant de r&eacute;sultat sera automatiquement lib&eacute;r&eacute;e.
    </para>
    <para>
     Pour des raisons de compatibilit&eacute; ascendante, mysql_freeresult()
     peut encore &ecirc;tre utilis&eacute;.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-insert-id">
   <refnamediv>
    <refname>mysql_insert_id</refname>
    <refpurpose>
     Retourne l'identifiant g&eacute;n&eacute;r&eacute; par la derni&egrave;re
     requ&ecirc;te INSERT.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>mysql_insert_id</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>
       link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_insert_id</function> retourne le dernier identifiant
     g&eacute;n&eacute;r&eacute; par un champs de type AUTO_INCREMENT,
     sur la connexion MySQL courante, ou bien s&ucirc;r la connexion
     sp&eacute;cifi&eacute;e par <parameter>link_identifier</parameter>.
     <function>mysql_insert_id</function> ne prend aucun argument. Elle
     retourne le dernier identifiant g&eacute;n&eacute;r&eacute; par la
     derni&egrave;re fonction INSERT effectu&eacute;e.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-list-dbs">
   <refnamediv>
    <refname>mysql_list_dbs</refname>
    <refpurpose>
     Liste les bases de donn&eacute;es disponibles sur le serveur MySQL.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>resource</type><methodname>mysql_list_dbs</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>
       link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_list_dbs</function> retournera un identifiant de
     r&eacute;sultat, qui contiendra les noms des bases de donn&eacute;es
     disponibles sur la connexion MySQL courante, ou bien s&ucirc;r la connexion
     sp&eacute;cifi&eacute;e par <parameter>link_identifier</parameter>.
     Utilisez la fonction <function>mysql_tablename</function> pour lire
     toutes les bases de donn&eacute;es.
    </para>
    <para>
     Pour des raisons de compatibilit&eacute; ascendante, mysql_listdbs()
     est encore disponible.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-list-fields">
   <refnamediv>
    <refname>mysql_list_fields</refname>
    <refpurpose>Liste les champs du r&eacute;sultat MySQL.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>resource</type><methodname>mysql_list_fields</methodname>
      <methodparam><type>string</type><parameter>database_name</parameter></methodparam>
      <methodparam><type>string</type><parameter>table_name</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
       link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_list_fields</function> recherche les informations
     relatives &agrave; la table <parameter>table_name</parameter> sur la connexion
     MySQL courante, ou bien s&ucirc;r la connexion sp&eacute;cifi&eacute;e par
     <parameter>link_identifier</parameter>. Les arguments
     sont la base de donn&eacute;es et le nom de la table. Un
     pointeur de r&eacute;sultat est retourn&eacute; et pourra
     &ecirc;tre pass&eacute; &agrave;
     <function>mysql_field_flags</function>,
     <function>mysql_field_len</function>,
     <function>mysql_field_name</function> et
     <function>mysql_field_type</function>.
    </para>
    <para>
     Un identifiant de r&eacute;sultat est un entier positif. La fonction retourne -1
     si une erreur survient. Une cha&icirc;ne d&eacute;crivant le probl&egrave;me
     rencontr&eacute; sera plac&eacute;e dans la variable
     <literal>$phperrmsg</literal> et, &agrave; moins que la fonction n'ait
     &eacute;t&eacute; appel&eacute;e sous la forme <literal>&#64;mysql()</literal>,
     cette erreur sera aussi affich&eacute;e.
    </para>
    <para>
     Pour des raisons de compatibilit&eacute; ascendante, mysql_listfields()
     est encore disponible.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-list-tables">
   <refnamediv>
    <refname>mysql_list_tables</refname>
    <refpurpose>Liste les tables d'une base de donn&eacute;es.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>resource</type><methodname>mysql_list_tables</methodname>
      <methodparam><type>string</type><parameter>database</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
       link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_list_tables</function> prend le nom d'une base de
     donn&eacute;es <parameter>database</parameter> et retourne un identifiant
     de r&eacute;sultat, qui contiendra la liste des tables sur la connexion MySQL
     courante, ou bien s&ucirc;r la connexion sp&eacute;cifi&eacute;e par
     <parameter>link_identifier</parameter>. La fonction
     <function>mysql_tablename</function> est le meilleur moyen
     d'extraire les noms des tables depuis l'identifiant de r&eacute;sultat.
    </para>
    <para>
     Pour des raisons de compatibilit&eacute; ascendante, mysql_listtables()
     est encore disponible.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-num-fields">
   <refnamediv>
    <refname>mysql_num_fields</refname>
    <refpurpose>Retourne le nombre de champs d'un r&eacute;sultat.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>mysql_num_fields</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_num_fields</function> retourne le nombre de champs du
     r&eacute;sultat <parameter>result_identifier</parameter>.
    </para>
    <para>
     Voir aussi
     <function>mysql_db_query</function>,
     <function>mysql_query</function>,
     <function>mysql_fetch_field</function> et
     <function>mysql_num_rows</function>.
    </para>
    <para>
     Pour des raisons de compatibilit&eacute; ascendante mysql_numfields()
     est encore disponible.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-num-rows">
   <refnamediv>
    <refname>mysql_num_rows</refname>
    <refpurpose>Retourne le nombre de lignes d'un r&eacute;sultat.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>mysql_num_rows</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_num_rows</function> retourne le nombre de lignes
     d'un r&eacute;sultat. Cette commande n'est valide que pour les commandes
     SELECT . Pour conna&icirc;tre le nombre de lignes retourn&eacute;es par
     INSERT, UPDATE ou DELETE, utilisez
     <function>mysql_affected_rows</function>.
    </para>
    <example>
     <title>
      Exemple <function>mysql_num_rows</function> par crubel&#64;trilizio.org
     </title>
     <programlisting role="php">
&lt;?php
  $conn = mysql_connect("adresse de l'h&ocirc;te", "utilisateur", "mot de passe");
  mysql_select_db("base",$conn); // n&eacute;cessaire si vous avez plusieurs bases
  $Resultfornummembers = mysql_query("SELECT * FROM Accounts",$conn);
  $NumMembers = mysql_num_rows($Resultfornummembers);
  echo "$NumMembers Membres";
?&gt;
     </programlisting>
    </example>
    <para>
     Voir aussi
     <function>mysql_db_query</function>,
     <function>mysql_query</function> et
     <function>mysql_fetch_row</function>.
    </para>
    <para>
     Pour des raisons de compatibilit&eacute; ascendante mysql_numrows() est encore
     disponible.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-pconnect">
   <refnamediv>
    <refname>mysql_pconnect</refname>
    <refpurpose>
     Ouvre une connexion persistante &agrave; un serveur MySQL.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>resource</type><methodname>mysql_pconnect</methodname>
      <methodparam choice="opt"><type>string</type><parameter>
       server
       </parameter></methodparam>
      <methodparam choice="opt"><type>string</type><parameter>username</parameter></methodparam>
      <methodparam choice="opt"><type>string</type><parameter>password</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_pconnect</function> retourne un lien persistant positif en
     cas de succ&egrave;s et sinon &false; en cas d'erreur.
    </para>
    <para>
     <function>mysql_pconnect</function> &eacute;tablit une connexion
     persistante &agrave; un serveur MySQL. Tous les arguments sont
     optionnels et des valeurs par d&eacute;faut seront utilis&eacute;r
     en cas d'omission ('<literal>localhost</literal>', nom d'utilisateur
     propri&eacute;taire du processus, mot de passe vide).
    </para>
    <para>
     Le nom de l'h&ocirc;te peut aussi inclure le num&eacute;ro de port,
     c'est-&agrave;-dire &quot;hostname:port&quot; ou un chemin jusqu'&agrave;
     la socket <literal>:/path/to/socket</literal> pour l'h&ocirc;te local.
     <note>
      <para>
       Le support de &quot;:port&quot; a &eacute;t&eacute; ajout&eacute;
       &agrave; partir de la version 3.0B4.
      </para>
      <para>
       Le support de &quot;:/path/to/socket&quot; a &eacute;t&eacute;
       ajout&eacute; &agrave; partir de la version 3.0.10.
      </para>
     </note>
    </para>
    <para>
     <function>mysql_pconnect</function> se comporte exactement comme
     <function>mysql_connect</function>, mais avec deux diff&eacute;rences majeures :
    </para>
    <para>
     Premi&egrave;rement, lors de la connexion, la fonction essaie de trouver une
     connexion permanente d&eacute;j&agrave; ouverte sur cet h&ocirc;te, avec le
     m&ecirc;me nom d'utilisateur et de mot de passe. Si une telle connexion
     est trouv&eacute;e, son identifiant est retourn&eacute;, sans ouvrir de
     nouvelle connexion.
    </para>
    <para>
     Deuxi&egrave;mement, la connexion au serveur MySQL ne sera pas termin&eacute;e avec la fin
     du script. Au lieu de cela, le lien sera conserv&eacute; pour un prochain acc&egrave;s
     (<function>mysql_close</function> ne terminera pas une connexion persistante
     &eacute;tablie par <function>mysql_pconnect</function>).
    </para>
    <para>
     C'est pourquoi ce type de connexion est dite 'persistante'.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-unbuffered-query">
   <refnamediv>
    <refname>mysql_unbuffered_query</refname>
    <refpurpose>
     Ex&eacute;cute une requ&ecirc;te SQL sans mobiliser les r&eacute;sultats
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>resource</type><methodname>mysql_unbuffered_query</methodname>
      <methodparam><type>string</type><parameter>query</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>link_identifier</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>result_mode</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_unbuffered_query</function> envoie la requ&ecirc;te
     SQL <parameter>query</parameter> au serveur MySQL identifi&eacute; par
     <parameter>link_identifier</parameter>, sans pr&eacute;parer les r&eacute;sultats
     pour la lecture, comme le fait <function>mysql_query</function>.
     D'une part, cela r&eacute;duit consid&eacute;rablement la consommation de
     m&eacute;moire par MySQL, lorsque les requ&ecirc;tes g&eacute;n&egrave;re
     des r&eacute;sultats de grandes tailles. D'autre part, vous pourrez utiliser les
     r&eacute;sultats d&egrave;s que la premi&egrave;re ligne aura &eacute;t&eacute;
     lue : pas besoin d'attendre que la requ&ecirc;te ait compl&egrave;tement
     &eacute;t&eacute; ex&eacute;cut&eacute;e.
    </para>
    <note>
     <para>
      L'int&eacute;r&ecirc;t de <function>mysql_unbuffered_query</function>
      est temp&eacute;r&eacute; par une limitation : <function>mysql_num_rows</function>
      ne fonctionne pas sur une ressource retourn&eacute;e par
      <function>mysql_unbuffered_query</function>. Vous devez aussi lire tous
      les r&eacute;sultats d'une premi&egrave;re requ&ecirc;te ex&eacute;cut&eacute;e
      avec <function>mysql_unbuffered_query</function>, avant de pouvoir en
      ex&eacute;cuter une autre.
     </para>
    </note>
    <para>
     Voir aussi
     <function>mysql_query</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-query">
   <refnamediv>
    <refname>mysql_query</refname>
    <refpurpose>Envoie une requ&ecirc;te SQL &agrave; un serveur MySQL.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>resource</type><methodname>mysql_query</methodname>
      <methodparam><type>string</type><parameter>query</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>link_identifier</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_query</function> envoie une requ&ecirc;te SQL &agrave;
     la base de donn&eacute;es actuellement active sur le serveur MysQL. Si
     <parameter>link_identifier</parameter> n'est pas pr&eacute;cis&eacute;,
     la derni&egrave;re connexion est utilis&eacute;e. Si aucune connexion n'a
     &eacute;t&eacute; ouverte, la fonction tentera d'en ouvrir une, avec la fonction
     <function>mysql_connect</function> mais sans aucun param&egrave;tre
     (c'est-&agrave;-dire avec les valeurs par d&eacute;faut).
    </para>
    <para>
     <function>mysql_query</function> retourne &true; ou
     &false;, pour indiquer le succ&egrave;s ou l'&eacute;chec
     de la requ&ecirc;te. En cas de retour &true;, la
     requ&ecirc;te &eacute;tait valide et a pu &ecirc;tre ex&eacute;cut&eacute;
     sur le serveur. Cela n'indique pas le nombre de lignes affect&eacute;es,
     ou retourn&eacute;es. Il est parfaitement possible qu'une requ&ecirc;te
     valide n'affecte aucune ligne ou ne retourne aucune ligne.
    </para>
    <para>
     L'exemple suivant est syntaxiquement invalide, ce qui conduit
     <function>mysql_query</function> &agrave; l'&eacute;chec et retourne
     &false;:
     <example>
      <title><function>mysql_query</function></title>
      <programlisting role="php">
&lt;?php
  $result = mysql_query ("SELECT * WHERE 1=1")
    or die ("Requ&ecirc;te invalide");
?&gt;
      </programlisting>
     </example>
    </para>
    <para>
      L'exemple suivant est s&eacute;mantiquement invalide si
      <literal>my_col</literal> n'est pas une colonne de la table
      <literal>my_tbl</literal>, ce qui conduit
      <function>mysql_query</function> &agrave; l'&eacute;chec et retourne
      &false; :
     <example>
      <title><function>mysql_query</function></title>
      <programlisting role="php">
&lt;?php
  $result = mysql_query ("SELECT my_col FROM my_tbl")
    or die ("Requ&ecirc;te invalide");
?&gt;
      </programlisting>
     </example>
    </para>
    <para>
     <function>mysql_query</function> &eacute;chouera aussi et retournera aussi
     &false; si les droits d'acc&egrave;s ne sont pas suffisants.
    </para>
    <para>
     En supposant que la requ&ecirc;te r&eacute;ussisse, vous pouvez appeler
     <function>mysql_affected_rows</function>  pour conna&icirc;tre le nombre de
     lignes affect&eacute;es (pour les commandes DELETE, INSERT, REPLACE, ou
     UPDATE ).
     Pour les commandes SELECT , <function>mysql_query</function> retourne un
     identifiant de r&eacute;sultat que vous pouvez passer &agrave;
     <function>mysql_result</function>. Lorsque vous avez termin&eacute;
     avec le r&eacute;sultat, lib&eacute;rez la m&eacute;moire avec
     <function>mysql_free_result</function>.
    </para>
    <para>
     Voir aussi
     <function>mysql_affected_rows</function>,
     <function>mysql_unbuffered_query</function>,
     <function>mysql_db_query</function>,
     <function>mysql_free_result</function>,
     <function>mysql_result</function>,
     <function>mysql_select_db</function> et
     <function>mysql_connect</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-result">
   <refnamediv>
    <refname>mysql_result</refname>
    <refpurpose>Retourne un champs d'un r&eacute;sultat.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>mixed</type><methodname>mysql_result</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
      <methodparam><type>int</type><parameter>row</parameter></methodparam>
      <methodparam choice="opt"><type>mixed</type><parameter>
       field
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_result</function> retourne le contenu d'un champs dans
     le r&eacute;sultat MySQL <parameter>result_identifier</parameter>.
     L'argument <parameter>field</parameter> peut-&ecirc;tre un offset de champs,
     ou le nom d'un champs, ou le nom de
     la table + point + le nom du champs ("table.champs"). Si la colonne a
     &eacute;t&eacute; alias&eacute;e, utilisez de pr&eacute;f&eacute;rence
     l'alias.
    </para>
    <para>
     Lorsque vous travaillez sur des r&eacute;sultats de grande taille,
     il est conseill&eacute; d'utiliser une des fonctions qui vont rechercher une ligne
     enti&egrave;re dans un tableau. Ces fonctions sont NETTEMENT plus
     rapides. De plus, utiliser un offset num&eacute;riques est
     aussi beaucoup plus rapide que sp&eacute;cifier un nom litt&eacute;ral.
    </para>
    <para>
     Les appels <function>mysql_result</function> ne devraient pas &ecirc;tre
     m&eacute;lang&eacute;s avec d'autres fonctions qui travaillent aussi sur
     le r&eacute;sultat.
    </para>
    <para>
     Alternatives &agrave; haut rendement, RECOMMANDEES :
     <function>mysql_fetch_row</function>,
     <function>mysql_fetch_array</function> et
     <function>mysql_fetch_object</function>.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-select-db">
   <refnamediv>
    <refname>mysql_select_db</refname>
    <refpurpose>S&eacute;lectionne une base de donn&eacute;es MySQL.</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>int</type><methodname>mysql_select_db</methodname>
      <methodparam><type>string</type><parameter>database_name</parameter></methodparam>
      <methodparam choice="opt"><type>resource</type><parameter>
       link_identifier
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_select_db</function> retourne &true;
     en cas de succ&egrave;s, &false; sinon.
    </para>
    <para>
     <function>mysql_select_db</function> change la base de donn&eacute;es
     active sur la connexion repr&eacute;sent&eacute;e par
     <parameter>link_identifier</parameter>. Si aucun identifiant
     n'est sp&eacute;cifi&eacute;, la
     derni&egrave;re connexion est utilis&eacute;e. S'il n'y a pas de
     derni&egrave;re connexion, la fonction tentera de se connecter seule, avec
     <function>mysql_connect</function> et les param&egrave;tres par
     d&eacute;faut.
    </para>
    <para>
     Toutes les requ&ecirc;tes suivantes avec <function>mysql_query</function>
     seront faites avec la base de donn&eacute;es active.
    </para>
    <para>
     Voir aussi
     <function>mysql_connect</function>,
     <function>mysql_pconnect</function> et
     <function>mysql_query</function>.
    </para>
    <para>
     Pour des raisons de compatibilit&eacute; ascendante mysql_selectdb() est
     encore disponible.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-tablename">
   <refnamediv>
    <refname>mysql_tablename</refname>
    <refpurpose>
     Lit le nom de la table qui contient le champs sp&eacute;cifi&eacute;.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>mysql_tablename</methodname>
      <methodparam><type>resource</type><parameter>result_identifier</parameter></methodparam>
      <methodparam><type>int</type><parameter>i</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_tablename</function> prend le pointeur de r&eacute;sultat
     obtenu avec <function>mysql_list_tables</function> ou bien un index entier
     et retourne le nom de la table. La fonction <function>mysql_num_rows</function>
     peut &ecirc;tre utilis&eacute;e pour d&eacute;terminer le nombre de
     tables dans le pointeur de r&eacute;sultat.
     <example>
      <title>Exemple <function>mysql_tablename</function></title>
      <programlisting role="php">
&lt;?php
  mysql_connect("localhost:3306");
  $result = mysql_list_tables ("wisconsin");
  $i = 0;
  while ($i &lt; mysql_num_rows($result)) {
    $tb_names[$i] = mysql_tablename ($result, $i);
    echo $tb_names[$i] . "&lt;br&gt;";
    $i++;
  }
?&gt;
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-get-client-info">
   <refnamediv>
    <refname>mysql_get_client_info</refname>
    <refpurpose>Lit les informations sur le client MySQL</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>mysql_get_client_info</methodname>
      <methodparam><type>void</type><parameter/></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_get_client_info</function> retourne une cha&icirc;ne
     qui repr&eacute;sente le num&eacute;ro de version du client utilis&eacute; par PHP.
    </para>
    <para>
     <function>mysql_get_client_info</function> a &eacute;t&eacute; ajout&eacute;e en PHP 4.0.5.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-get-host-info">
   <refnamediv>
    <refname>mysql_get_host_info</refname>
    <refpurpose>Lit les informations sur l'h&ocirc;te MySQL</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>mysql_get_host_info</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>link_identifier</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_get_host_info</function>retourne une cha&icirc;ne
     qui repr&eacute;sente le type de connexion utilis&eacute; avec la connexion
     <parameter>link_identifier</parameter>, y compris le nom du serveur h&ocirc;te.
     Si <parameter>link_identifier</parameter> est omis, la derni&egrave;re connexion
     ouverte est utilis&eacute;e.
    </para>
    <para>
     <function>mysql_get_host_info</function> a &eacute;t&eacute; ajout&eacute;e en PHP 4.0.5.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-get-proto-info">
   <refnamediv>
    <refname>mysql_get_proto_info</refname>
    <refpurpose>Lit les informations sur le protocole MySQL</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>mysql_get_proto_info</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>link_identifier</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_get_proto_info</function> retourne une cha&icirc;ne
     qui repr&eacute;sente la version du protocole utilis&eacute; par la connexion
     <parameter>link_identifier</parameter>.
     Si <parameter>link_identifier</parameter> est omis, la derni&egrave;re connexion
     ouverte est utilis&eacute;e.
    </para>
    <para>
     <function>mysql_get_proto_info</function> a &eacute;t&eacute; ajout&eacute;e en PHP 4.0.5.
    </para>
   </refsect1>
  </refentry>
  <refentry id="function.mysql-get-server-info">
   <refnamediv>
    <refname>mysql_get_server_info</refname>
    <refpurpose>Lit les informations sur le serveur MySQL</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Description</title>
     <methodsynopsis>
      <type>string</type><methodname>mysql_get_server_info</methodname>
      <methodparam choice="opt"><type>resource</type><parameter>link_identifier</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>mysql_get_server_info</function> retourne une cha&icirc;ne
     qui repr&eacute;sente la version du serveur, dont la connexion est
     Si <parameter>link_identifier</parameter> est omis, la derni&egrave;re connexion
     ouverte est utilis&eacute;e.
    </para>
    <para>
     <function>mysql_get_server_info</function> a &eacute;t&eacute; ajout&eacute;e en PHP 4.0.5.
    </para>
   </refsect1>
  </refentry>
 </reference>
 <!-- Keep this comment at the end of the file
 Local variables:
 mode: sgml
 sgml-omittag:t
 sgml-shorttag:t
 sgml-minimize-attributes:nil
 sgml-always-quote-attributes:t
 sgml-indent-step:1
 sgml-indent-data:t
indent-tabs-mode:nil
 sgml-parent-document:nil
 sgml-default-dtd-file:"././manual.ced"
 sgml-exposed-tags:nil
 sgml-local-catalogs:nil
 sgml-local-ecat-files:nil
 End:
 -->