repo_zf1/documentation/manual/de/module_specs/Zend_Search_Lucene-Queries.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 15157 -->
<!-- Reviewed: no -->
<sect1 id="zend.search.lucene.query-api">
    <title>Abfrage Erzeugungs API</title>

    <para>
        Zusätzlich zum automatischen Analysieren vom Abfragen ist es auch möglich diese durch eine API zu erzeugen.
    </para>

    <para>
        Benutzerabfragen können mit Abfragen die durch die API erstellte wurden kombiniert werden. Einfach den
        Abfrageparser verwenden um eine Abfrage von einem String zu erstellen:
        <programlisting role="php"><![CDATA[
$query = Zend_Search_Lucene_Search_QueryParser::parse($queryString);
]]></programlisting>
    </para>

    <sect2 id="zend.search.lucene.queries.exceptions">
        <title>Abfrageparser Ausnahmen</title>
        <para>
            Der Abfrageparser kann zwei Typen von Ausnahmen erstellen.
            <itemizedlist>
                <listitem>
                    <para>
                        <classname>Zend_Search_Lucene_Exception</classname> wird geworfen wenn irgendwas im Abfrageparser
                        selbst falsch läuft.
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <classname>Zend_Search_Lucene_Search_QueryParserException</classname> wird geworfen wenn ein
                        Fehler im Syntax der Abfrage ist.
                    </para>
                </listitem>
            </itemizedlist>
            Es ist eine gute Idee die <classname>Zend_Search_Lucene_Search_QueryParserException</classname>s abzufangen und
            richtig abzuarbeiten:
            <programlisting role="php"><![CDATA[
try {
    $query = Zend_Search_Lucene_Search_QueryParser::parse($queryString);
} catch (Zend_Search_Lucene_Search_QueryParserException $e) {
    echo "Abfrage Syntax Fehler: " . $e->getMessage() . "\n";
}
]]></programlisting>
        </para>

        <para>
            Die selbe Technik sollte für die find() Methode des <classname>Zend_Search_Lucene</classname> Objektes verwendet werden.
        </para>

        <para>
            Beginnend mit 1.5 werden Abfrageparser Exceptions standardmäßig unterdrückt. Wenn eine Abfrage
            nicht konform mit der Abfragesprache ist, dann wird Sie mithilfe des aktuellen Standardanalysators
            gestückelt und alle Begriffsstücke werden für die Suche verwendet.
            Die <classname>Zend_Search_Lucene_Search_QueryParser::dontSuppressQueryParsingExceptions()</classname> Methode
            kann verwendet werden um Exceptions einzuschalten. Die
            <classname>Zend_Search_Lucene_Search_QueryParser::suppressQueryParsingExceptions()</classname> und
            <classname>Zend_Search_Lucene_Search_QueryParser::queryParsingExceptionsSuppressed()</classname> Methoden
            sind auch dazu gedacht das Verhalten der Exceptionsbehandlung zu verwalten.
        </para>

    </sect2>

    <sect2 id="zend.search.lucene.queries.term-query">
        <title>Begriffsabfrage</title>
        <para>
            Begriffsabfragen können für das Suchen mit einem einzelnen Begriff verwendet werden.
        </para>

        <para>
            Abfragestring:
        </para>
        <programlisting role="querystring"><![CDATA[
word1
]]></programlisting>

        <para>oder</para>

        <para>
            Aufbau der Abfrage mit der Programmierschnittstelle (API):
        </para>
        <programlisting role="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>
            Das Term Feld ist optional. <classname>Zend_Search_Lucene</classname> durchsucht alle indizierten Felder in jedem
            Dokument wenn das Feld nicht spezifiziert
            wurde:
            <programlisting role="php"><![CDATA[
// Sucht nach 'word1' in allen indizierten Feldern
$term  = new Zend_Search_Lucene_Index_Term('wort1');
$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>Mehrfache Begriffsabfrage</title>
        <para>
            Mehrfache Begriffsabfragen sind für Suchen mit einem Satz von Begriffen gedacht.
        </para>

        <para>
            Jeder Begriff dieses Satzes kann als <emphasis>required</emphasis> (notwendig),
            <emphasis>prohibited</emphasis> (verboten) oder <emphasis>neither</emphasis> (weder
            noch) definiert werden.

            <itemizedlist>
                <listitem>
                    <para>
                        <emphasis>required</emphasis> bedeutet, dass Dokumente, die diesen
                        Begriff nicht enthalten, nicht der Abfrage entsprechen;
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <emphasis>prohibited</emphasis> bedeutet, dass Dokumente, die diesen
                        Begriff enthalten, nicht der Abfrage entsprechen;
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <emphasis>neither</emphasis>, in welchem Fall Dokumenten den Begriff weder
                        nicht enthalten dürfen, noch den Begriff enthalten müssen. Nichtsdestrotrotz
                        muß ein Dokument mindestens einem Begriff entsprechen, um der Abfrage
                        zu entsprechen.
                    </para>
                </listitem>
            </itemizedlist>
        </para>

        <para>
            Wenn einer Abfrage mit notwendigen Begriffen optionale Betriffe hinzugefügt werden, werden beide
            Abfragen das gleiche Set an Ergebnissen haben, aber der optionale Begriff kann die Bewertung
            der passenden Dokumente beeinflussen.
        </para>

        <para>
            Beide Suchmethoden können für Mehrfache Begriffsabfragen verwendet werden.
        </para>

        <para>
            Abfragestring:
        </para>
        <programlisting role="querystring"><![CDATA[
+word1 author:word2 -word3
]]></programlisting>

        <itemizedlist>
            <listitem>
                <para>
                    '+' wird für notwendige Begriffe verwendet.
                </para>
            </listitem>
            <listitem>
                <para>
                    '-' wird für verbotene Begriffe verwendet.
                </para>
            </listitem>
            <listitem>
                <para>
                    Der 'field:' Präfix wird für die Angabe des Dokumentenfelds für die Suche verwendet.
                    Wenn er weggelassen wird, werden alle Felder durchsucht.
                </para>
            </listitem>
        </itemizedlist>

        <para>oder</para>

        <para>
            Aufbau der Abfrage mit der Programmierschnittstelle (API):
        </para>
        <programlisting role="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>
            Es ist auch möglich Begriffslisten in einem MultiTerm Anfrage Konstruktor zu spezifizieren:
            <programlisting role="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>
            Das <code>$signs</code> Array enthält Informationen über den Begriffstyp:
            <itemizedlist>
                <listitem>
                    <para>
                        <code>true</code> wird für notwendige Begriffe verwendet.
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <code>false</code> wird für verbotene Begriffe verwendet.
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <code>null</code> wird für weder notwendige noch verbotene Begriffe verwendet.
                    </para>
                </listitem>
            </itemizedlist>
        </para>
    </sect2>

    <sect2 id="zend.search.lucene.queries.boolean-query">
        <title>Boolsche Abfragen</title>
        <para>
            Boolsche Abfragen erlauben die Erstellung von Abfragen die andere Abfragen und boolsche Operatoren
            verwenden.
        </para>

        <para>
            Jede Subabfrage in einem Set kann als <emphasis>required</emphasis>, <emphasis>prohibited</emphasis>,
            oder <emphasis>optional</emphasis> definiert werden.

            <itemizedlist>
                <listitem>
                    <para>
                        <emphasis>required</emphasis> bedeutet das Dokumente die dieser Unterabfrage nicht
                        entsprechen auch der Gesamtabfrage nicht entsprechen;
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <emphasis>prohibited</emphasis> bedeutet das Dokumente die dieser Unterabfrage entsprechen
                        auch der Gesamtabfrage nicht entsprechen;
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <emphasis>optional</emphasis>, in dem Fall das entsprechende Dokumente in der
                        Unterabfrage weder verboten noch benötigt werden. Ein Dokument muß trotzdem zumindest in 1
                        Unterabfrage entsprechen damit es der in der Gesamtabfrage entspricht.
                    </para>
                </listitem>
            </itemizedlist>
        </para>

        <para>
            Wenn optionale Unterabfragen einer Abfrage mit benötigen Unterabfragen hinzugefügt werden,
            werden beide Abfragen das gleiche Ergebnisset haben, aber die optionale Unterabfrage kann die
            Wertung der passenden Dokumente beeinflussen.
        </para>

        <para>
            Beide Suchmethoden können für boolsche Abfragen verwendet werden.
        </para>

        <para>
            Abfrage String:
        </para>
        <programlisting role="querystring"><![CDATA[
+(word1 word2 word3) author:(word4 word5) -word6
]]></programlisting>

        <itemizedlist>
            <listitem>
                <para>
                    '+' wird verwendet um eine benötigte Unterabfrage zu definieren.
                </para>
            </listitem>
            <listitem>
                <para>
                    '-' wird verwendet um eine verbotene Unterabfrage zu definieren.
                </para>
            </listitem>
            <listitem>
                <para>
                    'field:' Der Prefix wird verwendet um ein Feld des Dokuments für eine Suche zu markieren.
                    Wenn es nicht angegeben wird, werden alle Felder durchsucht.
                </para>
            </listitem>
        </itemizedlist>

        <para>oder</para>

        <para>
            Konstruktion der Abfrage durch die API:
        </para>
        <programlisting role="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  /* benötigt (required) */);
$query->addSubquery($subquery2, null  /* optional */);
$query->addSubquery($subquery3, false /* verboten (prohibited) */);

$hits  = $index->find($query);
]]></programlisting>

        <para>
            Es ist auch möglich Listen von Unterabfragen im Konstruktor der Boolschen Abfrage zu definieren:
            <programlisting role="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>
            Das <code>$signs</code> Array enthält Informationen über den Typ der Unterabfrage:
            <itemizedlist>
                <listitem>
                    <para>
                        <code>true</code> wird verwendet um eine benötigte Unterabfrage zu definieren.
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <code>false</code> wird verwendet um eine verbotene Unterabfrage zu definieren.
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <code>null</code> wird verwendet um eine Unterabfrage zu definieren die weder benötigt
                        noch verboten ist.
                    </para>
                </listitem>
            </itemizedlist>
        </para>

        <para>
            Jede Abfrage die boolsche Operatoren verwendet kann, kann auch auch umgeschrieben werden damit Sie
            die Vorzeichen-Schreibweise verwendet und mit Hilfe der API erstellt wird. Zum Beispiel:
            <programlisting role="querystring"><![CDATA[
word1 AND (word2 AND word3 AND NOT word4) OR word5
]]></programlisting>
            ist identisch mit
            <programlisting role="querystring"><![CDATA[
(+(word1) +(+word2 +word3 -word4)) (word5)
]]></programlisting>
        </para>
    </sect2>

    <sect2 id="zend.search.lucene.queries.wildcard">
        <title>Wildcard Abfragen</title>
        <para>
            Wildcard Abfragen können dazu verwendet werden um nach Dokumenten zu suchen die Strings enthalten
            welche den spezifizierten Patterns entsprechen.
        </para>

        <para>
            Das '?' Symbol wird als Wildcard für ein einzelnes Zeichen verwendet.
        </para>

        <para>
            Das '*' Symbol wird als Woldcard für mehrere Zeichen verwendet.
        </para>

        <para>
            Abfragestring:
            <programlisting role="querystring"><![CDATA[
field1:test*
]]></programlisting>
        </para>

        <para>oder</para>

        <para>
            Abfrageerstellung durch die API:
            <programlisting role="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>
            Die Ausdrucksfelder sind optional. <classname>Zend_Search_Lucene</classname> durchsucht alle Felder in jedem
            Dokument wenn kein Feld spezifiziert wurde:
            <programlisting role="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>Fuzzy Abfragen</title>
        <para>
            Fuzzy Abfragen können verwendet werden um nach Dokumenten zu Suchen die Strings enthalten welche
            Ausdrücken entsprechen die den spezifizierten Ausdrücken ähnlich sind.
        </para>

        <para>
            Abfrage String:
            <programlisting role="querystring"><![CDATA[
field1:test~
]]></programlisting>
            Diese Abfrage trifft Dokumente die die Wörter 'test' 'text' 'best' und andere enthalten.
        </para>

        <para>oder</para>

        <para>
            Abfrageerstellung durch die API:
            <programlisting role="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>
            Optional kann die Ähnlichkeit nach dem "~" Zeichen spezifiziert werden.
        </para>

        <para>
            Abfrage String:
            <programlisting role="querystring"><![CDATA[
field1:test~0.4
]]></programlisting>
        </para>

        <para>oder</para>

        <para>
            Abfrageerstellung durch die API:
            <programlisting role="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>
            Das Term Feld ist optional. <classname>Zend_Search_Lucene</classname> durchsucht alle Felder in jedem Dokument ob ein
            Feld nicht spezifiziert ist:
            <programlisting role="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>Phrasenabfrage</title>
        <para>
            Phrasenabfragen können für das Suchen einer Phrase innerhalb von Dokumenten verwendet werden.
        </para>

        <para>
            Phrasenabfragen sind sehr flexibel und erlauben dem Benutzer oder Entwickler nach exakten Phrasen
            zu suchen wie auch nach 'ungenauen' Phrasen.
        </para>

        <para>
            Phrasen können auch Lücken oder mehrere Begriffe an der selben Stelle enthalten; diese
            können mit Hilfe das Analysators für verschiedene Zwecke generiert werden, z.B. kann ein
            Begriff verdoppelt werden, um das Gewicht des Begriffs zu erhöhen oder verschiedene
            Synonyme können an einer Stelle platziert werden.
        </para>

        <programlisting role="php"><![CDATA[
$query1 = new Zend_Search_Lucene_Search_Query_Phrase();

// Füge 'word1' an der relativen Position 0 hinzu.
$query1->addTerm(new Zend_Search_Lucene_Index_Term('word1'));

// Füge 'word2' an der relativen Position 1 hinzu.
$query1->addTerm(new Zend_Search_Lucene_Index_Term('word2'));

// Füge 'word3' an der relativen Position 3 hinzu.
$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));

