<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 15743 -->
<!-- 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 language="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 language="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 language="querystring"><![CDATA[
word1
]]></programlisting>

        <para>oder</para>

        <para>
            Aufbau der Abfrage mit der Programmierschnittstelle (API):
        </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>
            Das Term Feld ist optional. <classname>Zend_Search_Lucene</classname> durchsucht alle
            indizierten Felder in jedem Dokument wenn das Feld nicht spezifiziert
            wurde:
            <programlisting language="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 language="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 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>
            Es ist auch möglich Begriffslisten in einem MultiTerm Anfrage Konstruktor zu
            spezifizieren:
            <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>
            Das <code>$signs</code> Array enthält Informationen über den Begriffstyp:
            <itemizedlist>
                <listitem>
                    <para>
                        <constant>TRUE</constant> wird für notwendige Begriffe verwendet.
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <constant>FALSE</constant> wird für verbotene Begriffe verwendet.
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <constant>NULL</constant> 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 language="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 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  /* 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 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>
            Das <code>$signs</code> Array enthält Informationen über den Typ der Unterabfrage:
            <itemizedlist>
                <listitem>
                    <para>
                        <constant>TRUE</constant> wird verwendet um eine benötigte Unterabfrage zu
                        definieren.
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <constant>FALSE</constant> wird verwendet um eine verbotene Unterabfrage zu
                        definieren.
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <constant>NULL</constant> 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 language="querystring"><![CDATA[
word1 AND (word2 AND word3 AND NOT word4) OR word5
]]></programlisting>
            ist identisch mit
            <programlisting language="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 language="querystring"><![CDATA[
field1:test*
]]></programlisting>
        </para>

        <para>oder</para>

        <para>
            Abfrageerstellung durch die API:
            <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>
            Die Ausdrucksfelder sind optional. <classname>Zend_Search_Lucene</classname> durchsucht
            alle Felder in jedem Dokument wenn kein Feld spezifiziert wurde:
            <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>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 language="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 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>
            Optional kann die Ähnlichkeit nach dem "~" Zeichen spezifiziert werden.
        </para>

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

        <para>oder</para>

        <para>
            Abfrageerstellung durch die API:
            <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>
            Das Term Feld ist optional. <classname>Zend_Search_Lucene</classname> durchsucht alle
            Felder in jedem Dokument ob ein Feld nicht spezifiziert ist:
            <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>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 language="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 language="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 language="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 language="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 language="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 language="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 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>
            Demnach wird hier nach der Phrase 'zend framework' gesucht.
        </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>
            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 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>
            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 language="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 language="querystring"><![CDATA[
mod_date:[20020101 TO 20030101]
title:{Aida TO Carmen}
]]></programlisting>
        </para>

        <para>oder</para>

        <para>
            Abfrageerstellung durch die API:
            <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>
            Begriffsfelder sind optional. <classname>Zend_Search_Lucene</classname> durchsucht alle
            Felder wenn das Feld nicht spezifiziert wurde:
            <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>
            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 language="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:
-->