repo_zf1Php7/documentation/manual/fr/module_specs/Zend_Search_Lucene-Queries.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: 24249 -->
<!-- Reviewed: no -->
<sect1 id="zend.search.lucene.query-api">
    <title>API de construction de requêtes</title>
    <para>
        En plus du parsage automatique d'une requête en chaîne de caractères, il est également possible de construire
        cette requête à l'aide de l'<acronym>API</acronym> de requête.
    </para>
    <para>
        Les requêtes utilisateur peuvent être combinées avec les requêtes créées à travers l'API de requêtes.
        Utilisez simplement le parseur de requêtes pour construire une requête à partir d'une chaîne :
        <programlisting language="php"><![CDATA[
$query = Zend_Search_Lucene_Search_QueryParser::parse($queryString);
]]></programlisting>
    </para>
    <sect2 id="zend.search.lucene.queries.exceptions">
        <title>Les Exceptions du parseur de requêtes</title>
        <para>
        Le parseur de requêtes peut générer deux types d'exceptions :
        <itemizedlist>
            <listitem>
                <para>
                    Une <classname>Zend_Search_Lucene_Exception</classname> est levée si quelque-chose d'anormal se produit dans le
                    parseur même.
                </para>
            </listitem>
            <listitem>
                <para>
                    Une <classname>Zend_Search_Lucene_Search_QueryParserException</classname> est levée s'il y a une erreur dans la syntaxe de la requête.
                </para>
            </listitem>
        </itemizedlist>
        C'est une bonne idée d'attraper les <classname>Zend_Search_Lucene_Search_QueryParserException</classname>s et
        de les traiter de manière appropriée :
        <programlisting language="php"><![CDATA[
try {
    $query = Zend_Search_Lucene_Search_QueryParser::parse($queryString);
} catch (Zend_Search_Lucene_Search_QueryParserException $e) {
    echo "Query syntax error: " . $e->getMessage() . "\n";
}
]]></programlisting>
        </para>
        <para>
            La même technique devrait être utilisée pour la méthode find() d'un objet <classname>Zend_Search_Lucene</classname>.
        </para>
        <para>
            Depuis la version 1.5, les exceptions de parsage de requête sont supprimées par défaut. Si la requête ne
            respecte pas le langage de requêtes, elle est "tokenizée" à l'aide de l'analyseur par défaut et tous les
            termes "tokenizés" sont utilisés dans la recherche.
            Pour activer les exceptions, utilisez <methodname>Zend_Search_Lucene_Search_QueryParser::dontSuppressQueryParsingExceptions()</methodname>.
            Les méthodes <methodname>Zend_Search_Lucene_Search_QueryParser::suppressQueryParsingExceptions()</methodname> et
            <methodname>Zend_Search_Lucene_Search_QueryParser::queryParsingExceptionsSuppressed()</methodname>
            sont également destinées à gérer le comportement de gestion des exceptions.
        </para>
    </sect2>
    <sect2 id="zend.search.lucene.queries.term-query">
        <title>Requête sur un terme</title>
        <para>
            Les requêtes de termes peuvent être utilisées pour une recherche
            sur un seul terme.
        </para>
        <para>
        Requête par chaîne de caractères:
        </para>
        <programlisting language="querystring"><![CDATA[
word1
]]></programlisting>
        <para>ou</para>
        <para>
        Construction de la requête via l'<acronym>API</acronym>:
        </para>
        <programlisting language="php"><![CDATA[
$term  = new Zend_Search_Lucene_Index_Term('word1', 'field1');
$query = new Zend_Search_Lucene_Search_Query_Term($term);
$hits  = $index->find($query);
]]></programlisting>
        <para>
            L'argument field est optionnel. <classname>Zend_Search_Lucene</classname> cherche dans
            tous les champs indexés si aucun champ n'a été spécifié :
            <programlisting language="php"><![CDATA[
// Recherche de 'word1' dans tous les champs indexés.
$term  = new Zend_Search_Lucene_Index_Term('word1');
$query = new Zend_Search_Lucene_Search_Query_Term($term);
$hits  = $index->find($query);
]]></programlisting>
        </para>
    </sect2>
    <sect2 id="zend.search.lucene.queries.multiterm-query">
        <title>Requête multi-termes</title>
        <para>
            Les requêtes multi-termes peuvent être utilisées pour chercher sur une
            collection de termes.
        </para>
        <para>
            Chaque terme dans une collection peut être défini comme <emphasis>requis</emphasis>,
            <emphasis>interdit</emphasis>, ou <emphasis>aucun des deux</emphasis>.
            <itemizedlist>
                <listitem>
                    <para>
                        <emphasis>requis</emphasis> signifie que les documents ne correspondant pas
                        au terme ne correspondront pas à la requête;
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <emphasis>interdit</emphasis> signifie que les documents correspondant
                        au terme ne correspondront pas à la requête;
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <emphasis>aucun des deux</emphasis>, dans ce cas les documents n'ont pas
                        l'interdiction, ni l'obligation de correspondre au terme. Cela dit, un document
                        devra correspondre au moins à l'un des termes pour correspondre à la requête.
                    </para>
                </listitem>
            </itemizedlist>
        </para>
        <para>
            Si des termes optionnels sont ajoutés à une requête possédant des termes requis,
            les deux requêtes auront les mêmes résultats, mais les termes optionnels pourraient
            influer sur le score des documents retournés.
        </para>
        <para>
            Les deux méthodes de recherche peuvent être utilisées pour les requêtes multi-termes.
        </para>
        <para>
            Requête par chaîne de caractères:
        </para>
        <programlisting language="querystring"><![CDATA[
+word1 author:word2 -word3
]]></programlisting>
        <itemizedlist>
            <listitem>
                <para>
                    '+' est utilisé pour définir un terme requis.
                </para>
            </listitem>
            <listitem>
                <para>
                    '-' est utilisé pour définir un terme interdit.
                </para>
            </listitem>
            <listitem>
                <para>
                    Le préfixe 'field:' est utilisé pour indiqué un champ sur lequel on veut chercher.
                    S'il est omis, la recherche se fera sur tous les champs.
                </para>
            </listitem>
        </itemizedlist>
        <para>or</para>
        <para>
        Construction de la requête via l'<acronym>API</acronym>:
        </para>
        <programlisting language="php"><![CDATA[
$query = new Zend_Search_Lucene_Search_Query_MultiTerm();
$query->addTerm(new Zend_Search_Lucene_Index_Term('word1'), true);
$query->addTerm(new Zend_Search_Lucene_Index_Term('word2', 'author'),
                null);
$query->addTerm(new Zend_Search_Lucene_Index_Term('word3'), false);
$hits  = $index->find($query);
]]></programlisting>
        <para>
            Il est également possible de spécifier des listes de termes dans le contructeur de la requête multi-termes :
            <programlisting language="php"><![CDATA[
$terms = array(new Zend_Search_Lucene_Index_Term('word1'),
               new Zend_Search_Lucene_Index_Term('word2', 'author'),
               new Zend_Search_Lucene_Index_Term('word3'));
$signs = array(true, null, false);
$query = new Zend_Search_Lucene_Search_Query_MultiTerm($terms, $signs);
$hits  = $index->find($query);
]]></programlisting>
        </para>
        <para>
            Le tableau <varname>$signs</varname> contient des informations sur le type de chaque terme :
            <itemizedlist>
                <listitem>
                    <para>
                        <constant>TRUE</constant> est utilisé pour définir un terme requis.
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <constant>FALSE</constant> est utilisé pour définir un terme interdit.
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <constant>NULL</constant> est utilisé pour définir un terme qui n'est ni
                        requis, ni interdit.
                    </para>
                </listitem>
            </itemizedlist>
        </para>
    </sect2>
    <sect2 id="zend.search.lucene.queries.boolean-query">
        <title>Requête booléene</title>
        <para>
            Les requêtes booléenes permettent de construire une requête qui utilise d'autres requêtes
            et des opérateurs booléens.
        </para>
        <para>
            Chaque sous-requête dans une collection peut être définie comme <emphasis>requis</emphasis>,
            <emphasis>interdit</emphasis>, ou <emphasis>optionnel</emphasis>.
            <itemizedlist>
                <listitem>
                    <para>
                        <emphasis>requis</emphasis> signifie que les documents ne correspondant pas
                        à la sous-requête ne correspondront pas à la requête;
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <emphasis>interdit</emphasis> signifie que les documents correspondant
                        à la sous-requête ne correspondront pas à la requête;
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <emphasis>optionel</emphasis>, dans ce cas les documents n'ont pas
                        l'interdiction, ni l'obligation de correspondre à la sous-requête. Cela dit, un document
                        devra correspondre au moins à l'une des sous-requêtes pour correspondre à la requête.
                    </para>
                </listitem>
            </itemizedlist>
        </para>
        <para>
            Si des sous-requêtes optionnelles sont ajoutées à une requête possédant des sous-requêtes requises,
            les deux requêtes auront les mêmes résultats, mais les sous-requêtes optionnelles pourraient
            influer sur le score des documents retournés.
        </para>
        <para>
            Les deux méthodes de recherche peuvent être utilisées pour les requêtes booléenes.
        </para>
        <para>
            Requête par chaîne de caractères:
        </para>
        <programlisting language="querystring"><![CDATA[
+(word1 word2 word3) (author:word4 author:word5) -(word6)
]]></programlisting>
        <itemizedlist>
            <listitem>
                <para>
                    '+' est utilisé pour définir une sous-requêtes requise.
                </para>
            </listitem>
            <listitem>
                <para>
                    '-' est utilisé pour définir une sous-requêtes interdite.
                </para>
            </listitem>
            <listitem>
                <para>
                    Le préfixe 'field:' est utilisé pour indiqué un champ sur lequel on veut chercher.
                    S'il est omis, la recherche se fera sur tous les champs.
                </para>
            </listitem>
        </itemizedlist>
        <para>or</para>
        <para>
        Construction de la requête via l'<acronym>API</acronym>:
        </para>
        <programlisting language="php"><![CDATA[
$query = new Zend_Search_Lucene_Search_Query_Boolean();
$subquery1 = new Zend_Search_Lucene_Search_Query_MultiTerm();
$subquery1->addTerm(new Zend_Search_Lucene_Index_Term('word1'));
$subquery1->addTerm(new Zend_Search_Lucene_Index_Term('word2'));
$subquery1->addTerm(new Zend_Search_Lucene_Index_Term('word3'));
$subquery2 = new Zend_Search_Lucene_Search_Query_MultiTerm();
$subquery2->addTerm(new Zend_Search_Lucene_Index_Term('word4', 'author'));
$subquery2->addTerm(new Zend_Search_Lucene_Index_Term('word5', 'author'));
$term6 = new Zend_Search_Lucene_Index_Term('word6');
$subquery3 = new Zend_Search_Lucene_Search_Query_Term($term6);
$query->addSubquery($subquery1, true  /* required */);
$query->addSubquery($subquery2, null  /* optional */);
$query->addSubquery($subquery3, false /* prohibited */);
$hits  = $index->find($query);
]]></programlisting>
        <para>
            Il est également possible de spécifier des listes de sous-requêtes dans le constructeur
            d'une requêtes booléene :
            <programlisting language="php"><![CDATA[
...
$subqueries = array($subquery1, $subquery2, $subquery3);
$signs = array(true, null, false);
$query = new Zend_Search_Lucene_Search_Query_Boolean($subqueries, $signs);
$hits  = $index->find($query);
]]></programlisting>
        </para>
        <para>
            Le tableau <varname>$signs</varname> contient des informations sur le type de chaque sous-requête :
            <itemizedlist>
                <listitem>
                    <para>
                        <constant>TRUE</constant> est utilisé pour définir une sous-requête requise.
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <constant>FALSE</constant> est utilisé pour définir une sous-requête interdite.
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <constant>NULL</constant> est utilisé pour définir une sous-requête qui n'est
                        ni requise, ni interdite.
                    </para>
                </listitem>
            </itemizedlist>
        </para>
        <para>
            Chaque requête qui utilise des opérateurs booléens peut être réécrite en utilisant les notations
            de signes et construites à l'aide de l'API. Par exemple :
            <programlisting language="querystring"><![CDATA[
word1 AND (word2 AND word3 AND NOT word4) OR word5
]]></programlisting>
            est équivalent à
            <programlisting language="querystring"><![CDATA[
(+(word1) +(+word2 +word3 -word4)) (word5)
]]></programlisting>
        </para>
    </sect2>
    <sect2 id="zend.search.lucene.queries.wildcard">
        <title>Requête Joker (wildcard)</title>
        <para>
            Les requêtes Joker peuvent être utilisées pour chercher des documents contenant
            des chaînes de caractères qui correspondent aux modèles (pattern) spécifiés.
        </para>
        <para>
            Le symbole '?' est utilisé comme un joker d'un seul caractère.
        </para>
        <para>
            Le symbole '*' est utilisé comme un joker pour plusieurs caractères.
        </para>
        <para>
            Requête par chaîne de caractères:
            <programlisting language="querystring"><![CDATA[
field1:test*
]]></programlisting>
        </para>
        <para>ou</para>
        <para>
            Construction de la requête via l'<acronym>API</acronym>:
            <programlisting language="php"><![CDATA[
$pattern = new Zend_Search_Lucene_Index_Term('test*', 'field1');
$query = new Zend_Search_Lucene_Search_Query_Wildcard($pattern);
$hits  = $index->find($query);
]]></programlisting>
        </para>
        <para>
            L'argument field est optionnel. <classname>Zend_Search_Lucene</classname> cherche dans
            tous les champs indexés si aucun champ n'a été spécifié :
            <programlisting language="php"><![CDATA[
$pattern = new Zend_Search_Lucene_Index_Term('test*');
$query = new Zend_Search_Lucene_Search_Query_Wildcard($pattern);
$hits  = $index->find($query);
]]></programlisting>
        </para>
    </sect2>
    <sect2 id="zend.search.lucene.queries.fuzzy">
        <title>Requête floue (fuzzy query)</title>
        <para>
            Les requêtes floues peuvent être utilisées pour chercher des documents contenant
            des chaînes de caractères qui correspondent à des termes similaires au terme cherché.
        </para>
        <para>
            Requête par chaîne de caractères:
            <programlisting language="querystring"><![CDATA[
field1:test~
]]></programlisting>
            Cette requête va correspondre à des documents contenant 'test', 'text', 'best' ou d'autres mots similaires.
        </para>
        <para>ou</para>
        <para>
            Construction de la requête via l'<acronym>API</acronym>:
            <programlisting language="php"><![CDATA[
$term = new Zend_Search_Lucene_Index_Term('test', 'field1');
$query = new Zend_Search_Lucene_Search_Query_Fuzzy($term);
$hits  = $index->find($query);
]]></programlisting>
        </para>
        <para>
            Un indice de similarité (optional similarity) peut être spécifié après le signe "~".
        </para>
        <para>
            Requête par chaîne de caractères:
            <programlisting language="querystring"><![CDATA[
field1:test~0.4
]]></programlisting>
        </para>
        <para>ou</para>
        <para>
            Construction de la requête via l'<acronym>API</acronym>:
            <programlisting language="php"><![CDATA[
$term = new Zend_Search_Lucene_Index_Term('test', 'field1');
$query = new Zend_Search_Lucene_Search_Query_Fuzzy($term, 0.4);
$hits  = $index->find($query);
]]></programlisting>
        </para>
        <para>
            L'argument field est optionnel. <classname>Zend_Search_Lucene</classname> cherche dans
            tous les champs indexés si aucun champ n'a été spécifié :
            <programlisting language="php"><![CDATA[
$term = new Zend_Search_Lucene_Index_Term('test');
$query = new Zend_Search_Lucene_Search_Query_Fuzzy($term);
$hits  = $index->find($query);
]]></programlisting>
        </para>
    </sect2>
    <sect2 id="zend.search.lucene.queries.phrase-query">
        <title>Requête de phrase</title>
        <para>
            Les requêtes de phrase peuvent être utilisées pour chercher une phrase dans des documents.
        </para>
        <para>
            Les requêtes de phrase sont très flexible et permettent à l'utilisateur ou au développeur de chercher
            des phrases exactes aussi bien que des phrases 'imprécises'.
        </para>
        <para>
            Les phrases peuvent aussi contenir des trous ou des termes aux mêmes places; elles peuvent
            être générées par l'analyseur dans différents buts. Par exemple, un terme peut être dupliqué
            pour augmenter son poids, ou plusieurs synonymes peuvent être placés sur une seule et unique position.
        </para>
        <programlisting language="php"><![CDATA[
$query1 = new Zend_Search_Lucene_Search_Query_Phrase();
// Ajoute 'word1' à la position relative 0.
$query1->addTerm(new Zend_Search_Lucene_Index_Term('word1'));
// Ajoute 'word2' à la position relative 1.
$query1->addTerm(new Zend_Search_Lucene_Index_Term('word2'));
// Ajoute 'word3' à la position relative 3.
$query1->addTerm(new Zend_Search_Lucene_Index_Term('word3'), 3);
...
$query2 = new Zend_Search_Lucene_Search_Query_Phrase(
                array('word1', 'word2', 'word3'), array(0,1,3));
...
// Requête sans trou.
$query3 = new Zend_Search_Lucene_Search_Query_Phrase(
                array('word1', 'word2', 'word3'));
...
$query4 = new Zend_Search_Lucene_Search_Query_Phrase(
                array('word1', 'word2'), array(0,1), 'annotation');
]]></programlisting>
        <para>
            Une requête de phrase peut être construite en une seule étape à l'aide du constructeur ou
            étape par étape avec des appels à la méthode <methodname>Zend_Search_Lucene_Search_Query_Phrase::addTerm()</methodname>.
        </para>
        <para>
            Le constructeur de la classe <classname>Zend_Search_Lucene_Search_Query_Phrase</classname> prends trois arguments optionnels :
        </para>
        <programlisting language="php"><![CDATA[
Zend_Search_Lucene_Search_Query_Phrase(
    [array $terms[, array $offsets[, string $field]]]
);
]]></programlisting>
        <para>
            Le paramètre <varname>$terms</varname> est un tableau de chaînes de caractères qui
            contient une collection de termes pour une phrase. S'il est omis ou égal à <constant>NULL</constant>,
            une requête vide sera construite.
        </para>
        <para>
            Le paramètre <varname>$offsets</varname> est un tableau d'entiers qui contient les positions
            des termes dans la phrase. S'il est omis ou égale à <constant>NULL</constant>, les positions
            des termes seront implicitement séquentielles sans trou.
        </para>
        <para>
            Le paramètre <varname>$field</varname> est un chaîne de caractères qui indique le
            champ dans lequel chercher. S'il est omis ou égal à <constant>NULL</constant>, la
            recherche se fera dans le champ par défaut.
        </para>
        <para>
            Ainsi :
        </para>
        <programlisting language="php"><![CDATA[
$query =
    new Zend_Search_Lucene_Search_Query_Phrase(array('zend', 'framework'));
]]></programlisting>
        <para>
            va chercher la phrase 'zend framework' dans tous les champs.
        </para>
        <programlisting language="php"><![CDATA[
$query = new Zend_Search_Lucene_Search_Query_Phrase(
                 array('zend', 'download'), array(0, 2)
             );
]]></programlisting>
        <para>
            va chercher la phrase 'zend ????? download' et correspondra à 'zend platform download', 'zend studio
            download', 'zend core download', 'zend framework download', etc.
        </para>
        <programlisting language="php"><![CDATA[
$query = new Zend_Search_Lucene_Search_Query_Phrase(
                 array('zend', 'framework'), null, 'title'
             );
]]></programlisting>
        <para>
            va chercher la phrase 'zend framework' dans le champ 'title'.
        </para>
        <para>
            La méthode <methodname>Zend_Search_Lucene_Search_Query_Phrase::addTerm()</methodname> prends deux
            arguments, un <classname>Zend_Search_Lucene_Index_Term</classname> requis et une position optionnelle :
        </para>
        <programlisting language="php"><![CDATA[
Zend_Search_Lucene_Search_Query_Phrase::addTerm(
    Zend_Search_Lucene_Index_Term $term[, integer $position]
);
]]></programlisting>
        <para>
            Le paramètre <varname>$term</varname> décrit le prochain terme dans la phrase. Il doit
            indiquer le même champ que les termes précédents, sinon une exception sera levée.
        </para>
        <para>
            Le paramètre <varname>$position</varname> indique la position du terme dans la phrase.
        </para>
        <para>
            Ainsi :
        </para>
        <programlisting language="php"><![CDATA[
$query = new Zend_Search_Lucene_Search_Query_Phrase();
$query->addTerm(new Zend_Search_Lucene_Index_Term('zend'));
$query->addTerm(new Zend_Search_Lucene_Index_Term('framework'));
]]></programlisting>
        <para>
            va chercher la phrase 'zend framework'.
         </para>
        <programlisting language="php"><![CDATA[
$query = new Zend_Search_Lucene_Search_Query_Phrase();
$query->addTerm(new Zend_Search_Lucene_Index_Term('zend'), 0);
$query->addTerm(new Zend_Search_Lucene_Index_Term('framework'), 2);
]]></programlisting>
        <para>
            va chercher la phrase 'zend ????? download' et correspondra à 'zend platform download', 'zend studio
            download', 'zend core download', 'zend framework download', etc.
        </para>
        <programlisting language="php"><![CDATA[
$query = new Zend_Search_Lucene_Search_Query_Phrase();
$query->addTerm(new Zend_Search_Lucene_Index_Term('zend', 'title'));
$query->addTerm(new Zend_Search_Lucene_Index_Term('framework', 'title'));
]]></programlisting>
        <para>
            va chercher la phrase 'zend framework' dans le champ 'title'.
        </para>
        <para>
            Le 'slop factor' établit le nombre d'autres mots autorisés entre les mots spécifiés dans la requête de phrase.
            S'il est défini à zéro, la requête correspondante sera une recherche d'une phrase exacte. Pour des valeurs
            supérieures à zéro, cela fonctionne comme les opérateurs WITHIN ou NEAR.
        </para>
        <para>
            Le 'slop factor' est en fait une distance d'édition, où les éditions consistent à déplacer les termes dans
            la phrase recherchée. Par exemple, inverser l'ordre de deux mots requiert deux déplacements (le premier
            déplacement positionne les mots l'un sur l'autre), donc pour permettre le réarrangement de phrase, le
            'slop factor' doit être d'au moins deux.
        </para>
        <para>
            Les correspondances les plus exactes possèdent un meilleur score que celles ayant eu recours au 'slop factor';
            ainsi les résultats de recherche sont classés par exactitude. Le 'slop factor' est à zéro par défaut, requérant des
            correspondances exactes.
        </para>
        <para>
            Le 'slop factor' peut être assigné après la création de la requête :
        </para>
        <programlisting language="php"><![CDATA[
// Requêtes sans trou.
$query =
    new Zend_Search_Lucene_Search_Query_Phrase(array('word1', 'word2'));
// Search for 'word1 word2', 'word1 ... word2'
$query->setSlop(1);
$hits1 = $index->find($query);
// Recherche pour 'word1 word2', 'word1 ... word2',
// 'word1 ... ... word2', 'word2 word1'
$query->setSlop(2);
$hits2 = $index->find($query);
]]></programlisting>
    </sect2>
    <sect2 id="zend.search.lucene.queries.range">
        <title>Requête d'intervalle</title>
        <para>
            Les <link linkend="zend.search.lucene.query-language.range">requêtes d'intervalle</link> sont dédiées à la recherche de termes dans un intervalle spécifié.
        </para>
        <para>
            Requête par chaîne de caractères:
            <programlisting language="querystring"><![CDATA[
mod_date:[20020101 TO 20030101]
title:{Aida TO Carmen}
]]></programlisting>
        </para>
        <para>ou</para>
        <para>
            Construction de la requête via l'<acronym>API</acronym>:
            <programlisting language="php"><![CDATA[
$from = new Zend_Search_Lucene_Index_Term('20020101', 'mod_date');
$to   = new Zend_Search_Lucene_Index_Term('20030101', 'mod_date');
$query = new Zend_Search_Lucene_Search_Query_Range(
                 $from, $to, true // inclusive
             );
$hits  = $index->find($query);
]]></programlisting>
        </para>
        <para>
            L'argument field est optionnel. <classname>Zend_Search_Lucene</classname> cherche dans
            tous les champs indexés si aucun champ n'a été spécifié :
            <programlisting language="php"><![CDATA[
$from = new Zend_Search_Lucene_Index_Term('Aida');
$to   = new Zend_Search_Lucene_Index_Term('Carmen');
$query = new Zend_Search_Lucene_Search_Query_Range(
                 $from, $to, false // non-inclusive
             );
$hits  = $index->find($query);
]]></programlisting>
        </para>
        <para>
            L'une ou l'autre (mais pas les deux) des bornes peut être définie à <constant>NULL</constant>.
            Dans ce cas, <classname>Zend_Search_Lucene</classname> cherche depuis le début ou jusqu'à la
            fin du dictionnaire pour le(s) champs spécifié(s) :
            <programlisting language="php"><![CDATA[
// recherche pour ['20020101' TO ...]
$from = new Zend_Search_Lucene_Index_Term('20020101', 'mod_date');
$query = new Zend_Search_Lucene_Search_Query_Range(
                 $from, null, true // inclusive
             );
$hits  = $index->find($query);
]]></programlisting>
        </para>
    </sect2>
</sect1>
<!--
vim:se ts=4 sw=4 et:
-->