> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Abfragesprache

> XML-Abfragesprache für FlexiCapture-Extraktionsskripte: Erstellen Sie Contain-Abfragen mit Required-, Optional- und Except-Elementen, Abständen und Fuzzy-Suche.

Eine Abfrage legt fest, welche Wörter oder Wortkombinationen ein Dokument enthalten muss. Die von Extraktionsskripten verwendete Abfragesprache basiert auf XML.

<div id="basic-query-structure">
  ## Grundlegende Abfragestruktur
</div>

Eine einfache Abfrage sieht folgendermaßen aus:

```xml theme={null}
<Request>
    <Query>
        <Contain>
            <Required>
                <Form><Text>first</Text></Form>
            </Required>
            <Optional>
                <Form><Text>second</Text></Form>
            </Optional>
            <Except>
                <Query>
                    <Contain>
                        <Required>
                            <Form><Text>third</Text></Form>
                        </Required>
                        <Optional>
                            <Form><Text>fourth</Text></Form>
                        </Optional>
                    </Contain>
                </Query>
            </Except>
        </Contain>
    </Query>
</Request>
```

Die folgenden Elemente bilden eine Abfrage:

| Element     | Beschreibung                                                                                                                                                                                                                         |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `<Request>` | Stammelement einer Abfrage.                                                                                                                                                                                                          |
| `<Query>`   | Einfache Abfrage. Enthält einen Abfragebaum, der die Bedingungen angibt, die die Wortkombination erfüllen muss. Eine einfache Abfrage kann Teil einer Kombination von Wortformen in einer übergeordneten Abfrage sein. Erforderlich. |
| `<Contain>` | Gibt an, welche Wörter oder Wortkombinationen ein Dokument enthalten muss. Eine Abfrage kann nur ein `<Contain>`-Element enthalten. Erforderlich.                                                                                    |

Das `<Contain>`-Element kann eine beliebige Anzahl der folgenden Elemente in beliebiger Reihenfolge enthalten:

| Element      | Beschreibung                                                                                      |
| ------------ | ------------------------------------------------------------------------------------------------- |
| `<Required>` | Gibt eine Wortform oder Unterabfrage an, die eine Wortkombination enthalten muss. Optional.       |
| `<Optional>` | Gibt eine Wortform oder Unterabfrage an, die eine Wortkombination enthalten kann. Optional.       |
| `<Except>`   | Gibt eine Wortform oder Unterabfrage an, die eine Wortkombination nicht enthalten darf. Optional. |

Jedes dieser Elemente muss eines der folgenden Elemente enthalten:

| Element   | Beschreibung                                                                                                            |
| --------- | ----------------------------------------------------------------------------------------------------------------------- |
| `<Query>` | Gibt an, ob eine Zeichenfolge von Wortformen in die Wortkombination aufgenommen oder daraus ausgeschlossen werden muss. |
| `<Form>`  | Gibt an, ob eine Wortform in eine Wortkombination aufgenommen oder daraus ausgeschlossen werden muss.                   |

<Note>
  Das `<Contain>`-Element muss mindestens ein `<Required>`- oder `<Optional>`-Element enthalten.
</Note>

<div id="attributes-of-the-contain-element">
  ## Attribute des Contain-Elements
</div>

Zusätzliche Einschränkungen für Kombinationen von Wortformen können in den Attributen des Tags `<Contain>` festgelegt werden.

<div id="mincount-attribute">
  ### Attribut `MinCount`
</div>

Geben Sie im Attribut `MinCount` die Mindestanzahl von Elementen in einer Kombination von Wortformen an. Jedes Element ist entweder eine Wortform oder eine von der Unterabfrage zurückgegebene Folge von Wortformen. Der Standardwert des Attributs ist `1`. Der Wert dieses Parameters darf nicht größer sein als die Gesamtzahl der Elemente `<Required>` und `<Optional>` in der Kombination von Wortformen.

Dieser Parameter ist nützlich, wenn eine Kombination von Wortformen ein oder mehrere `<Optional>`-Elemente enthält.

Die folgende Abfrage sucht nach dem ersten oder dem zweiten Parameter:

```xml theme={null}
<Query>
    <Contain>
        <Optional>
            <Form><Text>first</Text></Form>
        </Optional>
        <Optional>
            <Form><Text>second</Text></Form>
        </Optional>
    </Contain>
</Query>
```

