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.

# Wichtige Unterschiede zwischen einer relationalen (SQL) Datenbank und DynamoDB beim Lesen von Daten aus einer Tabelle
<a name="SQLtoNoSQL.ReadData"></a>

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
<a name="SQLtoNoSQL.ReadData.SingleItem"></a>

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
<a name="SQLtoNoSQL.ReadData.SingleItem.SQL"></a>

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
<a name="SQLtoNoSQL.ReadData.SingleItem.DynamoDB"></a>

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
<a name="SQLtoNoSQL.ReadData.Query"></a>

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
<a name="SQLtoNoSQL.ReadData.Query.SQL"></a>

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
<a name="SQLtoNoSQL.ReadData.Query.DynamoDB"></a>

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
<a name="SQLtoNoSQL.ReadData.Scan"></a>

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
<a name="SQLtoNoSQL.ReadData.Scan.SQL"></a>

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
<a name="SQLtoNoSQL.ReadData.Scan.DynamoDB"></a>

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)

------