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.

Verwenden Sie Ausdrücke

Bestimmte DynamoDB-Operationen akzeptieren Ausdrücke, mit denen Sie Einschränkungen oder Bedingungen angeben können. DynamoDB Mapper bietet eine idiomatische Kotlin-DSL zum Erstellen von Ausdrücken. Die DSL verleiht Ihrem Code mehr Struktur und Lesbarkeit und erleichtert auch das Schreiben von Ausdrücken.

In diesem Abschnitt wird die DSL-Syntax beschrieben und es werden verschiedene Beispiele bereitgestellt.

Verwenden Sie Ausdrücke in Operationen

Sie verwenden Ausdrücke beispielsweise in Operationenscan, bei denen die zurückgegebenen Elemente anhand von von Ihnen definierter Kriterien gefiltert werden. Um Ausdrücke mit DynamoDB Mapper zu verwenden, fügen Sie die Ausdruckskomponente zur Operationsanforderung hinzu.

Der folgende Ausschnitt zeigt ein Beispiel für einen Filterausdruck, der in einer Operation verwendet wird. scan Es verwendet ein Lambda-Argument, um die Filterkriterien zu beschreiben, die die zurückzugebenden Elemente auf Elemente mit dem year Attributwert 2001 beschränken:

val table = // A table instance.

table.scanPaginated {
    filter {
        attr("year") eq 2001
    }
}

Das folgende Beispiel zeigt eine query Operation, die Ausdrücke an zwei Stellen unterstützt: Sortierschlüsselfilterung und Nichtschlüsselfilterung:

table.queryPaginated {
    keyCondition = KeyFilter(partitionKey = 1000) { sortKey startsWith "M" }
    filter {
        attr("year") eq 2001
    }
}

Der vorherige Code filtert Ergebnisse nach Ergebnissen, die alle drei Kriterien erfüllen:

DSL-Komponenten

Die DSL-Syntax macht verschiedene Komponententypen verfügbar (siehe unten), die Sie zum Erstellen von Ausdrücken verwenden.

Attribute

Die meisten Bedingungen verweisen auf Attribute, die durch ihren Schlüssel oder Dokumentpfad identifiziert werden. Mit dem DSK erstellen Sie alle Attributreferenzen mithilfe der attr Funktion und nehmen optional weitere Änderungen vor.

Der folgende Code zeigt eine Reihe von einfachen bis komplexen Beispielattributen, z. B. die Dereferenzierung von Listen nach Index und die Dereferenzierung von Zuordnungen nach Schlüssel:

attr("foo")           // Refers to the value of top-level attribute `foo`.

attr("foo")[3]        // Refers to the value at index 3 in the list value of
                      // attribute `foo`.

attr("foo")[3]["bar"] // Refers to the value of key `bar` in the map value at
                      // index 3 of the list value of attribute `foo`.

Gleichheiten und Ungleichheiten

Sie können Attributwerte in einem Ausdruck anhand von Gleichheiten und Ungleichheiten vergleichen. Sie können Attributwerte mit Literalwerten oder anderen Attributwerten vergleichen. Die Funktionen, mit denen Sie die Bedingungen angeben, sind:

Sie kombinieren die Vergleichsfunktion mit Argumenten, indem Sie die Infix-Notation verwenden, wie in den folgenden Beispielen gezeigt:

attr("foo") eq 42           // Uses a literal. Specifies that the attribute value `foo` must be
                            // equal to 42.

attr("bar") gte attr("baz") // Uses another attribute value. Specifies that the attribute 
                            // value `bar` must be greater than or equal to the
                            // attribute value of `baz`.

Bereiche und Sätze

Zusätzlich zu Einzelwerten können Sie Attributwerte mit mehreren Werten in Bereichen oder Sätzen vergleichen. Sie verwenden die isIn Infix-Funktion, um den Vergleich durchzuführen, wie in den folgenden Beispielen gezeigt:

attr("foo") isIn 0..99  // Specifies that the attribute value `foo` must be
                        // in the range of `0` to `99` (inclusive).

attr("foo") isIn setOf( // Specifies that the attribute value `foo` must be
    "apple",            // one of `apple`, `banana`, or `cherry`.
    "banana",
    "cherry",
)

