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.
# Scannen von Tabellen in DynamoDB
Eine `Scan`-Operation in Amazon DynamoDB liest jedes Element in einer Tabelle oder einem Sekundärindex. Standardmäßig gibt ein `Scan`-Vorgang für jedes Element in der Tabelle oder im Index alle Datenattribute zurück. Sie können den `ProjectionExpression`-Parameter verwenden, sodass `Scan` nur einige der Attribute und nicht alle zurückgibt.
`Scan` gibt immer einen Ergebnissatz zurück. Wenn keine übereinstimmenden Elemente gefunden werden, ist die Ergebnismenge leer.
Eine einzelne `Scan`-Anforderung kann maximal 1 MB Daten abrufen. DynamoDB kann optional einen Filterausdruck auf diese Daten anwenden, um die Ergebnisse einzugrenzen, bevor sie an den Benutzer zurückgegeben werden.
**Topics**
+ [Filterausdrücke für Scan](#Scan.FilterExpression)
+ [Begrenzung der Anzahl an Elementen in der Ergebnismenge](#Scan.Limit)
+ [Paginierung der Ergebnisse](#Scan.Pagination)
+ [Zählen der Elemente in den Ergebnissen](#Scan.Count)
+ [Durch die Abfrage verbrauchte Kapazitätseinheiten](#Scan.CapacityUnits)
+ [Lesekonsistenz für Scan](#Scan.ReadConsistency)
+ [Parallele Scans](#Scan.ParallelScan)
## Filterausdrücke für Scan
Wenn Sie die `Scan`-Ergebnisse weiter eingrenzen müssen, können Sie optional einen Filterausdruck angeben. Ein *Filterausdruck* bestimmt, welche Elemente in den `Scan`-Ergebnissen an Sie zurückgegeben werden. Alle anderen Ergebnisse werden verworfen.
Ein Filterausdruck wird angewendet, nachdem eine `Scan` abgeschlossen ist, aber bevor die Ergebnisse zurückgegeben werden. Folglich verbraucht eine `Scan` unabhängig davon, ob ein Filterausdruck vorhanden ist oder nicht, gleich viel Lesekapazität.
Eine `Scan`-Operation kann bis zu 1 MB an Daten abrufen. Diese Größenbeschränkung gilt, bevor der Filterausdruck ausgewertet wird.
Mit `Scan` können Sie Attribute in einem Filterausdruck angeben—einschließlich Partitionsschlüsseln und Sortierschlüsselattributen.
Die Syntax für einen Filterausdruck ist identisch mit der für einen Bedingungsausdruck. Filterausdrücke können dieselben Vergleichsoperatoren, Funktionen und logischen Operatoren wie ein Bedingungsausdruck verwenden. Weitere Informationen zu logischen Operatoren finden Sie unter [Bedingungs- und Filterausdrücke, Operatoren und Funktionen in DynamoDB](Expressions.OperatorsAndFunctions.md).
**Example**
Das folgende Beispiel AWS Command Line Interface (AWS CLI) scannt die `Thread` Tabelle und gibt nur die Elemente zurück, die zuletzt von einem bestimmten Benutzer gepostet wurden.
```
aws dynamodb scan \
--table-name Thread \
--filter-expression "LastPostedBy = :name" \
--expression-attribute-values '{":name":{"S":"User A"}}'
```
## Begrenzung der Anzahl an Elementen in der Ergebnismenge
Die `Scan`-Operation ermöglicht es Ihnen, die Anzahl der Elemente einzuschränken, die in den Ergebnissen zurückgegeben werden. Legen Sie dafür vor dem Filtern der Ausdrucksauswertung den Parameter `Limit` auf die maximale Anzahl von Elementen fest, die die `Scan`-Operation zurückgeben soll.
Beispiel: Sie führen eine `Scan`-Operation für eine Tabelle mit einem `Limit`-Wert von `6` und ohne Filterausdruck durch. Die`Scan`-Ergebnis enthält die ersten sechs Elemente der Tabelle.
Angenommen, Sie fügen nun einen Filterausdruck der `Scan` hinzu. In diesem Fall wendet DynamoDB den entsprechenden Filterausdruck auf die sechs zurückgegebenen Elemente an, wobei die nicht übereinstimmenden verworfen werden. Das letzte `Scan`-Ergebnis enthält sechs Elemente oder weniger, je nachdem, wie viele Elemente gefiltert wurden.
## Paginierung der Ergebnisse
DynamoDB *paginiert* die Ergebnisse von `Scan`-Operationen. Bei der Paginierung werden die `Scan`-Ergebnisse in „Seiten“ mit Daten von einer Größe von 1 MB (oder weniger) unterteilt. Eine Anwendung kann die erste Ergebnisseite verarbeiten, dann die zweite Seite und so weiter.
Eine einzelne `Scan`-Operation gibt nur einen Ergebnissatz zurück, der innerhalb des Grenzwerts von 1 MB liegt.
Um zu bestimmen, ob es mehr Ergebnisse gibt, und diese seitenweise abzurufen, sollten Anwendungen die folgenden Schritte ausführen:
1. Überprüfen Sie das `Scan`-Low-Level-Ergebnis:
+ Wenn das Ergebnis ein `LastEvaluatedKey`-Element enthält, fahren Sie mit Schritt 2 fort.
+ Wenn im Ergebnis *kein* `LastEvaluatedKey` vorhanden ist, sind keine Elemente mehr zum Abrufen vorhanden.
1. Erstellen Sie eine neue `Scan`-Anforderung mit den gleichen Parametern wie bei der vorherigen Anforderung. Verwenden Sie jedoch dieses Mal den `LastEvaluatedKey`-Wert aus Schritt 1 als `ExclusiveStartKey`-Parameter in der neuen `Scan`-Anforderung.
1. Führen Sie die neue `Scan`-Anforderung aus.
1. Fahren Sie mit Schritt 1 fort.
Mit anderen Worten: Der `LastEvaluatedKey` einer `Scan`-Antwort sollte als `ExclusiveStartKey` für die nächste `Scan`-Anforderung verwendet werden. Wenn in einer `Scan`-Antwort kein `LastEvaluatedKey`-Element vorhanden ist, haben Sie die letzte Ergebnisseite abgerufen. (Dass `LastEvaluatedKey` nicht vorhanden ist, ist der einzige Hinweis darauf, dass Sie das Ende des Ergebnissatzes erreicht haben.)
Sie können das verwenden AWS CLI , um sich dieses Verhalten anzusehen. Der AWS CLI sendet wiederholt `Scan` Anfragen auf niedriger Ebene an DynamoDB, bis er in den Ergebnissen nicht mehr vorhanden `LastEvaluatedKey` ist. Stellen Sie sich das folgende AWS CLI Beispiel vor, das die gesamte `Movies` Tabelle scannt, aber nur die Filme eines bestimmten Genres zurückgibt.
```
aws dynamodb scan \
--table-name Movies \
--projection-expression "title" \
--filter-expression 'contains(info.genres,:gen)' \
--expression-attribute-values '{":gen":{"S":"Sci-Fi"}}' \
--page-size 100 \
--debug
```
Normalerweise AWS CLI verarbeitet der die Seitennummerierung automatisch. In diesem Beispiel begrenzt der AWS CLI `--page-size` Parameter jedoch die Anzahl der Elemente pro Seite. Der `--debug`-Parameter gibt Low-Level-Informationen zu Anforderungen und Antworten aus.
**Anmerkung**
Ihre Paginierungsergebnisse unterscheiden sich auch basierend auf den Eingabeparametern, die Sie übergeben.
Die Verwendung von `aws dynamodb scan --table-name Prices --max-items 1` gibt `NextToken` zurück.
Die Verwendung von `aws dynamodb scan --table-name Prices --limit 1` gibt `LastEvaluatedKey` zurück.
Beachten Sie auch, dass insbesondere die Verwendung von `--starting-token` den Wert `NextToken` erfordert.
Wenn Sie das Beispiel ausführen, sieht die erste Antwort von DynamoDB ungefähr folgendermaßen aus.
```
2017-07-07 12:19:14,389 - MainThread - botocore.parsers - DEBUG - Response body:
b'{"Count":7,"Items":[{"title":{"S":"Monster on the Campus"}},{"title":{"S":"+1"}},
{"title":{"S":"100 Degrees Below Zero"}},{"title":{"S":"About Time"}},{"title":{"S":"After Earth"}},
{"title":{"S":"Age of Dinosaurs"}},{"title":{"S":"Cloudy with a Chance of Meatballs 2"}}],
"LastEvaluatedKey":{"year":{"N":"2013"},"title":{"S":"Curse of Chucky"}},"ScannedCount":100}'
```
Der `LastEvaluatedKey` in der Antwort gibt an, dass nicht alle Elemente abgerufen wurden. Das sendet AWS CLI dann eine weitere `Scan` Anfrage an DynamoDB. Dieses Anforderungs- und Antwortmuster wird bis zur endgültigen Antwort fortgesetzt.
```
2017-07-07 12:19:17,830 - MainThread - botocore.parsers - DEBUG - Response body:
b'{"Count":1,"Items":[{"title":{"S":"WarGames"}}],"ScannedCount":6}'
```
Das Fehlen von `LastEvaluatedKey` gibt an, dass keine abrufbaren Elemente mehr vorhanden sind.
**Anmerkung**
Sie AWS SDKs verarbeiten DynamoDB-Antworten auf niedriger Ebene (einschließlich des Vorhandenseins oder Fehlens von`LastEvaluatedKey`) und bieten verschiedene Abstraktionen für die Paginierung von Ergebnissen. `Scan` Beispielsweise stellt SDK für die Java-Dokumentschnittstelle `java.util.Iterator`-Unterstützung bereit, sodass Sie die Ergebnisse nacheinander durchgehen können.
Codebeispiele in verschiedenen Programmiersprachen finden Sie im [Amazon-DynamoDB-Handbuch für erste Schritte](https://docs.aws.amazon.com/amazondynamodb/latest/gettingstartedguide/) und in der AWS SDK-Dokumentation für Ihre Sprache.
## Zählen der Elemente in den Ergebnissen
Zusätzlich zu den Elementen, die mit Ihren Kriterien übereinstimmen, enthält die `Scan`-Antwort noch die folgenden Elemente:
+ `ScannedCount` – Anzahl der ausgewerteten Elemente vor jedem `ScanFilter` angewendet wird. Ein hoher `ScannedCount`-Wert mit wenigen oder gar keinen `Count`-Ergebnissen weist auf eine ineffiziente `Scan`-Operation hin. Wenn Sie keinen Filter in der Anforderung verwendet haben, haben `ScannedCount` und `Count` denselben Wert.
+ `Count` – die Anzahl der Elemente, die verbleiben, *nachdem* ein Filterausdruck (falls vorhanden) angewendet wurde.
**Anmerkung**
Wenn Sie keinen Filterausdruck verwenden, haben `ScannedCount` und `Count` denselben Wert.
Wenn der `Scan`-Ergebnissatz größer als 1 MB ist, repräsentieren `ScannedCount` und `Count` nur eine Teilmenge der Gesamtelemente. Sie müssen mehrere `Scan`-Operationen ausführen, um alle Ergebnisse abzurufen (siehe [Paginierung der Ergebnisse](#Scan.Pagination)).
Jede `Scan`-Antwort enthält die `ScannedCount` und `Count` für die Elemente, die von der betreffenden `Scan`-Anforderung verarbeitet wurden. Um eine Gesamtsumme für alle `Scan`-Anforderungen zu erhalten, könnten Sie eine laufende Zählung von `ScannedCount` und `Count` vornehmen.
## Durch die Abfrage verbrauchte Kapazitätseinheiten
Sie können `Scan` für jede Tabelle und jeden Sekundärindex ausführen. `Scan`-Operationen verbrauchen Lesekapazitätseinheiten wie folgt.
****
| Wenn Sie `Scan` eine ... | DynamoDB verbraucht Lesekapazitätseinheiten von ... |
| --- | --- |
| Tabelle | Die bereitgestellte Lesekapazität der Tabelle. |
| Globaler sekundärer Index | Die bereitgestellte Lesekapazität des Index. |
| Lokaler sekundärer Index | Die bereitgestellte Lesekapazität der Basistabelle. |
**Anmerkung**
Kontoübergreifender Zugriff für sekundäre Indexscanvorgänge wird derzeit nicht für [ressourcenbasierte Richtlinien](access-control-resource-based.md) unterstützt.
Standardmäßig gibt eine `Scan`-Operation keine Daten über seinen Lesekapazitätsverbrauch zurück. Jedoch können Sie den `ReturnConsumedCapacity`-Parameter in einer `Scan`-Anforderung angeben, um diese Information zu erhalten. Folgende sind die gültigen Einstellungen für `ReturnConsumedCapacity`:
+ `NONE` – Es werden keine verbrauchten Kapazitätsdaten zurückgegeben. (Dies ist die Standardeinstellung.)
+ `TOTAL` – Die Antwort enthält die zusammengefasste Anzahl der verbrauchten Lesekapazitätseinheiten.
+ `INDEXES` – Die Antwort zeigt die zusammengefasste Anzahl der verbrauchten Lesekapazitätseinheiten, zusammen mit der verbrauchten Kapazität für jede aufgerufene Tabelle und jeden aufgerufenen Index, an.
DynamoDB berechnet die Anzahl von verbrauchten Lesekapazitätseinheiten basierend auf der Anzahl und Größe der Elemente, nicht der Menge der Daten, die an eine Anwendung zurückgegeben werden. Aus diesem Grund bleibt die Anzahl der verbrauchten Kapazitätseinheiten gleich, unabhängig davon, ob Sie alle Attribute (das Standardverhalten) oder nur einige von ihnen anfordern (mithilfe eines Projektionsausdrucks). Die Anzahl ist auch gleich, unabhängig davon, ob Sie einen Filterausdruck verwenden oder nicht. `Scan` verbraucht eine Mindestlesekapazitätseinheit für einen strikt konsistenten Lesevorgang pro Sekunde oder zwei letztendlich konsistente Lesevorgänge pro Sekunde für ein Element von bis zu 4 KB. Wenn Sie ein Element lesen möchten, das größer als 4 KB ist, benötigt DynamoDB zusätzliche Leseanforderungseinheiten. Bei leeren Tabellen und sehr großen Tabellen mit einer geringen Anzahl an Partitionsschlüsseln können zusätzliche RCUs Gebühren anfallen, die über die Menge der gescannten Daten hinausgehen. Damit werden die Kosten für die Bearbeitung der `Scan`-Anfrage gedeckt, auch wenn keine Daten vorhanden sind.
## Lesekonsistenz für Scan
Eine `Scan`-Operation führt standardmäßig lEventually Consistent-Lesevorgänge aus. Dies bedeutet, dass die `Scan`-Ergebnisse Änderungen aufgrund kürzlich abgeschlossener `PutItem` oder `UpdateItem`-Operationen, nicht wiedergeben könnten. Weitere Informationen finden Sie unter [DynamoDB-Lesekonsistenz](HowItWorks.ReadConsistency.md).
Wenn Sie Strongly Consistent-Lesevorgänge benötigen, setzen Sie zum Zeitpunkt, an dem der `Scan` beginnt, den `ConsistentRead`-Parameter in der `Scan`-Anforderung auf `true`. Dadurch wird sichergestellt, dass alle Schreibvorgänge, die vor `Scan`-Beginn abgeschlossen wurden, in die `Scan`-Antwort aufgenommen werden.
Die Festlegung von `ConsistentRead` für `true` kann beim Backup von Tabellen oder in Replikationsszenarien mit [DynamoDB Streams](./Streams.html) hilfreich sein. Sie verwenden zuerst `Scan`, während `ConsistentRead` auf "true" eingestellt ist, um eine konsistente Kopie der Daten in der Tabelle zu erhalten. Während der `Scan`-Operation zeichnet DynamoDB Streams alle zusätzlichen Schreibaktivitäten auf, die in der Tabelle ausgeführt werden. Nach Abschluss der `Scan` können Sie die Schreibaktivität vom Stream auf die Tabelle anwenden.
**Anmerkung**
Beachten Sie, dass eine `Scan`-Operation, bei der `ConsistentRead` auf `true` festgelegt ist, doppelt so viele Lesekapazitätseinheiten verbraucht wie mit dem `ConsistentRead`-Standardwert (`false`).
## Parallele Scans
Standardmäßig verarbeitet die `Scan`-Operation Daten sequenziell. Amazon DynamoDB gibt Daten in Schritten von 1 MB an die Anwendung zurück, und eine Anwendung führt zusätzliche `Scan`-Operationen aus, um die nächsten 1 MB Daten abzurufen.
Je größer die gescannte Tabelle oder der Index, desto mehr Zeit benötigt `Scan` um zu beenden. Außerdem kann eine sequenzielle `Scan` möglicherweise die bereitgestellte Lesedurchsatzkapazität nicht immer vollständig nutzen: Auch wenn DynamoDB die Daten einer großen Tabelle über mehrere physische Partitionen verteilt, kann eine `Scan`-Operation nur jeweils eine Partition lesen. Aus diesem Grund wird der Durchsatz einer `Scan`-Operation durch den maximalen Durchsatz einer einzelnen Partition beschränkt.
Um diese Probleme zu beheben, kann die `Scan`-Operation eine Tabelle oder einen sekundären Index in mehrere *Segmente* logisch unterteilen, wobei mehrere Anwendungs-Worker die Segmente parallel scannen. Jeder Worker kann ein Thread (in Programmiersprachen, die Multithreading unterstützen) oder ein Betriebssystemprozess sein. Zum Durchführen eines parallelen Scans erstellt jeder Worker eine eigene `Scan`-Anforderung mit den folgenden Parametern:
+ `Segment` – Ein Segment, das von einem bestimmten Worker gescannt werden soll. Jeder Worker sollte einen anderen Wert für `Segment` verwenden.
+ `TotalSegments` – Die Gesamtanzahl der Segmente für den parallelen Scan. Dieser Wert muss mit der Anzahl der Worker übereinstimmen, die Ihre Anwendung verwenden wird.
Das folgende Diagramm zeigt, wie eine Multithread-Anwendung eine parallele `Scan`-Operation mit drei Grad Parallelität ausführt.
![\[Eine Multithread-Anwendung, die einen parallelen Scan durchführt, indem sie eine Tabelle in drei Segmente unterteilt.\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/ParallelScan.png)
In diesem Diagramm ruft die Anwendung drei Threads auf und weist jedem Thread eine Zahl zu. (Segmente sind nullbasiert, sodass die erste Zahl immer 0 ist.) Jeder Thread erstellt eine `Scan`-Anforderung, mit der `Segment` auf die zugewiesene Zahl und `TotalSegments` auf 3 eingestellt wird. Jeder Thread scannt ein zugewiesenes Segment, indem 1 MB Daten abgerufen werden, und gibt die Daten an den Haupt-Thread der Anwendung zurück.
DynamoDB weist Elemente *Segmenten* zu, indem es eine Hash-Funktion auf den Partitionsschlüssel jedes Elements anwendet. Bei einem bestimmten `TotalSegments` Wert werden alle Elemente mit demselben Partitionsschlüssel immer demselben zugewiesen. `Segment` Das bedeutet, dass in einer Tabelle, in der sich *Element 1**, Element 2* *und Element 3* alle teilen `pk="account#123"` (aber unterschiedliche Sortierschlüssel haben), diese Elemente von demselben Worker verarbeitet werden, unabhängig von den Sortierschlüsselwerten oder der Größe der *Elementsammlung*.
Da die *Segmentzuweisung* ausschließlich auf dem Hash des Partitionsschlüssels basiert, können Segmente ungleichmäßig verteilt sein. Einige Segmente enthalten möglicherweise keine Elemente, während andere viele Partitionsschlüssel mit großen Elementsammlungen enthalten können. Daher garantiert eine Erhöhung der Gesamtzahl der Segmente keine schnellere Scanleistung, insbesondere wenn die Partitionsschlüssel nicht gleichmäßig über den Schlüsselraum verteilt sind.
Die Werte für `Segment` und `TotalSegments` gelten für einzelne `Scan`-Anforderungen. Sie können jederzeit andere Werte verwenden. Sie müssen ggf. mit diesen Werten und der Anzahl der verwendeten Worker experimentieren, bis Ihre Anwendung eine optimale Leistung erzielt.
**Anmerkung**
Ein paralleler Scan mit einer großen Anzahl von Workern kann leicht den gesamten bereitgestellten Durchsatz für die Tabelle oder den Index, die bzw. der gescannt wird, verbrauchen. Es ist am besten, solche Scans zu verhindern, wenn für die Tabelle oder den Index auch viele Lese- und Schreibaktivitäten von anderen Anwendungen erfolgen.
Zur Steuerung der Datenmenge, die pro Anforderung zurückgegeben wird, verwenden Sie den Parameter `Limit`. Auf diese Weise können Sie Situationen verhindern, in denen ein Worker den gesamten bereitgestellten Durchsatz auf Kosten aller anderen Worker verbraucht.