Mit der folgenden Abfrage werden mindestens drei der vier in der Abfrage angegebenen Wörter gefunden, von denen zwei erforderlich sind:

```xml theme={null}
<Query>
    <Contain MinCount="3">
        <Optional>
            <Form><Text>US</Text></Form>
        </Optional>
        <Required>
            <Form><Text>President</Text></Form>
        </Required>
        <Optional>
            <Form><Text>Barack</Text></Form>
        </Optional>
        <Required>
            <Form><Text>Obama</Text></Form>
        </Required>
    </Contain>
</Query>
```

Diese Abfrage findet folgende Ausdrücke: „US President Barack Obama“, „President Barack Obama“ und „US President Obama“.

<div id="keeporder-attribute">
  ### KeepOrder-Attribut
</div>

Um eine feste Reihenfolge von Elementen in einer Kombination von Wortformen festzulegen, verwenden Sie das Attribut `KeepOrder` vom Typ Boolean. Der Standardwert des Attributs ist `false`.

Die folgende Abfrage legt fest, dass die Reihenfolge der Elemente festgelegt ist:

```xml theme={null}
<Query>
    <Contain KeepOrder="true">
        <Required>
            <Form><Text>first</Text></Form>
        </Required>
        <Required>
            <Form><Text>second</Text></Form>
        </Required>
        <Required>
            <Form><Text>third</Text></Form>
        </Required>
    </Contain>
</Query>
```

Die Kombination „first third second third“ entspricht nicht der Abfrage, obwohl die Abfrage eine Wortfolge enthält, die in der erforderlichen Reihenfolge angeordnet ist.

`KeepOrder` gilt auch für alle `<Except>`-Elemente. Wörter, die in einer Abfrage den `<Except>`-Elementen entsprechen, dürfen nicht zwischen den Wörtern vorkommen, die sie in der Abfrage voneinander trennen. Sie können jedoch an beliebigen anderen Positionen außerhalb der Abfragestrings mit fester Reihenfolge vorkommen.

Wenn Sie beispielsweise die vorherige Abfrage ändern und die Wortform „second“ statt in ein `<Required>`- in ein `<Except>`-Element setzen, entspricht ein Dokument, das die Kombination der Wortformen „first third second“ enthält, der Abfrage (die Wortform „second“ wird jedoch nicht in das Ergebnis aufgenommen). Wenn Sie anschließend das Attribut `KeepOrder` entfernen, wird ein Dokument, das die Kombination der Wortformen „first third second“ enthält, nicht in das Ergebnis aufgenommen, da die Wortform „second“ nirgendwo im Text eines Dokuments vorkommen darf.

<div id="mindistance-and-maxdistance-attributes">
  ### MinDistance- und MaxDistance-Attribute
</div>

Die Attribute `MinDistance` und `MaxDistance` geben den minimalen und maximalen Abstand zwischen Wörtern in einer Abfrage an. Diese Attribute haben keine Standardwerte. Wenn eines der beiden Attribute nicht angegeben ist, gelten keine Abstandsbeschränkungen.

Der Abstand zwischen Wörtern wird in Wörtern gemessen und als Differenz zwischen den Positionen der beiden entsprechenden Wörter berechnet. Der Abstand zwischen zwei benachbarten Wörtern beträgt 1, daher ist der Mindestwert für beide Attribute 1. `MaxDistance` muss größer oder gleich `MinDistance` sein.

Der Abstand zwischen zwei Wortfolgen wird wie folgt berechnet. Wenn sich die Wortfolgen nicht überlappen, wird der Abstand als Differenz zwischen der Position des ganz links stehenden Worts in der rechten Wortfolge und der Position des ganz rechts stehenden Worts in der linken Wortfolge berechnet. Wenn sich die Wortfolgen überlappen, wird ein Abstand von 0 angenommen.

Beispielsweise beträgt in der Formulierung „The quick brown fox jumped over the lazy dog“ der Abstand zwischen den Wortfolgen „quick fox“ und „lazy dog“ 4, und der Abstand zwischen den Wortfolgen „quick fox“ und „brown lazy dog“ beträgt 0.

Für `<Except>`-Elemente wird der Abstand zwischen Wörtern wie folgt berechnet:

