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. # Arbeiten mit CQL-Abfragen in Amazon Keyspaces Dieser Abschnitt enthält eine Einführung in die Arbeit mit Abfragen in Amazon Keyspaces (für Apache Cassandra). Die verfügbaren CQL-Anweisungen zum Abfragen, Transformieren und Verwalten von Daten lauten`SELECT`,`INSERT`, `UPDATE` und. `DELETE` In den folgenden Themen werden einige der komplexeren Optionen beschrieben, die bei der Arbeit mit Abfragen verfügbar sind. Die vollständige Sprachsyntax mit Beispielen finden Sie unter[DML-Anweisungen (Datenmanipulationssprache) in Amazon Keyspaces](cql.dml.md). **Topics** + [Verwenden Sie den `IN` Operator mit der `SELECT` Anweisung in einer Abfrage in Amazon Keyspaces](in.select.md) + [Batch-Anweisungen in Amazon Keyspaces verwenden](batchStatements.md) + [Ergebnisse `ORDER BY` in Amazon Keyspaces bestellen](ordering-results.md) + [Ergebnisse in Amazon Keyspaces paginieren](paginating-results.md) # Verwenden Sie den `IN` Operator mit der `SELECT` Anweisung in einer Abfrage in Amazon Keyspaces **WÄHLEN SIE IN** Sie können Daten aus Tabellen mit der `SELECT` Anweisung abfragen, die eine oder mehrere Spalten für eine oder mehrere Zeilen in einer Tabelle liest und eine Ergebnismenge zurückgibt, die die Zeilen enthält, die der Anforderung entsprechen. Eine `SELECT` Anweisung enthält eine`select_clause`, die bestimmt, welche Spalten gelesen und in der Ergebnismenge zurückgegeben werden sollen. Die Klausel kann Anweisungen zum Transformieren der Daten enthalten, bevor sie zurückgegeben werden. Die optionale `WHERE` Klausel gibt an, welche Zeilen abgefragt werden müssen, und besteht aus Beziehungen zu den Spalten, die Teil des Primärschlüssels sind. Amazon Keyspaces unterstützt das `IN` Schlüsselwort in der `WHERE` Klausel. In diesem Abschnitt wird anhand von Beispielen gezeigt, wie Amazon Keyspaces `SELECT` Anweisungen mit dem `IN` Schlüsselwort verarbeitet. Dieses Beispiel zeigt, wie Amazon Keyspaces die `SELECT` Anweisung mit dem `IN` Schlüsselwort in *Unterabfragen* aufteilt. In diesem Beispiel verwenden wir eine Tabelle mit dem Namen. `my_keyspace.customers` Die Tabelle hat eine Primärschlüsselspalte`department_id`, zwei Clusterspalten `sales_region_id` und eine Spalte`sales_representative_id`, die den Namen des Kunden in der `customer_name` Spalte enthält. ``` SELECT * FROM my_keyspace.customers; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 0 | 0 | 0 | a 0 | 0 | 1 | b 0 | 1 | 0 | c 0 | 1 | 1 | d 1 | 0 | 0 | e 1 | 0 | 1 | f 1 | 1 | 0 | g 1 | 1 | 1 | h ``` Mithilfe dieser Tabelle können Sie die folgende `SELECT` Anweisung ausführen, um anhand des `IN` Schlüsselworts in der `WHERE` Klausel die Kunden in den Abteilungen und Vertriebsregionen zu finden, an denen Sie interessiert sind. Die folgende Aussage ist ein Beispiel dafür. ``` SELECT * FROM my_keyspace.customers WHERE department_id IN (0, 1) AND sales_region_id IN (0, 1); ``` Amazon Keyspaces unterteilt diese Anweisung in vier Unterabfragen, wie in der folgenden Ausgabe dargestellt. ``` SELECT * FROM my_keyspace.customers WHERE department_id = 0 AND sales_region_id = 0; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 0 | 0 | 0 | a 0 | 0 | 1 | b SELECT * FROM my_keyspace.customers WHERE department_id = 0 AND sales_region_id = 1; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 0 | 1 | 0 | c 0 | 1 | 1 | d SELECT * FROM my_keyspace.customers WHERE department_id = 1 AND sales_region_id = 0; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 1 | 0 | 0 | e 1 | 0 | 1 | f SELECT * FROM my_keyspace.customers WHERE department_id = 1 AND sales_region_id = 1; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 1 | 1 | 0 | g 1 | 1 | 1 | h ``` Wenn das `IN` Schlüsselwort verwendet wird, paginiert Amazon Keyspaces die Ergebnisse in den folgenden Fällen automatisch: + Nachdem jede zehnte Unterabfrage verarbeitet wurde. + Nach der Verarbeitung von 1 MB logischer I/O. + Wenn Sie eine konfiguriert haben`PAGE SIZE`, paginiert Amazon Keyspaces nach dem Lesen der Anzahl der Abfragen, die auf der Gruppe basieren, die verarbeitet werden sollen. `PAGE SIZE` + Wenn Sie das `LIMIT` Schlüsselwort verwenden, um die Anzahl der zurückgegebenen Zeilen zu reduzieren, paginiert Amazon Keyspaces, nachdem es die Anzahl der Abfragen gelesen hat, die auf dem Satz basieren. `LIMIT` Die folgende Tabelle wird verwendet, um dies anhand eines Beispiels zu veranschaulichen. Weitere Hinweise zur Seitennummerierung finden Sie unter[Ergebnisse in Amazon Keyspaces paginieren](paginating-results.md). ``` SELECT * FROM my_keyspace.customers; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 2 | 0 | 0 | g 2 | 1 | 1 | h 2 | 2 | 2 | i 0 | 0 | 0 | a 0 | 1 | 1 | b 0 | 2 | 2 | c 1 | 0 | 0 | d 1 | 1 | 1 | e 1 | 2 | 2 | f 3 | 0 | 0 | j 3 | 1 | 1 | k 3 | 2 | 2 | l ``` Sie können die folgende Anweisung für diese Tabelle ausführen, um zu sehen, wie die Paginierung funktioniert. ``` SELECT * FROM my_keyspace.customers WHERE department_id IN (0, 1, 2, 3) AND sales_region_id IN (0, 1, 2) AND sales_representative_id IN (0, 1); ``` Amazon Keyspaces verarbeitet diese Anweisung als 24 Unterabfragen, da die Kardinalität des kartesischen Produkts aller in dieser Abfrage enthaltenen `IN` Begriffe 24 ist. ``` department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 0 | 0 | 0 | a 0 | 1 | 1 | b 1 | 0 | 0 | d 1 | 1 | 1 | e ---MORE--- department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 2 | 0 | 0 | g 2 | 1 | 1 | h 3 | 0 | 0 | j ---MORE--- department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 3 | 1 | 1 | k ``` Dieses Beispiel zeigt, wie Sie die `ORDER BY` Klausel in einer Anweisung mit dem Schlüsselwort verwenden können. `SELECT` `IN` ``` SELECT * FROM my_keyspace.customers WHERE department_id IN (3, 2, 1) ORDER BY sales_region_id DESC; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 3 | 2 | 2 | l 3 | 1 | 1 | k 3 | 0 | 0 | j 2 | 2 | 2 | i 2 | 1 | 1 | h 2 | 0 | 0 | g 1 | 2 | 2 | f 1 | 1 | 1 | e 1 | 0 | 0 | d ``` Unterabfragen werden in der Reihenfolge verarbeitet, in der die Spalten Partitionsschlüssel und Clusterschlüssel in der Abfrage dargestellt werden. Im folgenden Beispiel werden Unterabfragen für den Partitionsschlüsselwert“ 2 „zuerst verarbeitet, gefolgt von Unterabfragen für den Partitionsschlüsselwert“ 3 „und“ 1“. Die Ergebnisse einer bestimmten Unterabfrage werden gemäß der Sortierklausel der Abfrage, falls vorhanden, oder der bei der Tabellenerstellung definierten Clusterreihenfolge der Tabelle sortiert. ``` SELECT * FROM my_keyspace.customers WHERE department_id IN (2, 3, 1) ORDER BY sales_region_id DESC; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 2 | 2 | 2 | i 2 | 1 | 1 | h 2 | 0 | 0 | g 3 | 2 | 2 | l 3 | 1 | 1 | k 3 | 0 | 0 | j 1 | 2 | 2 | f 1 | 1 | 1 | e 1 | 0 | 0 | d ``` # Batch-Anweisungen in Amazon Keyspaces verwenden Sie können mehrere `INSERT``UPDATE`, und `DELETE` Operationen zu einer `BATCH` Anweisung kombinieren. `LOGGED`Batches sind die Standardeinstellung. ``` batch_statement ::= BEGIN [ UNLOGGED ] BATCH [ USING update_parameter( AND update_parameter)* ] modification_statement ( ';' modification_statement )* APPLY BATCH modification_statement ::= insert_statement | update_statement | delete_statement ``` Wenn Sie eine Batch-Anweisung ausführen, fasst der Treiber alle Anweisungen im Batch zu einem einzigen Batch-Vorgang zusammen. Bei der Entscheidung, welche Art von Batch-Operation verwendet werden soll, können Sie die folgenden Richtlinien berücksichtigen. Verwenden Sie protokollierte Batches, wenn: + Sie benötigen atomare Transaktionsgarantien. + Etwas höhere Latenzen sind ein akzeptabler Kompromiss. Verwenden Sie nicht protokollierte Batches in folgenden Fällen: + Sie müssen den Betrieb einzelner Partitionen optimieren. + Sie möchten den Netzwerk-Overhead reduzieren. + Sie haben Anforderungen an einen hohen Durchsatz. Informationen zu Kontingenten für Batch-Kontoauszüge finden Sie unter[Kontingente für Amazon Keyspaces (für Apache Cassandra)](quotas.md). ## Nicht protokollierte Batches Bei **nicht protokollierten Batches** verarbeitet Amazon Keyspaces mehrere Operationen als eine einzige Anfrage, ohne ein Batch-Protokoll zu führen. Bei einem nicht protokollierten Batch-Vorgang ist es möglich, dass einige der Aktionen erfolgreich sind, während andere fehlschlagen. Nicht protokollierte Batches sind nützlich, wenn Sie: + Optimieren Sie die Abläufe innerhalb einer einzelnen Partition. + Reduzieren Sie den Netzwerkverkehr, indem Sie verwandte Anfragen gruppieren. Die Syntax für einen nicht protokollierten Batch ähnelt der eines protokollierten Batches, mit dem Zusatz des `UNLOGGED` Schlüsselworts. ``` BEGIN UNLOGGED BATCH INSERT INTO users (id, firstname, lastname) VALUES (1, 'John', 'Doe'); INSERT INTO users (id, firstname, lastname) VALUES (2, 'Jane', 'Smith'); APPLY BATCH; ``` ## Protokollierte Batches Ein **protokollierter** Batch kombiniert mehrere Schreibaktionen zu einer einzigen atomaren Operation. Wenn Sie einen protokollierten Batch ausführen: + Alle Aktionen sind entweder gemeinsam erfolgreich oder schlagen gemeinsam fehl. + Die Operation ist synchron und idempotent. + Sie können in mehrere Amazon Keyspaces-Tabellen schreiben, sofern sie sich im selben AWS Konto befinden und AWS-Region. Protokollierte Batches können etwas höhere Latenzen aufweisen. Für Anwendungen mit hohem Durchsatz sollten Sie die Verwendung nicht protokollierter Batches in Betracht ziehen. Für die Verwendung protokollierter Batches in Amazon Keyspaces fallen keine zusätzlichen Kosten an. Sie zahlen nur für die Schreibvorgänge, die Teil Ihrer Batch-Operationen sind. Amazon Keyspaces führt zwei grundlegende Schreibvorgänge für jede Zeile im Batch durch: einen, um die Zeile für den Batch vorzubereiten, und einen, um den Batch zu übergeben. Denken Sie bei der Kapazitätsplanung für Tabellen, die protokollierte Batches verwenden, daran, dass jede Zeile in einem Batch die doppelte Kapazität eines Standard-Schreibvorgangs benötigt. Wenn Ihre Anwendung beispielsweise einen protokollierten Batch pro Sekunde mit drei Zeilen mit 1 KB ausführt, müssen Sie sechs Schreibkapazitätseinheiten (WCUs) bereitstellen, während es WCUs für einzelne Schreibvorgänge oder nicht protokollierte Batches nur drei sind. Preisinformationen finden Sie unter [Amazon Keyspaces (für Apache Cassandra)](https://aws.amazon.com/keyspaces/pricing) — Preise. ### Bewährte Methoden für Batch-Operationen Beachten Sie bei der Verwendung von Amazon Keyspaces-Batchoperationen die folgenden empfohlenen Vorgehensweisen. + Aktivieren Sie die automatische Skalierung, sodass Sie über eine ausreichende Durchsatzkapazität für Ihre Tabellen verfügen, um Batch-Operationen und die zusätzlichen Durchsatzanforderungen protokollierter Batches abzuwickeln. + Verwenden Sie einzelne Operationen oder nicht protokollierte Batches, wenn Vorgänge unabhängig voneinander ausgeführt werden können, ohne die Richtigkeit der Anwendung zu beeinträchtigen. + Entwerfen Sie Ihre Anwendung so, dass die Anzahl gleichzeitiger Aktualisierungen derselben Zeilen minimiert wird, da gleichzeitige Batchvorgänge zu Konflikten führen und fehlschlagen können. + Verwenden Sie einzelne Schreibvorgänge oder nicht protokollierte Batches für die Massenaufnahme von Daten mit hohem Durchsatz ohne Atomizitätsanforderungen. ### Konsistenz und Parallelität Amazon Keyspaces erzwingt die folgenden Regeln für Konsistenz und Parallelität für protokollierte Batches: + Alle Batch-Operationen verwenden die Konsistenzstufe. `LOCAL_QUORUM` + Gleichzeitige Batches, die sich auf verschiedene Zeilen auswirken, können gleichzeitig ausgeführt werden. + Gleichzeitige `DELETE` Operationen oder Operationen an Zeilen `INSERT``UPDATE`, die an einem laufenden Batch beteiligt sind, schlagen fehl und führen zu einem Konflikt. ### Unterstützte Operatoren und Bedingungen Unterstützte `WHERE` Klauseloperatoren: + Gleichheit (=) Nicht unterstützte Operatoren: + Bereichsoperatoren (>, <, >=, < =) + `IN`-Operator + `LIKE`-Operator + `BETWEEN`-Operator Wird in protokollierten Batches nicht unterstützt: + Mehrere Anweisungen, die dieselbe Zeile betreffen + Gegenoperationen + Bereich wird gelöscht ### Fehlerbedingungen protokollierter Batch-Anweisungen Ein protokollierter Batch-Vorgang kann in einem der folgenden Fälle fehlschlagen: + Bedingungsausdrücke (wie `IF NOT EXISTS` oder`IF`) werden als falsch ausgewertet. + Eine oder mehrere Operationen enthalten ungültige Parameter. + Die Anforderung steht in Konflikt mit einem anderen Batch-Vorgang, der in denselben Zeilen ausgeführt wird. + In der Tabelle fehlt es an ausreichender bereitgestellter Kapazität. + Eine Zeile überschreitet die maximale Größenbeschränkung. + Das Eingabedatenformat ist ungültig. ### Batch-Anweisungen und Replikation in mehreren Regionen In Bereitstellungen mit mehreren Regionen: + Operationen in der Quellregion sind synchron und atomar. + Operationen in der Zielregion sind asynchron. + Alle Batch-Operationen werden in Zielregionen repliziert, wobei die Isolation während der Anwendung möglicherweise nicht aufrechterhalten wird. ### Überwachen Sie Batch-Operationen Sie können Batch-Operationen mithilfe von CloudWatch Amazon-Metriken überwachen, um Leistung, Fehler und Nutzungsmuster nachzuverfolgen. Amazon Keyspaces bietet die folgenden CloudWatch Metriken für die Überwachung von Batch-Vorgängen pro Tabelle: + `SuccessfulRequestCount`— Verfolgen Sie erfolgreiche Batch-Operationen. + `Latency`— Messen Sie die Leistung von Batch-Vorgängen. + `ConsumedWriteCapacityUnits`— Überwachen Sie den Kapazitätsverbrauch von Batch-Vorgängen. Weitere Informationen finden Sie unter [Amazon-Keyspaces-Metriken](metrics-dimensions.md#keyspaces-metrics-dimensions). Zusätzlich zu den CloudWatch Metriken können Sie AWS CloudTrail alle Amazon Keyspaces-API-Aktionen protokollieren. Jede API-Aktion im Batch wird protokolliert, CloudTrail was es einfacher macht, Batch-Operationen in Ihren Amazon Keyspaces-Tabellen zu verfolgen und zu prüfen. ### Beispiele für Batch-Operationen Im Folgenden finden Sie ein Beispiel für eine grundlegende protokollierte Batch-Anweisung. ``` BEGIN BATCH INSERT INTO users (id, firstname, lastname) VALUES (1, 'John', 'Doe'); INSERT INTO users (id, firstname, lastname) VALUES (2, 'Jane', 'Smith'); APPLY BATCH; ``` Dies ist ein Beispiel für einen Batch, der `INSERT` `UPDATE` ,- und `DELETE` Anweisungen enthält. ``` BEGIN BATCH INSERT INTO users (id, firstname, lastname) VALUES (1, 'John', 'Doe'); UPDATE users SET firstname = 'Johnny' WHERE id = 2; DELETE FROM users WHERE id = 3; APPLY BATCH; ``` Dies ist ein Beispiel für einen Batch, der clientseitige Zeitstempel verwendet. ``` BEGIN BATCH INSERT INTO users (id, firstname, lastname) VALUES (1, 'John', 'Stiles') USING TIMESTAMP 1669069624; INSERT INTO users (id, firstname, lastname) VALUES (2, 'Jane', 'Doe') USING TIMESTAMP 1669069624; APPLY BATCH; BEGIN BATCH UPDATE users USING TIMESTAMP 1669069624 SET firstname = 'Carlos' WHERE id = 1; UPDATE users USING TIMESTAMP 1669069624 SET firstname = 'Diego' WHERE id = 2; APPLY BATCH; ``` Dies ist ein Beispiel für einen bedingten Batch. ``` BEGIN BATCH INSERT INTO users (id, firstname, lastname) VALUES (1, 'Jane', 'Doe') IF NOT EXISTS; INSERT INTO users (id, firstname, lastname) VALUES (2, 'John', 'Doe') IF NOT EXISTS; APPLY BATCH; BEGIN BATCH UPDATE users SET lastname = 'Stiles' WHERE id = 1 IF lastname = 'Doe'; UPDATE users SET lastname = 'Stiles' WHERE id = 2 IF lastname = 'Doe'; APPLY BATCH; ``` Dies ist ein Beispiel für einen Batch, der Time to Live (TTL) verwendet. ``` BEGIN BATCH INSERT INTO users (id, firstname, lastname) VALUES (1, 'John', 'Doe') USING TTL 3600; INSERT INTO users (id, firstname, lastname) VALUES (2, 'Jane', 'Smith') USING TTL 7200; APPLY BATCH; ``` Dies ist ein Beispiel für eine Batch-Anweisung, die mehrere Tabellen aktualisiert. ``` BEGIN BATCH INSERT INTO users (id, firstname) VALUES (1, 'John'); INSERT INTO user_emails (user_id, email) VALUES (1, 'john@example.com'); APPLY BATCH; ``` Dies ist ein Beispiel für eine Batch-Operation mit benutzerdefinierten Typen (UDTs). Das Beispiel geht davon aus, dass die UDT existiert. `address` ``` BEGIN BATCH INSERT INTO users (id, firstname, address) VALUES (1, 'John', {street: '123 Main St', city: 'NYC', zip: '10001'}); INSERT INTO users (id, firstname, address) VALUES (2, 'Jane', {street: '456 Oak Ave', city: 'LA', zip: '90210'}); APPLY BATCH; BEGIN BATCH UPDATE users SET address.zip = '10002' WHERE id = 1; UPDATE users SET address.city = 'Boston' WHERE id = 2; APPLY BATCH; ``` # Ergebnisse `ORDER BY` in Amazon Keyspaces bestellen Die `ORDER BY` Klausel gibt die Sortierreihenfolge der in einer `SELECT` Anweisung zurückgegebenen Ergebnisse an. Die Anweisung verwendet eine Liste von Spaltennamen als Argumente, und für jede Spalte können Sie die Sortierreihenfolge für die Daten angeben. Sie können Gruppierungsspalten nur in Sortierklauseln angeben. Spalten, die keine Gruppierung bilden, sind nicht zulässig. Die beiden verfügbaren Sortierreihenoptionen für die zurückgegebenen Ergebnisse sind für die aufsteigende und `ASC` `DESC` für die absteigende Sortierreihenfolge. ``` SELECT * FROM my_keyspace.my_table ORDER BY (col1 ASC, col2 DESC, col3 ASC); col1 | col2 | col3 ------+------+------ 0 | 6 | a 1 | 5 | b 2 | 4 | c 3 | 3 | d 4 | 2 | e 5 | 1 | f 6 | 0 | g ``` ``` SELECT * FROM my_keyspace.my_table ORDER BY (col1 DESC, col2 ASC, col3 DESC); col1 | col2 | col3 ------+------+------ 6 | 0 | g 5 | 1 | f 4 | 2 | e 3 | 3 | d 2 | 4 | c 1 | 5 | b 0 | 6 | a ``` Wenn Sie die Sortierreihenfolge in der Abfrageanweisung nicht angeben, wird die Standardreihenfolge der Clusterspalte verwendet. Die möglichen Sortierreihenfolgen, die Sie in einer Sortierklausel verwenden können, hängen von der Sortierreihenfolge ab, die jeder Clusterspalte bei der Tabellenerstellung zugewiesen wurde. Abfrageergebnisse können nur in der Reihenfolge sortiert werden, die für alle Clusterspalten bei der Tabellenerstellung definiert wurde, oder in der umgekehrten Reihenfolge der definierten Sortierreihenfolge. Andere mögliche Kombinationen sind nicht zulässig. Wenn die Tabelle beispielsweise (col1 ASC, col2 DESC, col3 ASC) `CLUSTERING ORDER` lautet, dann `ORDER BY` sind die gültigen Parameter für entweder (col1 ASC, col2 DESC, col3 ASC) oder (col1 DESC, col2 ASC, col3 DESC) gültig. Weitere Informationen zu finden Sie unter. `CLUSTERING ORDER` `table_options` [CREATE TABLE](cql.ddl.table.md#cql.ddl.table.create) # Ergebnisse in Amazon Keyspaces paginieren Amazon Keyspaces *paginiert* die Ergebnisse von `SELECT` Kontoauszügen automatisch, wenn die zur Verarbeitung der `SELECT` Anweisung gelesenen Daten 1 MB überschreiten. Bei der Paginierung werden die `SELECT` Abrechnungsergebnisse in „Seiten“ mit Daten aufgeteilt, die 1 MB (oder weniger) groß sind. Eine Anwendung kann die erste Ergebnisseite verarbeiten, dann die zweite Seite und so weiter. Kunden sollten bei der Verarbeitung von `SELECT` Abfragen, die mehrere Zeilen zurückgeben, immer nach Paginierungstoken suchen. Wenn ein Kunde eine liefert, für `PAGE SIZE` die mehr als 1 MB an Daten gelesen werden müssen, teilt Amazon Keyspaces die Ergebnisse automatisch auf der Grundlage der 1-MB-Datenlesegeschritte in mehrere Seiten auf. Wenn die durchschnittliche Größe einer Zeile beispielsweise 100 KB beträgt und Sie einen Wert `PAGE SIZE` von 20 angeben, paginiert Amazon Keyspaces Daten automatisch, nachdem es 10 Zeilen gelesen hat (1000 KB gelesener Daten). Da Amazon Keyspaces Ergebnisse auf der Grundlage der Anzahl der Zeilen paginiert, die es zur Bearbeitung einer Anfrage liest, und nicht auf der Anzahl der im Ergebnissatz zurückgegebenen Zeilen, enthalten einige Seiten möglicherweise keine Zeilen, wenn Sie gefilterte Abfragen ausführen. Wenn Sie beispielsweise `PAGE SIZE` auf 10 setzen und Keyspaces 30 Zeilen auswertet, um Ihre `SELECT` Abfrage zu verarbeiten, gibt Amazon Keyspaces drei Seiten zurück. Wenn nur eine Teilmenge der Zeilen mit Ihrer Anfrage übereinstimmt, haben einige Seiten möglicherweise weniger als 10 Zeilen. Ein Beispiel dafür, wie sich `LIMIT` Abfragen auf `PAGE SIZE` die Lesekapazität auswirken können, finden Sie unter[Schätzen Sie den Lesekapazitätsverbrauch von Grenzabfragen](limit_queries.md). Einen Vergleich mit der Paginierung von Apache Cassandra finden Sie unter. [Paginierung](functional-differences.md#functional-differences.paging)