...

// Abfrage ohne eine Lücke.
$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>
            Eine Phrasenabfrage kann in einem Schritt mit einem Klassenkonstruktor erstellt werden
            oder Schritt für Schritt mit der <classname>Zend_Search_Lucene_Search_Query_Phrase::addTerm()</classname>
            Methode.
        </para>

        <para>
            Der <classname>Zend_Search_Lucene_Search_Query_Phrase</classname> Klassenkonstruktor nimmt drei optionale
            Argumente entgegen:
        </para>
        <programlisting role="php"><![CDATA[
Zend_Search_Lucene_Search_Query_Phrase(
    [array $terms[, array $offsets[, string $field]]]
);
]]></programlisting>

        <para>
            Der <code>$terms</code> Parameter ist ein Array von Strings die ein Set von Phrasen Strings
            enthalten. Wenn er ausgelassen wird oder null ist, wird eine leere Abfrage erstellt.
        </para>

        <para>
            Der <code>$offsets</code> Parameter ist von ganzen Zahlen, welche den Offset von Begriffen in
            einer Phrase enthalten. Wenn er ausgelassen wird oder null ist, werden die Positionen der Begriffe
            als sequentiell, ohne Zwischenräume, angenommen.
        </para>

        <para>
            Der <code>$field</code> Parameter ist ein String, der das zu durchsuchende Dokumentenfeld angibt.
            Wenn dies ausgelassen wird oder null entspricht, wird das Standardfeld durchsucht.
        </para>

        <programlisting role="php"><![CDATA[
$query =
    new Zend_Search_Lucene_Search_Query_Phrase(array('zend', 'framework'));
]]></programlisting>
        <para>
            Wird nach der Phrase 'zend framework' in allen Feldern suchen.
        </para>

        <programlisting role="php"><![CDATA[
$query = new Zend_Search_Lucene_Search_Query_Phrase(
                 array('zend', 'download'), array(0, 2)
             );
]]></programlisting>

        <para>
            Es wird nach der Phrase 'zend ????? download' gesucht und die Phrasen 'zend platform download',
            'zend studio download', 'zend core download', 'zend framework download' und so weiter
            werden gefunden.
        </para>

        <programlisting role="php"><![CDATA[
$query = new Zend_Search_Lucene_Search_Query_Phrase(
                 array('zend', 'framework'), null, 'title'
             );
]]></programlisting>

        <para>
            Wird nach der Phrase 'zend framework' im 'title' Feld suchen.
        </para>


        <para>
            Die <classname>Zend_Search_Lucene_Search_Query_Phrase::addTerm()</classname> Methode nimmt zwei
            Argumente entgeben. Ein <classname>Zend_Search_Lucene_Index_Term</classname> Objekt ist
            erforderlich und die Position optional:
        </para>
        <programlisting role="php"><![CDATA[
Zend_Search_Lucene_Search_Query_Phrase::addTerm(
    Zend_Search_Lucene_Index_Term $term[, integer $position]
);
]]></programlisting>

        <para>
            <code>$term</code> enthält den nächsten Begriff in der Phrase. Er muss das selbe Feld
            ansprechen wie der vorherige Begriff. Andernfalls wird eine Ausnahme geworfen.
        </para>

        <para>
            <code>$position</code> gibt die Position des Begriffes an.
        </para>

        <programlisting role="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>
            Demnach wird hier nach der Phrase 'zend framework' gesucht.
        </para>

        <programlisting role="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>
            Es wird nach der Phrase 'zend ????? download' gesucht und die Phrasen 'zend platform download',
            'zend studio download', 'zend core download', 'zend framework download' und so weiter
            werden gefunden.
        </para>

        <programlisting role="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>
            Es wird nach der Phrase 'zend framework' im 'title' Feld gesucht.
        </para>

        <para>
            Der Ungenauigkeitsfaktor (slop factor) legt die Anzahl der anderen Wörter fest die zwischen den
            spezifizierten Phrasenabfragen erlaubt sind. Wenn der Wert 0 ist, ist die entsprechende Abfrage
            eine exakte Suche nach der Phrase. Für größere Werte funktioniert das ähnlich dem WITHIN (innerhalb)
            oder NEAR (nahe) Operator.
        </para>
        <para>
            Der Ungenauigkeitsfaktor ist tatsächlich eine veränderbare Distanz, wobei die Veränderung dem
            Verschieben von Begriffen in der Phrasenabfrage entspricht. Um zum Beispiel die Reihenfolge von
            zwei Wörtern zu wechseln, werden zwei Verschiebungen benötigt (die erste Verschiebung plaziert die
            Wörter übereinander). Um also die Neusortierung der Phrasen zu erlauben, muß der
            Ungenauigkeitsfaktor mindestens zwei sein.
        </para>
        <para>
            Exaktere Treffer werden höher bewertet als ungenauere Treffer, so dass die
            Suchergebnisse nach der Genauigkeit sortiert werden. Die Ungenauigkeit liegt
            standardmäßig bei 0, was exakte Treffer erfordert.
        </para>
        <para>
            Der Ungenauigkeitsfaktor kannnach der Erstellung der Abfrage zugeordnet werden:
        </para>
        <programlisting role="php"><![CDATA[
// Query without a gap.
$query =
    new Zend_Search_Lucene_Search_Query_Phrase(array('word1', 'word2'));

// Search for 'word1 word2', 'word1 ... word2'
$query->setSlop(1);
$hits1 = $index->find($query);

// Search for '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>Bereichsabfragen</title>
        <para>
            <link linkend="zend.search.lucene.query-language.range">Bereichsabfragen</link> sind dazu gedacht
            Terme innerhalb eines spezifizierten Intervalls zu suchen.
        </para>

        <para>
            Abfragestring:
            <programlisting role="querystring"><![CDATA[
mod_date:[20020101 TO 20030101]
title:{Aida TO Carmen}
]]></programlisting>
        </para>

        <para>oder</para>

        <para>
            Abfrageerstellung durch die API:
            <programlisting role="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>
            Begriffsfelder sind optional. <classname>Zend_Search_Lucene</classname> durchsucht alle Felder wenn das Feld nicht spezifiziert
            wurde:
            <programlisting role="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>
            Jede (aber nicht beide) der Begrenzungsausdrücke kann auf null gesetzt werden. <classname>Zend_Search_Lucene</classname> sucht
            vom Anfang oder bis zum Ende des Verzeichnisses für die spezifizierten Feld(er) für diesen Fall:
            <programlisting role="php"><![CDATA[
// Sucht nach ['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:
-->