* Wenn `KeepOrder="true"` gilt, darf das Wort nicht innerhalb des angegebenen Abstands zu den benachbarten Wörtern in der Wortfolge vorkommen (also zu den Wörtern, zwischen denen es in der Abfrage vorkommt). Gleichzeitig muss der Abstand zwischen den Nachbarn des `<Except>`-Elements innerhalb des angegebenen Bereichs liegen.
* Wenn `KeepOrder="false"` gilt, darf das Wort nicht innerhalb des angegebenen Abstands zu irgendeinem anderen Wort in der Wortfolge vorkommen.

Die folgende Abfrage verwendet `KeepOrder="true"` und `MaxDistance="2"`:

```xml theme={null}
<Query>
    <Contain KeepOrder="true" MaxDistance="2">
        <Required>
            <Form><Text>sodium /Text></Form>
        </Required>
        <Except>
            <Form><Text>tetraborate</Text></Form>
        </Except>
        <Optional>
            <Form><Text>carborate</Text></Form>
        </Optional>
        <Optional>
            <Form><Text>sulfate</Text></Form>
        </Optional>
        <Required>
            <Form><Text>decahydrate</Text></Form>
        </Required>
    </Contain>
</Query>
```

Diese Abfrage findet Ausdrücke wie „sodium carborate decahydrate“ und „sodium sulfate decahydrate“.

Die nächste Abfrage verwendet `KeepOrder="false"` und `MaxDistance="2"`:

```xml theme={null}
<Query>
    <Contain KeepOrder="false" MaxDistance="2">
        <Required>
            <Form><Text>sodium /Text></Form>
        </Required>
        <Except>
            <Form><Text>tetraborate</Text></Form>
        </Except>
        <Optional>
            <Form><Text>carborate</Text></Form>
        </Optional>
        <Optional>
            <Form><Text>sulfate</Text></Form>
        </Optional>
        <Required>
            <Form><Text>decahydrate</Text></Form>
        </Required>
    </Contain>
</Query>
```

Diese Abfrage findet nur „Natriumsulfat-Decahydrat“, weil das Wort "tetraborate" in den `<Except>`-Tags steht und der maximale Abstand zwischen "tetraborate" und „sodium“ zwei Wörter beträgt.

<div id="form-element">
  ## Form-Element
</div>

Eine Abfrage für eine Wortform wird mit einem `<Form>`-Element angegeben. Dieses Element kann die folgenden Elemente enthalten:

* `<Attributes>` — Optionales Element, das eine Abfrage nach den Attributen einer Wortform enthält. Weitere Informationen finden Sie unter [Wann Extraktionsskripte verwendet werden](/de/flexi-capture/nlp-extraction-scripts).
* `<Text>` — Optionales Element, das den Unicode-Text einer Wortform enthält. Wenn kein Text angegeben ist, erfüllt jedes Wort, das der Attributabfrage entspricht, die Abfrage. In diesem Fall ist die Attributabfrage erforderlich.

Zusätzliche Suchbedingungen für eine Wortform können in den Attributen des Tags `<Form>` angegeben werden.

<div id="searchtype-attribute">
  ### SearchType-Attribut
</div>

Der Typ der Suche nach Wortformen kann im Attribut `SearchType` des Tags `<Form>` angegeben werden. Dieses Attribut kann die folgenden Werte haben:

| Wert                | Beschreibung                                                                                                                                                                                                                                                                                                                                                         |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `AllFormsSearch`    | Sucht nach allen Formen des angegebenen Worts.                                                                                                                                                                                                                                                                                                                       |
| `ExactSearch`       | Sucht nur nach der angegebenen Form des Worts.                                                                                                                                                                                                                                                                                                                       |
| `PrefixSearch`      | Sucht nach allen Wortformen, die mit der angegebenen Zeichenfolge beginnen.                                                                                                                                                                                                                                                                                          |
| `FuzzySearch`       | Führt eine Fuzzy-Suche nach dem angegebenen Wort durch. Dies ist nützlich, wenn Ihre Texte OCR-Fehler enthalten können und `ExactSearch` deshalb nicht funktioniert. Kann nur für Wörter mit mindestens 3 Zeichen verwendet werden. Bei Wörtern mit 3 bis 5 Zeichen ist 1 OCR-Fehler zulässig, bei Wörtern mit mehr als 5 Zeichen sind bis zu 2 OCR-Fehler zulässig. |
| `FuzzyPrefixSearch` | Führt eine Fuzzy-Suche nach allen Wörtern durch, die mit der angegebenen Zeichenfolge beginnen.                                                                                                                                                                                                                                                                      |

