intagg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- Dernière modification
     le       $Date$
     par      $Author$
     révision $Revision$ -->

<sect1 id="intagg">
 <title>intagg</title>
 
 <indexterm zone="intagg">
  <primary>intagg</primary>
 </indexterm>

 <para>
  Le module <filename>intagg</filename> fournit un
  agrégateur d'entiers et un énumérateur. <filename>intagg</filename> est
  maintenant obsolète car il existe des fonctions intégrées qui fournissent
  les mêmes fonctionnalités. Néanmoins, le module est toujours disponible
  pour fournir des fonctions de compatibilité.
 </para>

 <sect2>
  <title>Fonctions</title>

 <para>
  L'agrégateur est une fonction d'agrégat
  <function>int_array_aggregate(integer)</function> qui produit un tableau
  d'entiers contenant exactement les entiers fournis en argument.
  Cette fonction appelle <function>array_agg</function> pour des raisons de
  compatibilité.
 </para>

 <para>
  L'énumérateur est une fonction
  <function>int_array_enum(integer[])</function> qui renvoie
  <type>setof integer</type>. C'est essentiellement une opération reverse de
  l'agrégateur&nbsp;: elle étend un tableau d'entiers en un ensemble de
  lignes. Cette fonction appelle <function>unnest</function>, pour des raisons
  de compatibilité.
 </para>

 </sect2>

 <sect2>
  <title>Exemples d'utilisation</title>

  <para>
   Un grand nombre de bases de données utilisent la notion de table <quote>une vers
   plusieurs</quote> (<foreignphrase>one to many</foreignphrase>). Ce type de table
   se trouve habituellement entre deux tables indexés, par exemple&nbsp;:
  </para>

 <programlisting>
CREATE TABLE left (id INT PRIMARY KEY, ...);
CREATE TABLE right (id INT PRIMARY KEY, ...);
CREATE TABLE one_to_many(left INT REFERENCES left, right INT REFERENCES right);
 </programlisting>

 <para>
  Il est typiquement utilisé de cette façon&nbsp;:
 </para>

 <programlisting>
  SELECT right.* from right JOIN one_to_many ON (right.id = one_to_many.right)
    WHERE one_to_many.left = <replaceable>item</replaceable>;
 </programlisting>

 <para>
  Cela renvoie tous les éléments de la table de droite pour un enregistrement
  de la table de gauche donné. Il s'agit d'une construction assez commune en SQL.
 </para>

 <para>
  Cette méthode devient complexe lorsqu'il existe de nombreuses entrées dans la
  table <structname>one_to_many</structname>. Souvent, une jointure
  de ce type résulte en un parcours d'index et une récupération de chaque enregistrement de
  la table de droite pour une entrée particulière de la table de gauche.
  Sur un système dynamique, il n'y a pas grand chose à faire. Au contraire,
  lorsqu'une partie des données est statique, une table de résumé peut être
  créée par agrégation.
 </para>

 <programlisting>
CREATE TABLE summary as
  SELECT left, int_array_aggregate(right) AS right
  FROM one_to_many
  GROUP BY left;
 </programlisting>

 <para>
  Ceci crée une table avec une ligne par élément gauche et un tableau d'éléments
  droits. En l'absence de méthode d'utilisation de tableau, c'est réellement
  inutilisable, d'où l'énumérateur.
 </para>

 <para>
  Exemple&nbsp;:
 </para>
 <programlisting>
SELECT left, int_array_enum(right) FROM summary WHERE left = <replaceable>item</replaceable>;
 </programlisting>

 <para>
  La requête ci-dessus, qui utilise <function>int_array_enum</function>, produit les mêmes résultats
  que celle-ci&nbsp;:
 </para>
 <programlisting>
SELECT left, right FROM one_to_many WHERE left = <replaceable>item</replaceable>;
 </programlisting>
 
 <para>
  La différence tient dans le fait que la requête qui utilise la table de résumé
  ne récupère qu'une ligne de la table alors que la requête directe à
  <structname>one_to_many</structname> doit faire un parcours d'index et
  récupérer une ligne par enregistrement.
 </para>
 <para>
  Sur un système particulier, un <command>EXPLAIN</command> a montré qu'une requête avec
  un coût de 8488 a été réduite à une requête d'un coût de 329. La requête
  originale était une jointure impliquant la table
  <structname>one_to_many</structname>, remplacée par&nbsp;:
 </para>
 <programlisting>
SELECT right, count(right) FROM
  ( SELECT left, int_array_enum(right) AS right
    FROM summary JOIN (SELECT left FROM left_table WHERE left = <replaceable>item</replaceable>) AS lefts
         ON (summary.left = lefts.left)
  ) AS list
  GROUP BY right
  ORDER BY count DESC;
 </programlisting>

 </sect2>

</sect1>