doc-fr/reference/sqlite/functions/sqlite-create-aggregate.xml

<?xml version="1.0" encoding="iso-8859-1"?>
<!-- $Revision: 1.10 $ -->
<!-- EN-Revision: 1.10 Maintainer: yannick Status: ready -->
<refentry id="function.sqlite-create-aggregate">
 <refnamediv>
  <refname>sqlite_create_aggregate</refname>
  <refpurpose>Enregistre une UDF agregeante pour les requêtes SQLite</refpurpose>
 </refnamediv>
 <refsect1>
  <title>Description</title>
  <methodsynopsis>
   <type>bool</type><methodname>sqlite_create_aggregate</methodname>
   <methodparam><type>resource</type><parameter>dbhandle</parameter></methodparam>
   <methodparam><type>string</type><parameter>function_name</parameter></methodparam>
   <methodparam><type>callback</type><parameter>step_func</parameter></methodparam>
   <methodparam><type>callback</type><parameter>finalize_func</parameter></methodparam>
   <methodparam choice="opt"><type>int</type><parameter>num_args</parameter></methodparam>
  </methodsynopsis>
  <para>
   <function>sqlite_create_aggregate</function> est similaire à
   <function>sqlite_create_function</function>, car elle enregistre une
   fonction qui sera utilisée pour calculer un résultat agrégé sur plusieurs
   lignes d'une requête.
  </para>
  <para>
   La différence principale entre cette fonction et 
   <function>sqlite_create_function</function> est que deux fonctions sont nécessaires
   pour gérer les agrégations : <parameter>step_func</parameter> est
   appelée pour chaque ligne du résultat. Votre fonction &php; doit accumuler
   le résultat, et le stocker dans le contexte d'agrégation.
   Une fois que toutes les lignes ont été appelées, 
   <parameter>finalize_func</parameter> sera appelée, et elle doit alors
   lire les données dans ce contexte d'agrégation, et en retourner le résultat.
   Les fonctions de callback doivent retourner un type compréhensible par SQLite (i.e.
   <link linkend="language.types.intro">type scalaire</link>).
  </para>
  <para>
   <example>
    <title>Exemple d'UDF SQLite : taille maximale de chaîne</title>
    <programlisting role="php">
<![CDATA[
<?php
$data = array(
   'one',
   'two',
   'three',
   'four',
   'five',
   'six',
   'seven',
   'eight',
   'nine',
   'ten'
   );
$db = sqlite_open(':memory:');
sqlite_query($db, "CREATE TABLE strings(a)");
foreach ($data as $str) {
    $str = sqlite_escape_string($str);
    sqlite_query($db, "INSERT INTO strings VALUES('$str')");
}

function max_len_step(&$context, $string) 
{
  if (strlen($string) > $context) {
    $context = strlen($string);
  }
}

function max_len_finalize(&$context) 
{
  return $context;
}

sqlite_create_aggregate($db, 'max_len', 'max_len_step', 'max_len_finalize');

var_dump(sqlite_array_query($db, 'SELECT max_len(a) from strings'));

?>
]]>
    </programlisting>
   </example>
  </para>
  <para>
   Dans cet exemple, nous créons une fonction d'agrégation qui va calculer
   la taille de la plus longue chaîne dans l'une des colonnes de la table.
   Pour chaque ligne, la fonction <literal>max_len_step</literal> 
   est appelée, et reçoit le paramètre <parameter>context</parameter>. Le contexte
   est une autre variable &php;, et il peut contenir un tableau ou même un objet.
   Dans notre exemple, nous l'utilisons pour stocker la taille maximale 
   de la colonne courante. Si <parameter>string</parameter> est plus grand
   que la valeur maximale que nous avons enregistré, nous modifions notre
   contexte en conséquence.
  </para>
  <para>
   Une fois que toutes les lignes ont été traitées, SQLite appelle la fonction
   <literal>max_len_finalize</literal> pour déterminer le résultat de 
   l'agrégation. Nous pourrions alors effectuer plusieurs calculs en fonction 
   des données que nous avons récolté dans <parameter>context</parameter>.
   Dans notre exemple simple, 
   nous avons calculé le résultat au fur et à mesure de la progression de la requête,
   ce qui nous permet de n'avoir qu'à retourner la valeur de notre contexte.
  </para>
  <note>
   <para>
    L'exemple ci-dessus ne fonctionnera pas correctement si 
    une colonne contient une donnée binaire. Reportez-vous à la fonction
    <function>sqlite_udf_decode_binary</function> pour plus de détails, et d'un
    exemple pour travailler avec des chaînes binaires.
   </para>
  </note>
  <tip>
   <para>
    Il n'est pas recommandé de stocker une copie des valeurs dans le contexte,
    puis de les traiter à la fin, car cela conduirait SQLite à consommer beaucoup
    de mémoire : imaginez simplement la quantité de mémoire que prendrons vos millions
    de lignes de 32 caractères en fin de requête.
   </para>
  </tip>
  <tip>
   <para>
    Vous pouvez utiliser <function>sqlite_create_function</function> et
    <function>sqlite_create_aggregate</function> pour remplacer des fonctions
    natives SQLite.
   </para>
  </tip>
  <para>
   Voir aussi
   <function>sqlite_create_function</function>,
   <function>sqlite_udf_encode_binary</function> et
   <function>sqlite_udf_decode_binary</function>.
  </para>
 </refsect1>
</refentry>
<!-- 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
 sgml-parent-document:nil
 sgml-default-dtd-file:"../../manual.ced"
 sgml-exposed-tags:nil
 sgml-local-catalogs:nil
 sgml-local-ecat-files:nil
 End:
 vim600: syn=xml fen fdm=syntax fdl=2 si
 vim: et tw=78 syn=sgml
 vi: ts=1 sw=1
 -->