Das Attribut `SearchType` ist optional. Standardmäßig ist `AllFormsSearch` festgelegt.

<div id="casesensitive-attribute">
  ### Attribut CaseSensitive
</div>

Für Suchen unter Beachtung der Groß-/Kleinschreibung kann das Attribut `CaseSensitive` des Tags `<Form>` verwendet werden. Dieses Attribut ist optional und standardmäßig auf `false` gesetzt.

Die folgende Abfrage verwendet die Attribute `SearchType` und `CaseSensitive` des Tags `<Form>`:

```xml theme={null}
<Query>
    <Contain KeepOrder="true">
        <Required>
            <Form SearchType="ExactSearch" CaseSensitive="true">
                <Text>WHO</Text>
            </Form>
        </Required>
    </Contain>
</Query>
```

Diese Abfrage sucht nach dem Akronym WHO genau in dieser Schreibweise. So lässt sich eine große Zahl redundanter Ergebnisse vermeiden, die „who“, „whom“ oder „whose“ enthalten.

<div id="attributes-element">
  ## Attributes-Element
</div>

Eine Abfrage nach Attributen von Wortformen ist ein logischer Ausdruck, der mit den Operatoren AND, OR und NOT aufgebaut wird. NOT ist ein unärer Operator, während AND und OR *n*-stellig sind. Die Operanden dieses logischen Ausdrucks sind Werte vom Typ Bool. Dieser logische Ausdruck wird in Form eines Baums geschrieben. Das Ergebnis der Abfrage sind die Wortformen im Text eines Dokuments, die diesen logischen Ausdruck erfüllen.

Um Attribute von Wortformen abzurufen, verwenden Sie ein `<Attributes>`-Element. Dieses Element kann die folgenden Elemente enthalten:

| Element       | Beschreibung                                                                                         |
| ------------- | ---------------------------------------------------------------------------------------------------- |
| `<Attribute>` | Enthält den Text des erforderlichen Wortattributs. Es ist ein Blatt im Baum des logischen Ausdrucks. |
| `<Or>`        | Der ODER-Operator. Ein Knoten im Baum.                                                               |
| `<And>`       | Der AND-Operator. Ein Knoten im Baum.                                                                |
| `<Not>`       | Der NOT-Operator. Ein Knoten im Baum.                                                                |

Das Element `<Not>` ist genauso aufgebaut wie das Element `<Attributes>` und kann nur eines dieser Elemente enthalten.

Die Elemente `<Or>` und `<And>` müssen mindestens zwei dieser Elemente enthalten.

Das Tag `<Attribute>` hat ein optionales Attribut `SearchType`, das die Art der Attributsuche angibt. Dieses Attribut kann die folgenden Werte haben:

* `ExactSearch` — Sucht nach dem Attribut genau in der in der Abfrage angegebenen Form.
* `PrefixSearch` — Sucht nach beliebigen Attributen, die mit dem angegebenen Text beginnen.

Bei der Suche nach Attributen wird immer zwischen Groß- und Kleinschreibung unterschieden. Das Attribut `SearchType` ist standardmäßig auf `ExactSearch` gesetzt.

Angenommen, Sie haben ein Dokument, in dem Sie bereits Folgendes identifiziert haben:

* NER-Objekte durch Aufruf der Funktion `ExtractNerObjects`
* Wortformen aus einem Benutzerdictionary mit dem Namen `dictionary` durch Aufruf der Funktion `ExtractWordsFromUserDictionary`
* Alle Objekte, die einem als Parameter übergebenen regulären Ausdruck entsprechen, durch Aufruf der Funktion `ExtractRegularExpression`

Angenommen, die resultierende Sammlung dieser Objekte heißt `regExp`.

<Note>
  Der Name der Sammlung kann in XML-Abfragen verwendet werden, die für das indizierte Dokument ausgeführt werden. Auf die resultierende Sammlung selbst kann über ihren Namen zugegriffen werden.