Die isIn Funktion bietet Überladungen für Sammlungen (wieSet<String>) und für Grenzen, die Sie als Kotlin ausdrücken können ClosedRange<T> (z. B.). IntRange Für Grenzen, die Sie nicht als a ausdrücken können ClosedRange<T> (wie Byte-Arrays oder andere Attributverweise), können Sie die Funktion verwenden: isBetween

val lowerBytes = byteArrayOf(0x48, 0x65, 0x6c)  // Specifies that the attribute value
val upperBytes = byteArrayOf(0x6c, 0x6f, 0x21)  // `foo` is between the values
attr("foo").isBetween(lowerBytes, upperBytes)   // `0x48656c` and `0x6c6f21`

attr("foo").isBetween(attr("bar"), attr("baz")) // Specifies that the attribute value
                                                // `foo` is between the values of
                                                // attributes `bar` and `baz`.

Boolesche Logik

Sie können einzelne Bedingungen kombinieren oder mithilfe der booleschen Logik ändern, indem Sie die folgenden Funktionen verwenden:

Die folgenden Beispiele zeigen jede Funktion:

and(                           // Both conditions must be met:
    attr("foo") eq "banana",   // * attribute value `foo` must equal `banana`
    attr("bar") isIn 0..99,    // * attribute value `bar` must be between
)                              //   0 and 99 (inclusive)

or(                            // At least one condition must be met:
    attr("foo") eq "cherry",   // * attribute value `foo` must equal `cherry`
    attr("bar") isIn 100..199, // * attribute value `bar` must be between
)                              //   100 and 199 (inclusive)

not(                           // The attribute value `foo` must *not* be
    attr("baz") isIn setOf(    // one of `apple`, `banana`, or `cherry`.
        "apple",               // Stated another way, the attribute value
        "banana",              // must be *anything except* `apple`, `banana`,
        "cherry",              // or `cherry`--including potentially a
    ),                         // non-string value or no value at all.
)

Sie können boolesche Bedingungen weiter mit booleschen Funktionen kombinieren, um verschachtelte Logik zu erstellen, wie im folgenden Ausdruck dargestellt:

or(
    and(
        attr("foo") eq 123,
        attr("bar") eq "abc",
    ),
    and(
        attr("foo") eq 234,
        attr("bar") eq "bcd",
    ),
)

Der vorherige Ausdruck filtert Ergebnisse nach Ergebnissen, die eine der folgenden Bedingungen erfüllen:

Dies entspricht dem folgenden booleschen Kotlin-Ausdruck:

(foo == 123 && bar == "abc") || (foo == 234 && bar == "bcd")

Funktionen und Eigenschaften

Die folgenden Funktionen und Eigenschaften bieten zusätzliche Ausdrucksmöglichkeiten:

Die folgenden Beispiele zeigen die Verwendung zusätzlicher Funktionen und Eigenschaften, die Sie in Ausdrücken verwenden können:

attr("foo") contains "apple" // Specifies that the attribute value `foo` must be
                             // a list that contains an `apple` element or a string
                             // which contains the substring `apple`.

attr("bar").exists()         // Specifies that the `bar` must exist and have a
                             // value (including potentially `null`).

attr("baz").size lt 100      // Specifies that the attribute value `baz` must have
                             // a size of less than 100.

attr("qux") isOfType AttributeType.String // Specifies that the attribute `qux`
                                          // must have a string value.

Schlüsselfilter sortieren

Filterausdrücke für Sortierschlüssel (z. B. im keyCondition Parameter der query Operation) verwenden keine benannten Attributwerte. Um einen Sortierschlüssel in einem Filter zu verwenden, müssen Sie das Schlüsselwort sortKey in allen Vergleichen verwenden. Das sortKey Schlüsselwort ersetztattr("<sort key name>"), wie in den folgenden Beispielen gezeigt:

sortKey startsWith "abc" // The sort key attribute value must begin with the
                         // substring `abc`.

sortKey isIn 0..99       // The sort key attribute value must be between 0
                         // and 99 (inclusive).

Sie können Sortierschlüsselfilter nicht mit boolescher Logik kombinieren und sie unterstützen nur eine Teilmenge der oben beschriebenen Vergleiche: