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. # Erfahren Sie, wie Sie von SQL zu NoSQL wechseln. Als Anwendungsentwickler haben Sie möglicherweise Erfahrung mit relationalen Datenbankmanagementsystemen (RDBMS) und SQL (Structured Query Language). Wenn Sie mit Amazon DynamoDB arbeiten, werden Sie nicht nur viele Gemeinsamkeiten, sondern auch viele Unterschiede feststellen. Mit dem Begriff *NoSQL* werden nicht relationale Datenbanksysteme beschrieben, die hoch verfügbar, skalierbar und für hohe Leistung optimiert sind. Anstatt des relationalen Modells nutzen NoSQL-Datenbanken (wie DynamoDB) alternative Datenverwaltungsmodelle, z. B. Schlüssel-Wert-Paare oder Dokumentenspeicher. Weitere Informationen finden Sie unter [Was ist NoSQL?](https://aws.amazon.com/nosql). Amazon DynamoDB unterstützt [PartiQL](https://partiql.org/), eine Open-Source-, SQL-kompatible Abfragesprache, mit der Sie Daten effizient abfragen können, unabhängig davon, wo oder in welchem Format sie gespeichert sind. Mit PartiQL können Sie problemlos strukturierte Daten aus relationalen Datenbanken, halbstrukturierte und verschachtelte Daten in offenen Datenformaten und sogar schemalose Daten in NoSQL- oder Dokumentdatenbanken verarbeiten, die verschiedene Attribute für verschiedene Zeilen zulassen. Weitere Informationen finden Sie unter [PartiQL-Abfragesprache](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html). In den folgenden Abschnitten werden allgemeine Datenbankaufgaben beschrieben, wobei SQL-Anweisungen mit ihren entsprechenden DynamoDB-Operationen verglichen und gegenübergestellt werden. **Anmerkung** Die SQL-Beispiele in diesem Abschnitt sind mit dem MySQL-RDBMS kompatibel. Die in diesem Abschnitt genannten DynamoDB-Beispiele enthalten den Namen der DynamoDB-Operation zusammen mit dem Parameter für diese Operation im JSON-Format. **Topics** + [Auswahl zwischen relational (SQL) und NoSQL](SQLtoNoSQL.WhyDynamoDB.md) + [Unterschiede beim Zugriff auf eine relationale (SQL) Datenbank und DynamoDB](SQLtoNoSQL.Accessing.md) + [Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Erstellen einer Tabelle](SQLtoNoSQL.CreateTable.md) + [Unterschiede zwischen dem Abrufen von Tabelleninformationen aus einer relationalen (SQL) Datenbank und DynamoDB](SQLtoNoSQL.GetTableInfo.md) + [Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Schreiben von Daten in eine Tabelle](SQLtoNoSQL.WriteData.md) + [Wichtige Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Lesen von Daten aus einer Tabelle](SQLtoNoSQL.ReadData.md) + [Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Verwalten von Indizes](SQLtoNoSQL.Indexes.md) + [Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Ändern von Daten in einer Tabelle](SQLtoNoSQL.UpdateData.md) + [Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Löschen von Daten aus einer Tabelle](SQLtoNoSQL.DeleteData.md) + [Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Entfernen einer Tabelle](SQLtoNoSQL.RemoveTable.md) # Auswahl zwischen relational (SQL) und NoSQL Aktuelle Anwendungen stellen mehr anspruchsvolle Anforderungen als je zuvor. Beispielsweise beginnt ein Online-Spiel mit nur wenigen Benutzern und einer sehr kleinen Datenmenge. Wenn das Spiel jedoch erfolgreicher wird, kann es die Ressourcen des zugrunde liegenden Datenbankmanagementsystems sehr schnell überfordern. Häufig haben webbasierte Anwendungen Hunderte, Tausende oder Millionen von Benutzern gleichzeitig, wobei mehrere Terabyte an neuen Daten pro Tag generiert werden. Datenbanken für diese Anwendungen müssen Zehntausende (oder Hunderttausende) von Lese- und Schreibvorgängen pro Sekunde verarbeiten. Amazon DynamoDB eignet sich besonders für solche Workloads. Als Entwickler können Sie in kleinem Maße beginnen und diesen schrittweise erhöhen, wenn Ihre Anwendung an Beliebtheit gewinnt. DynamoDB lässt sich nahtlos skalieren, um sehr große Datenmengen und sehr große Benutzerzahlen zu verarbeiten. Weitere Informationen zur herkömmlichen relationalen Datenbankmodellierung und deren Anpassung an DynamoDB finden Sie unter [Bewährte Methoden für die Modellierung relationaler Daten in DynamoDB](bp-relational-modeling.md). In der folgenden Tabelle sind einige allgemeine Unterschiede zwischen einem relationalen Datenbankmanagementsystem (RDBMS) und DynamoDB aufgeführt. **** | Merkmal | Relationales Datenbankmanagementsystem (RDBMS) | Amazon DynamoDB | | --- | --- | --- | | Optimale Workloads | Ad-hoc-Abfragen, Data Warehousing, OLAP (Online Analytical Processing). | Web-Scale-Anwendungen, einschließlich sozialer Netzwerke, Gaming, gemeinsamer Mediennutzung und Internet of Things (IoT). | | Datenmodell | Das relationale Modell erfordert ein eindeutig definiertes Schema, in dem Daten in Tabellen, Zeilen und Spalten standardisiert werden. Darüber hinaus werden alle Beziehungen zwischen Tabellen, Spalten, Indizes und sonstige Datenbankelementen definiert. | DynamoDB ist schemalos. Jede Tabelle muss über einen Primärschlüssel verfügen, um jedes Datenelement eindeutig zu identifizieren. Es gibt jedoch keine ähnlichen Einschränkungen bei anderen Nicht-Schlüsselattributen. DynamoDB kann strukturierte und halbstrukturierte Daten, einschließlich JSON-Dokumenten, verwalten. | | Datenzugriff | SQL ist der Standard für das Speichern und Abrufen von Daten. Relationale Datenbanken bieten eine umfassende Auswahl an Tools, die die Entwicklung datenbankgestützter Anwendungen erleichtern. Diese Tools verwenden jedoch alle SQL. | Sie können die AWS-Managementkonsole, die oder NoSQL verwenden AWS CLI, um mit DynamoDB WorkBench zu arbeiten und Ad-hoc-Aufgaben auszuführen. Mit [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), einer SQL-kompatiblen Abfragesprache, können Sie Daten in DynamoDB auswählen, einfügen, aktualisieren und löschen. Anwendungen können die AWS Software Development Kits (SDKs) verwenden, um mit DynamoDB zu arbeiten und dabei objektbasierte, dokumentenzentrierte oder einfache Schnittstellen zu verwenden. | | Leistung | Da relationale Datenbanken für das Speichern optimiert sind, hängt die Leistung in der Regel vom Datenträgersubsystem ab. Developer und Datenbankadministratoren müssen Abfragen, Indizes und Tabellenstrukturen optimieren, um Spitzenleistung zu erreichen. | Da DynamoDB für die Datenverarbeitung optimiert ist, stellt die Leistung hauptsächlich eine Funktion der zugrunde liegenden Hardware und Netzwerklatenz dar. Als verwalteter Service schützt DynamoDB Sie und Ihre Anwendungen vor diesen Implementierungsdetails, sodass Sie sich darauf konzentrieren können, robuste High-Performance-Anwendungen zu entwerfen und zu entwickeln. | | Skalierung | Eine Skalierung nach oben ist durch den Einsatz schnellerer Hardware am einfachsten. Datenbanktabellen können sich auch über mehrere Hosts in einem verteilten System erstrecken. Dazu sind allerdings zusätzliche Investitionen erforderlich. Relationale Datenbanken unterliegen Höchstwerten im Hinblick auf die Anzahl und Größe der Dateien, wodurch der Skalierbarkeit Obergrenzen gesetzt werden. | DynamoDB wurde für die horizontale Skalierung mithilfe verteilter Hardwarecluster entwickelt. Dieses Design ermöglicht einen größeren Durchsatz ohne höhere Latenz. Kunden legen ihre Durchsatzanforderungen fest und DynamoDB weist ausreichende Ressourcen zu, um diesen Anforderungen gerecht zu werden. Es gibt weder in Bezug auf die Anzahl der Elemente pro Tabelle noch die Gesamtgröße dieser Tabelle Beschränkungen. | # Unterschiede beim Zugriff auf eine relationale (SQL) Datenbank und DynamoDB Um auf eine Datenbank zuzugreifen, muss sich Ihre Anwendung *authentifizieren*, um sicherzustellen, dass sie berechtigt ist, die Datenbank zu verwenden. Außerdem muss sie *autorisiert* sein, damit sie die Aktionen ausführen kann, zu denen sie berechtigt ist. Das folgende Diagramm zeigt Interaktionen eines Clients mit einer relationalen Datenbank und mit Amazon DynamoDB. ![\[Interaktion mit relationalen und NoSQL-Datenbanken.\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/SQLtoNoSQL.png) In der folgenden Tabelle finden Sie weitere Informationen zu Interaktionsaufgaben von Clients: **** | Merkmal | Relationales Datenbankmanagementsystem (RDBMS) | Amazon DynamoDB | | --- | --- | --- | | Tools für den Zugriff auf die Datenbank | Die meisten relationalen Datenbanken bieten eine Befehlszeilenschnittstelle (Command Line Interface, CLI), sodass Sie Ad-hoc-SQL-Anweisungen eingeben und die Ergebnisse sofort sehen können. | In den meisten Fällen schreiben Sie Anwendungscode. Sie können auch die AWS-Managementkonsole AWS Command Line Interface (AWS CLI) oder NoSQL Workbench verwenden, um Ad-hoc-Anfragen an DynamoDB zu senden und die Ergebnisse anzuzeigen. Mit [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), einer SQL-kompatiblen Abfragesprache, können Sie Daten in DynamoDB auswählen, einfügen, aktualisieren und löschen. | | Verbinden mit der Datenbank | Ein Anwendungsprogramm stellt eine Netzwerkverbindung mit der Datenbank her. Wenn die Anwendung beendet ist, wird die Verbindung unterbrochen. | DynamoDB ist ein Web-Service. Interaktionen mit diesem Service sind zustandslos. Anwendungen müssen keine dauerhaften Netzwerkverbindungen unterhalten. Stattdessen erfolgt die Interaktion mit DynamoDB unter Verwendung von HTTP(S)-Anforderungen und -Antworten. | | Authentifizierung | Eine Anwendung kann erst eine Verbindung mit der Datenbank herstellen, wenn sie authentifiziert ist. Das RDBMS kann die Authentifizierung selbst durchführen oder diese Aufgabe auf das Host-Betriebssystem oder einen Verzeichnisdienst auslagern. | Jede Anforderung an DynamoDB muss eine kryptografische Signatur enthalten, die die betreffende Anforderung authentifiziert. AWS SDKsSie bieten die gesamte Logik, die zum Erstellen von Signaturen und Signieranfragen erforderlich ist. Weitere Informationen finden Sie unter [Signieren von AWS API-Anfragen](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) im Allgemeine AWS-Referenz. | | Autorisierung | Anwendungen können nur die Aktionen ausführen, für die sie autorisiert sind. Datenbankadministratoren oder Anwendungseigentümer können mit den SQL-Anweisungen GRANT und REVOKE den Zugriff auf Datenbankobjekte (z. B. Tabellen), Daten (z. B. Zeilen in einer Tabelle) oder die Möglichkeit zum Durchführen bestimmter SQL-Anweisungen steuern. | In DynamoDB wird die Autorisierung von AWS Identity and Access Management (IAM) abgewickelt. Sie können eine IAM-Richtlinie schreiben, um Berechtigungen für eine DynamoDB-Ressource (z. B. eine Tabelle) zu erteilen und Benutzern und Rollen erlauben, die Richtlinie anzuwenden. IAM bietet außerdem eine differenzierte Zugriffskontrolle für die einzelnen Datenelemente in DynamoDB-Tabellen. Weitere Informationen finden Sie unter [Identity and Access Management für Amazon DynamoDB](security-iam.md). | | Senden einer Anfrage | Die Anwendung sendet eine SQL-Anweisung für jede Datenbankoperation, die ausgeführt werden soll. Nach Erhalt der SQL-Anweisung überprüft das RDBMS seine Syntax, erstellt einen Plan zum Ausführen des Vorgangs und führt dann den Plan aus. | Die Anwendung sendet HTTP(S)-Anfragen an DynamoDB. Die Anfragen enthalten den Namen der auszuführenden DynamoDB-Operation sowie die entsprechenden Parameter. DynamoDB führt die Anfrage sofort aus. | | Empfangen einer Antwort | Das RDBMS gibt die Ergebnisse der SQL-Anweisung zurück. Wenn ein Fehler auftritt, gibt das RDBMS einen Fehlerstatus und eine Fehlermeldung aus. | DynamoDB gibt eine HTTP(S)-Antwort mit den Ergebnissen der Operation zurück. Wenn ein Fehler auftritt, gibt DynamoDB einen HTTP-Fehlerstatus und Fehlermeldungen zurück. | # Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Erstellen einer Tabelle Tabellen stellen die grundlegenden Datenstrukturen in relationalen Datenbanken und in Amazon DynamoDB dar. Bei relationalen Datenbankmanagementsystemen (RDBMS) müssen Sie das Tabellenschema beim Erstellen der Tabelle definieren. Im Gegensatz dazu sind DynamoDB-Tabellen schemalos mit Ausnahme des Primärschlüssels müssen Sie beim Erstellen einer Tabelle keine zusätzlichen Attribute oder Datentypen definieren. Im folgenden Abschnitt wird verglichen, wie Sie eine Tabelle mit SQL erstellen würden und wie Sie sie mit DynamoDB erstellen würden. **Topics** + [Erstellen einer Tabelle mit SQL](#SQLtoNoSQL.CreateTable.SQL) + [Erstellen einer Tabelle mit DynamoDB](#SQLtoNoSQL.CreateTable.DynamoDB) ## Erstellen einer Tabelle mit SQL Mit SQL verwenden Sie die `CREATE TABLE`-Anweisung, um eine Tabelle zu erstellen, wie im folgenden Beispiel veranschaulicht. ``` CREATE TABLE Music ( Artist VARCHAR(20) NOT NULL, SongTitle VARCHAR(30) NOT NULL, AlbumTitle VARCHAR(25), Year INT, Price FLOAT, Genre VARCHAR(10), Tags TEXT, PRIMARY KEY(Artist, SongTitle) ); ``` Der Primärschlüssel für diese Tabelle besteht aus *Artist* und. *SongTitle* Definieren Sie alle Tabellenspalten und Datentypen sowie den Primärschlüssel der Tabelle. (Mit der `ALTER TABLE`-Anweisung können Sie diese Definitionen später ändern, falls erforderlich.) Viele SQL-Implementierungen ermöglichen eine Definition der Speicherspezifikationen für Ihre Tabelle im Rahmen der `CREATE TABLE`-Anweisungen. Die Tabelle wird mit den Standardspeichereinstellungen erstellt, sofern Sie nichts anderes angeben. In einer Produktionsumgebung kann ein Datenbankadministrator Ihnen dabei helfen, die optimalen Speicherparameter festzulegen. ## Erstellen einer Tabelle mit DynamoDB Verwenden Sie die Aktion `CreateTable`, um eine Tabelle mit dem Modus bereitgestellter Kapazität zu erstellen und Parameter wie folgt anzugeben: ``` { TableName : "Music", KeySchema: [ { AttributeName: "Artist", KeyType: "HASH" //Partition key }, { AttributeName: "SongTitle", KeyType: "RANGE" //Sort key } ], AttributeDefinitions: [ { AttributeName: "Artist", AttributeType: "S" }, { AttributeName: "SongTitle", AttributeType: "S" } ], ProvisionedThroughput: { // Only specified if using provisioned mode ReadCapacityUnits: 1, WriteCapacityUnits: 1 } } ``` Der Primärschlüssel für diese Tabelle besteht aus *Artist* (Partitionsschlüssel) und *SongTitle*(Sortierschlüssel). Sie müssen die folgenden Parameter für `CreateTable` angeben: + `TableName` – Name der Tabelle. + `KeySchema` – Attribute, die für den Primärschlüssel verwendet werden. Weitere Informationen erhalten Sie unter [Tabellen, Elemente und Attribute](HowItWorks.CoreComponents.md#HowItWorks.CoreComponents.TablesItemsAttributes) und [Primärschlüssel](HowItWorks.CoreComponents.md#HowItWorks.CoreComponents.PrimaryKey). + `AttributeDefinitions` – Datentypen für die Schlüsselschemaattribute. + `ProvisionedThroughput (for provisioned tables)` – Anzahl der Lese- und Schreibvorgänge pro Sekunde, die Sie für diese Tabelle benötigen. DynamoDB reserviert ausreichend Speicher- und Systemressourcen, sodass Ihre Durchsatzanforderungen immer erfüllt werden. Mit der Aktion `UpdateTable` können Sie diese später ändern, falls erforderlich. Sie müssen die Speicheranforderungen einer Tabelle nicht angeben, da die Speicherzuweisung vollständig von DynamoDB verwaltet wird. # Unterschiede zwischen dem Abrufen von Tabelleninformationen aus einer relationalen (SQL) Datenbank und DynamoDB Sie können überprüfen, ob eine Tabelle Ihren Spezifikationen entsprechend erstellt wurde. In einer relationalen Datenbank wird das gesamte Tabellenschema angezeigt. Amazon-DynamoDB-Tabellen sind schemalos, sodass nur die Primärschlüsselattribute angezeigt werden. **Topics** + [Abrufen von Informationen zu einer Tabelle mit SQL](#SQLtoNoSQL.GetTableInfo.SQL) + [Abrufen von Informationen zu einer Tabelle in DynamoDB](#SQLtoNoSQL.GetTableInfo.DynamoDB) ## Abrufen von Informationen zu einer Tabelle mit SQL Die meisten relationalen Datenbankmanagementsysteme (RDBMS) ermöglichen Ihnen, die Struktur einer Tabelle – Spalten, Datentypen, Primärschlüsseldefinition usw. – zu beschreiben. Dafür gibt es in SQL keine Standardmethode. Viele Datenbanksysteme stellen den Befehl `DESCRIBE` zur Verfügung. Das folgende Beispiel kommt aus MySQL. ``` DESCRIBE Music; ``` In diesem Beispiel wird die Struktur der Tabelle mit allen Spaltennamen, Datentypen und Größen zurückgegeben. ``` +------------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +------------+-------------+------+-----+---------+-------+ | Artist | varchar(20) | NO | PRI | NULL | | | SongTitle | varchar(30) | NO | PRI | NULL | | | AlbumTitle | varchar(25) | YES | | NULL | | | Year | int(11) | YES | | NULL | | | Price | float | YES | | NULL | | | Genre | varchar(10) | YES | | NULL | | | Tags | text | YES | | NULL | | +------------+-------------+------+-----+---------+-------+ ``` Der Primärschlüssel für diese Tabelle besteht aus *Artist* und. *SongTitle* ## Abrufen von Informationen zu einer Tabelle in DynamoDB DynamoDB verfügt über eine `DescribeTable`-Aktion, die ähnlich ist. Der einzige Parameter ist der Tabellenname. ``` { TableName : "Music" } ``` Die Antwort von `DescribeTable` sieht wie folgt aus: ``` { "Table": { "AttributeDefinitions": [ { "AttributeName": "Artist", "AttributeType": "S" }, { "AttributeName": "SongTitle", "AttributeType": "S" } ], "TableName": "Music", "KeySchema": [ { "AttributeName": "Artist", "KeyType": "HASH" //Partition key }, { "AttributeName": "SongTitle", "KeyType": "RANGE" //Sort key } ], ... ``` `DescribeTable` gibt auch Informationen über Indexe in der Tabelle, Einstellungen für den bereitgestellten Durchsatz, eine ungefähre Elementanzahl und andere Metadaten zurück. # Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Schreiben von Daten in eine Tabelle Relationale Datenbanktabellen enthalten *Datenzeilen*. Die Zeilen bestehen aus *Spalten*. Amazon DynamoDB Tabellen enthalten *Elemente*. Elemente bestehen aus *Attributen*. In diesem Abschnitt wird beschrieben, wie Sie eine Zeile (bzw. ein Element) in eine Tabelle schreiben. **Topics** + [Schreiben von Daten in eine Tabelle mit SQL](#SQLtoNoSQL.WriteData.SQL) + [Schreiben von Daten in eine Tabelle in DynamoDB](#SQLtoNoSQL.WriteData.DynamoDB) ## Schreiben von Daten in eine Tabelle mit SQL Eine Tabelle in einer relationalen Datenbank ist eine zweidimensionale Datenstruktur, die sich aus Zeilen und Spalten zusammensetzt. Einige Datenbankmanagementsysteme bieten auch Unterstützung für halbstrukturierte Daten, in der Regel mit nativen JSON- oder XML-Datentypen. Die Implementierungsdetails sind je nach Anbieter unterschiedlich. In SQL verwenden Sie die `INSERT`-Anweisung zum Hinzufügen einer Zeile zu einer Tabelle. ``` INSERT INTO Music (Artist, SongTitle, AlbumTitle, Year, Price, Genre, Tags) VALUES( 'No One You Know', 'Call Me Today', 'Somewhat Famous', 2015, 2.14, 'Country', '{"Composers": ["Smith", "Jones", "Davis"],"LengthInSeconds": 214}' ); ``` Der Primärschlüssel für diese Tabelle besteht aus *Artist* und. *SongTitle* Sie müssen Werte für diese Spalten angeben. **Anmerkung** In diesem Beispiel wird die Spalte *Tags* zum Speichern halbstrukturierter Daten zu den Songs in der Tabelle *Musik* verwendet. Die Spalte *Tags* ist als Typ TEXT definiert. Dieser kann bis zu 65 535 Zeichen in MySQL speichern. ## Schreiben von Daten in eine Tabelle in DynamoDB In Amazon DynamoDB können Sie entweder die DynamoDB-API oder [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), eine SQL-kompatible Abfragesprache, verwenden, um einer Tabelle ein Element hinzuzufügen. ------ #### [ DynamoDB API ] Mit der DynamoDB-API verwenden Sie die `PutItem`-Operation zum Hinzufügen eines Elements zu einer Tabelle. ``` { TableName: "Music", Item: { "Artist":"No One You Know", "SongTitle":"Call Me Today", "AlbumTitle":"Somewhat Famous", "Year": 2015, "Price": 2.14, "Genre": "Country", "Tags": { "Composers": [ "Smith", "Jones", "Davis" ], "LengthInSeconds": 214 } } } ``` Der Primärschlüssel für diese Tabelle besteht aus *Artist* und. *SongTitle* Sie müssen Werte für diese Attribute angeben. Im Folgenden sind einige wichtige Fakten zu diesem `PutItem`-Beispiel aufgeführt: + DynamoDB bietet native Unterstützung für Dokumente unter Verwendung von JSON. Dadurch ist DynamoDB ideal zum Speichern halbstrukturierter Daten wie *Tags* geeignet. Sie können Daten innerhalb von JSON-Dokumenten auch abrufen und bearbeiten. + Die Tabelle *Music* hat außer dem Primärschlüssel (*Artist* und *SongTitle*) keine vordefinierten Attribute. + Die meisten SQL-Datenbanken sind transaktionsorientiert. Wenn Sie eine `INSERT`-Anweisung erstellen, sind die Datenänderungen erst dauerhaft, sobald Sie eine `COMMIT`-Anweisung generieren. Mit Amazon DynamoDB sind die Auswirkungen einer `PutItem`-Aktion dauerhaft, wenn DynamoDB mit einem HTTP 200-Statuscode (`OK`) antwortet. Im Folgenden sind weitere `PutItem`-Beispiele aufgeführt. ``` { TableName: "Music", Item: { "Artist": "No One You Know", "SongTitle": "My Dog Spot", "AlbumTitle":"Hey Now", "Price": 1.98, "Genre": "Country", "CriticRating": 8.4 } } ``` ``` { TableName: "Music", Item: { "Artist": "No One You Know", "SongTitle": "Somewhere Down The Road", "AlbumTitle":"Somewhat Famous", "Genre": "Country", "CriticRating": 8.4, "Year": 1984 } } ``` ``` { TableName: "Music", Item: { "Artist": "The Acme Band", "SongTitle": "Still In Love", "AlbumTitle":"The Buck Starts Here", "Price": 2.47, "Genre": "Rock", "PromotionInfo": { "RadioStationsPlaying":[ "KHCR", "KBQX", "WTNR", "WJJH" ], "TourDates": { "Seattle": "20150625", "Cleveland": "20150630" }, "Rotation": "Heavy" } } } ``` ``` { TableName: "Music", Item: { "Artist": "The Acme Band", "SongTitle": "Look Out, World", "AlbumTitle":"The Buck Starts Here", "Price": 0.99, "Genre": "Rock" } } ``` **Anmerkung** Neben `PutItem` unterstützt DynamoDB eine `BatchWriteItem`-Aktion zum Schreiben mehrerer Elemente gleichzeitig. ------ #### [ PartiQL for DynamoDB ] Mit PartiQL verwenden Sie die `ExecuteStatement`-Operation zum Hinzufügen eines Elements zu einer Tabelle mit PartiQL `Insert`-Anweisung. ``` INSERT into Music value { 'Artist': 'No One You Know', 'SongTitle': 'Call Me Today', 'AlbumTitle': 'Somewhat Famous', 'Year' : '2015', 'Genre' : 'Acme' } ``` Der Primärschlüssel für diese Tabelle besteht aus *Artist* und *SongTitle*. Sie müssen Werte für diese Attribute angeben. **Anmerkung** Codebeispiele, die `Insert` und `ExecuteStatement` verwenden, finden Sie unter [PartiQL-Insert-Anweisungen für DynamoDB](ql-reference.insert.md). ------ # Wichtige Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Lesen von Daten aus einer Tabelle Mit SQL verwenden Sie die `SELECT`-Anweisung, um eine oder mehrere Zeilen aus einer Tabelle abzurufen. Sie verwenden die `WHERE`-Klausel, um die Daten zu bestimmen, die an Sie zurückgesendet werden. Dies unterscheidet sich von der Verwendung von Amazon DynamoDB, das die folgenden Operationen zum Lesen von Daten bereitstellt: + `ExecuteStatement` ruft ein einzelnes oder mehrere Elemente aus einer Tabelle ab. `BatchExecuteStatement` ruft mehrere Elemente aus verschiedenen Tabellen in einem einzigen Vorgang ab. Beide dieser Operationen verwenden [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), eine SQL-kompatible Abfragesprache. + `GetItem` – Ruft ein einzelnes Element aus einer Tabelle ab. Dies ist die effizienteste Methode, um ein einzelnes Element zu lesen, da sie direkten Zugriff auf den physischen Standort des Elements ermöglicht. (DynamoDB bietet auch die `BatchGetItem`-Operation, mit der Sie bis zu 100 `GetItem`-Aufrufe in einer einzigen Operation ausführen können.) + `Query` – Ruft alle Elemente mit einem bestimmten Partitionsschlüssel ab. Innerhalb dieser Elemente können Sie eine Bedingung auf den Sortierschlüssel anwenden und nur eine Teilmenge der Daten abrufen. `Query` ermöglicht schnellen und effizienten Zugriff auf die Partitionen, in denen die Daten gespeichert sind. (Weitere Informationen finden Sie unter [Partitionen und Datenverteilung in DynamoDB](HowItWorks.Partitions.md).) + `Scan` – Ruft alle Elemente in der angegebenen Tabelle ab. (Diese Operation sollte nicht über großen Tabellen ausgeführt werden, da sie große Mengen an Systemressourcen belegen kann.) **Anmerkung** Mit einer relationalen Datenbank können Sie die `SELECT`-Anweisung verwenden, um Daten aus mehreren Tabellen zu verknüpfen und die Ergebnisse zurückzugeben. Joins (Verknüpfungen) sind eine Voraussetzung für das relationale Modell. Um sicherzustellen, dass Joins effizient ausgeführt werden, sollten die Datenbank und die zugehörigen Anwendungen kontinuierlich leistungsoptimiert werden. DynamoDB ist eine nicht relationale NoSQL-Datenbank und unterstützt keine Tabellen-Joins. Stattdessen lesen die Anwendungen die Daten aus den Tabellen nacheinander aus. In den folgenden Abschnitten werden die verschiedenen Anwendungsfälle für das Lesen von Daten sowie Anleitungen zum Ausführen dieser Aufgaben mit einer relationalen Datenbank und mit DynamoDB beschrieben. **Topics** + [Unterschiede beim Lesen eines Elements mit dem zugehörigen Primärschlüssel](SQLtoNoSQL.ReadData.SingleItem.md) + [Unterschiede beim Abfragen einer Tabelle](SQLtoNoSQL.ReadData.Query.md) + [Unterschiede beim Scannen einer Tabelle](SQLtoNoSQL.ReadData.Scan.md) # Unterschiede beim Lesen eines Elements mit dem zugehörigen Primärschlüssel Ein gängiges Zugriffsmuster für Datenbanken besteht darin, ein einzelnes Element aus einer Tabelle zu lesen. Sie müssen den Primärschlüssel des gewünschten Elements angeben. **Topics** + [Lesen eines Elements mit dem zugehörigen Primärschlüssel mit SQL](#SQLtoNoSQL.ReadData.SingleItem.SQL) + [Lesen eines Elements mit dem zugehörigen Primärschlüssel in DynamoDB](#SQLtoNoSQL.ReadData.SingleItem.DynamoDB) ## Lesen eines Elements mit dem zugehörigen Primärschlüssel mit SQL In SQL verwenden Sie die `SELECT`-Anweisung zum Abrufen von Daten aus einer Tabelle. Sie können eine oder mehrere Spalten im Ergebnis abfragen (oder alle Spalten, wenn Sie den `*`-Operator verwenden). Die `WHERE`-Klausel bestimmt, welche Zeilen zurückgegeben werden. Das folgende Beispiel umfasst eine `SELECT`-Anweisung zum Abrufen einer einzelnen Zeile aus der Tabelle *Music*. Die `WHERE`-Klausel gibt die Primärschlüsselwerte an. ``` SELECT * FROM Music WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today' ``` Sie können diese Abfrage ändern und nur eine Teilmenge der Spalten abrufen. ``` SELECT AlbumTitle, Year, Price FROM Music WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today' ``` *Beachten Sie, dass der Primärschlüssel für diese Tabelle aus Artist und besteht. *SongTitle** ## Lesen eines Elements mit dem zugehörigen Primärschlüssel in DynamoDB In Amazon DynamoDB können Sie entweder die DynamoDB-API oder [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), eine SQL-kompatible Abfragesprache, verwenden, um ein Element aus einer Tabelle zu lesen. ------ #### [ DynamoDB API ] Mit der DynamoDB-API verwenden Sie die `PutItem`-Operation zum Hinzufügen eines Elements zu einer Tabelle. DynamoDB stellt die Aktion `GetItem` zum Abrufen eines Elements über dessen Primärschlüssel bereit. `GetItem` ist äußerst effizient, da die Aktion direkten Zugriff auf den physischen Speicherort des Elements ermöglicht. (Weitere Informationen finden Sie unter [Partitionen und Datenverteilung in DynamoDB](HowItWorks.Partitions.md).) Standardmäßig gibt `GetItem` das gesamte Element mit allen zugehörigen Attributen zurück. ``` { TableName: "Music", Key: { "Artist": "No One You Know", "SongTitle": "Call Me Today" } } ``` Sie können einen `ProjectionExpression`-Parameter hinzufügen, um nur einige der Attribute zurückzugeben. ``` { TableName: "Music", Key: { "Artist": "No One You Know", "SongTitle": "Call Me Today" }, "ProjectionExpression": "AlbumTitle, Year, Price" } ``` Beachten Sie, dass der Primärschlüssel für diese Tabelle aus *Artist* und besteht. *SongTitle* Die `GetItem`-DynamoDB-Aktion ist sehr effizient. Sie bestimmt anhand der Primärschlüsselwerte den genauen Speicherort des entsprechenden Elements und ruft es direkt von dort ab. Die SQL-Anweisung `SELECT` ist im Hinblick auf das Abrufen von Elementen mithilfe von Primärschlüsselwerten ähnlich effizient. Die SQL-Anweisung `SELECT` unterstützt viele Arten von Abfragen und Tabellen-Scans. DynamoDB bietet eine ähnliche Funktionalität mit den Aktionen `Query` und `Scan`, die in [Unterschiede beim Abfragen einer Tabelle](SQLtoNoSQL.ReadData.Query.md) und [Unterschiede beim Scannen einer Tabelle](SQLtoNoSQL.ReadData.Scan.md) beschrieben sind. Die SQL-Anweisung `SELECT` kann Tabellen-Joins durchführen, sodass Sie Daten aus mehreren Tabellen gleichzeitig abrufen können. Joins sind am effektivsten, wenn die Datenbanktabellen normalisiert und die Beziehungen zwischen den Tabellen eindeutig sind. Wenn Sie allerdings zu viele Tabellen in einer `SELECT`-Anweisung verknüpfen, kann sich dies negativ auf die Anwendungsleistung auswirken. Sie können diese Probleme umgehen, indem Sie Datenbankreplikation, materialisierte Ansichten oder Abfrageumschreibungen verwenden. DynamoDB ist eine nicht zusammenhängende Datenbank und unterstützt keine Tabellen-Joins. Wenn Sie eine vorhandene Anwendung von einer relationalen Datenbank nach DynamoDB migrieren, müssen Sie Ihr Datenmodell denormalisieren, damit keine Joins erforderlich sind. ------ #### [ PartiQL for DynamoDB ] Mit PartiQL verwenden Sie die `ExecuteStatement`-Operation zum Lesen eines Elements aus einer Tabelle mit PartiQL `Select`-Anweisung. ``` SELECT AlbumTitle, Year, Price FROM Music WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today' ``` Beachten Sie, dass der Primärschlüssel für diese Tabelle aus Artist und besteht SongTitle. **Anmerkung** Die select PartiQL-Anweisung kann auch verwendet werden, um eine DynamoDB-Tabelle abzufragen oder zu scannen Codebeispiele, die `Select` und `ExecuteStatement` verwenden, finden Sie unter [PartiQL-Select-Anweisungen für DynamoDB](ql-reference.select.md). ------ # Unterschiede beim Abfragen einer Tabelle Ein anderes gängiges Zugriffsmuster besteht darin, mehrere Elemente aus einer Tabelle basierend auf Ihren Abfragekriterien zu lesen. **Topics** + [Abfragen einer Tabelle mit SQL](#SQLtoNoSQL.ReadData.Query.SQL) + [Abfragen einer Tabelle in DynamoDB](#SQLtoNoSQL.ReadData.Query.DynamoDB) ## Abfragen einer Tabelle mit SQL Bei Verwendung von SQL können Sie mit der Anweisung `SELECT` Schlüsselspalten, Nicht-Schlüsselspalten oder eine beliebige Kombination daraus abfragen. Die `WHERE`-Klausel bestimmt, welche Zeilen zurückgegeben werden, wie in den folgenden Beispielen gezeigt. ``` /* Return a single song, by primary key */ SELECT * FROM Music WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'; ``` ``` /* Return all of the songs by an artist */ SELECT * FROM Music WHERE Artist='No One You Know'; ``` ``` /* Return all of the songs by an artist, matching first part of title */ SELECT * FROM Music WHERE Artist='No One You Know' AND SongTitle LIKE 'Call%'; ``` ``` /* Return all of the songs by an artist, only if the price is less than 1.00 */ SELECT * FROM Music WHERE Artist='No One You Know' AND Price < 1.00; ``` Beachten Sie, dass der Primärschlüssel für diese Tabelle aus *Artist* und besteht *SongTitle*. ## Abfragen einer Tabelle in DynamoDB In Amazon DynamoDB können Sie entweder die DynamoDB-API oder [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), eine SQL-kompatible Abfragesprache, verwenden, um ein Element aus einer Tabelle abzufragen. ------ #### [ DynamoDB API ] Mit Amazon DynamoDB können Sie mit der Aktion `Query` Daten auf ähnliche Weise abrufen. Die Aktion `Query` bietet schnellen und effizienten Zugriff auf die physischen Orte, an denen die Daten gespeichert sind. Weitere Informationen finden Sie unter [Partitionen und Datenverteilung in DynamoDB](HowItWorks.Partitions.md). Sie können `Query` mit jeder Tabelle oder jedem sekundären Index verwenden. Sie müssen eine Gleichheitsbedingung für den Wert des Partitionsschlüssels festlegen und können optional eine andere Bedingung für das Sortierschlüsselattribut angeben, falls definiert. Der Parameter `KeyConditionExpression` gibt die Schlüsselwerte an, die Sie abfragen möchten. Sie können einen optionalen `FilterExpression` verwenden, um bestimmte Elemente aus den Ergebnissen zu entfernen, bevor diese zurückgegeben werden. In DynamoDB müssen Sie als Platzhalter `ExpressionAttributeValues` in Ausdrucksparametern (z. B. `KeyConditionExpression` und `FilterExpression`) verwenden. Dies entspricht der Verwendung von *Bindungsvariablen* in relationalen Datenbanken, in denen Sie die tatsächlichen Werte in der `SELECT`-Anweisung zur Laufzeit ersetzen. Beachten Sie, dass der Primärschlüssel für diese Tabelle aus *Artist* und besteht *SongTitle*. Im Folgenden sind weitere DynamoDB `Query`-Beispiele aufgeführt. ``` // Return a single song, by primary key { TableName: "Music", KeyConditionExpression: "Artist = :a and SongTitle = :t", ExpressionAttributeValues: { ":a": "No One You Know", ":t": "Call Me Today" } } ``` ``` // Return all of the songs by an artist { TableName: "Music", KeyConditionExpression: "Artist = :a", ExpressionAttributeValues: { ":a": "No One You Know" } } ``` ``` // Return all of the songs by an artist, matching first part of title { TableName: "Music", KeyConditionExpression: "Artist = :a and begins_with(SongTitle, :t)", ExpressionAttributeValues: { ":a": "No One You Know", ":t": "Call" } } ``` ``` // Return all of the songs by an artist, only if the price is less than 1.00 { TableName: "Music", KeyConditionExpression: "Artist = :a", FilterExpression: "Price < :p", ExpressionAttributeValues: { ":a": "No One You Know", ":p": 1.00 } } ``` **Anmerkung** A `FilterExpression` wird nach den `Query` Lesevorgängen angewendet, die den Elementen entsprechen, sodass die verbrauchte Lesekapazität nicht reduziert wird. Modellieren Sie Ihre Daten nach Möglichkeit so, dass Bereichsbedingungen für effiziente Abfragen `KeyConditionExpression` auf den Sortierschlüssel angewendet werden. Weitere Informationen finden Sie unter [Abfragen von Tabellen in DynamoDB](Query.md). ------ #### [ PartiQL for DynamoDB ] Mit PartiQL können Sie eine Abfrage ausführen, indem Sie die `ExecuteStatement`-Aktion und die `Select`-Anweisung auf den Partitionsschlüssel anwenden. ``` SELECT AlbumTitle, Year, Price FROM Music WHERE Artist='No One You Know' ``` Verwendung der `SELECT`-Anweisung gibt auf diese Weise alle Songs zurück, die mit diesem bestimmten `Artist` assoziiert sind. Codebeispiele, die `Select` und `ExecuteStatement` verwenden, finden Sie unter [PartiQL-Select-Anweisungen für DynamoDB](ql-reference.select.md). ------ # Unterschiede beim Scannen einer Tabelle In SQL gibt eine `SELECT`-Anweisung ohne `WHERE`-Klausel alle Zeilen einer Tabelle zurück. In Amazon DynamoDB übernimmt die `Scan`-Operation diese Funktion. In beiden Fällen können Sie alle oder nur einige Elemente abrufen. Unabhängig davon, ob Sie eine SQL- oder eine NoSQL-Datenbank verwenden, sollten Scans jedoch sparsam eingesetzt werden, da sie große Mengen an Systemressourcen belegen können. Manchmal ist ein Scan angebracht (z. B. Scannen einer kleinen Tabelle) oder unvermeidbar (wie die Ausführung eines Massenexports von Daten). Als allgemeine Regel sollten Sie Ihre Anwendungen so konzipieren, dass Scans vermieden werden. Weitere Informationen finden Sie unter [Abfragen von Tabellen in DynamoDB](Query.md). **Anmerkung** Bei einem Massenexport wird außerdem mindestens 1 Datei pro Partition erstellt. Alle Elemente in jeder Datei stammen aus dem Hash-Keyspace der betreffenden Partition. **Topics** + [Scannen einer Tabelle mit SQL](#SQLtoNoSQL.ReadData.Scan.SQL) + [Scannen einer Tabelle in DynamoDB](#SQLtoNoSQL.ReadData.Scan.DynamoDB) ## Scannen einer Tabelle mit SQL Bei Verwendung von SQL können Sie eine Tabelle scannen und alle Daten mit einer `SELECT`-Anweisung ohne Angabe einer `WHERE`-Bedingung abrufen. Sie können eine oder mehrere Spalten im Ergebnis abfragen. Sie können auch alle Spalten abfragen, wenn Sie das Platzhalterzeichen (\$1) verwenden. Es folgen Beispiele für eine `SELECT`-Anweisung. ``` /* Return all of the data in the table */ SELECT * FROM Music; ``` ``` /* Return all of the values for Artist and Title */ SELECT Artist, Title FROM Music; ``` ## Scannen einer Tabelle in DynamoDB In Amazon DynamoDB können Sie entweder die DynamoDB-API oder [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), eine SQL-kompatible Abfragesprache, verwenden, um einen Scan für eine Tabelle durchzuführen. ------ #### [ DynamoDB API ] Mit der DynamoDB-API verwenden Sie die `Scan`-Operation, um ein oder mehrere Elemente und Elementattribute zurückzugeben, indem Sie auf jedes Element in einer Tabelle oder einem sekundären Index zugreifen. ``` // Return all of the data in the table { TableName: "Music" } ``` ``` // Return all of the values for Artist and Title { TableName: "Music", ProjectionExpression: "Artist, Title" } ``` Die `Scan`-Aktion bietet auch einen Parameter `FilterExpression`, der es ermöglicht, Elemente zu verwerfen, die nicht in den Ergebnissen enthalten sein sollen. `FilterExpression` wird angewendet, nachdem der Scan durchgeführt wurde, aber bevor die Ergebnisse an Sie zurückgegeben werden. (Für große Tabellen wird dies nicht empfohlen: Sie werden für den gesamten `Scan` belastet, auch wenn nur einige übereinstimmende Elemente zurückgegeben werden.) ------ #### [ PartiQL for DynamoDB ] Mit PartiQL führen Sie einen Scan durch, indem Sie den `ExecuteStatement`-Vorgang verwenden, um den gesamten Inhalt einer Tabelle mit der `Select`-Anweisung zurückzugeben. ``` SELECT AlbumTitle, Year, Price FROM Music ``` Beachten Sie, dass diese Anweisung alle Elemente für in der Tabelle Musik zurückgibt. Codebeispiele mit `Select` und `ExecuteStatement` finden Sie unter [PartiQL-Select-Anweisungen für DynamoDB](ql-reference.select.md) ------ # Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Verwalten von Indizes Indexe ermöglichen Ihnen den Zugriff auf alternative Abfragemuster und können Abfragen beschleunigen. In diesem Abschnitt werden die Indexerstellung und -verwendung in SQL und Amazon DynamoDB verglichen und gegenübergestellt. Ganz gleich, ob Sie eine relationale Datenbank oder DynamoDB verwenden, sollten Sie bei der Indexerstellung mit Bedacht vorgehen. Bei jedem Schreibvorgang in einer Tabelle müssen alle Indexe der Tabelle aktualisiert werden. In einer Umgebung mit vielen Schreibvorgängen und großen Tabellen können dadurch große Mengen von Systemressourcen belegt werden. In schreibgeschützten Umgebungen (bzw. Umgebungen, indenen Daten vor allem gelesen werden) stellt dies kein Problem dar. Sie sollten jedoch sicherstellen, dass die Indexe tatsächlich von der Anwendung verwendet werden und nicht nur Speicherplatz belegen. **Topics** + [Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Erstellen eines Index](#SQLtoNoSQL.Indexes.Creating) + [Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Abfragen und Scannen eines Index](#SQLtoNoSQL.Indexes.QueryAndScan) ## Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Erstellen eines Index Vergleichen Sie die Anweisung `CREATE INDEX` in SQL mit der Operation `UpdateTable` in Amazon DynamoDB. **Topics** + [Erstellen eines Index mit SQL](#SQLtoNoSQL.Indexes.Creating.SQL) + [Erstellen eines Index in DynamoDB](#SQLtoNoSQL.Indexes.Creating.DynamoDB) ### Erstellen eines Index mit SQL In einer relationalen Datenbank ist ein Index eine Datenstruktur, mit der Sie schnelle Abfragen für verschiedene Spalten einer Tabelle ausführen können. Mit der SQL-Anweisung `CREATE INDEX` können Sie einer vorhandenen Tabelle einen Index hinzufügen, indem Sie die zu indizierenden Spalten angeben. Nachdem der Index erstellt wurde, können Sie die Daten in der Tabelle wie üblich abfragen. Die Datenbank kann die angegebenen Zeilen in der Tabelle anhand des Index schnell finden, sodass nicht die gesamte Tabelle gescannt werden muss. Nachdem Sie einen Index erstellt haben, wird dieser von der Datenbank gepflegt. Sobald Sie Daten in der Tabelle ändern, wird der Index automatisch den Änderungen in der Tabelle entsprechend angepasst. In MySQL können Sie einen Index wie den folgenden erstellen: ``` CREATE INDEX GenreAndPriceIndex ON Music (genre, price); ``` ### Erstellen eines Index in DynamoDB In DynamoDB können Sie einen *sekundären Index* für ähnliche Zwecke erstellen und verwenden. Indexe in DynamoDB unterscheiden sich von ihren relationalen Gegenstücken. Wenn Sie einen sekundären Index erstellen, müssen Sie dessen Schlüsselattribute angeben – einen Partitionsschlüssel und einen Sortierschlüssel. Nachdem Sie den sekundären Index erstellt haben, können Sie `Query` oder `Scan` wie bei einer Tabelle erstellen. DynamoDB bietet keinen Abfrageoptimierer, sodass ein sekundärer Index nur bei der `Query`- oder `Scan`-Aktion verwendet wird. DynamoDB unterstützt zwei verschiedene Arten von Indexen: + Globale sekundäre Indizes – Der Primärschlüssel des Index kann aus zwei beliebigen Attributen der Tabelle bestehen. + Lokale sekundäre Indizes – Der Partitionsschlüssel des Index muss mit dem Partitionsschlüssel der Tabelle übereinstimmen. Der Sortierschlüssel kann ein beliebiges, anderes Attribut sein. DynamoDB stellt sicher, dass die Daten in einem sekundären Index schließlich mit seiner Tabelle konsistent sind. Sie können stark konsistente `Query`- oder `Scan`-Aktionen für eine Tabelle oder einen lokalen sekundären Index anfordern. Globale sekundäre Indizes unterstützen jedoch nur die letztendliche Datenkonsistenz. Sie können einer vorhandenen Tabelle einen globalen sekundären Index hinzufügen, indem Sie die `UpdateTable`-Aktion verwenden und `GlobalSecondaryIndexUpdates` angeben. ``` { TableName: "Music", AttributeDefinitions:[ {AttributeName: "Genre", AttributeType: "S"}, {AttributeName: "Price", AttributeType: "N"} ], GlobalSecondaryIndexUpdates: [ { Create: { IndexName: "GenreAndPriceIndex", KeySchema: [ {AttributeName: "Genre", KeyType: "HASH"}, //Partition key {AttributeName: "Price", KeyType: "RANGE"}, //Sort key ], Projection: { "ProjectionType": "ALL" }, ProvisionedThroughput: { // Only specified if using provisioned mode "ReadCapacityUnits": 1,"WriteCapacityUnits": 1 } } } ] } ``` Sie müssen die folgenden Parameter für `UpdateTable` angeben: + `TableName` – Die Tabelle, mit der der Index verknüpft wird. + `AttributeDefinitions` – Die Datentypen für die Schlüsselschemaattribute des Index. + `GlobalSecondaryIndexUpdates` – Details zu dem Index, den Sie erstellen möchten: + `IndexName` – Ein Name für den Index. + `KeySchema` – Die Attribute, die für den Indexprimärschlüssel verwendet werden. + `Projection` – Attribute aus der Tabelle, die in den Index kopiert werden. In diesem Fall bedeutet `ALL`, dass alle Attribute kopiert werden. + `ProvisionedThroughput (for provisioned tables)` – Die Anzahl der Lese- und Schreibvorgänge pro Sekunde, die Sie für diesen Index benötigen. (Dieser Wert steht nicht mit den Einstellungen für den bereitgestellten Durchsatz der Tabelle in Zusammenhang.) Ein Teil dieser Operation umfasst das Abgleichen von Daten aus der Tabelle mit dem neuen Index. Während des Abgleichs ist die Tabelle weiterhin verfügbar. Der Index ist allerdings erst bereit, wenn sich das Attribut `Backfilling` von TRUE in FALSE ändert. Sie können die Aktion `DescribeTable` zum Anzeigen dieses Attributs verwenden. ## Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Abfragen und Scannen eines Index Vergleichen Sie das Abfragen und Scannen eines Index mithilfe der SELECT-Anweisung in SQL mit den Operationen `Query` und `Scan` in Amazon DynamoDB. **Topics** + [Abfragen und Scannen eines Index mit SQL](#SQLtoNoSQL.Indexes.QueryAndScan.SQL) + [Abfragen und Scannen eines Index in DynamoDB](#SQLtoNoSQL.Indexes.QueryAndScan.DynamoDB) ### Abfragen und Scannen eines Index mit SQL In einer relationalen Datenbank arbeiten Sie nicht direkt mit Indexen. Stattdessen fragen Sie Tabellen mithilfe von `SELECT`-Anweisungen ab. Der Abfrageoptimierer kann jeden beliebigen Index nutzen. Ein *Abfrageoptimierer* ist eine Komponente eines relationalen Datenbankmanagementsystems (RDBMS), die verfügbare Indexe auswertet und bestimmt, ob diese zum Beschleunigen einer Abfrage verwendet werden können. Wenn die Indexe zum Beschleunigen einer Abfrage verwendet werden können, greift das RDBMS zuerst auf den Index zu und sucht damit die Daten in der Tabelle. Im Folgenden finden Sie einige SQL-Anweisungen, mit denen Sie die Leistung verbessern können *GenreAndPriceIndex*. Wir setzen voraus, dass die Tabelle *Musik* genügend Daten enthält, damit der Abfrageoptimierer diesen Index verwendet, statt die gesamte Tabelle einfach zu scannen. ``` /* All of the rock songs */ SELECT * FROM Music WHERE Genre = 'Rock'; ``` ``` /* All of the cheap country songs */ SELECT Artist, SongTitle, Price FROM Music WHERE Genre = 'Country' AND Price < 0.50; ``` ### Abfragen und Scannen eines Index in DynamoDB In DynamoDB führen Sie `Query` und `Scan`-Operationen direkt für den Index aus, genauso wie für eine Tabelle. Sie können entweder die DynamoDB-API verwenden oder [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), eine SQL-kompatiblen Abfragesprache, um den Index abzufragen oder zu scannen. Sie müssen sowohl `TableName` als auch `IndexName` angeben. Im Folgenden finden Sie einige Abfragen *GenreAndPriceIndex*in DynamoDB. (Das Schlüsselschema für diesen Index besteht aus *Genre* und *Preis*.) ------ #### [ DynamoDB API ] ``` // All of the rock songs { TableName: "Music", IndexName: "GenreAndPriceIndex", KeyConditionExpression: "Genre = :genre", ExpressionAttributeValues: { ":genre": "Rock" }, }; ``` In diesem Beispiel wird ein `ProjectionExpression` verwendet, um anzugeben, dass nicht alle, sondern nur einige Attribute in den Ergebnissen enthalten sein sollen. ``` // All of the cheap country songs { TableName: "Music", IndexName: "GenreAndPriceIndex", KeyConditionExpression: "Genre = :genre and Price < :price", ExpressionAttributeValues: { ":genre": "Country", ":price": 0.50 }, ProjectionExpression: "Artist, SongTitle, Price" }; ``` Im Folgenden ist ein Scan aktiviert. *GenreAndPriceIndex* ``` // Return all of the data in the index { TableName: "Music", IndexName: "GenreAndPriceIndex" } ``` ------ #### [ PartiQL for DynamoDB ] Mit PartiQL verwenden Sie die PartiQL `Select`-Anweisung zur Durchführung von Abfragen und Scans für den Index. ``` // All of the rock songs SELECT * FROM Music.GenreAndPriceIndex WHERE Genre = 'Rock' ``` ``` // All of the cheap country songs SELECT * FROM Music.GenreAndPriceIndex WHERE Genre = 'Rock' AND Price < 0.50 ``` Das Folgende ist ein Scan aktiviert *GenreAndPriceIndex*. ``` // Return all of the data in the index SELECT * FROM Music.GenreAndPriceIndex ``` **Anmerkung** Codebeispiele, die `Select` verwenden, finden Sie unter [PartiQL-Select-Anweisungen für DynamoDB](ql-reference.select.md). ------ # Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Ändern von Daten in einer Tabelle Die SQL-Sprache bietet die `UPDATE`-Anweisung zum Ändern von Daten. Amazon DynamoDB verwendet die `UpdateItem`-Operation für ähnliche Aufgaben. **Topics** + [Ändern von Daten in einer Tabelle mit SQL](#SQLtoNoSQL.UpdateData.SQL) + [Ändern von Daten in einer Tabelle in DynamoDB](#SQLtoNoSQL.UpdateData.DynamoDB) ## Ändern von Daten in einer Tabelle mit SQL In SQL verwenden Sie die `UPDATE`-Anweisung, um eine oder mehrere Zeilen zu ändern. Die `SET`-Klausel gibt neue Werte für eine oder mehrere Spalten an und mit der `WHERE`-Klausel wird bestimmt, welche Zeilen geändert werden. Im Folgenden wird ein -Beispiel gezeigt. ``` UPDATE Music SET RecordLabel = 'Global Records' WHERE Artist = 'No One You Know' AND SongTitle = 'Call Me Today'; ``` Wenn keine Zeilen mit der `WHERE`-Klausel übereinstimmen, ist die `UPDATE`-Anweisung wirkungslos. ## Ändern von Daten in einer Tabelle in DynamoDB In DynamoDB können Sie entweder die DynamoDB-API oder [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), eine SQL-kompatible Abfragesprache, verwenden, um ein einzelnes Element zu ändern. Wenn Sie mehrere Elemente ändern möchten, müssen Sie mehrere Operationen verwenden. ------ #### [ DynamoDB API ] In der DynamoDB-API verwenden Sie die `UpdateItem`-Aktion, um ein einzelnes Element zu ändern. ``` { TableName: "Music", Key: { "Artist":"No One You Know", "SongTitle":"Call Me Today" }, UpdateExpression: "SET RecordLabel = :label", ExpressionAttributeValues: { ":label": "Global Records" } } ``` Sie müssen die `Key`-Attribute des zu ändernden Elements angeben sowie einen `UpdateExpression` zur Angabe der Attributwerte. `UpdateItem` verhält sich wie eine „upsert“-Operation. Das Element wird aktualisiert, wenn es in der Tabelle vorhanden ist. Andernfalls wird ein neues Element hinzugefügt (eingefügt). `UpdateItem` unterstützt *bedingte Schreibvorgänge*, in denen die Operation nur erfolgreich abgeschlossen wird, wenn ein bestimmter `ConditionExpression` mit TRUE ausgewertet wird. Die folgende `UpdateItem`-Aktion führt die Aktualisierung nur durch, wenn der Preis des Songs größer oder gleich 2,00 ist. ``` { TableName: "Music", Key: { "Artist":"No One You Know", "SongTitle":"Call Me Today" }, UpdateExpression: "SET RecordLabel = :label", ConditionExpression: "Price >= :p", ExpressionAttributeValues: { ":label": "Global Records", ":p": 2.00 } } ``` `UpdateItem` unterstützt außerdem *unteilbare Zähler*, dies sind Attribute vom Typ `Number`, die schrittweise erhöht oder verringert werden können. Unteilbare Zähler ähneln in vielerlei Hinsicht Sequenzgeneratoren, Identitätsspalten oder Feldern für die automatische Inkrementierung in SQL-Datenbanken. Das folgende Beispiel ist eine `UpdateItem`-Operation zur Initialisierung eines neuen Attributs (*Plays*), um zu verfolgen, wie oft der Song abgespielt wurde. ``` { TableName: "Music", Key: { "Artist":"No One You Know", "SongTitle":"Call Me Today" }, UpdateExpression: "SET Plays = :val", ExpressionAttributeValues: { ":val": 0 }, ReturnValues: "UPDATED_NEW" } ``` Der Parameter `ReturnValues` wird auf `UPDATED_NEW` festgelegt. Hiermit werden die neuen Werte aktualisierter Attribute zurückgegeben. In diesem Fall wird 0 (Null) zurückgegeben. Sobald dieser Song abgespielt wird, können wir die folgende `UpdateItem`-Operation verwenden, um das Attribut *Plays* um eins zu erhöhen. ``` { TableName: "Music", Key: { "Artist":"No One You Know", "SongTitle":"Call Me Today" }, UpdateExpression: "SET Plays = Plays + :incr", ExpressionAttributeValues: { ":incr": 1 }, ReturnValues: "UPDATED_NEW" } ``` ------ #### [ PartiQL for DynamoDB ] Mit PartiQL verwenden Sie die `ExecuteStatement`-Operation zum Ändern eines Elements in einer Tabelle mit PartiQL `Update`-Anweisung. Der Primärschlüssel für diese Tabelle besteht aus *Artist* und. *SongTitle* Sie müssen Werte für diese Attribute angeben. ``` UPDATE Music SET RecordLabel ='Global Records' WHERE Artist='No One You Know' AND SongTitle='Call Me Today' ``` Sie können wie im folgenden Beispiel auch mehrere Felder gleichzeitig ändern. ``` UPDATE Music SET RecordLabel = 'Global Records' SET AwardsWon = 10 WHERE Artist ='No One You Know' AND SongTitle='Call Me Today' ``` `Update` unterstützt außerdem *unteilbare Zähler*, dies sind Attribute vom Typ `Number`, die schrittweise erhöht oder verringert werden können. Unteilbare Zähler ähneln in vielerlei Hinsicht Sequenzgeneratoren, Identitätsspalten oder Feldern für die automatische Inkrementierung in SQL-Datenbanken. Das folgende Beispiel ist eine `Update`-Anweisung zur Initialisierung eines neuen Attributs (*Plays*), um zu verfolgen, wie oft der Song abgespielt wurde. ``` UPDATE Music SET Plays = 0 WHERE Artist='No One You Know' AND SongTitle='Call Me Today' ``` Sobald dieser Song abgespielt wird, können wir die folgende `Update`-Anweisung verwenden, um das Attribut *Spielt* um eins zu erhöhen. ``` UPDATE Music SET Plays = Plays + 1 WHERE Artist='No One You Know' AND SongTitle='Call Me Today' ``` **Anmerkung** Codebeispiele, die `Update` und `ExecuteStatement` verwenden, finden Sie unter [Aktualisierungen für PartiQL-Anweisungen für DynamoDB](ql-reference.update.md). ------ # Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Löschen von Daten aus einer Tabelle In SQL wird mit der `DELETE`-Anweisung eine oder mehrere Zeilen aus einer Tabelle entfernt. Amazon DynamoDB verwendet die `DeleteItem`-Operation, um jeweils ein Element zu löschen. **Topics** + [Löschen von Daten aus einer Tabelle mit SQL](#SQLtoNoSQL.DeleteData.SQL) + [Löschen von Daten aus einer Tabelle in DynamoDB](#SQLtoNoSQL.DeleteData.DynamoDB) ## Löschen von Daten aus einer Tabelle mit SQL In SQL verwenden Sie die `DELETE`-Anweisung, um eine oder mehrere Zeilen zu löschen. Die `WHERE`-Klausel bestimmt, welche Zeilen geändert werden sollen. Im Folgenden wird ein -Beispiel gezeigt. ``` DELETE FROM Music WHERE Artist = 'The Acme Band' AND SongTitle = 'Look Out, World'; ``` Sie können die `WHERE`-Klausel ändern, um mehrere Zeilen zu löschen. Sie können beispielsweise alle Songs eines bestimmten Interpreten löschen, wie in dem folgenden Beispiel gezeigt wird. ``` DELETE FROM Music WHERE Artist = 'The Acme Band' ``` ## Löschen von Daten aus einer Tabelle in DynamoDB In DynamoDB können Sie entweder die DynamoDB-API oder [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), eine SQL-kompatible Abfragesprache, verwenden, um ein einzelnes Element zu löschen. Wenn Sie mehrere Elemente ändern möchten, müssen Sie mehrere Operationen verwenden. ------ #### [ DynamoDB API ] In der DynamoDB-API verwenden Sie die Aktion `DeleteItem`, um Daten elementweise aus einer Tabelle zu löschen. Sie müssen die Primärschlüsselwerte des Elements angeben. ``` { TableName: "Music", Key: { Artist: "The Acme Band", SongTitle: "Look Out, World" } } ``` **Anmerkung** Neben `DeleteItem` unterstützt Amazon DynamoDB eine `BatchWriteItem`-Aktion zum gleichzeitigen Löschen mehrerer Elemente. `DeleteItem` unterstützt *bedingte Schreibvorgänge*, in denen die Operation nur erfolgreich abgeschlossen wird, wenn ein bestimmter `ConditionExpression` mit TRUE ausgewertet wird. Beispielsweise löscht der folgende `DeleteItem` Vorgang das Element nur, wenn es über ein Attribut verfügt. *RecordLabel* ``` { TableName: "Music", Key: { Artist: "The Acme Band", SongTitle: "Look Out, World" }, ConditionExpression: "attribute_exists(RecordLabel)" } ``` ------ #### [ PartiQL for DynamoDB ] Mit PartiQL verwenden Sie die `Delete`-Anweisung durch die`ExecuteStatement`-Operation zum Löschen von Daten aus einer Tabelle, jeweils ein Element. Sie müssen die Primärschlüsselwerte des Elements angeben. Der Primärschlüssel für diese Tabelle besteht aus *Artist* und *SongTitle*. Sie müssen Werte für diese Attribute angeben. ``` DELETE FROM Music WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks' ``` Sie können auch zusätzliche Bedingungen für die Operation angeben. Die folgende `DELETE`-Operation löscht das Element nur, wenn es mehr als 11 *Auszeichnungen* hat. ``` DELETE FROM Music WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks' AND Awards > 11 ``` **Anmerkung** Codebeispiele, die `DELETE` und `ExecuteStatement` verwenden, finden Sie unter [PartiQL-Delete-Anweisungen für DynamoDB](ql-reference.delete.md). ------ # Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Entfernen einer Tabelle In SQL verwenden Sie die `DROP TABLE`-Anweisung zum Entfernen einer Tabelle. In Amazon DynamoDB verwenden Sie die `DeleteTable`-Operation. **Topics** + [Entfernen einer Tabelle mit SQL](#SQLtoNoSQL.RemoveTable.SQL) + [Entfernen einer Tabelle in DynamoDB](#SQLtoNoSQL.RemoveTable.DynamoDB) ## Entfernen einer Tabelle mit SQL Wenn Sie eine Tabelle nicht mehr benötigen und sie dauerhaft löschen möchten, verwenden Sie die `DROP TABLE`-Anweisung in SQL. ``` DROP TABLE Music; ``` Nachdem eine Tabelle entfernt wurde, kann sie nicht wiederhergestellt werden. (Bei einigen relationalen Datenbanken ist es möglich, eine `DROP TABLE`-Operation rückgängig zu machen. Hierbei handelt es sich jedoch um eine anbieterspezifische Funktionalität, die nicht gängig ist.) ## Entfernen einer Tabelle in DynamoDB In DynamoDB ist die `DeleteTable`-Aktion ähnlich. Im folgenden Beispiel wird die Tabelle dauerhaft gelöscht. ``` { TableName: "Music" } ```