</Note>

Eine Abfrage nach Wortformattributen sieht dann wie folgt aus:

```xml theme={null}
<Query>
    <Contain>
        <Required>
            <Form>
                <Attributes>
                    <Attribute>regExp1</Attribute>
                </Attributes>
            </Form>
        </Required>
        <Required>
            <Form>
                <Attributes>
                    <And>
                        <Attribute>NerOrg1</Attribute>
                        <Not>
                            <Attribute> dictionary1</Attribute>
                        </Not>
                    </And>
                </Attributes>
            </Form>
        </Required>
    </Contain>
</Query>
```

Diese Abfrage sucht nach einer Wortgruppe aus zwei Wörtern, bei der das erste Wort dem angegebenen regulären Ausdruck entsprechen muss und das zweite ein zulässiger Name einer Organisation ist.

Die Ziffern hinter den Attributnamen kennzeichnen die gesuchten Wörter in erkannten Objekten mit mehreren Wörtern, die mit den jeweiligen Attributen indiziert wurden. Ein regulärer Ausdruck mit dem Namen `date` kann beispielsweise ein Datum im Format „May 31, 2019“ finden. Dann entspricht `date1` dem Wort „May“, `date2` „31“ und `date3` „2019“.

<div id="formset-element">
  ## FormSet-Element
</div>

Eine Abfrage für mehrere Wortformen wird mit einem `<FormSet>`-Element angegeben.

Dieser Abfragetyp kombiniert mehrere Einzelabfragen für Wortformen mit OR. Er entspricht einer `<Query>`-Abfrage, bei der alle Unterabfragen optionale Wortformabfragen sind.

Bei einer `<FormSet>`-Abfrage können Sie jedoch eine Attributabfrage angeben, die für alle Formen gemeinsam gilt. Dadurch werden Suchvorgänge effizienter, wenn `ExactSearch` verwendet wird, um alle Wortformen zu finden, für jede Form eine Attributabfrage vorhanden ist und all diese Attributabfragen ein gemeinsames Fragment enthalten.

Ein `<FormSet>`-Element enthält die folgenden Elemente:

* `<Attributes>` — Optionales Element, das eine Abfrage für Formattribute enthält. Diese Abfrage wird mit Attributabfragen für Formen per AND kombiniert.
* `<Form>` — erforderliches Element, das eine Abfrage für eine Wortform enthält. Ein `<FormSet>`-Element muss mindestens ein `<Form>`-Element enthalten.

## <a id="xml-parsing" />Beispiel für eine XML-Abfrage zur Adress-Extraktion

Das Ergebnis einer Abfrage zur Adress-Extraktion ist eine Textzeichenfolge, die das erste Wort des Landes, das erste Wort der Straße, das erste Wort der Stadt, das erste Wort des Bundesstaats und das erste Wort der Postleitzahl enthält (in dieser Reihenfolge und sofern die einzelnen Wörter jeweils nicht mehr als 5 Wörter voneinander entfernt sind).

Die aufeinanderfolgenden Wörter, aus denen eine Komponente besteht (z. B. ein Straßenname), werden im Index zusätzlich nummeriert, beginnend mit 1.

```javascript theme={null}
var xmlQuery = "<Request> \
<Query> \
     <Contain MaxDistance=\"5\" KeepOrder=\"true\"> \
          <Optional> \
               <Form><Attributes><Attribute>NerCountry1</Attribute></Attributes></Form> \
          </Optional> \
          <Optional> \
               <Form><Attributes><Attribute>NerStreet1</Attribute></Attributes></Form> \
          </Optional> \
          <Optional> \
               <Form><Attributes><Attribute>NerCity1</Attribute></Attributes></Form> \
          </Optional> \
          <Optional> \
               <Form><Attributes><Attribute>NerState1</Attribute></Attributes></Form> \
          </Optional> \
          <Required> \
               <Form><Attributes><Attribute>NerZipCode1</Attribute></Attributes></Form> \
          </Required> \
     </Contain> \
</Query> \
</Request>";
```

Das Ergebnis einer Abfrage zur Adress-Extraktion wird im wiederholbaren Feld `xmlQueryResult` gespeichert:

```javascript theme={null}
this.RunQueryAndSaveToField( xmlQuery, "query", "xmlQueryResult" );
```