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.
# Amazon DynamoDB: Funktionsweise
Die folgenden Abschnitte vermitteln eine Übersicht über Amazon-DynamoDB-Servicekomponenten und darüber, wie sie interagieren.
**Topics**
+ [Spickzettel für DynamoDB](CheatSheet.md)
+ [Kernkomponenten von Amazon DynamoDB](HowItWorks.CoreComponents.md)
+ [DynamoDB API](HowItWorks.API.md)
+ [Unterstützte Datentypen und Benennungsregeln in Amazon DynamoDB](HowItWorks.NamingRulesDataTypes.md)
+ [DynamoDB-Tabellenklassen](HowItWorks.TableClasses.md)
+ [Partitionen und Datenverteilung in DynamoDB](HowItWorks.Partitions.md)
+ [Erfahren Sie, wie Sie von SQL zu NoSQL wechseln.](SQLtoNoSQL.md)
+ [Lernressourcen und Tools für Amazon DynamoDB](AdditionalResources.md)
# Spickzettel für DynamoDB
Dieser Spickzettel bietet eine Kurzreferenz für die Arbeit mit Amazon DynamoDB und seinen verschiedenen Funktionen. AWS SDKs
## Erstes Einrichten von
1. [Melden Sie sich an für](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.SignUpForAWS). AWS
1. [Rufen Sie einen AWS -Zugriffsschlüssel](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.GetCredentials) für den programmgesteuerten Zugriff auf DynamoDB ab.
1. [Konfigurieren Sie Ihre DynamoDB-Anmeldeinformationen](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.ConfigureCredentials).
**Weitere Informationen finden Sie auch unter:**
+ [Einrichten von DynamoDB (Webservice)](SettingUp.DynamoWebService.html)
+ [Erste Schritte mit DynamoDB](GettingStartedDynamoDB.html)
+ [Grundlegender Überblick über die zentralen Komponenten](HowItWorks.CoreComponents.html)
## SDK oder CLI
Wählen Sie Ihr bevorzugtes [SDK](sdk-general-information-section.html) aus oder richten Sie die [AWS CLI](/cli/latest/index.html) ein.
**Anmerkung**
Wenn Sie AWS CLI unter Windows den verwenden, wird ein umgekehrter Schrägstrich (\$1), der sich nicht in einem Anführungszeichen befindet, als Zeilenumbruch behandelt. Außerdem müssen Sie alle Anführungszeichen und geschweiften Klammern innerhalb anderer Anführungszeichen mit einem Escape-Zeichen versehen. Ein Beispiel finden Sie auf der Registerkarte **Windows** unter „Erstellen einer Tabelle“ im nächsten Abschnitt.
**Weitere Informationen finden Sie auch unter:**
+ [AWS CLI mit DynamoDB](Tools.CLI.html)
+ [Erste Schritte mit DynamoDB – Schritt 2](getting-started-step-2.html)
## Grundlegende Aktionen
In diesem Abschnitt finden Sie Code für grundlegende DynamoDB-Aufgaben. Weitere Informationen zu diesen Aufgaben finden Sie unter [Erste Schritte mit DynamoDB und](GettingStarted.html) unter. AWS SDKs
### Erstellen einer Tabelle
------
#### [ Default ]
```
aws dynamodb create-table \
--table-name Music \
--attribute-definitions \
AttributeName=Artist,AttributeType=S \
AttributeName=SongTitle,AttributeType=S \
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
--billing-mode PAY_PER_REQUEST \
--table-class STANDARD
```
------
#### [ Windows ]
```
aws dynamodb create-table ^
--table-name Music ^
--attribute-definitions ^
AttributeName=Artist,AttributeType=S ^
AttributeName=SongTitle,AttributeType=S ^
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE ^
--billing-mode PAY_PER_REQUEST ^
--table-class STANDARD
```
------
### Schreiben eines Elements in eine Tabelle
```
aws dynamodb put-item \ --table-name Music \ --item file://item.json
```
### Lesen eines Elements aus einer Tabelle
```
aws dynamodb get-item \ --table-name Music \ --item file://item.json
```
### Löschen eines Elements aus einer Tabelle
```
aws dynamodb delete-item --table-name Music --key file://key.json
```
### Tabellen abfragen
```
aws dynamodb query --table-name Music
--key-condition-expression "ArtistName=:Artist and SongName=:Songtitle"
```
### Löschen einer Tabelle
```
aws dynamodb delete-table --table-name Music
```
### Auflisten von Tabellennamen
```
aws dynamodb list-tables
```
## Benennungsregeln
+ Alle Namen müssen mit UTF-8 kodiert werden und die Groß- und Kleinschreibung muss beachtet werden.
+ Tabellen- und Indexnamen müssen zwischen 3 und 255 Zeichen lang sein und dürfen nur folgende Zeichen enthalten:
+ `a-z`
+ `A-Z`
+ `0-9`
+ `_` (Unterstrich)
+ `-` (Bindestrich)
+ `.` (Punkt)
+ Attributnamen müssen mindestens ein Zeichen lang und dürfen nicht größer als 64 KB sein.
Weitere Informationen finden Sie unter [Benennungsregeln](HowItWorks.NamingRulesDataTypes.html).
## Grundlegende Informationen zu Service Quotas
**Lese- und Schreibeinheiten**
+ **Lesekapazitätseinheit (Read capacity unit, RCU)** – Ein strikt konsistenter Lesevorgang pro Sekunde oder zwei letztendlich konsistente Lesevorgänge pro Sekunde für Elemente mit einer Größe von bis zu 4 KB.
+ **Schreibkapazitätseinheit (Write capacity unit, WCU)** – Ein Schreibvorgang pro Sekunde für Elemente mit einer Größe von bis zu 1 KB.
**Tabellen-Limits**
+ **Tabellengröße** – Es gibt praktisch kein Limit für die Tabellengröße. Tabellen sind in Bezug auf die Anzahl von Elementen oder die Anzahl von Bytes unbeschränkt.
+ **Anzahl der Tabellen** — Für jedes AWS Konto gibt es ein anfängliches Kontingent von 2.500 Tabellen pro AWS Region.
+ **Seitengrößenbeschränkung für Abfrage und Scan** – Es gibt ein Limit von 1 MB pro Seite, pro Abfrage oder Scan. Wenn Ihre Abfrageparameter oder die Scan-Operation für eine Tabelle mehr als 1 MB an Daten ergeben, gibt DynamoDB die ersten übereinstimmenden Elemente zurück. Es wird auch eine Eigenschaft `LastEvaluatedKey` zurückgegeben, die Sie in einer neuen Anforderung verwenden können, um die nächste Seite zu lesen.
**Indizes**
+ **Lokale sekundäre Indizes (LSIs)** — Sie können maximal fünf lokale sekundäre Indizes definieren. LSIs sind in erster Linie nützlich, wenn ein Index eine starke Konsistenz mit der Basistabelle aufweisen muss.
+ **Globale Sekundärindizes (GSIs)** — Es gibt ein Standardkontingent von 20 globalen Sekundärindizes pro Tabelle.
+ **Projizierte sekundäre Indexattribute pro Tabelle** – Sie können insgesamt bis zu 100 Attribute in alle lokalen und globalen sekundären Indizes einer Tabelle projizieren. Dies gilt nur für vom Benutzer angegebene, projizierte Attribute.
**Partitionsschlüssel**
+ Die Mindestlänge eines Partitionsschlüsselwerts beträgt 1 Byte. Die maximale Länge beträgt 2 048 Byte.
+ Es gibt praktisch keine Einschränkung in Bezug auf die Anzahl von eindeutigen Partitionsschlüsselwerten, weder für Tabellen noch für sekundäre Indizes.
+ Die Mindestlänge eines Sortierschlüsselwerts beträgt 1 Byte. Die maximale Länge beträgt 1 024 Byte.
+ Im Prinzip gibt es praktisch keine Einschränkung in Bezug auf die Anzahl von eindeutigen Sortierschlüsselwerten pro Partitionsschlüsselwert. Eine Ausnahme bilden Tabellen mit sekundären Indizes.
Weitere Informationen zu sekundären Indizes sowie zum Entwurf von Partitionsschlüsseln und Sortierschlüsseln finden Sie unter [Bewährte Methoden](best-practices.html).
**Grenzwerte für häufig verwendete Datentypen**
+ **Zeichenfolge** – Die Länge einer Zeichenfolge ist durch die maximale Elementgröße von 400 KB beschränkt. Die Zeichenfolgen sind Unicode mit binärer UTF-8-Kodierung.
+ **Zahl** – Eine Zahl kann bis zu 38 Nachkommastellen besitzen und positiv, negativ oder null sein.
+ **Binär** – Die Länge eines binären Werts ist durch die maximale Elementgröße von 400 KB beschränkt. Anwendungen, die binäre Attribute verwenden, müssen die Daten vor dem Senden an DynamoDB mit der base64-Verschlüsselung kodieren.
Eine Liste der unterstützten Datentypen finden Sie unter [Datentypen](HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes). Weitere Informationen finden Sie unter [Service Quotas](ServiceQuotas.html#limits-items).
### Elemente, Attribute und Ausdrucksparameter
Die maximale Elementgröße in DynamoDB beträgt 400 KB. Darin inbegriffen sind die binäre Länge (UTF-8-Länge) des Attributnamens und die binäre Länge (UTF-8-Länge) des Attributwerts. Der Attributname wird bei der Größenbeschränkung mit eingerechnet.
Es gibt keine Beschränkungen in Bezug auf die Anzahl der Werte in einer Liste, einer Zuordnung oder einem Satz, solange das Element, das die Werte enthält, das Limit der Elementgröße von 400 KB einhält.
Für Ausdrucksparameter beträgt die maximale Länge von Ausdruckszeichenfolgen 4 KB.
Weitere Informationen zu Elementgröße, Attributen und Ausdrucksparametern finden Sie unter [Service Quotas](ServiceQuotas.html#limits-items).
## Weitere Informationen
+ [Sicherheit](security.html)
+ [Überwachung und Protokollierung](monitoring.html)
+ [Arbeiten mit Datenströmen](streamsmain.html)
+ [Backups](Backup-and-Restore.html) [und Wiederherstellung Point-in-time ](Point-in-time-recovery.html)
+ [Integration mit anderen AWS Diensten](OtherServices.html)
+ [API-Referenz](/amazondynamodb/latest/APIReference/Welcome.html)
+ [Architekturzentrum: Bewährte Methoden für Datenbanken](https://aws.amazon.com/architecture/databases/)
+ [Video-Tutorials](https://youtu.be/Mw8wCj0gkRc)
+ [DynamoDB-Forum](https://repost.aws/search/questions?globalSearch=dynamodb)
# Kernkomponenten von Amazon DynamoDB
In DynamoDB sind Tabellen, Elemente und Attribute die zentralen Komponenten, mit denen Sie arbeiten. Eine *Tabelle* ist eine Sammlung von *Elementen* und jedes Element wiederum eine Sammlung von *Attributen*. DynamoDB nutzt Primärschlüssel, um jedes Element in einer Tabelle eindeutig zu identifizieren. Sie können DynamoDB Streams verwenden, um Datenänderungsereignisse in DynamoDB-Tabellen zu erfassen.
Es gibt Beschränkungen in DynamoDB. Weitere Informationen finden Sie unter [Kontingente in Amazon DynamoDB](ServiceQuotas.md).
Das folgende Video gibt Ihnen einen einführenden Einblick in Tabellen, Elemente und Attribute.
[Tabellen, Elemente und Attribute](https://www.youtube.com/embed/Mw8wCj0gkRc)
## Tabellen, Elemente und Attribute
![\[Jede DynamoDB-Tabelle enthält null oder mehr Elemente, die aus einem oder mehreren Attributen bestehen.\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/HowItWorksTables-2024.png)
Folgendes sind die grundlegenden DynamoDB-Komponenten:
+ **Tabellen** – Ähnlich wie bei anderen Datenbankmanagementsystemen werden auch die Daten von DynamoDB in Tabellen gespeichert. Eine *Tabelle* ist eine Sammlung von Daten. Ein Beispiel ist die folgende Tabelle *People*, die Sie zum Speichern von persönlichen Kontaktinformationen zu Freunden, Familienmitgliedern oder anderen Personen verwenden könnten. Sie könnten auch eine Tabelle namens *Cars* haben, um Informationen über Fahrzeuge zu pflegen.
+ **Elemente** - Jede Tabelle enthält keine oder mehrere Elemente. Ein *Element* ist eine Gruppe von Attributen, die unter allen anderen Elementen eindeutig identifizierbar ist. In einer *People*-Tabelle stellt jedes Element eine Person dar. In einer *Cars*-Tabelle stellt jedes Element ein Fahrzeug dar. Elemente in DynamoDB gleichen in vielerlei Hinsicht Zeilen, Datensätzen oder Tupel in anderen Datenbanksystemen. Bei DynamoDB gibt es keine Beschränkungen hinsichtlich Anzahl der Elemente, die in einer Tabelle gespeichert werden können.
+ **Attribute** – Jedes Element besteht aus einem oder mehreren Attributen. Ein *Attribut* ist ein grundlegendes Datenelement, das nicht weiter untergliedert werden muss. Beispielsweise enthält ein Element in einer *Personentabelle* Attribute mit der Bezeichnung *PersonID *LastName*FirstName***,, usw. In einer *Department*-Tabelle könnte ein Element Attribute wie beispielsweise *DepartmentID*, *Name*, *Manager* usw. aufweisen. In DynamoDB gleichen Attribute in vielerlei Hinsicht Feldern oder Spalten in anderen Datenbanksystemen.
Das folgende Diagramm zeigt eine Tabelle mit dem Namen *People* mit einigen Beispielelementen und -attributen.
```
People
{
"PersonID": 101,
"LastName": "Smith",
"FirstName": "Fred",
"Phone": "555-4321"
}
{
"PersonID": 102,
"LastName": "Jones",
"FirstName": "Mary",
"Address": {
"Street": "123 Main",
"City": "Anytown",
"State": "OH",
"ZIPCode": 12345
}
}
{
"PersonID": 103,
"LastName": "Stephens",
"FirstName": "Howard",
"Address": {
"Street": "123 Main",
"City": "London",
"PostalCode": "ER3 5K8"
},
"FavoriteColor": "Blue"
}
```
Beachten Sie im Hinblick auf die Tabelle *People* Folgendes:
+ Jedes Element in der Tabelle verfügt über einen eindeutigen Bezeichner oder Primärschlüssel, der das Element von allen anderen Elementen in der Tabelle unterscheidet. In der Tabelle *People* besteht der Primärschlüssel aus einem Attribut (*PersonID*).
+ Mit Ausnahme des Primärschlüssels ist die Tabelle *People* schemalos. Dies bedeutet, dass weder die Attribute noch deren Datentypen im Vorfeld definiert werden müssen. Jedes Element kann über eigene eindeutige Attribute verfügen.
+ Die meisten Attribute sind *skalar*, das heißt, sie können nur einen Wert annehmen. Zeichenfolgen und Zahlen sind allgemeine Beispiele für skalare Werte.
+ Einige Elemente verfügen über ein verschachteltes Attribut (*Address*). DynamoDB unterstützt verschachtelte Attribute bis zu einer Tiefe von 32 Ebenen.
Im Folgenden finden Sie eine weitere Beispieltabelle mit dem Namen *Music*, die Sie verwenden können, um Ihre Musiksammlung zu erfassen.
```
Music
{
"Artist": "No One You Know",
"SongTitle": "My Dog Spot",
"AlbumTitle": "Hey Now",
"Price": 1.98,
"Genre": "Country",
"CriticRating": 8.4
}
{
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road",
"AlbumTitle": "Somewhat Famous",
"Genre": "Country",
"CriticRating": 8.4,
"Year": 1984
}
{
"Artist": "The Acme Band",
"SongTitle": "Still in Love",
"AlbumTitle": "The Buck Starts Here",
"Price": 2.47,
"Genre": "Rock",
"PromotionInfo": {
"RadioStationsPlaying": [
"KHCR",
"KQBX",
"WTNR",
"WJJH"
],
"TourDates": {
"Seattle": "20150622",
"Cleveland": "20150630"
},
"Rotation": "Heavy"
}
}
{
"Artist": "The Acme Band",
"SongTitle": "Look Out, World",
"AlbumTitle": "The Buck Starts Here",
"Price": 0.99,
"Genre": "Rock"
}
```
Beachten Sie im Hinblick auf die Tabelle *Music* Folgendes:
+ Der Primärschlüssel für *Musik* besteht aus zwei Attributen (*Künstler* und *SongTitle*). Jedes Element in der Tabelle muss über diese beiden Attribute verfügen. Die Kombination von *Artist* und *SongTitle*unterscheidet jedes Element in der Tabelle von allen anderen.
+ Mit Ausnahme des Primärschlüssels ist die Tabelle *Music* schemalos. Dies bedeutet, dass weder die Attribute noch deren Datentypen im Vorfeld definiert werden müssen. Jedes Element kann über eigene eindeutige Attribute verfügen.
+ Eines der Elemente hat ein verschachteltes Attribut (*PromotionInfo*), das andere verschachtelte Attribute enthält. DynamoDB unterstützt bis zu 32 Ebenen verschachtelter Attribute.
Weitere Informationen finden Sie unter [Arbeiten mit Tabellen und Daten in DynamoDB](WorkingWithTables.md).
## Primärschlüssel
Wenn Sie eine Tabelle erstellen, müssen Sie außer dem Tabellennamen auch den Primärschlüssel der Tabelle angeben. Der Primärschlüssel identifiziert jedes Element in der Tabelle eindeutig, sodass keine zwei Elemente denselben Schlüssel haben können.
DynamoDB unterstützt zwei verschiedene Arten von Primärschlüsseln:
+ **Partitionsschlüssel** – Ein einfacher Primärschlüssel bestehend aus einem Attribut, das als *Partitionsschlüssel* bezeichnet wird.
DynamoDB verwendet den Wert des Partitionsschlüssels als Eingabe für eine interne Hash-Funktion. Die Ausgabe der Hash-Funktion bestimmt die Partition (physischer interner Speicher von DynamoDB), in der das Element gespeichert wird.
In einer Tabelle mit nur einem Partitionsschlüssel können zwei Elemente in einer Tabelle nicht den gleichen Partitionsschlüsselwert haben.
Die Tabelle *People*, die in [Tabellen, Elemente und Attribute](#HowItWorks.CoreComponents.TablesItemsAttributes) beschrieben wird, ist ein Beispiel für eine Tabelle mit einem einfachen Primärschlüssel (*PersonID*). Sie können direkt auf jedes Element in der Tabelle *Personen* zugreifen, indem Sie den *PersonId*Wert für dieses Element angeben.
+ **Partitionsschlüssel und Sortierschlüssel** – Diese Schlüssel werden als *zusammengesetzter Primärschlüssel* bezeichnet, da er aus zwei Attributen besteht. Das erste Attribut ist der *Partitionsschlüssel* und das zweite der *Sortierschlüssel*.
DynamoDB verwendet den Wert des Partitionsschlüssels als Eingabe für eine interne Hash-Funktion. Die Ausgabe der Hash-Funktion bestimmt die Partition (physischer interner Speicher von DynamoDB), in der das Element gespeichert wird. Alle Elemente mit dem gleichen Partitionsschlüsselwert werden zusammen gespeichert, und zwar sortiert nach Sortierschlüsselwert.
In einer Tabelle, die über einen Partitionsschlüssel und einen Sortierschlüssel verfügt, ist es möglich, dass mehrere Elemente denselben Partitionsschlüsselwert aufweisen. Diese Elemente müssen aber verschiedene Sortierschlüsselwerte aufweisen.
Die unter beschriebene Tabelle *Music* [Tabellen, Elemente und Attribute](#HowItWorks.CoreComponents.TablesItemsAttributes) ist ein Beispiel für eine Tabelle mit einem zusammengesetzten Primärschlüssel (*Artist* und *SongTitle*). Sie können direkt auf jedes Element in der Tabelle *Musik* zugreifen, wenn Sie den *Interpreten* und die *SongTitle*Werte für dieses Element angeben.
Mit einem zusammengesetzten Primärschlüssel erhalten Sie noch mehr Flexibilität bei der Abfrage von Daten. Wenn Sie beispielsweise nur den Wert für *Artist* angeben, ruft DynamoDB alle Songs dieses Interpreten ab. Um nur eine Teilmenge der Songs eines bestimmten Interpreten abzurufen, können Sie einen Wert für *Artist* zusammen mit einem Wertebereich für *SongTitle*angeben.
**Anmerkung**
Der Partitionsschlüssel eines Elements wird auch als *Hash-Attribut* bezeichnet. Der Begriff *Hash-Attribut* leitet sich von der Verwendung einer internen Hash-Funktion in DynamoDB ab, durch die Datenelemente basierend auf ihren Partitionsschlüsselwerten gleichmäßig auf die Partitionen verteilt werden.
Der Sortierschlüssel eines Elements wird auch als *Bereichsattribut* bezeichnet. Der Begriff *Bereichsattribut* bezieht sich auf die Art und Weise, wie DynamoDB Elemente mit demselben Partitionsschlüssel physisch nah beieinander speichert, und zwar sortiert nach dem Sortierschlüsselwert.
Jedes Primärschlüsselattribut muss ein Skalarwert sein (das bedeutet, dass es nur einen einzigen Wert annehmen kann). Die einzigen Datentypen, die für Primärschlüsselattribute zulässig sind, sind Zeichenfolge, Zahl oder Binärwert. Es gibt keine Einschränkungen für andere Nicht-Schlüsselattribute.
## Sekundäre Indizes
Sie können einen oder mehrere sekundäre Indizes für eine Tabelle erstellen. Ein *Sekundärindex* ermöglicht – ergänzend zu Abfragen über den Primärschlüssel – das Abfragen der Daten in der Tabelle über einen alternativen Schlüssel. Für DynamoDB ist die Verwendung von Indexen nicht erforderlich. Sie ermöglichen Ihren Anwendungen jedoch mehr Flexibilität beim Abfragen der Daten. Nachdem Sie einen sekundären Index für eine Tabelle erstellt haben, können Sie Daten aus dem Index ähnlich wie aus der Tabelle lesen.
DynamoDB unterstützt zwei Arten von Indexen:
+ Globaler sekundärer Index – Ein Index mit einem Partitionsschlüssel und einem Sortierschlüssel, die sich von denen in der Tabelle unterscheiden können. Die Primärschlüsselwerte in globalen sekundären Indizes müssen nicht eindeutig sein.
+ Lokaler sekundärer Index – Ein Index, der denselben Partitionsschlüssel wie die Tabelle hat, aber einen anderen Sortierschlüssel.
In DynamoDB sind globale Sekundärindizes (GSIs) Indizes, die sich über die gesamte Tabelle erstrecken, sodass Sie Abfragen über alle Partitionsschlüssel durchführen können. Lokale sekundäre Indizes (LSIs) sind Indizes, die denselben Partitionsschlüssel wie die Basistabelle, aber einen anderen Sortierschlüssel haben.
Jede Tabelle in DynamoDB verfügt über ein Kontingent von 20 globalen sekundären Indizes (Standardkontingent) und 5 lokalen sekundären Indizes.
In der zuvor gezeigten Beispieltabelle „*Musik*“ können Sie Datenelemente nach *Künstler* (Partitionsschlüssel) oder nach *Künstler* und *SongTitle*(Partitionsschlüssel und Sortierschlüssel) abfragen. Was ist, wenn Sie die Daten auch nach *Genre* und abfragen möchten *AlbumTitle*? Dazu könnten Sie einen Index für *Genre* und erstellen und den Index dann auf die gleiche Weise abfragen *AlbumTitle*, wie Sie die *Musiktabelle* abfragen würden.
Das folgende Diagramm zeigt die Beispieltabelle *Music* mit einem neuen Index namens *GenreAlbumTitle*. Im Index ist *Genre* der Partitionsschlüssel und *AlbumTitle*der Sortierschlüssel.
| Tabelle „Musik“ | *GenreAlbumTitle* |
| --- | --- |
|
{
"Artist": "No One You Know",
"SongTitle": "My Dog Spot",
"AlbumTitle": "Hey Now",
"Price": 1.98,
"Genre": "Country",
"CriticRating": 8.4
}
|
{
"Genre": "Country",
"AlbumTitle": "Hey Now",
"Artist": "No One You Know",
"SongTitle": "My Dog Spot"
}
|
|
{
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road",
"AlbumTitle": "Somewhat Famous",
"Genre": "Country",
"CriticRating": 8.4,
"Year": 1984
}
|
{
"Genre": "Country",
"AlbumTitle": "Somewhat Famous",
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road"
}
|
|
{
"Artist": "The Acme Band",
"SongTitle": "Still in Love",
"AlbumTitle": "The Buck Starts Here",
"Price": 2.47,
"Genre": "Rock",
"PromotionInfo": {
"RadioStationsPlaying": {
"KHCR",
"KQBX",
"WTNR",
"WJJH"
},
"TourDates": {
"Seattle": "20150622",
"Cleveland": "20150630"
},
"Rotation": "Heavy"
}
}
|
{
"Genre": "Rock",
"AlbumTitle": "The Buck Starts Here",
"Artist": "The Acme Band",
"SongTitle": "Still In Love"
}
|
|
{
"Artist": "The Acme Band",
"SongTitle": "Look Out, World",
"AlbumTitle": "The Buck Starts Here",
"Price": 0.99,
"Genre": "Rock"
}
|
{
"Genre": "Rock",
"AlbumTitle": "The Buck Starts Here",
"Artist": "The Acme Band",
"SongTitle": "Look Out, World"
}
|
Beachten Sie im Hinblick auf den Index *GenreAlbumTitle* Folgendes:
+ Jeder Index gehört zu einer Tabelle, die als *Basistabelle* für den Index bezeichnet wird. Im vorherigen Beispiel ist *Music* die Basistabelle für den *GenreAlbumTitle*Index.
+ DynamoDB verwaltet Indexe automatisch. Beim Hinzufügen, Aktualisieren und Löschen eines Elements in der Basistabelle fügt DynamoDB das entsprechende Element in allen Indexen hinzu, die zu dieser Tabelle gehören, bzw. aktualisiert oder löscht sie.
+ Wenn Sie einen Index erstellen, geben Sie an, welche Attribute aus der Basistabelle in den Index kopiert oder *projiziert* werden. DynamoDB projiziert mindestens die Schlüsselattribute aus der Basistabelle in den Index. Dies ist der Fall bei `GenreAlbumTitle`, da hier nur die Schlüsselattribute aus der Tabelle `Music` in den Index projiziert werden.
Sie können den *GenreAlbumTitle*Index abfragen, um alle Alben eines bestimmten Genres zu finden (z. B. alle *Rock-Alben*). Sie können den Index auch abfragen, um alle Alben in einem bestimmten Genre mit bestimmten Albumtiteln zu finden (z. B. alle *Country*-Alben mit Titeln, die mit dem Buchstaben H beginnen).
Weitere Informationen finden Sie unter [Verbessern des Datenzugriffs mit sekundären Indizes in DynamoDB](SecondaryIndexes.md).
## DynamoDB Streams
DynamoDB Streams ist eine optionale Funktion, die Datenänderungsereignisse in DynamoDB-Tabellen erfasst. Die Daten über diese Ereignisse erscheinen nahezu in Echtzeit und in der Reihenfolge, in der die Ereignisse aufgetreten sind, im Stream.
Jedes Ereignis wird durch einen *Stream-Datensatz* repräsentiert. Wenn Sie einen Stream für eine Tabelle aktivieren, schreibt DynamoDB Streams einen Stream-Datensatz, sobald eines der folgenden Ereignisse eintritt:
+ Ein neues Element wird der Tabelle hinzugefügt: Der Stream erfasst ein Image des gesamten Elements, einschließlich aller Attribute.
+ Ein Element wird aktualisiert: Der Stream erfasst das Image von Attributen, die im Element modifiziert wurden, vor und nach der Änderung.
+ Ein Element wird aus der Tabelle gelöscht: Der Stream erfasst ein Image des gesamten Elements, bevor es gelöscht wurde.
Jeder Stream-Datensatz enthält auch den Namen der Tabelle, den Ereigniszeitstempel und andere Metadaten. Stream-Datensätze haben eine Lebensdauer von 24 Stunden. Danach werden sie automatisch aus dem Stream entfernt.
Sie können DynamoDB Streams zusammen mit verwenden, AWS Lambda um einen *Triggercode* zu erstellen, der automatisch ausgeführt wird, wenn ein interessierendes Ereignis in einem Stream auftritt. Nehmen wir als Beispiel eine *Customers*-Tabelle mit Kundeninformationen für ein Unternehmen. Angenommen, Sie möchten eine Willkommens-E-Mail an jeden neuen Kunden senden. Sie können einen Stream für diese Tabelle aktivieren und den Stream anschließend einer Lambda-Funktion zuordnen. Die Lambda-Funktion wird immer dann ausgeführt, wenn ein neuer Stream-Datensatz erscheint. Es werden jedoch nur neue Elemente verarbeitet, die der Tabelle *Kunden* hinzugefügt wurden. Für ein Element mit einem `EmailAddress`-Attribut ruft die Lambda-Funktion den Amazon Simple Email Service (Amazon SES) auf, um eine E-Mail an diese Adresse zu senden.
![\[Integration von DynamoDB Streams und Lambda, um automatisch eine Willkommens-E-Mail an neue Kunden zu senden\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/HowItWorksStreams.png)
**Anmerkung**
In diesem Beispiel erhält der letzte Kunde, Craig Roe, keine E-Mail-Nachricht, da kein Wert für `EmailAddress` vorhanden ist.
Neben Triggern ermöglicht DynamoDB Streams leistungsstarke Lösungen wie Datenreplikation innerhalb und zwischen AWS Regionen, materialisierte Ansichten von Daten in DynamoDB-Tabellen, Datenanalyse mit materialisierten Kinesis-Ansichten und vieles mehr.
Weitere Informationen finden Sie unter [Ändern Sie die Datenerfassung für DynamoDB Streams](Streams.md).
# DynamoDB API
Um mit Amazon DynamoDB arbeiten zu können, muss Ihre Anwendung einige einfache API-Operationen verwenden. Im Folgenden finden Sie eine Zusammenfassung dieser Operationen nach Kategorie sortiert.
**Anmerkung**
Eine vollständige Liste der API-Operationen finden Sie in der [Amazon-DynamoDB-API-Referenz](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/Welcome.html).
**Topics**
+ [Steuerebene](#HowItWorks.API.ControlPlane)
+ [Datenebene](#HowItWorks.API.DataPlane)
+ [DynamoDB Streams](#HowItWorks.API.Streams)
+ [Transaktionen](#HowItWorks.API.Transactions)
## Steuerebene
Mit *Steuerungsebenenoperationen* können Sie DynamoDB-Tabellen erstellen und verwalten. Außerdem ermöglichen sie die Arbeit mit Indexen, Streams und anderen Objekten, die von Tabellen abhängen.
+ `CreateTable` – Erstellt eine neue Tabelle. Optional können Sie eine oder mehrere sekundäre Indxe erstellen und DynamoDB Streams für die Tabelle aktivieren
+ `DescribeTable` – Gibt Informationen über eine Tabelle zurück, wie das entsprechende Primärschlüsselschema, Durchsatzeinstellungen und Indexinformationen.
+ `ListTables` – Gibt die Namen aller Ihrer Tabellen in einer Liste zurück
+ `UpdateTable` – Ändert die Einstellungen einer Tabelle oder deren Index, erstellt oder entfernt neue Indexe aus einer Tabelle oder ändert die DynamoDB-Streams-Einstellungen für eine Tabelle
+ `DeleteTable` – Entfernt eine Tabelle und alle davon abhängigen Objekte aus DynamoDB
## Datenebene
Mit Operationen auf *Datenebene* können Sie Aktionen zum Erstellen, Lesen, Aktualisieren und Löschen (auch als *CRUD* bezeichnet) für Daten in einer Tabelle ausführen. Einige Operationen auf Datenebene ermöglichen außerdem das Lesen von Daten aus einem Sekundärindex.
Sie können diese CRUD-Operationen verwenden[PartiQL – Eine SQL-kompatible Abfragesprache für Amazon DynamoDB](ql-reference.md), oder Sie können das klassische APIs CRUD von DynamoDB verwenden, das jede Operation in einen eigenen API-Aufruf unterteilt.
### PartiQL – Eine SQL-kompatible Abfragesprache
+ `ExecuteStatement` - Liest mehrere Elemente aus einer Tabelle. Sie können auch ein einzelnes Element aus einer Tabelle schreiben oder aktualisieren. Beim Schreiben oder Aktualisieren eines einzelnen Elements müssen Sie die Primärschlüsselattribute angeben.
+ `BatchExecuteStatement` - Schreibt, aktualisiert oder liest mehrere Elemente aus einer Tabelle. Dies ist effizienter, als `ExecuteStatement` weil Ihre Anwendung nur einen einzigen Netzwerk-Roundtrip zum Schreiben oder Lesen der Elemente benötigt.
### Klassisch APIs
#### Erstellen von Daten
+ `PutItem` – Schreibt ein einzelnes Element in eine Tabelle. Sie müssen nur die Primärschlüsselattribute angeben, keine anderen Attribute.
+ `BatchWriteItem` – Schreibt bis zu 25 Elemente in eine Tabelle. Dies ist effizienter als `PutItem` mehrfach aufzurufen, da Ihre Anwendung nur einen einzigen Netzlauf zum Schreiben der Elemente benötigt.
#### Lesen von Daten
+ `GetItem` – Ruft ein einzelnes Element aus einer Tabelle ab. Sie müssen den Primärschlüssel für das gewünschte Element angeben. Sie können das gesamte Element oder nur eine Teilmenge seiner Attribute abrufen.
+ `BatchGetItem` – Ruft bis zu 100 Elemente aus einer oder mehreren Tabellen ab. Dies ist effizienter als `GetItem` mehrfach aufzurufen, da Ihre Anwendung nur einen einzigen Netzlauf zum Lesen der Elemente benötigt.
+ `Query` – Ruft alle Elemente mit einem bestimmten Partitionsschlüssel ab. Sie müssen den Partitionsschlüsselwert angeben. Sie können ganze Elemente oder nur eine Teilmenge ihrer Attribute abrufen. Optional können Sie eine Bedingung auf die Sortierschlüsselwerte anwenden, so dass Sie nur den Teil der Daten abrufen, denen derselbe Partitionsschlüssel zugeordnet ist. Sie können diese Operation für eine Tabelle verwenden, sofern die Tabelle sowohl einen Partitions- als auch einen Sortierschlüssel hat. Außerdem können Sie diese Operation für einen Index nutzen, sofern der Index sowohl einen Partitions- als auch einen Sortierschlüssel umfasst.
+ `Scan` – Ruft alle Elemente in der angegebenen Tabelle oder dem Index ab. Sie können ganze Elemente oder nur eine Teilmenge ihrer Attribute abrufen. Optional können Sie eine Filterbedingung anwenden, um nur die gewünschten Werte zurückzugeben und den Rest zu verwerfen.
#### Aktualisieren von Daten
+ `UpdateItem` – Ändert ein oder mehrere Attribute in einem Element. Sie müssen den Primärschlüssel für das Element angeben, das Sie ändern möchten. Sie können neue Attribute hinzufügen und vorhandene Attribute ändern oder entfernen. Außerdem können Sie bedingte Aktualisierungen durchführen, so dass die Aktualisierung nur erfolgreich ist, wenn eine benutzerdefinierte Bedingung erfüllt ist. Wahlweise können Sie einen unteilbaren Zähler implementieren, der ein numerisches Attribut erhöht oder senkt, ohne dass Konflikte mit anderen Schreibanforderungen auftreten.
#### Löschen von Daten
+ `DeleteItem` – Löscht ein einzelnes Element aus einer Tabelle. Sie müssen den Primärschlüssel für das Element angeben, das Sie löschen möchten.
+ `BatchWriteItem` – Löscht bis zu 25 Elemente aus einer oder mehreren Tabellen. Dies ist effizienter, als `DeleteItem` mehrfach aufzurufen, da Ihre Anwendung nur einen einzigen Netzlauf zum Löschen der Elemente benötigt.
**Anmerkung**
Sie können `BatchWriteItem` verwenden, um sowohl Daten zu erstellen als auch Daten zu löschen.
## DynamoDB Streams
Mit *DynamoDB-Streams*-Operationen können Sie einen Stream in einer Tabelle aktivieren oder deaktivieren und den Zugriff auf die in einem Stream enthaltenen Datenänderungsdatensätze zulassen.
+ `ListStreams` – Gibt eine Liste aller Streams oder nur den Stream für eine bestimmte Tabelle zurück
+ `DescribeStream` – Gibt Informationen über einen Stream, wie den Amazon-Ressourcennamen (ARN), und die Position zurück, an der Ihre Anwendung mit dem Lesen der ersten Stream-Datensätze beginnen kann
+ `GetShardIterator` – Gibt einen *Shard Iterator* zurück. Hierbei handelt es sich um eine Datenstruktur, die Ihre Anwendung zum Abrufen der Datensätze aus dem Stream verwendet.
+ `GetRecords` – Ruft einen oder mehrere Stream-Datensätze unter Verwendung eines bestimmten Shard Iterators ab
## Transaktionen
*Transaktionen* stellen Atomizität, Konsistenz, Isolation und Haltbarkeit (Atomicity, Consistency, Isolation und Durability, ACID) bereit. Dies ermöglicht eine einfachere Aufrechterhaltung der Richtigkeit der Daten in Ihren Anwendungen.
Sie können[PartiQL – Eine SQL-kompatible Abfragesprache für Amazon DynamoDB](ql-reference.md), verwenden, um Transaktionsoperationen durchzuführen, oder Sie können das klassische CRUD von DynamoDB verwenden APIs , das jeden Vorgang in einen eigenen API-Aufruf unterteilt.
### PartiQL – Eine SQL-kompatible Abfragesprache
+ `ExecuteTransaction`— Eine Batch-Operation, die CRUD-Operationen für mehrere Elemente sowohl innerhalb als auch tabellenübergreifend mit einem garantierten Ergebnis ermöglicht. all-or-nothing
### Klassisch APIs
+ `TransactWriteItems`— Ein Batch-Vorgang, der `Delete` Operationen mit `Put``Update`, und für mehrere Elemente sowohl innerhalb als auch tabellenübergreifend mit einem garantierten all-or-nothing Ergebnis ermöglicht.
+ `TransactGetItems` – Ein Batch-Vorgang, der `Get`-Operationen verwendet, um mehrere Elemente aus einer oder mehreren Tabellen abzurufen.
# Unterstützte Datentypen und Benennungsregeln in Amazon DynamoDB
In diesem Abschnitt werden die Amazon-DynamoDB-Benennungsregeln und die verschiedenen Datentypen beschrieben, die DynamoDB unterstützt. Für Datentypen gelten bestimmte Limits. Weitere Informationen finden Sie unter [Datentypen](Constraints.md#limits-data-types).
**Topics**
+ [Benennungsregeln](#HowItWorks.NamingRules)
+ [Datentypen](#HowItWorks.DataTypes)
+ [Datentypbeschreibungen](#HowItWorks.DataTypeDescriptors)
## Benennungsregeln
Tabellen, Attribute und andere Objekte in DynamoDB muss einen Namen haben. Namen sollten sinnvoll und präzise sein – Namen wie beispielsweise *Produkte*, *Bücher* und *Verfasser* sind selbsterklärend.
Die folgenden Benennungsregeln gelten für DynamoDB:
+ Alle Namen müssen mit UTF-8 kodiert werden und die Groß- und Kleinschreibung beachten.
+ Tabellen- und Indexnamen müssen zwischen 3 und 255 Zeichen lang sein und dürfen nur folgende Zeichen enthalten:
+ `a-z`
+ `A-Z `
+ ` 0-9 `
+ `_` (Unterstrich)
+ `-` (Bindestrich)
+ `.` (Punkt)
+ Attributnamen müssen mindestens ein Zeichen lang und dürfen nicht größer als 64 KB sein. Eine bewährte Methode besteht darin, Attributnamen möglichst kurz zu halten. Dies trägt zur Reduzierung der verbrauchten Leseanforderungseinheiten bei, da Attributnamen beim Erfassen der Speicher- und Durchsatznutzung berücksichtigt werden.
Dabei gibt es die folgenden Ausnahmen. Diese Attributnamen dürfen maximal 255 Zeichen lang sein:
+ Partitionsschlüsselnamen des sekundären Indexes
+ Sortierschlüsselnamen des sekundären Indexes
+ Die Namen aller vom Benutzer angegebenen, projizierten Attribute (gilt nur für lokale sekundäre Indizes)
### Reservierte Wörter und Sonderzeichen
DynamoDB verfügt über eine Liste mit reservierten Wörtern und Sonderzeichen. Eine vollständige Liste finden Sie hier: [Reservierte Wörter in DynamoDB](ReservedWords.md). Außerdem haben die folgenden Zeichen in DynamoDB eine besondere Bedeutung: **\$1** (Hash) und **:** (Doppelpunkt).
Auch wenn DynamoDB diese reservierten Wörter und Sonderzeichen für Namen zulässt, empfehlen wir, diese nicht zu verwenden, da Sie Platzhaltervariablen definieren müssen, sobald Sie diese Namen in einem Ausdruck verwenden. Weitere Informationen finden Sie unter [Ausdrucksattributnamen (Aliasse) in DynamoDB](Expressions.ExpressionAttributeNames.md).
## Datentypen
DynamoDB unterstützt viele verschiedene Datentypen für Attribute in einer Tabelle. Sie können wie folgt kategorisiert werden:
+ **Skalare Typen** – Ein skalarer Typ kann genau einen Wert repräsentieren. Die skalaren Typen sind Zahl, Zeichenfolge, Binärwert, Boolescher Wert und Null.
+ **Dokumenttypen** – Ein Dokumenttyp kann eine komplexe Struktur mit verschachtelten Attributen repräsentieren, wie sie z. B. in einem JSON-Dokument zu finden sind. Die Dokumenttypen sind Liste und Zuordnung.
+ **Satztypen** – Ein Satztyp kann mehrere Skalarwerte repräsentieren. Die Satztypen sind Zeichenfolgensatz, Zahlensatz und Binärwertesatz.
Wenn Sie eine Tabelle oder einen Sekundärindex erstellen, müssen Sie die Namen und Datentypen der einzelnen Primärschlüsselattribute (Partitions- und Sortierschlüssel) angeben. Darüber hinaus muss jedes Schlüsselattribut als Zeichenfolgen-, Zahlen- oder Binärtyp definiert sein.
DynamoDB ist eine NoSQL-Datenbank und *schemalos*. Dies bedeutet, dass Sie beim Erstellen von Tabellen abgesehen von den Primärschlüsselattributen keine Attribute oder Datentypen definieren müssen. Im Vergleich dazu erfordern relationale Datenbanken beim Erstellen einer Tabelle die Angabe der Namen und Datentypen für jede einzelne Spalte.
Es folgen Beschreibungen der einzelnen Datentypen. Außerdem sind einige Beispiele im JSON-Format angegeben.
### Skalare Typen
Die skalaren Typen sind Zahl, Zeichenfolge, Binärwert, Boolescher Wert und Null.
#### Zahl
Zahlen können positiv, negativ oder Null sein. Zahlen können auf 38 Stellen genau sein. Wird dieser Wert überschritten, wird eine Ausnahme ausgegeben. Wenn Sie eine höhere Genauigkeit als 38 Stellen benötigen, können Sie Zeichenfolgen verwenden.
+ Positiver Bereich: 1E-130 bis 9,9999999999999999999999999999999999999E\$1125
+ Negativer Bereich: -9,9999999999999999999999999999999999999E\$1125 bis -1E-130
In DynamoDB werden Zahlen als variable Länge dargestellt. Nullen am Anfang und am Ende werden abgeschnitten.
Alle Zahlen werden über das Netzwerk an DynamoDB als Zeichenfolgen übertragen, um die Kompatibilität über die Sprachen und Bibliotheken hinweg zu maximieren. DynamoDB behandelt sie jedoch als Zahlentypattribute für mathematische Operationen.
Sie können den Datentyp Zahl verwenden, um ein Datum oder einen Zeitstempel zu repräsentieren. Eine Möglichkeit, dies zu tun, ist die Verwendung der Epochenzeit - die Anzahl der Sekunden seit 00:00:00 UTC am 1. Januar 1970. Die Epochenzeit `1437136300` stellt 12:31:40 UTC am 17. Juli 2015 dar.
Weitere Informationen finden Sie unter [http://en.wikipedia. org/wiki/Unix\$1Zeit.](http://en.wikipedia.org/wiki/Unix_time)
#### Zeichenfolge
Die Zeichenfolgen sind Unicode mit binärer UTF-8-Kodierung. Die Mindestlänge einer Zeichenfolge kann Null sein, wenn das Attribut nicht als Schlüssel für einen Index oder eine Tabelle verwendet wird und durch die maximale DynamoDB-Elementgrößenbeschränkung von 400 KB eingeschränkt ist.
Wenn Sie einen Primärschlüssel als Attribut des Typs Zeichenfolge definieren, gelten die folgenden zusätzlichen Einschränkungen:
+ Für einen einfachen Primärschlüssel beträgt die maximale Länge des ersten Attributwerts (der Partitionsschlüssel) 2048 Byte.
+ Für einen zusammengesetzten Primärschlüssel beträgt die maximale Länge des zweiten Attributwerts (Sortierschlüssel) 1024 Byte.
DynamoDB sortiert und vergleicht Zeichenfolgen mithilfe der Bytes der zugrunde liegenden UTF-8-Zeichenfolgenkodierung. Beispiel: „`a`” (0x61) ist größer als „`A`” (0x41) und „`¿`” (0xC2BF) ist größer als „`z`” (0x7A).
Sie können den Datentyp Zeichenfolge verwenden, um ein Datum oder einen Zeitstempel zu repräsentieren. Eine Möglichkeit dazu ist die Verwendung von ISO 8601-Zeichenfolgen, wie in folgenden Beispielen gezeigt:
+ `2016-02-15`
+ `2015-12-21T17:42:34Z`
+ `20150311T122706Z`
Weitere Informationen finden Sie unter [http://en.wikipedia. org/wiki/ISO\$18601](http://en.wikipedia.org/wiki/ISO_8601).
**Anmerkung**
Im Gegensatz zu herkömmlichen relationalen Datenbanken unterstützt DynamoDB nativ keinen Datums- und Uhrzeitdatentyp. Es kann hilfreich sein, Daten und Zeitdaten stattdessen als Zahlendatentyp zu speichern, wobei die Unix-Epochenzeit verwendet wird.
#### Binär
Attribute vom Typ Binärwert können beliebige binäre Daten speichern, wie z. B. komprimierte Textdateien, verschlüsselte Daten oder Bilder. Beim Binärtyp betrachtet DynamoDB beim Vergleichen der binären Werte jedes Byte der Binärdaten ohne Vorzeichen.
Die Länge eines binären Attributs kann Null sein, wenn das Attribut nicht als Schlüssel für einen Index oder eine Tabelle verwendet wird und durch die maximale DynamoDB-Elementgrößenbeschränkung von 400 KB eingeschränkt ist.
Wenn Sie einen Primärschlüssel als Attribut des Typs Binärwert definieren, gelten die folgenden zusätzlichen Einschränkungen:
+ Für einen einfachen Primärschlüssel beträgt die maximale Länge des ersten Attributwerts (der Partitionsschlüssel) 2048 Byte.
+ Für einen zusammengesetzten Primärschlüssel beträgt die maximale Länge des zweiten Attributwerts (Sortierschlüssel) 1024 Byte.
Ihre Anwendungen müssen Binärwerte im Base64-codierten Format codieren, bevor sie an DynamoDB gesendet werden. Nach dem Empfang dieser Werte dekodiert DynamoDB die Daten in ein nicht signiertes Byte-Array und verwendet dies als Länge des binären Attribut
Im folgenden Beispiel wird ein binäres Attribut mit base64-verschlüsseltem Text dargestellt.
```
dGhpcyB0ZXh0IGlzIGJhc2U2NC1lbmNvZGVk
```
#### Boolesch
Ein Attribut vom Typ Boolescher Wert kann entweder `true` oder `false` speichern.
#### Null
Null stellt ein Attribut mit einem unbekannten oder nicht definierten Status dar.
### Dokumenttypen
Die Dokumenttypen sind Liste und Zuordnung. Diese Datentypen können ineinander verschachtelt werden, um komplexe Datenstrukturen bis zu 32 Ebenen tief darzustellen.
Es gibt keine Beschränkungen in Bezug auf die Anzahl der Werte in einer Liste oder Zuordnung, solange das Element, das die Werte enthält, das Limit der DynamoDB-Elementgröße (400 KB) einhält.
Ein Attributwert kann eine leere Zeichenfolge oder ein leerer Binärwert sein, wenn das Attribut nicht für einen Tabellen- oder Indexschlüssel verwendet wird. Ein Attributwert kann kein leerer Satz sein (Zeichenfolgensatz, Zahlensatz oder Binärsatz), jedoch sind leere Listen und Zuordnungen zulässig. Leere Zeichenfolgen- und Binärwerte sind in Listen und Zuordnungen zulässig. Weitere Informationen finden Sie unter [Attribute](Constraints.md#limits-attributes).
#### Auflisten
Ein Attribut vom Typ Liste kann eine geordnete Sammlung von Werten speichern. Listen werden in eckige Klammern gesetzt: `[ ... ]`
Eine Liste ähnelt einem JSON-Array. Es gibt keine Einschränkungen hinsichtlich der Datentypen, die in einem Listenelement gespeichert werden können. Die Elemente in einem Listenelement müssen nicht vom selben Typ sein.
Das folgende Beispiel zeigt eine Liste mit zwei Zeichenfolgen und einer Zahl.
```
FavoriteThings: ["Cookies", "Coffee", 3.14159]
```
**Anmerkung**
Mit DynamoDB können Sie mit einzelnen Elementen innerhalb der Listen arbeiten, auch wenn diese Elemente stark verschachtelt sind. Weitere Informationen finden Sie unter [Verwenden von Ausdrücken in DynamoDB](Expressions.md).
#### Zuordnung
Ein Attribut vom Typ Zuordnung kann eine ungeordnete Sammlung von Name-Wert-Paaren speichern. Zuordnungen werden in geschweifte Klammern gesetzt: `{ ... }`
Eine Zuordnung ist mit einem JSON-Objekt vergleichbar. Es gibt keine Einschränkungen hinsichtlich der Datentypen, die in einem Zuordnungselement gespeichert werden können. Die Elemente in einem Zuordnungselement müssen nicht vom selben Typ sein.
Zuordnungen eignen sich optimal für das Speichern von JSON-Dokumenten in DynamoDB. Das folgende Beispiel zeigt eine Zuordnung, die eine Zeichenfolge, eine Zahl und eine verschachtelte Liste mit einer weiteren Zuordnung enthält.
```
{
Day: "Monday",
UnreadEmails: 42,
ItemsOnMyDesk: [
"Coffee Cup",
"Telephone",
{
Pens: { Quantity : 3},
Pencils: { Quantity : 2},
Erasers: { Quantity : 1}
}
]
}
```
**Anmerkung**
Mit DynamoDB können Sie mit einzelnen Elementen innerhalb von Zuordnungen arbeiten, auch wenn diese Elemente stark verschachtelt sind. Weitere Informationen finden Sie unter [Verwenden von Ausdrücken in DynamoDB](Expressions.md).
### Sätze
DynamoDB unterstützt Typen, die Sätze mit Zahlen-, Zeichenfolgen- und Binärwerten darstellen. Alle Elemente in einem Satz müssen jedoch vom selben Typ sein. Ein Zahlensatz kann z. B. nur Zahlen enthalten und ein Zeichenfolgensatz kann nur Zeichenfolgen enthalten.
Es gibt keine Beschränkungen in Bezug auf die Anzahl der Werte in einem Satz, solange das Element, das die Werte enthält, das Limit der DynamoDB-Elementgröße (400 KB) einhält.
Jeder Wert innerhalb eines Satzes muss eindeutig sein. In einem Satz spielt die Reihenfolge der Werte keine Rolle. Aus diesem Grund dürfen Ihre Anwendungen nicht davon ausgehen, dass die Elemente innerhalb des Satzes in einer bestimmten Reihenfolge vorliegen. Leere Mengen werden von DynamoDB nicht unterstützt, jedoch sind leere Zeichenfolgen und Binärwerte innerhalb einer Menge zulässig.
Das folgende Beispiel zeigt einen Zeichenfolgensatz, einen Zahlensatz und einen Binärwertesatz:
```
["Black", "Green", "Red"]
[42.2, -19, 7.5, 3.14]
["U3Vubnk=", "UmFpbnk=", "U25vd3k="]
```
## Datentypbeschreibungen
Das Low-Level-DynamoDB-API-Protokoll verwendet *Datentypdeskriptoren* als Token, die DynamoDB mitteilen, wie die einzelnen Attribute zu interpretieren sind.
Im Folgenden sehen Sie eine vollständige Liste der DynamoDB-Datentypbeschreibungen:
+ **`S`** – Zeichenfolge
+ **`N`** – Zahl
+ **`B`** – Binary
+ **`BOOL`** – Boolean
+ **`NULL`** – Nullwert
+ **`M`** – Zuordnung
+ **`L`** – Liste
+ **`SS`** – Zeichenfolgensatz
+ **`NS`** – Zahlensatz
+ **`BS`** – Binärzahlensatz
# DynamoDB-Tabellenklassen
DynamoDB bietet zwei Tabellenklassen an, mit denen Sie die Kosten optimieren können. Die DynamoDB-Standard-Tabellenklasse ist die Standardeinstellung und wird für die große Mehrheit der Workloads empfohlen. Die Tabellenklasse DynamoDB Standard-Infrequent Access (DynamoDB Standard-IA) ist für Tabellen optimiert, in denen Speicher die dominierenden Kosten sind. Zum Beispiel sind Tabellen, die selten aufgerufene Daten speichern, wie Anwendungsprotokolle, alte Social-Media-Posts, E-Commerce-Bestellhistorie und frühere Spielerrungenschaften, gute Kandidaten für die Standard-IA Tabellenklasse. Siehe [Amazon-DynamoDB-Preise](https://aws.amazon.com/dynamodb/pricing/on-demand/) für weitere Informationen zur Preisdetails.
Jede DynamoDB-Tabelle ist einer Tabellenklasse zugeordnet (Standardmäßig DynamoDB Standard). Alle der Tabelle zugeordneten sekundären Indizes verwenden dieselbe Tabellenklasse. Jede Tabellenklasse bietet unterschiedliche Preise für die Datenspeicherung sowie für Lese- und Schreibanfragen. Sie können die kostengünstigste Tabellenklasse für Ihre Tabelle basierend auf ihren Speicher- und Durchsatznutzungsmustern auswählen.
Die Wahl einer Tabellenklasse ist nicht dauerhaft — Sie können diese Einstellung mit der AWS CLI oder dem AWS-Managementkonsole SDK ändern. AWS DynamoDB unterstützt auch die Verwaltung Ihrer Tabellenklasse mithilfe von AWS CloudFormation Tabellen mit nur einer Region und globalen Tabellen. Weitere Informationen zur Auswahl Ihrer Tabellenklasse finden Sie unter [Überlegungen bei der Auswahl einer Tabellenklasse in DynamoDB](WorkingWithTables.tableclasses.md).
# Partitionen und Datenverteilung in DynamoDB
Amazon DynamoDB speichert Daten in Partitionen. Eine *Partition* ist eine Speicherzuweisung für eine Tabelle, die durch Solid-State-Laufwerke (SSDs) gesichert und automatisch über mehrere Availability Zones innerhalb einer Region repliziert wird. AWS Die Partitionsverwaltung wird ausschließlich von DynamoDB ausgeführt, d. h. Sie müssen Partitionen nicht selbst verwalten.
Beim Erstellen einer Tabelle ist der Anfangsstatus `CREATING`. In dieser Phase weist DynamoDB der Tabelle ausreichende Partitionen zu, sodass diese Ihre Anforderungen für den bereitgestellten Durchsatz erfüllen kann. Sie können mit dem Schreiben und Lesen von Tabellendaten beginnen, sobald sich der Tabellenstatus zu `ACTIVE` ändert.
DynamoDB weist einer Tabelle in folgenden Situationen zusätzliche Partitionen zu:
+ Wenn Sie die Einstellungen für den bereitgestellten Durchsatz der Tabelle über das Maß erhöhen, das die vorhandenen Partitionen unterstützen können.
+ Wenn eine vorhandene Partition bis zur Kapazität gefüllt ist und mehr Speicherplatz erforderlich ist.
Die Partitionsverwaltung wird automatisch im Hintergrund ausgeführt und ist für Ihre Anwendungen transparent. Ihre Tabelle bleibt verfügbar und unterstützt Ihre Anforderungen des bereitgestellten Durchsatzes vollständig.
Weitere Details finden Sie unter [Entwerfen von Partitionsschlüsseln](bp-partition-key-design.md).
Globale sekundäre Indizes in DynamoDB bestehen ebenfalls aus Partitionen. Die Daten in einem globalen sekundären Index werden getrennt von den Daten in der Basistabelle gespeichert. Indexpartitionen verhalten sich jedoch ähnlich wie Tabellenpartitionen.
## Datenverteilung: Partitionsschlüssel
Wenn Ihre Tabelle über einen einfachen Primärschlüssel (nur Partitionsschlüssel) verfügt, speichert und ruft DynamoDB jedes Element basierend auf seinem Partitionsschlüsselwert ab.
Um ein Element in die Tabelle zu schreiben, verwendet DynamoDB den Wert des Partitionsschlüssels als Eingabe für eine interne Hash-Funktion. Der Ausgabewert der Hash-Funktion bestimmt die Partition, in der das Element gespeichert wird.
Um ein Element aus der Tabelle zu lesen, müssen Sie den Partitionsschlüsselwert für das Element angeben. DynamoDB verwendet diesen Wert als Eingabe für die Hash-Funktion. Daraus ergibt sich die Partition, in der das Element gefunden werden kann.
Das folgende Diagramm zeigt eine Tabelle mit dem Namen *Pets*, die sich über mehrere Partitionen erstreckt. Der Primärschlüssel der Tabelle ist *AnimalType*(nur dieses Schlüsselattribut wird angezeigt). DynamoDB verwendet eine Hash-Funktion, um zu ermitteln, wo ein neues Element gespeichert werden soll, und zwar in diesem Fall basierend auf dem Hash-Wert der Zeichenfolge *Dog*. Hinweis: Die Elemente werden nicht sortiert gespeichert. Die Position jedes einzelnen Elements wird durch den Hash-Wert seines Partitionsschlüssels bestimmt.
![\[Verteilung von Tabellenelementen in DynamoDB über Partitionen basierend auf dem Hashwert des Partitionsschlüssels\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/HowItWorksPartitionKey.png)
**Anmerkung**
DynamoDB ist für eine einheitliche Verteilung von Elementen über die Partitionen einer Tabelle optimiert, unabhängig davon, wie viele Partitionen vorliegen. Wir empfehlen, dass Sie einen Partitionsschlüssel verwenden, der eine großen Anzahl von eindeutigen Werten in Bezug auf die Anzahl der Elemente in der Tabelle aufnehmen kann.
## Datenverteilung: Partitions- und Sortierschlüssel
Wenn die Tabelle über einen zusammengesetzten Primärschlüssel (Partitionsschlüssel und Sortierschlüssel) verfügt, berechnet DynamoDB den Hashwert des Partitionsschlüssels auf die gleiche Weise wie unter [Datenverteilung: Partitionsschlüssel](#HowItWorks.Partitions.SimpleKey) beschrieben. Dabei werden jedoch Elemente, die denselben Partitionsschlüsselwert haben, nahe beieinander und in sortierter Reihenfolge nach dem Wert des Sortierschlüsselattributs beibehalten. Der Satz von Elementen, die denselben Partitionsschlüsselwert haben, wird als Elementauflistung bezeichnet. Elementauflistungen sind für das effiziente Abrufen von Elementbereichen innerhalb der Auflistung optimiert. Wenn Ihre Tabelle keine lokalen sekundären Indizes enthält, teilt DynamoDB Ihre Elementauflistung automatisch auf die Anzahl von Partitionen auf, die erforderlich ist, um die Daten zu speichern und den Lese- und Schreibdurchsatz zu gewährleisten.
Beim Schreiben eines Elements in die Tabelle berechnet DynamoDB den Hash-Wert des Partitionsschlüssels, um zu ermitteln, welche Partition das Element enthalten soll. In dieser Partition können mehrere Elemente denselben Wert für den Partitionsschlüssel haben. DynamoDB speichert dann das Element zusammen mit den anderen Elementen mit demselben Partitionsschlüssel nach Sortierschlüssel sortiert in aufsteigender Reihenfolge.
Um ein Element aus der Tabelle zu lesen, müssen Sie den Partitions- und Sortierschlüsselwert für das Element angeben. DynamoDB berechnet den Hash-Wert des Partitionsschlüssels. Daraus ergibt sich die Partition, in der sich das Element befindet.
Sie können mehrere Elemente aus der Tabelle in einer einzigen Operation (`Query`) lesen, sofern die gewünschten Elemente denselben Partitionsschlüsselwert besitzen. DynamoDB gibt alle Elemente mit diesem Partitionsschlüsselwert zurück. Optional können Sie eine Bedingung auf den Sortierschlüssel anwenden, so dass nur die Elemente in einem bestimmten Wertebereich zurückgegeben werden.
Angenommen, die *Pets-Tabelle* hat einen zusammengesetzten Primärschlüssel, der aus *AnimalType*(Partitionsschlüssel) und *Name* (Sortierschlüssel) besteht. Das folgende Diagramm veranschaulicht, wie DynamoDB ein Element mit dem Partitionsschlüsselwert *Dog* und dem Sortierschlüsselwert *Fido* schreibt.
![\[DynamoDB speichert ein Element mit einem zusammengesetzten Partitionsschlüssel und sortiert das Element anhand des Werts des Sortierschlüsselattributs.\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/HowItWorksPartitionKeySortKey.png)
Um dasselbe Element aus der Tabelle *Pets* zu lesen, berechnet DynamoDB den Hash-Wert von *Dog*. Daraus ergibt sich die Partition, in der diese Elemente gespeichert sind. DynamoDB scannt dann die Attributwerte des Sortierschlüssels, bis *Fido* gefunden wird.
Um alle Elemente mit dem Wert *AnimalType*von *Dog* zu lesen, können Sie einen `Query` Vorgang ausführen, ohne eine Sortierschlüsselbedingung anzugeben. Standardmäßig werden die Elemente in der Reihenfolge zurückgegeben, in der sie gespeichert sind (d. h. in aufsteigender Reihenfolge nach Sortierschlüssel). Wahlweise können Sie stattdessen die absteigende Reihenfolge anfordern.
Um nur einige der *Dog*-Elemente abzufragen, können Sie eine Bedingung auf den Sortierschlüssel anwenden (z. B. nur die *Dog*-Elemente, in denen *Name* mit einem Buchstaben im Bereich von `A` bis `K` beginnt).
**Anmerkung**
In der DynamoDB-Tabelle gibt es keine Einschränkung in Bezug auf die Anzahl von eindeutigen Sortierschlüsselwerten pro Partitionsschlüsselwert. Wenn Sie viele Milliarden von *Dog*-Elementen in der Tabelle *Pets* speichern müssen, weist DynamoDB automatisch genügend Speicherplatz zu, um diese Anforderung zu erfüllen.
# 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"
}
```
# Lernressourcen und Tools für Amazon DynamoDB
Sie können die folgenden weiteren Ressourcen nutzen, um DynamoDB zu verstehen und damit zu arbeiten.
**Topics**
+ [Tools für die Codierung und Visualisierung](#AdditionalResources.Tools)
+ [Artikel über Prescriptive Guidance](#AdditionalResources.PrescriptiveGuidance)
+ [Wissenscenter-Artikel](#AdditionalResources.KnowledgeCenter)
+ [Blogbeiträge, Repositorys und Leitfäden](#AdditionalResources.Guides)
+ [Datenmodellierung und Designmusterpräsentationen](#AdditionalResources.DataModeling)
+ [Schulungskurse](#AdditionalResources.Training)
## Tools für die Codierung und Visualisierung
Sie können die folgenden Codierungs- und Visualisierungstools für die Arbeit mit DynamoDB verwenden:
+ [NoSQL Workbench für Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.html) – ein einheitliches, visuelles Tool, mit dem Sie DynamoDB-Tabellen entwerfen, erstellen, abfragen und verwalten können. Es bietet Funktionen zur Datenmodellierung, Datenvisualisierung und Abfrageentwicklung.
+ [Dynobase](https://dynobase.dev/) – ein Desktop-Tool, das das Anzeigen Ihrer DynamoDB-Tabellen und die Arbeit damit sowie das Erstellen von Anwendungscode und das Bearbeiten von Datensätzen mit Echtzeit-Validierung erleichtert.
+ [DynamoDB Toolbox](https://github.com/jeremydaly/dynamodb-toolbox) — Ein Projekt von Jeremy Daly, das hilfreiche Hilfsprogramme für die Arbeit mit Datenmodellierung und JavaScript Node.js bietet.
+ [DynamoDB-Streams-Prozessor](https://github.com/jeremydaly/dynamodb-streams-processor) – ein einfaches Tool für die Arbeit mit [DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html).
## Artikel über Prescriptive Guidance
AWS Prescriptive Guidance bietet bewährte Strategien, Leitfäden und Muster, mit denen Sie Ihre Projekte beschleunigen können. Diese Ressourcen wurden von AWS Technologieexperten und der weltweiten AWS Partnergemeinschaft auf der Grundlage ihrer jahrelangen Erfahrung bei der Unterstützung von Kunden beim Erreichen ihrer Geschäftsziele entwickelt.
**Datenmodellierung und -migration**
+ [Ein hierarchisches Datenmodell in DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-hierarchical-data-model/introduction.html)
+ [Modellieren von Daten mit DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-data-modeling/welcome.html)
+ [Migrieren Sie eine Oracle-Datenbank zu DynamoDB mit AWS DMS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.html)
**Globale Tabellen**
+ [Verwenden der globalen Amazon-DynamoDB-Tabellen](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-global-tables/introduction.html)
**Serverless**
+ [Implementieren Sie das serverlose Saga-Muster mit AWS Step Functions](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/implement-the-serverless-saga-pattern-by-using-aws-step-functions.html)
**SaaS-Architektur**
+ [Mandanten für mehrere SaaS-Produkte auf einer einzigen Steuerebene verwalten](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/manage-tenants-across-multiple-saas-products-on-a-single-control-plane.html)
+ [Mandanten-Onboarding in SaaS-Architektur für das Silomodell mit C\$1 und AWS -CDK](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html)
**Datenschutz und Datenverschiebung**
+ [Kontenübergreifenden Zugriff auf Amazon DynamoDB konfigurieren](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)
+ [Optionen zum Kopieren ganzer Tabellen für DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-full-table-copy-options/)
+ [Strategie zur Notfallwiederherstellung für Datenbanken in AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/strategy-database-disaster-recovery/)
**Sonstiges**
+ [Bei der Durchsetzung von Tagging in DynamoDB helfen](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/help-enforce-dynamodb-tagging.html)
**Beispielhafte Videoanleitungen mit präskriptiven Anleitungen**
+ [Verwenden einer Serverless-Architektur zur Erstellung von Daten-Pipelines](https://youtu.be/JiWHomdh1oI?)
+ [Novartis – Einkaufs-Engine: KI-gestütztes Einkaufsportal](https://youtu.be/vp8oPiHN4cA)
+ [Veritiv: Ermöglichen Sie Einblicke, um die Umsatznachfrage auf AWS Data Lakes zu Forecast](https://youtu.be/jg85DzUZ9Ac)
+ [mimik: Hybrid-Edge-Cloud-Nutzung AWS zur Support von Edge Microservice Mesh](https://youtu.be/-S-R7MWRpaI)
+ [Ändern der Datenerfassung mit Amazon DynamoDB](https://youtu.be/6YVjzD-70p4)
Weitere Artikel und Videos zu Prescriptive Guidance für DynamoDB finden Sie unter [Prescriptive Guidance](https://tiny.amazon.com/fiui3cog/ForinternaldemoofnewpageExternalURLwillbeneededforlive).
## Wissenscenter-Artikel
Die Artikel und Videos im AWS Knowledge Center behandeln die häufigsten Fragen und Anfragen, die wir von AWS Kunden erhalten. Im Folgenden finden Sie einige aktuelle Wissenscenter-Artikel zu bestimmten Aufgaben, die sich auf DynamoDB beziehen:
**Kostenoptimierung**
+ [Wie optimiere ich die Kosten mit Amazon DynamoDB?](https://repost.aws/knowledge-center/dynamodb-optimize-costs)
**Drosselung und Latenz**
+ [Wie kann ich Probleme mit hoher Latenz in einer Amazon DynamoDB-Tabelle beheben?](https://repost.aws/knowledge-center/dynamodb-high-latency)
+ [Warum wird meine DynamoDB-Tabelle gedrosselt?](https://repost.aws/knowledge-center/dynamodb-table-throttled)
+ [Warum wird meine On-Demand-DynamoDB-Tabelle gedrosselt?](https://repost.aws/knowledge-center/on-demand-table-throttling-dynamodb)
**Paginierung**
+ [Wie implementiere ich die Paginierung in DynamoDB](https://repost.aws/knowledge-center/dynamodb-implement-pagination)
**Transaktionen**
+ [Warum schlägt mein `TransactWriteItems`-API-Aufruf in DynamoDB fehl?](https://repost.aws/knowledge-center/dynamodb-transactwriteitems)
**Fehlersuche**
[]()
+ [Wie löse ich Probleme mit DynamoDB Auto Scaling?](https://repost.aws/knowledge-center/dynamodb-auto-scaling)
+ [Wie behebe ich HTTP-4XX-Fehler in DynamoDB](https://repost.aws/knowledge-center/usererrors-dynamodb-table)
Weitere Artikel und Videos zu DynamoDB finden Sie in den [Wissenscenter-Artikeln](https://repost.aws/search/knowledge-center?globalSearch=dynamodb).
## Blogbeiträge, Repositorys und Leitfäden
Zusätzlich zum [DynamoDB-Entwicklerhandbuch](Introduction.md) gibt es viele nützliche Ressourcen für die Arbeit mit DynamoDB. Hier finden Sie einige ausgewählte Blogbeiträge, Repositorys und Anleitungen für die Arbeit mit DynamoDB:
+ AWS [Repository mit [DynamoDB-Codebeispielen](https://github.com/aws-samples/aws-dynamodb-examples) in verschiedenen AWS SDK-Sprachen: [Node.js](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/node.js), [Java](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/java), [Python](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/python), [.Net](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/dotnet), [Go](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/golang) und Rust.](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/rust)
+ [Das DynamoDB-Buch](https://www.dynamodbbook.com/) — Ein umfassender Leitfaden von [Alex DeBrie](https://twitter.com/alexbdebrie), der einen strategieorientierten Ansatz für die Datenmodellierung mit DynamoDB vermittelt.
+ [DynamoDB-Leitfaden](https://www.dynamodbguide.com/) — Ein offener Leitfaden von [Alex DeBrie](https://twitter.com/alexbdebrie), der die grundlegenden Konzepte und erweiterten Funktionen der DynamoDB-NoSQL-Datenbank erläutert.
+ [So wechseln Sie in nur 20 einfachen Schritten von RDBMS zu DynamoDB](https://www.jeremydaly.com/how-to-switch-from-rdbms-to-dynamodb-in-20-easy-steps/) – eine Liste nützlicher Schritte zum Erlernen der Datenmodellierung von [Jeremy Daly](https://twitter.com/jeremy_daly).
+ [ JavaScript DocumentClient DynamoDB-Spickzettel — Ein Spickzettel](https://github.com/dabit3/dynamodb-documentclient-cheat-sheet), der Ihnen bei den ersten Schritten beim Erstellen von Anwendungen mit DynamoDB in einer Node.js oder Umgebung hilft. JavaScript
+ [DynamoDB-Core-Konzeptvideos](https://www.youtube.com/playlist?list=PLJo-rJlep0EDNtcDeHDMqsXJcuKMcrC5F) – diese Wiedergabeliste deckt viele der Kernkonzepte von DynamoDB ab.
## Datenmodellierung und Designmusterpräsentationen
Mit den folgenden Ressourcen zu Datenmodellierung und Entwurfsmustern können Sie DynamoDB optimal nutzen:
+ [AWS re:Invent 2019: Datenmodellierung mit DynamoDB](https://www.youtube.com/watch?v=DIQVJqiSUkE)
+ Ein Vortrag von [Alex DeBrie](https://twitter.com/alexbdebrie), der Ihnen hilft, mit den Prinzipien der DynamoDB-Datenmodellierung zu beginnen.
+ [AWS re:Invent 2020: Datenmodellierung mit DynamoDB — Teil 1](https://www.youtube.com/watch?v=fiP2e-g-r4g)
+ [AWS re:Invent 2020: Datenmodellierung mit DynamoDB — Teil 2](https://www.youtube.com/watch?v=0uLF1tjI_BI)
+ [AWS re:Invent 2017: Fortgeschrittene Entwurfsmuster](https://www.youtube.com/watch?v=jzeKPKpucS0)
+ [AWS re:Invent 2018: Fortschrittliche Entwurfsmuster](https://www.youtube.com/watch?v=HaEPXoXVf2k)
+ [AWS re:Invent 2019: Fortschrittliche Entwurfsmuster](https://www.youtube.com/watch?v=6yqfmXiZTlM)
+ Jeremy Daly berichtet über seine [12 wichtigsten Erkenntnisse](https://www.jeremydaly.com/takeaways-from-dynamodb-deep-dive-advanced-design-patterns-dat403/) aus diesem Vortrag.
+ [AWS re:Invent 2020: DynamoDB Fortgeschrittene Designmuster – Teil 1](https://www.youtube.com/watch?v=MF9a1UNOAQo&index=1)
+ [AWS re:Invent 2020: DynamoDB-Entwurfsmuster für Fortgeschrittene — Teil 2](https://www.youtube.com/watch?v=_KNrRdWD25M&index=2)
+ [DynamoDB Sprechstunden auf Twitch](https://amazondynamodbofficehrs.splashthat.com/)
**Anmerkung**
In jedem Vortrag werden verschiedene Anwendungsfälle und Beispiele behandelt.
## Schulungskurse
Es gibt viele verschiedene Trainings und Bildungsmöglichkeiten, um mehr über DynamoDB zu erfahren. Hier sind einige aktuelle Beispiele:
+ [Entwickeln mit Amazon DynamoDB](https://www.aws.training/Details/Curriculum?id=65583) — Entwickelt von AWS , um Sie vom Anfänger zum Experten für die Entwicklung realer Anwendungen mit Datenmodellierung für Amazon DynamoDB zu machen.
+ [DynamoDB-Vertiefungskurs](https://www.pluralsight.com/courses/aws-dynamodb-deep-dive-2019) – ein Kurs von Pluralsight.
+ [Amazon DynamoDB: Entwicklung datenbankgestützter NoSQL-Anwendungen](https://www.edx.org/course/amazon-dynamodb-building-nosql-database-driven-app) — Ein Kurs des AWS Schulungs- und Zertifizierungsteams, der auf edX gehostet wird.