Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Bedingungs- und Filterausdrücke, Operatoren und Funktionen in DynamoDB
<a name="Expressions.OperatorsAndFunctions"></a>

Zum Bearbeiten der Daten in einer DynamoDB-Tabelle verwenden Sie die Operationen `PutItem`, `UpdateItem` und `DeleteItem`. Für diese Datenmanipulationsoperationen können Sie einen Bedingungsausdruck angeben, um zu ermitteln, welche Elemente geändert werden sollten. Wenn der Bedingungsausdruck „true“ ergibt, ist die Operation erfolgreich. Andernfalls schlägt sie fehl.

In diesem Abschnitt werden die integrierten Funktionen und Schlüsselwörter zum Schreiben von Filter- und Bedingungsausdrücken in Amazon DynamoDB erörtert. Ausführlichere Informationen zu Funktionen und Programmierung mit DynamoDB finden Sie unter [Programmieren mit DynamoDB und AWS SDKs](Programming.md) und in der [DynamoDB-API-Referenz](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/).

**Topics**
+ [Syntax für Filter- und Bedingungsausdrücke](#Expressions.OperatorsAndFunctions.Syntax)
+ [Durchführen von Vergleichen](#Expressions.OperatorsAndFunctions.Comparators)
+ [Funktionen](#Expressions.OperatorsAndFunctions.Functions)
+ [Logische Auswertungen](#Expressions.OperatorsAndFunctions.LogicalEvaluations)
+ [Klammern](#Expressions.OperatorsAndFunctions.Parentheses)
+ [Priorität in Bedingungen](#Expressions.OperatorsAndFunctions.Precedence)

## Syntax für Filter- und Bedingungsausdrücke
<a name="Expressions.OperatorsAndFunctions.Syntax"></a>

In der folgenden Syntaxzusammenfassung {{operand}} kann an wie folgt lauten: 
+ Ein Attributname auf oberster Ebene, z. B. `Id`, `Title`, `Description` oder `ProductCategory`
+ Ein Dokumentpfad, der auf ein verschachteltes Attribut verweist

```
condition-expression ::=
      {{operand}} comparator {{operand}}
    | {{operand}} BETWEEN {{operand}} AND {{operand}}
    | {{operand}} IN ( {{operand}} (',' {{operand}} (, ...) ))
    | function
    | {{condition}} AND {{condition}}
    | {{condition}} OR {{condition}}
    | NOT {{condition}}
    | ( {{condition}} )

comparator ::=
    =
    | <>
    | <
    | <=
    | >
    | >=

function ::=
    attribute_exists ({{path}})
    | attribute_not_exists ({{path}})
    | attribute_type ({{path}}, {{type}})
    | begins_with ({{path}}, {{substr}})
    | contains ({{path}}, {{operand}})
    | size ({{path}})
```

## Durchführen von Vergleichen
<a name="Expressions.OperatorsAndFunctions.Comparators"></a>

Verwenden Sie diese Komparatoren, um einen Operanden mit einem einzelnen Wert zu vergleichen:
+ `{{a}} = {{b}}`— Wahr, wenn gleich {{a}} ist{{b}}.
+ `{{a}} <> {{b}}`— Wahr, wenn ungleich {{a}} ist{{b}}.
+ `{{a}} < {{b}}`— {{a}} Stimmt, wenn weniger als{{b}}.
+ `{{a}} <= {{b}}`— Wahr, wenn kleiner oder gleich {{a}} ist{{b}}.
+ `{{a}} > {{b}}`— Wahr, wenn größer als {{a}} ist{{b}}.
+ `{{a}} >= {{b}}`— Wahr, wenn größer oder gleich {{a}} ist{{b}}.

Verwenden Sie die Schlüsselwörter `BETWEEN` und `IN`, um einen Operanden mit einer Reihe von Werten oder einer Aufzählung von Werten zu vergleichen:
+ `{{a}} BETWEEN {{b}} AND {{c}}`— Wahr{{b}}, wenn größer oder gleich und kleiner als oder gleich {{a}} ist{{c}}.
+ `{{a}} IN ({{b}}, {{c}}, {{d}}) `— Wahr, wenn {{a}} es einem beliebigen Wert in der Liste entspricht, z. B. einem beliebigen Wert von {{b}}{{c}}, oder. {{d}} Die Liste kann bis zu 100 Werte enthalten, die durch Kommas getrennt sind.

Um nach einem booleschen Attribut zu filtern, vergleichen Sie es mit einem booleschen Wert, indem Sie den `=` `<>` Operator or verwenden — Sie können das Attribut nicht alleine als Bedingung referenzieren. Geben Sie den booleschen Wert in den Ausdrucksattributwerten an. Der folgende Filterausdruck gibt beispielsweise nur Elemente zurück, deren `isVisible` Attribut lautet: `true`

```
--filter-expression "isVisible = :visible" \
--expression-attribute-values '{":visible": {"BOOL": true}}'
```

## Funktionen
<a name="Expressions.OperatorsAndFunctions.Functions"></a>

Verwenden Sie die folgenden Funktionen, um zu bestimmen, ob ein Attribut in einem Element vorhanden ist, oder um den Wert eines Attributs zu bewerten. Bei Funktionsnamen wird zwischen Groß- und Kleinschreibung unterschieden. Bei einem verschachtelten Attribut müssen Sie den vollständigen Dokumentpfad angeben.



| Funktion | Description | 
| --- | --- | 
| `attribute_exists ({{path}})` | True, wenn das Element das von `path` angegebene Attribut enthält.<br />Ein Attribut, dessen gespeicherter Wert vom Typ Null (`NULL`) ist, wird immer noch als vorhanden betrachtet und `attribute_exists` gibt daher den Wert true zurück. Dies unterscheidet sich von einem Attribut, das im Element fehlt. Einige SDKs und Objektmapper lassen Attribute, die einen Nullwert haben, in Ihrer Anwendung weg, anstatt den `NULL` Typ zu speichern. In diesem Fall ist das Attribut nicht vorhanden und `attribute_exists` gibt false zurück.<br />Beispiel: Prüfung, ob ein Element in der Tabelle `Product` über ein Seitenansichtsbild verfügt.+  `attribute_exists (#Pictures.#SideView)`  | 
| `attribute_not_exists ({{path}})` | True, wenn das Element das von `path` angegebene Attribut nicht enthält.<br />Beispiel: Prüfung, ob ein Element über ein `Manufacturer`-Attribut verfügt+  `attribute_not_exists (Manufacturer)`  | 
| `attribute_type ({{path}}, {{type}})` | True, wenn das Attribut am angegebenen Pfad einen bestimmten Datentyp hat. Der Parameter `type` muss einer der folgenden Werte aufweisen:+  `S` – Zeichenfolge <br />+  `SS` – Zeichenfolgensatz <br />+  `N` – Zahl <br />+  `NS` – Zahlensatz <br />+  `B` – Binary <br />+  `BS` – Binärzahlensatz <br />+  `BOOL` – Boolean <br />+  `NULL` – Nullwert <br />+  `L` – Liste <br />+  `M` – Zuordnung <br />Sie müssen einen Ausdrucksattributwert für den Parameter `type` verwenden.<br />Beispiel: Prüfung, ob das Attribut `QuantityOnHand` vom Typ Liste ist. In diesem Beispiel ist `:v_sub` ein Platzhalter für die Zeichenfolge `L`.+   `attribute_type (ProductReviews.FiveStar, :v_sub)` <br />Sie müssen einen Ausdrucksattributwert für den Parameter `type` verwenden.  | 
| `begins_with ({{path}}, {{substr}})` | True, wenn das von `path` angegebene Attribut mit einer bestimmten Teilzeichenfolge beginnt.<br />Beispiel: Prüfung, ob die ersten Zeichen der URL zum Vorderansichtsbild `http://` lauten.+  `begins_with (Pictures.FrontView, :v_sub)` <br />Der Ausdrucksattributwert `:v_sub` ist ein Platzhalter für `http://`. | 
| `contains ({{path}}, {{operand}})` | True, wenn das von `path` angegebene Attribut Folgendes ist:+  ein `String`, der eine bestimmte Teilzeichenfolge enthält <br />+  ein `Set`, der ein bestimmtes Element innerhalb des Satzes enthält <br />+  ein `List`, der ein bestimmtes Element innerhalb der Liste enthält <br />Wenn das von `path` angegebene Attribut eine `String` ist, muss der `operand` `String` sein. Wenn das von `path` angegebene Attribut `Set` ist muss `operand` der Elementtyp des Satzes sein.<br />Der Pfad und der Operand müssen unterschiedlich sein. Das heißt, bei `contains (a, a)` wird ein Fehler zurückgegeben.<br />Beispiel: Prüfung, ob das Attribut `Brand` die Teilzeichenfolge `Company` enthält.+  `contains (Brand, :v_sub)` <br />Der Ausdrucksattributwert `:v_sub` ist ein Platzhalter für `Company`.<br />Beispiel: Prüfung, ob das Produkt in rot verfügbar ist.+  `contains (Color, :v_sub)` <br />Der Ausdrucksattributwert `:v_sub` ist ein Platzhalter für `Red`. | 
| `size ({{path}})` | Gibt eine Zahl zurück, die für die Größe eines Attributs steht. Die folgenden sind gültige Datentypen, die mit `size` verwendet werden können.<br /><br />Wenn das Attribut vom Typ `String` ist, gibt `size` die Länge der Zeichenfolge zurück.<br />Beispiel: Prüfung, ob die Zeichenfolge `Brand` kleiner oder gleich 20 Zeichen ist. Der Ausdrucksattributwert `:v_sub` ist ein Platzhalter für `20`.+  `size (Brand) <= :v_sub` <br /><br />Wenn das Attribut vom Typ `Binary` ist, gibt `size` die Anzahl der Bytes im Attributwert zurück.<br />Beispiel: Angenommen, das Element `ProductCatalog` verfügt über ein binäres Attribut mit der Bezeichnung `VideoClip`, das ein kurzes Video über das betreffende Produkt enthält. Der folgende Ausdruck überprüft, ob `VideoClip` 64.000 Byte überschreitet. Der Ausdrucksattributwert `:v_sub` ist ein Platzhalter für `64000`. +  `size(VideoClip) > :v_sub` <br /><br />Wenn das Attribut vom Typ `Set` ist, gibt `size` die Anzahl der Elemente im Satz zurück. <br />Beispiel: Prüfung, ob das Produkt in mehr als einer Farbe verfügbar ist. Der Ausdrucksattributwert `:v_sub` ist ein Platzhalter für `1`.+  `size (Color) < :v_sub` <br /><br />Wenn das Attribut vom Typ `List` oder `Map` ist, gibt `size` die Anzahl der untergeordneten Elemente zurück.<br />Beispiel: Prüfung, ob die Anzahl der `OneStar`-Rezensionen einen bestimmten Grenzwert überschritten hat. Der Ausdrucksattributwert `:v_sub` ist ein Platzhalter für `3`.+  `size(ProductReviews.OneStar) > :v_sub`  | 

## Logische Auswertungen
<a name="Expressions.OperatorsAndFunctions.LogicalEvaluations"></a>

Verwenden Sie die Schlüsselwörter `AND`, `OR` und `NOT`, um logische Auswertungen durchzuführen. In der folgenden Liste {{b}} stehen sie für Bedingungen, {{a}} die ausgewertet werden müssen.
+ `{{a}} AND {{b}}`— Wahr, wenn {{a}} und beide wahr {{b}} sind.
+ `{{a}} OR {{b}}`— Wahr, wenn entweder {{a}} oder {{b}} (oder beide) wahr sind.
+ `NOT {{a}}`— Wahr, wenn falsch {{a}} ist. Falsch, wenn wahr {{a}} ist.

Im Folgenden finden Sie ein Codebeispiel für AND in einer Operation.

`dynamodb-local (*)> select * from exprtest where a > 3 and a < 5;`

## Klammern
<a name="Expressions.OperatorsAndFunctions.Parentheses"></a>

Verwenden Sie Klammern, um die Priorität einer logischen Auswertung zu ändern. Nehmen wir zum Beispiel an, dass die Bedingungen {{b}} 1 {{a}} und 2 wahr sind und diese Bedingung falsch {{c}} ist. Der folgenden Ausdruck ergibt True:
+ `{{a}} OR {{b}} AND {{c}}`

Wenn Sie jedoch eine Bedingung in Klammern setzen, wird diese zuerst ausgewertet. Folgendes ergibt z. B. False:
+  `({{a}} OR {{b}}) AND {{c}}`

**Anmerkung**  
Sie können Klammern in einem Ausdruck schachteln. Die innersten Klammern werden zuerst ausgewertet.

Im Folgenden finden Sie ein Codebeispiel mit Klammern in einer logischen Auswertung.

`dynamodb-local (*)> select * from exprtest where attribute_type(b, string) or ( a = 5 and c = “coffee”);`

## Priorität in Bedingungen
<a name="Expressions.OperatorsAndFunctions.Precedence"></a>

 DynamoDB wertet Bedingungen von links nach rechts entsprechend der folgenden Prioritätsregeln aus:
+ `= <> < <= > >=`
+ `IN`
+ `BETWEEN`
+ `attribute_exists attribute_not_exists begins_with contains`
+ Klammern
+ `NOT`
+ `AND`
+ `OR`