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. # PartiQL – Eine SQL-kompatible Abfragesprache für Amazon DynamoDB Amazon DynamoDB unterstützt [PartiQL](https://partiql.org/), eine SQL-kompatible Abfragesprache, um Daten in Amazon DynamoDB auszuwählen, einzufügen, zu aktualisieren und zu löschen. Mit PartiQL können Sie problemlos mit DynamoDB-Tabellen interagieren und Ad-hoc-Abfragen mithilfe von NoSQL Workbench und DynamoDB for PartiQL ausführen. AWS-Managementkonsole AWS Command Line Interface APIs PartiQL-Operationen bieten die gleiche Verfügbarkeit, Latenz und Performance wie die anderen DynamoDB-Datenebenen-Operationen. In den folgenden Abschnitten wird die DynamoDB-Implementierung von PartiQL beschrieben. **Topics** + [Was ist PartiQL?](#ql-reference.what-is) + [PartiQL in Amazon DynamoDB](#ql-reference.what-is) + [Erste Schritte](ql-gettingstarted.md) + [Datentypen](ql-reference.data-types.md) + [Anweisungen](ql-reference.statements.md) + [Funktionen](ql-functions.md) + [Betreiber](ql-operators.md) + [Transaktionen](ql-reference.multiplestatements.transactions.md) + [Batch-Vorgänge](ql-reference.multiplestatements.batching.md) + [IAM-Richtlinien](ql-iam.md) ## Was ist PartiQL? *PartiQL* bietet SQL-kompatiblen Abfragezugriff über mehrere Datenspeicher mit strukturierten, halbstrukturierten und verschachtelten Daten hinweg. Es ist bei Amazon weit verbreitet und ist jetzt als Teil vieler AWS Dienste verfügbar, einschließlich DynamoDB. Die PartiQL-Spezifikation und ein Tutorial zur Core-Abfragesprache finden Sie in der [PartiQL-Dokumentation](https://partiql.org/docs.html). **Anmerkung** Amazon DynamoDB unterstützt eine *Teilmenge* der [PartiQL](https://partiql.org/)-Abfragesprache. Amazon DynamoDB unterstützt das [Amazon-Ion](http://amzn.github.io/ion-docs/)-Datenformat oder Amazon-Ion-Literale nicht. ## PartiQL in Amazon DynamoDB Zum Ausführen von PartiQL-Abfragen in DynamoDB können Sie Folgendes verwenden: + Die DynamoDB-Konsole + NoSQL Workbench + Das AWS Command Line Interface ()AWS CLI + Die DynamoDB APIs Weitere Informationen zum Verwenden dieser Methoden für den Zugriff auf DynamoDB finden Sie unter [Zugreifen auf DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AccessingDynamoDB.html). # Erste Schritte mit PartiQL für DynamoDB In diesem Abschnitt wird beschrieben, wie PartiQL für DynamoDB von der Amazon DynamoDB DynamoDB-Konsole, der AWS Command Line Interface ()AWS CLI und DynamoDB aus verwendet wird. APIs In den folgenden Beispielen ist die DynamoDB-Tabelle, die im Tutorial [Erste Schritte mit DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) definiert ist, eine Voraussetzung. [Informationen zur Verwendung der DynamoDB-Konsole oder DynamoDB für den Zugriff auf DynamoDB finden Sie unter APIs Accessing DynamoDB. AWS Command Line Interface](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AccessingDynamoDB.html) Um die [NoSQL Workbench](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.html) [herunterzuladen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.settingup.html) und zu verwenden, um [PartiQL for DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (PartiQL für DynamoDB) Anweisungen zu erstellen, wählen Sie **PartiQL operations** (PartiQL-Operationen) in der oberen rechten Ecke der NoSQL Workbench für DynamoDB [Operation Builder](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.querybuilder.operationbuilder.html). ------ #### [ Console ] ![\[PartiQL-Editor-Schnittstelle, die das Ergebnis der Abfrage-Operation in der Tabelle Music anzeigt.\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/partiqlgettingstarted.png) 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die DynamoDB-Konsole unter. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 1. Wählen Sie im Navigationsbereich auf der linken Seite der Konsole **PartiQL editor** (PartiQL-Editor) aus. 1. Wählen Sie die Tabelle **Music** (Musik). 1. Klicken Sie auf die **Query table** (Abfragetabelle). Diese Aktion generiert eine Abfrage, die nicht zu einem vollständigen Tabellenscan führt. 1. ErsetzenSie `partitionKeyValue` mit dem Zeichenfolgen-Wert `Acme Band`. ErsetzenSie `sortKeyValue` mit dem Zeichenfolgen-Wert `Happy Day`. 1. Wählen Sie die Schaltfläche **Run** (Ausführen) aus. 1. Sie können die Ergebnisse der Abfrage anzeigen, indem Sie die Schaltflächen **Table view** (Tabellenansicht) oder **JSON view** (JSON-Ansicht) auswählen. ------ #### [ NoSQL workbench ] ![\[NoSQL Workbench-Schnittstelle. Sie zeigt eine PartiQL SELECT-Anweisung, die Sie in der Tabelle Music ausführen können.\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/images/workbench/partiql.single.png) 1. Klicken Sie auf **PartiQL statement** (PartiQL-Anweisung). 1. Geben Sie die folgende PartiQL-[SELECT-Anweisung](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html) ein ``` SELECT * FROM Music WHERE Artist=? and SongTitle=? ``` 1. So geben Sie einen Wert für den `Artist`- und `SongTitle`-Parameter ein: 1. Klicken Sie auf **Optional request parameter** (Optionale Anfrageparameter). 1. Klicken Sie auf **Add new parameters** (Fügen Sie neue Parameter hinzu). 1. Wählen Sie den Attributtyp **string** (Zeichenfolge) und den Wert `Acme Band`. 1. Wiederholen Sie die Schritte b und c, und wählen Sie den Typ **string** (Zeichenfolge) und den Wert `PartiQL Rocks`. 1. Falls Sie Code generieren möchten, wählen Sie **Generate code** (Code generieren) aus. Wählen Sie in den angezeigten Tabs Ihre gewünschte Sprache aus. Sie können diesen Code jetzt kopieren und in Ihrer Anwendung verwenden. 1. Falls die Operation sofort ausgeführt werden soll, wählen Sie **Run** (Ausführen). ------ #### [ AWS CLI ] 1. Erstellen Sie mit der INSERT-PartiQL-Anweisung ein Element in der Tabelle `Music`. ``` aws dynamodb execute-statement --statement "INSERT INTO Music \ VALUE \ {'Artist':'Acme Band','SongTitle':'PartiQL Rocks'}" ``` 1. Rufen Sie mit der SELECT-PartiQL-Anweisung ein Element aus der Musiktabelle ab. ``` aws dynamodb execute-statement --statement "SELECT * FROM Music \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` 1. Aktualisieren Sie ein Element in der Tabelle `Music` mit der UPDATE-PartiQL-Anweisung. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardsWon=1 \ SET AwardDetail={'Grammys':[2020, 2018]} \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Fügen Sie einen Listenwert für ein Element in der `Music`-Tabelle ein ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Entfernen Sie einen Listenwert für ein Element in der `Music`-Tabelle ``` aws dynamodb execute-statement --statement "UPDATE Music \ REMOVE AwardDetail.Grammys[2] \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Fügen Sie ein neues Kartenelement für ein Element in der `Music`-Tabelle ein ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardDetail.BillBoard=[2020] \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Fügen Sie ein neues Zeichenfolgensatzattribut für ein Element in der `Music`-Tabelle hinzu. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET BandMembers =<<'member1', 'member2'>> \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Aktualisieren Sie ein neues Zeichenfolgensatzattribut für ein Element in der `Music`-Tabelle- ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET BandMembers =set_add(BandMembers, <<'newmember'>>) \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` 1. Löschen Sie ein Element aus dem`Music`-Tabelle mit der DELETE-PartiQL-Anweisung. ``` aws dynamodb execute-statement --statement "DELETE FROM Music \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` ------ #### [ Java ] ``` import java.util.ArrayList; import java.util.List; import com.amazonaws.AmazonClientException; import com.amazonaws.AmazonServiceException; import software.amazon.dynamodb.AmazonDynamoDB; import software.amazon.dynamodb.AmazonDynamoDBClientBuilder; import software.amazon.dynamodb.model.AttributeValue; import software.amazon.dynamodb.model.ConditionalCheckFailedException; import software.amazon.dynamodb.model.ExecuteStatementRequest; import software.amazon.dynamodb.model.ExecuteStatementResult; import software.amazon.dynamodb.model.InternalServerErrorException; import software.amazon.dynamodb.model.ItemCollectionSizeLimitExceededException; import software.amazon.dynamodb.model.ProvisionedThroughputExceededException; import software.amazon.dynamodb.model.RequestLimitExceededException; import software.amazon.dynamodb.model.ResourceNotFoundException; import software.amazon.dynamodb.model.TransactionConflictException; public class DynamoDBPartiQGettingStarted { public static void main(String[] args) { // Create the DynamoDB Client with the region you want AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-1"); try { // Create ExecuteStatementRequest ExecuteStatementRequest executeStatementRequest = new ExecuteStatementRequest(); List parameters= getPartiQLParameters(); //Create an item in the Music table using the INSERT PartiQL statement processResults(executeStatementRequest(dynamoDB, "INSERT INTO Music value {'Artist':?,'SongTitle':?}", parameters)); //Retrieve an item from the Music table using the SELECT PartiQL statement. processResults(executeStatementRequest(dynamoDB, "SELECT * FROM Music where Artist=? and SongTitle=?", parameters)); //Update an item in the Music table using the UPDATE PartiQL statement. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist=? and SongTitle=?", parameters)); //Add a list value for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) where Artist=? and SongTitle=?", parameters)); //Remove a list value for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music REMOVE AwardDetail.Grammys[2] where Artist=? and SongTitle=?", parameters)); //Add a new map member for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music set AwardDetail.BillBoard=[2020] where Artist=? and SongTitle=?", parameters)); //Add a new string set attribute for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET BandMembers =<<'member1', 'member2'>> where Artist=? and SongTitle=?", parameters)); //update a string set attribute for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET BandMembers =set_add(BandMembers, <<'newmember'>>) where Artist=? and SongTitle=?", parameters)); //Retrieve an item from the Music table using the SELECT PartiQL statement. processResults(executeStatementRequest(dynamoDB, "SELECT * FROM Music where Artist=? and SongTitle=?", parameters)); //delete an item from the Music Table processResults(executeStatementRequest(dynamoDB, "DELETE FROM Music where Artist=? and SongTitle=?", parameters)); } catch (Exception e) { handleExecuteStatementErrors(e); } } private static AmazonDynamoDB createDynamoDbClient(String region) { return AmazonDynamoDBClientBuilder.standard().withRegion(region).build(); } private static List getPartiQLParameters() { List parameters = new ArrayList(); parameters.add(new AttributeValue("Acme Band")); parameters.add(new AttributeValue("PartiQL Rocks")); return parameters; } private static ExecuteStatementResult executeStatementRequest(AmazonDynamoDB client, String statement, List parameters ) { ExecuteStatementRequest request = new ExecuteStatementRequest(); request.setStatement(statement); request.setParameters(parameters); return client.executeStatement(request); } private static void processResults(ExecuteStatementResult executeStatementResult) { System.out.println("ExecuteStatement successful: "+ executeStatementResult.toString()); } // Handles errors during ExecuteStatement execution. Use recommendations in error messages below to add error handling specific to // your application use-case. private static void handleExecuteStatementErrors(Exception exception) { try { throw exception; } catch (ConditionalCheckFailedException ccfe) { System.out.println("Condition check specified in the operation failed, review and update the condition " + "check before retrying. Error: " + ccfe.getErrorMessage()); } catch (TransactionConflictException tce) { System.out.println("Operation was rejected because there is an ongoing transaction for the item, generally " + "safe to retry with exponential back-off. Error: " + tce.getErrorMessage()); } catch (ItemCollectionSizeLimitExceededException icslee) { System.out.println("An item collection is too large, you\'re using Local Secondary Index and exceeded " + "size limit of items per partition key. Consider using Global Secondary Index instead. Error: " + icslee.getErrorMessage()); } catch (Exception e) { handleCommonErrors(e); } } private static void handleCommonErrors(Exception exception) { try { throw exception; } catch (InternalServerErrorException isee) { System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage()); } catch (RequestLimitExceededException rlee) { System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " + "retrying. Error: " + rlee.getErrorMessage()); } catch (ProvisionedThroughputExceededException ptee) { System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " + "Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " + ptee.getErrorMessage()); } catch (ResourceNotFoundException rnfe) { System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage()); } catch (AmazonServiceException ase) { System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " + "service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " + "configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage()); } catch (AmazonClientException ace) { System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " + "service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+ "Error: " + ace.getMessage()); } catch (Exception e) { System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage()); } } } ``` ------ ## Verwenden von parametrisierten Anweisungen Anstatt Werte direkt in eine PartiQL-Anweisungszeichenfolge einzubetten, können Sie Fragezeichen-Platzhalter (`?`) verwenden und die Werte separat in das Feld eingeben. `Parameters` Jeder Wert `?` wird durch den entsprechenden Parameterwert ersetzt, und zwar in der Reihenfolge, in der er angegeben wurde. Die Verwendung parametrisierter Anweisungen ist eine bewährte Methode, da sie die Anweisungsstruktur von den Datenwerten trennt, sodass Anweisungen leichter zu lesen und wiederzuverwenden sind. Außerdem müssen Attributwerte in der Anweisungszeichenfolge nicht manuell formatiert und maskiert werden. Parametrisierte Anweisungen werden in `ExecuteStatement``BatchExecuteStatement`, und `ExecuteTransaction` -Operationen unterstützt. In den folgenden Beispielen wird mithilfe parametrisierter Werte für den Partitionsschlüssel und den Sortierschlüssel ein Element aus der `Music` Tabelle abgerufen. ------ #### [ AWS CLI parameterized ] ``` aws dynamodb execute-statement \ --statement "SELECT * FROM \"Music\" WHERE Artist=? AND SongTitle=?" \ --parameters '[{"S": "Acme Band"}, {"S": "PartiQL Rocks"}]' ``` ------ #### [ Java parameterized ] ``` List parameters = new ArrayList<>(); parameters.add(new AttributeValue("Acme Band")); parameters.add(new AttributeValue("PartiQL Rocks")); ExecuteStatementRequest request = new ExecuteStatementRequest() .withStatement("SELECT * FROM Music WHERE Artist=? AND SongTitle=?") .withParameters(parameters); ExecuteStatementResult result = dynamoDB.executeStatement(request); ``` ------ #### [ Python parameterized ] ``` response = dynamodb_client.execute_statement( Statement="SELECT * FROM Music WHERE Artist=? AND SongTitle=?", Parameters=[ {'S': 'Acme Band'}, {'S': 'PartiQL Rocks'} ] ) ``` ------ **Anmerkung** Das Java-Beispiel im vorherigen Abschnitt „Erste Schritte“ verwendet durchweg parametrisierte Anweisungen. Die `getPartiQLParameters()` Methode erstellt die Parameterliste, und jede Anweisung verwendet `?` Platzhalter anstelle von Inline-Werten. # PartiQL-Datentypen für DynamoDB In der folgenden Tabelle sind die Datentypen aufgeführt, die Sie mit PartiQL für DynamoDB verwenden können. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/amazondynamodb/latest/developerguide/ql-reference.data-types.html) ## Beispiele Die folgende Anweisung veranschaulicht, wie die folgenden Datentypen eingefügt werden: `String`, `Number`, `Map`, `List`, `Number Set` und `String Set`. ``` INSERT INTO TypesTable value {'primarykey':'1', 'NumberType':1, 'MapType' : {'entryname1': 'value', 'entryname2': 4}, 'ListType': [1,'stringval'], 'NumberSetType':<<1,34,32,4.5>>, 'StringSetType':<<'stringval','stringval2'>> } ``` Die folgende Anweisung veranschaulicht, wie neue Elemente in die `Map`, `List`, `Number Set` und `String Set`-Typen eingefügt werden und den Wert eines `Number`-Typ ändern. ``` UPDATE TypesTable SET NumberType=NumberType + 100 SET MapType.NewMapEntry=[2020, 'stringvalue', 2.4] SET ListType = LIST_APPEND(ListType, [4, <<'string1', 'string2'>>]) SET NumberSetType= SET_ADD(NumberSetType, <<345, 48.4>>) SET StringSetType = SET_ADD(StringSetType, <<'stringsetvalue1', 'stringsetvalue2'>>) WHERE primarykey='1' ``` Die folgende Anweisung veranschaulicht, wie neue Elemente aus den `Map`, `List`, `Number Set` und `String Set`-Typen entfernt werden und den Wert eines `Number`-Typ ändern. ``` UPDATE TypesTable SET NumberType=NumberType - 1 REMOVE ListType[1] REMOVE MapType.NewMapEntry SET NumberSetType = SET_DELETE( NumberSetType, <<345>>) SET StringSetType = SET_DELETE( StringSetType, <<'stringsetvalue1'>>) WHERE primarykey='1' ``` Weitere Informationen finden Sie unter [DynamoDB-Datentypen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes). # PartiQL-Anweisungen für DynamoDB Amazon DynamoDB unterstützt die folgenden PartiQL-Anweisungen. **Anmerkung** DynamoDB unterstützt nicht alle PartiQL-Anweisungen. Diese Referenz enthält grundlegende Syntax- und Verwendungsbeispiele für PartiQL-Anweisungen, die Sie manuell mit dem AWS CLI oder APIs ausführen. *Data Manipulation Language* (DML) ist die Gruppe von PartiQL-Anweisungen, die Sie zum Verwalten von Daten in DynamoDB-Tabellen verwenden. Sie verwenden DML-Anweisungen, um Daten in einer Tabelle hinzuzufügen, zu ändern oder zu löschen. Die folgenden Anweisungen für DML- und Abfragesprachen werden unterstützt: + [PartiQL-Select-Anweisungen für DynamoDB](ql-reference.select.md) + [Aktualisierungen für PartiQL-Anweisungen für DynamoDB](ql-reference.update.md) + [PartiQL-Insert-Anweisungen für DynamoDB](ql-reference.insert.md) + [PartiQL-Delete-Anweisungen für DynamoDB](ql-reference.delete.md) [Ausführen von Transaktionen mit PartiQL für DynamoDB](ql-reference.multiplestatements.transactions.md) und [Ausführen von Batchoperationen mit PartiQL für DynamoDB](ql-reference.multiplestatements.batching.md) werden auch von PartiQL für DynamoDB unterstützt. # PartiQL-Select-Anweisungen für DynamoDB Verwenden Sie die `SELECT`-Anweisung zum Abrufen von Daten aus einer Tabelle in Amazon DynamoDB. Die Verwendung der `SELECT`-Anweisung kann zu einem vollständigen Tabellenscan führen, wenn in der WHERE-Klausel keine Gleichheitsbedingung oder IN-Bedingung mit einem Partitionsschlüssel angegeben ist. Die Scan-Operation untersucht jedes Element auf die angeforderten Werte und kann den bereitgestellten Durchsatz für eine große Tabelle oder Index in einer einzigen Operation verbrauchen. Wenn Sie den vollständigen Tabellenscan in PartiQL vermeiden möchten, können Sie: + Erstellen Sie Ihre `SELECT`-Anweisungen so, dass keine vollständigen Tabellenscans durchgeführt werden, indem Sie sicherstellen, dass die Bedingung der [WHERE-Klausel entsprechend](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html#ql-reference.select.parameters) konfiguriert ist. + Deaktivieren Sie vollständige Tabellenscans mithilfe der IAM-Richtlinie, die unter [Beispiel: In PartiQL für DynamoDB Select-Anweisungen erlauben und vollständige Tabellenscan-Anweisungen verweigern](ql-iam.md#access-policy-ql-iam-example6) im DynamoDB-Entwicklerhandbuch. Weitere Informationen finden Sie unter [Bewährte Methoden für das Abfragen und Scannen von Daten](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-query-scan.html) im DynamoDB-Entwicklerhandbuch. **Topics** + [Syntax](#ql-reference.select.syntax) + [Parameters](#ql-reference.select.parameters) + [Beispiele](#ql-reference.select.examples) ## Syntax ``` SELECT expression [, ...] FROM table[.index] [ WHERE condition ] [ [ORDER BY key [DESC|ASC] , ...] ``` ## Parameters ***expression*** (erforderlich) Eine Projektion aus dem `*`-Platzhalter oder eine Projektionsliste aus einem oder mehreren Attributnamen oder Dokumentpfaden aus dem Ergebnissatz. Ein Ausdruck kann aus Aufrufen an [Verwenden von PartiQL-Funktionen mit DynamoDB](ql-functions.md) oder Feldern bestehen, die von [PartiQL-Arithmetik-, Vergleichs- und logische Operatoren für DynamoDB](ql-operators.md) geändert werden. ***table*** (Erforderlich) Der abzufragende Tabellenname. ***index*** (Optional) Der Name des abzufragenden Indexes. Sie müssen dem Tabellennamen und dem Indexnamen doppelte Anführungszeichen hinzufügen, wenn Sie einen Index abfragen. ``` SELECT * FROM "TableName"."IndexName" ``` ***condition*** (Optional) Die Auswahlkriterien für die Abfrage. Um sicherzustellen, dass eine `SELECT`-Anweisung nicht zu einem vollständigen Tabellenscan führt, muss die `WHERE`-Klauselbedingung einen Partitionsschlüssel angeben. Verwenden Sie den Gleichheits- oder IN-Operator. Angenommen, Sie haben eine `Orders`-Tabelle mit `OrderID`-Partitionsschlüssel und andere Nicht-Schlüsselattribute, einschließlich eines `Address`, würden die folgenden Anweisungen nicht zu einem vollständigen Tabellenscan führen: ``` SELECT * FROM "Orders" WHERE OrderID = 100 SELECT * FROM "Orders" WHERE OrderID = 100 and Address='some address' SELECT * FROM "Orders" WHERE OrderID = 100 or OrderID = 200 SELECT * FROM "Orders" WHERE OrderID IN [100, 300, 234] ``` Folgende `SELECT`-Anweisungen führen jedoch zu einem vollständigen Tabellenscan: ``` SELECT * FROM "Orders" WHERE OrderID > 1 SELECT * FROM "Orders" WHERE Address='some address' SELECT * FROM "Orders" WHERE OrderID = 100 OR Address='some address' ``` ***key*** (Optional) Ein Hash-Schlüssel oder ein Sortierschlüssel, der zum Sortieren von ausgegebenen Ergebnissen verwendet werden soll. Die Standardreihenfolge ist aufsteigend (`ASC`) Geben Sie an.`DESC`, wenn die Ergebnisse in absteigender Reihenfolge neu abgestimmt werden sollen. **Anmerkung** Wenn Sie die `WHERE`-Klausel weglassen, werden alle Elemente in der Tabelle abgerufen. ## Beispiele Die folgende Abfrage gibt ein Element, falls vorhanden, aus der `Orders`-Tabelle zurück, indem der Partitionsschlüssel `OrderID` angegeben und der Gleichheitsoperator verwendet wird. ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID = 1 ``` Die folgende Abfrage gibt alle Elemente in der `Orders`-Tabelle mit einem bestimmten Partitionsschlüssel `OrderID` zurück, mithilde von Werten mit dem Operator OR. ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID = 1 OR OrderID = 2 ``` Die folgende Abfrage gibt alle Elemente in der `Orders`-Tabelle mit einem bestimmten Partitionsschlüssel `OrderID` zurück, mithilde von Werten mit dem Operator IN. Die zurückgegebenen Ergebnisse sind in absteigender Reihenfolge, basierend auf dem `OrderID`-Attributwert. ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID IN [1, 2, 3] ORDER BY OrderID DESC ``` Die folgende Abfrage zeigt einen vollständigen Tabellenscan, der alle Elemente aus der `Orders`-Tabelle zurückgibt, deren `Total` größer als 500 ist, wobei `Total` ein Nicht-Schlüsselattribut ist. ``` SELECT OrderID, Total FROM "Orders" WHERE Total > 500 ``` Die folgende Abfrage zeigt einen vollständigen Tabellenscan, der alle Elemente aus der `Orders`-Tabelle innerhalb eines bestimmten `Total`-Reihenfolgebereichs zurückgibt, wobei der IN-Operator und ein Nicht-Schlüsselattribut `Total` verwendet werden. ``` SELECT OrderID, Total FROM "Orders" WHERE Total IN [500, 600] ``` Die folgende Abfrage zeigt einen vollständigen Tabellenscan, der alle Elemente aus der `Orders`-Tabelle innerhalb eines bestimmten `Total`-Reihenfolgebereichs zurückgibt, wobei der BETWEEN-Operator und ein Nicht-Schlüsselattribut `Total` verwendet werden. ``` SELECT OrderID, Total FROM "Orders" WHERE Total BETWEEN 500 AND 600 ``` Die folgende Abfrage gibt das erste Datum zurück, an dem ein Firestick-Gerät zum Überwachen verwendet wurde, indem der `CustomerID`-Partitionsschlüssel und der `MovieID`-Sortierschlüssel in der Bedingung der WHERE-Klausel angegeben und Dokumentpfade in der SELECT-Klausel verwendet werden. ``` SELECT Devices.FireStick.DateWatched[0] FROM WatchList WHERE CustomerID= 'C1' AND MovieID= 'M1' ``` Die folgende Abfrage zeigt einen vollständigen Tabellenscan, der die Liste der Elemente zurückgibt, bei denen ein Firestick-Gerät nach dem 24.12.19 zum ersten Mal unter Verwendung von Dokumentpfaden in der WHERE-Klausel Bedingung verwendet wurde. ``` SELECT Devices FROM WatchList WHERE Devices.FireStick.DateWatched[0] >= '12/24/19' ``` # Aktualisierungen für PartiQL-Anweisungen für DynamoDB Verwenden der `UPDATE`-Anweisung, um den Wert eines oder mehrerer Attribute innerhalb eines Elements in einer Amazon-DynamoDB-Tabelle zu ändern. **Anmerkung** Sie können nur ein Element gleichzeitig aktualisieren. Sie können keine einzelne DynamoDB-PartiQL-Anweisung ausgeben, die mehrere Elemente aktualisiert. Weitere Informationen zum Aktualisieren mehrerer Elemente finden Sie unter [Ausführen von Transaktionen mit PartiQL für DynamoDB](ql-reference.multiplestatements.transactions.md) oder [Ausführen von Batchoperationen mit PartiQL für DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Syntax](#ql-reference.update.syntax) + [Parameters](#ql-reference.update.parameters) + [Rückgabewert](#ql-reference.update.return) + [Beispiele](#ql-reference.update.examples) ## Syntax ``` UPDATE table [SET | REMOVE] path [= data] […] WHERE condition [RETURNING returnvalues] ::= [ALL OLD | MODIFIED OLD | ALL NEW | MODIFIED NEW] * ``` ## Parameters ***table*** (erforderlich) Die Benutzertabelle mit den zu ändernden Daten. ***path*** (Erforderlich) Ein Attributname oder Dokumentpfad, der erstellt oder geändert werden soll. ***data*** (Erforderlich) Ein Attributwert oder das Ergebnis einer Operation. Die unterstützten Operationen, die mit SET verwendet werden sollen: + LIST\$1APPEND: fügt einem Listentyp einen Wert hinzu. + SET\$1ADD: fügt einem Zahlen- oder Zeichenfolgensatz einen Wert hinzu. + SET\$1DELETE: Entfernt einen Wert aus einem Zahlen- oder Zeichenfolgensatz. ***condition*** (erforderlich) Die Auswahlkriterien für die Elemente, die geändert werden sollen. Diese Bedingung muss auf einen einzelnen Primärschlüsselwert aufgelöst werden. ***returnvalues*** (Optional) Verwenden Sie `returnvalues`, wenn Sie die Elementattribute so abrufen möchten, wie sie vor oder nach der Aktualisierung angezeigt werden. Die gültigen Werte sind: + `ALL OLD *` – Gibt alle Attribute des Elements so zurück, wie sie vor dem Aktualisieren dargestellt wurden. + `MODIFIED OLD *` – Gibt nur die aktualisierten Attribute so zurück, wie sie vor dem Aktualisieren dargestellt wurden. + `ALL NEW *` – Gibt alle Attribute des Elements zurück, wie sie nach dem Aktualisierungsvorgang angezeigt werden. + `MODIFIED NEW *` – Gibt nur die aktualisierten Attribute so zurück, wie sie nach dem `UpdateItem` vorkommen. ## Rückgabewert Diese Anweisung gibt keinen Wert zurück, es sei denn der `returnvalues`-Parameter ist angegeben. **Anmerkung** Wenn die WHERE-Klausel der UPDATE-Anweisung für kein Element in der DynamoDB-Tabelle als wahr ausgewertet wird, wird `ConditionalCheckFailedException` zurückgegeben. ## Beispiele Aktualisieren Sie einen Attributwert in einem vorhandenen Element. Wenn das Attribut nicht vorhanden ist, wird es erstellt. Mit der folgenden Abfrage wird ein Element in der `"Music"`-Tabelle durch Hinzufügen eines Attributs vom Typ „number“ (`AwardsWon`) und ein Attribut vom Typ „map“ (`AwardDetail`) enthalten. ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` Sie können `RETURNING ALL OLD *` hinzufügen, um die Attribute so zurückzugeben, wie sie vor der `Update`-Operation erschienen. ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' RETURNING ALL OLD * ``` Damit wird Folgendes zurückgegeben: ``` { "Items": [ { "Artist": { "S": "Acme Band" }, "SongTitle": { "S": "PartiQL Rocks" } } ] } ``` Sie können `RETURNING ALL NEW *` hinzufügen, um die Attribute so zurückzugeben, wie sie nach der `Update`-Operation erschienen. ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' RETURNING ALL NEW * ``` Damit wird Folgendes zurückgegeben: ``` { "Items": [ { "AwardDetail": { "M": { "Grammys": { "L": [ { "N": "2020" }, { "N": "2018" } ] } } }, "AwardsWon": { "N": "1" } } ] } ``` Mit der folgenden Abfrage wird ein Element in der `"Music"`-Tabelle durch Anhängen an eine Liste `AwardDetail.Grammys` aktualisiert. ``` UPDATE "Music" SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` Mit der folgenden Abfrage wird ein Element in der `"Music"`-Tabelle durch Entfernen aus einer Liste `AwardDetail.Grammys` aktualisiert. ``` UPDATE "Music" REMOVE AwardDetail.Grammys[2] WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` Mit der folgenden Abfrage wird ein Element in der `"Music"`-Tabelle durch Hinzufügen von `BillBoard` zur Karte `AwardDetail` aktualisiert. ``` UPDATE "Music" SET AwardDetail.BillBoard=[2020] WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` Die folgende Abfrage aktualisiert ein Element in der `"Music"`-Tabelle durch Hinzufügen des Zeichenfolgensatzattributs `BandMembers`. ``` UPDATE "Music" SET BandMembers =<<'member1', 'member2'>> WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` Die folgende Abfrage aktualisiert ein Element in der `"Music"`-Tabelle, indem `newbandmember` zum Zeichenfolgensatz `BandMembers` hinzugefügt wird. ``` UPDATE "Music" SET BandMembers =set_add(BandMembers, <<'newbandmember'>>) WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` # PartiQL-Delete-Anweisungen für DynamoDB Verwenden der`DELETE`-Anweisung verwenden, um ein vorhandenes Element aus Ihrer Amazon-DynamoDB-Tabelle zu löschen. **Anmerkung** Sie können nur jeweils ein Element löschen. Sie können keine einzelne DynamoDB-PartiQL-Anweisung ausgeben, die mehrere Elemente löscht. Informationen zum Löschen mehrerer Elemente finden Sie unter [Ausführen von Transaktionen mit PartiQL für DynamoDB](ql-reference.multiplestatements.transactions.md) oder [Ausführen von Batchoperationen mit PartiQL für DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Syntax](#ql-reference.delete.syntax) + [Parameters](#ql-reference.delete.parameters) + [Rückgabewert](#ql-reference.delete.return) + [Beispiele](#ql-reference.delete.examples) ## Syntax ``` DELETE FROM table WHERE condition [RETURNING returnvalues] ::= ALL OLD * ``` ## Parameters ***table*** (Erforderlich) Die DynamoDB-Tabelle, die das zu löschende Element enthält. ***condition*** (Erforderlich) Die Auswahlkriterien für das zu löschende Element; diese Bedingung muss auf einen einzelnen Primärschlüsselwert aufgelöst werden. ***returnvalues*** (Optional) Verwenden Sie `returnvalues`, wenn Sie die Elementattribute so erhalten möchten, wie sie vor dem Löschen dargestellt wurden. Die gültigen Werte sind: + `ALL OLD *`- die Inhalte des alten Elements werden zurückgegeben. ## Rückgabewert Diese Anweisung gibt keinen Wert zurück, es sei denn der `returnvalues`-Parameter ist angegeben. **Anmerkung** Wenn in der DynamoDB-Tabelle kein Element mit demselben Primärschlüssel wie dem des Elements vorhanden ist, für das das DELETE ausgegeben wird, wird SUCCESS zurückgegeben, wobei 0 Elemente gelöscht wurden. Wenn die Tabelle ein Element mit demselben Primärschlüssel enthält, aber die Bedingung in der WHERE-Klausel der DELETE-Anweisung als falsch ausgewertet wird, wird `ConditionalCheckFailedException` zurückgegeben. ## Beispiele Mit der folgenden Abfrage wird ein Element in der Tabelle `"Music"` gelöscht. ``` DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks' ``` Sie können den Parameter `RETURNING ALL OLD *` hinzufügen, um die gelöschten Daten zurückzugeben. ``` DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks' RETURNING ALL OLD * ``` Die `Delete`-Anweisung gibt nun Folgendes zurück: ``` { "Items": [ { "Artist": { "S": "Acme Band" }, "SongTitle": { "S": "PartiQL Rocks" } } ] } ``` # PartiQL-Insert-Anweisungen für DynamoDB Verwenden Sie die `INSERT`-Anweisung, um einer Tabelle in Amazon DynamoDB ein Element hinzuzufügen. **Anmerkung** Sie können nur ein Element gleichzeitig einfügen. Sie können keine einzelne DynamoDB-PartiQL-Anweisung ausgeben, die mehrere Elemente einfügt. Weitere Informationen zum Einfügen mehrerer Elemente finden Sie unter [Ausführen von Transaktionen mit PartiQL für DynamoDB](ql-reference.multiplestatements.transactions.md) oder [Ausführen von Batchoperationen mit PartiQL für DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Syntax](#ql-reference.insert.syntax) + [Parameters](#ql-reference.insert.parameters) + [Rückgabewert](#ql-reference.insert.return) + [Beispiele](#ql-reference.insert.examples) ## Syntax Fügen Sie ein einzelnes Element ein. ``` INSERT INTO table VALUE item ``` ## Parameters ***table*** (erforderlich) Die Tabelle, in der Sie die Daten einfügen möchten. Die Tabelle muss bereits vorhanden sein. ***item*** (Erforderlich) Ein gültiges DynamoDB Element, das als [PartiQL-Tupel](https://partiql.org/docs.html) gezeigt wird. Sie müssen nur *ein* Element angeben, und bei jedem Attributnamen im Element wird die Groß-/Kleinschreibung beachtet und kann in PartiQL mit *einfachen* Anführungszeichen (`'...'`) gekennzeichnet werden. Zeichenfolgenwerte werden in PartiQL auch mit *einfachen* Anführungszeichen (`'...'`) angegeben. ## Rückgabewert Diese Anweisung gibt keine Werte zurück. **Anmerkung** Wenn die DynamoDB-Tabelle bereits ein Element mit demselben Primärschlüssel wie der Primärschlüssel des einzufügenden Elements enthält, wird `DuplicateItemException` zurückgegeben. ## Beispiele ``` INSERT INTO "Music" value {'Artist' : 'Acme Band','SongTitle' : 'PartiQL Rocks'} ``` # Verwenden von PartiQL-Funktionen mit DynamoDB PartiSQL in Amazon DynamoDB unterstützt die folgenden integrierten Varianten von SQL-Standardfunktionen. **Anmerkung** SQL-Funktionen, die nicht in dieser Liste enthalten sind, werden derzeit in DynamoDB nicht unterstützt. ## Aggregationsfunktionen + [Verwenden der SIZE-Funktion mit PartiQL für Amazon DynamoDB](ql-functions.size.md) ## Konditionale Funktionen + [Verwenden der EXISTS-Funktion mit PartiQL für DynamoDB](ql-functions.exists.md) + [Verwenden der ATTRIBUTE\$1TYPE-Funktion mit PartiQL für DynamoDB](ql-functions.attribute_type.md) + [Verwenden der BEGINS\$1WITH-Funktion mit PartiQL für DynamoDB](ql-functions.beginswith.md) + [Verwenden der CONTAINS-Funktion mit PartiQL für DynamoDB](ql-functions.contains.md) + [Verwenden der MISSING-Funktion mit PartiQL für DynamoDB](ql-functions.missing.md) # Verwenden der EXISTS-Funktion mit PartiQL für DynamoDB Sie können EXISTS verwenden, um dieselbe Funktion wie `ConditionCheck` in der [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems)-API auszuführen. Die EXISTS-Funktion kann nur in Transaktionen verwendet werden. Gibt bei Vorliegen eines Werts `TRUE` zurück, wenn der Wert eine nicht-leere Sammlung ist. Gibt andernfalls `FALSE` zurück. **Anmerkung** Diese Funktion kann nur in Transaktionsoperationen verwendet werden. ## Syntax ``` EXISTS ( statement ) ``` ## Argumente *statement* (Erforderlich) Die SELECT-Anweisung, die die Funktion auswertet. Die SELECT-Anweisung muss einen vollständigen Primärschlüssel und eine andere Bedingung angeben. ## Rückgabetyp `bool` ## Beispiele ``` EXISTS( SELECT * FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks') ``` # Verwenden der BEGINS\$1WITH-Funktion mit PartiQL für DynamoDB Gibt `TRUE` zurück, wenn das angegebene Attribut mit einer bestimmten Teilzeichenfolge beginnt. ## Syntax ``` begins_with(path, value ) ``` ## Argumente *path* (Erforderlich) Der zu verwendende Attributname oder Dokumentpfad. *value* (Erforderlich) Die Zeichenfolge, nach der gesucht werden soll. ## Rückgabetyp `bool` ## Beispiele ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND begins_with("Address", '7834 24th') ``` # Verwenden der MISSING-Funktion mit PartiQL für DynamoDB Gibt `TRUE` zurück, wenn das Element das angegebene Attribut nicht enthält. Mit dieser Funktion können nur Gleichheits- und Ungleichheitsoperatoren verwendet werden. ## Syntax ``` attributename IS | IS NOT MISSING ``` ## Argumente *attributename* (Erforderlich) Der Attributname, nach dem Sie suchen möchten. ## Rückgabetyp `bool` ## Beispiele ``` SELECT * FROM Music WHERE "Awards" is MISSING ``` # Verwenden der ATTRIBUTE\$1TYPE-Funktion mit PartiQL für DynamoDB Gibt `TRUE` zurück, wenn das Attribut am angegebenen Pfad einen bestimmten Datentyp hat. ## Syntax ``` attribute_type( attributename, type ) ``` ## Argumente *attributename* (Erforderlich) Der zu verwendende Attributname. *type* (Erforderlich) Der Attributtyp, nach dem geprüft werden soll. Eine Liste der gültigen Werte finden Sie unter DynamoDB [attribute\$1type](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions). ## Rückgabetyp `bool` ## Beispiele ``` SELECT * FROM "Music" WHERE attribute_type("Artist", 'S') ``` # Verwenden der CONTAINS-Funktion mit PartiQL für DynamoDB Gibt `TRUE` zurück, wenn das vom Pfad angegebene Attribut Folgendes ist: + Eine Zeichenfolge, die eine bestimmte Teilzeichenfolge enthält + Einen Satz, der ein bestimmtes Element innerhalb des Satzes enthält Weitere Informationen finden Sie im Thema zur DynamoDB-[Contains](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions)-Funktion. ## Syntax ``` contains( path, substring ) ``` ## Argumente *path* (Erforderlich) Der zu verwendende Attributname oder Dokumentpfad. *substring* (Erforderlich) Die Attribut-Teilzeichenfolge oder das Satz-Element, nach dem Sie suchen möchten Weitere Informationen finden Sie im Thema zur DynamoDB-[Contains](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions)-Funktion. ## Rückgabetyp `bool` ## Beispiele ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND contains("Address", 'Kirkland') ``` # Verwenden der SIZE-Funktion mit PartiQL für Amazon DynamoDB Gibt eine Zahl zurück, die für die Größe eines Attributs in Bytes steht. Die folgenden sind gültige Datentypen, die mit Größe verwendet werden können. Weitere Informationen finden Sie in der DynamoDB-[size](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions)-Funktion. ## Syntax ``` size( path) ``` ## Argumente *path* (Erforderlich) Der Attributname oder Dokumentpfad. Weitere Informationen zu unterstützten Typen finden Sie im Thema DynamoDB-[SIZE](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions)-Funktion. ## Rückgabetyp `int` ## Beispiele ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND size("Image") >300 ``` # PartiQL-Arithmetik-, Vergleichs- und logische Operatoren für DynamoDB PartiSQL in Amazon DynamoDB unterstützt die folgenden [SQL-Standardoperatoren](https://www.w3schools.com/sql/sql_operators.asp). **Anmerkung** SQL-Operatoren, die nicht in dieser Liste enthalten sind, werden derzeit in DynamoDB nicht unterstützt. ## Arithmetische Operatoren **** | Operator | Description | | --- | --- | | \$1 | Addition | | - | Subtraktion | ## Vergleichsoperatoren **** | Operator | Description | | --- | --- | | = | gleich | | <> | nicht gleich | | \$1= | nicht gleich | | > | Größer als | | < | Kleiner als | | >= | Größer als oder gleich | | <= | Kleiner als oder gleich | ## Logische Operatoren **** | Operator | Description | | --- | --- | | AND | TRUE, wenn alle durch AND getrennten Bedingungen TRUE sind | | BETWEEN | `TRUE`, wenn der Operand innerhalb des Vergleichsbereichs liegt. Dieser Operator umfasst die Unter- und Obergrenze der Operanden, auf die Sie ihn anwenden. | | IN | `TRUE`wenn der Operand einem aus einer Liste von Ausdrücken entspricht (bei maximal 50 Hash-Attributwerten oder bei maximal 100 Nichtschlüsselattributwerten). Die Ergebnisse werden in Seiten mit bis zu 10 Elementen zurückgegeben. Wenn die `IN` Liste mehr Werte enthält, müssen Sie die in der Antwort `NextToken` zurückgegebenen Werte verwenden, um nachfolgende Seiten abzurufen. | | IS | TRUE, wenn der Operand ein bestimmter PartiQL-Datentyp ist, einschließlich NULL oder MISSING | | NOT | Kehrt den Wert eines gegebenen booleschen Ausdrucks um | | OR | TRUE, wenn eine der von OR getrennten Bedingungen TRUE ist | Weitere Informationen zu logischen Operatoren finden Sie unter [Durchführen von Vergleichen](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.Comparators) und [Logische Auswertungen](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.LogicalEvaluations). # Ausführen von Transaktionen mit PartiQL für DynamoDB In diesem Abschnitt wird die Verwendung von Transaktionen mit PartiQL für DynamoDB beschrieben. PartiQL-Transaktionen sind auf insgesamt 100 Anweisungen (Aktionen) begrenzt. Weitere Informationen zu DynamoDB-Transaktionen finden Sie unter [Verwalten komplexer Workflows mit DynamoDB-Transaktionen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html). **Anmerkung** Die gesamte Transaktion muss entweder aus Leseanweisungen oder Schreibanweisungen bestehen. Sie können nicht beides in einer Transaktion mischen. Die EXISTS-Funktion ist eine Ausnahme. Sie können es verwenden, um den Zustand bestimmter Attribute des Elements auf ähnliche Weise wie `ConditionCheck` bei der [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems)API-Operation zu überprüfen. **Topics** + [Syntax](#ql-reference.multiplestatements.transactions.syntax) + [Parameters](#ql-reference.multiplestatements.transactions.parameters) + [Rückgabewerte](#ql-reference.multiplestatements.transactions.return) + [Beispiele](#ql-reference.multiplestatements.transactions.examples) ## Syntax ``` [ { "Statement":" statement ", "Parameters":[ { " parametertype " : " parametervalue " }, ...] } , ... ] ``` ## Parameters ***statement*** (Erforderlich) Eine unterstützte PartiQL für DynamoDB-Anweisung. Die gesamte Transaktion muss entweder aus Leseanweisungen oder Schreibanweisungen bestehen. Sie können nicht beides in einer Transaktion mischen. ***parametertype*** (Optional) Ein DynamoDB-Typ, wenn Parameter bei der Angabe der PartiQL-Anweisung verwendet wurden. ***parametervalue*** (Optional) Ein Parameterwert, wenn Parameter bei der Angabe der PartiQL-Anweisung verwendet wurden. ## Rückgabewerte Diese Anweisung gibt keine Werte für Schreibvorgänge (INSERT, UPDATE oder DELETE) zurück. Sie gibt jedoch verschiedene Werte für Lesevorgänge (SELECT) basierend auf den in der WHERE-Klausel angegebenen Bedingungen zurück. **Anmerkung** Wenn eine der Singleton-Operationen INSERT, UPDATE oder DELETE einen Fehler zurückgibt, werden die Transaktionen mit einer `TransactionCanceledException`-Ausnahme abgebrochen, und der Code für den Abbruchgrund enthält die Fehler der einzelnen Singleton-Operationen. ## Beispiele Im folgenden Beispiel werden mehrere Anweisungen als Transaktion ausgeführt. ------ #### [ AWS CLI ] 1. Speichern Sie den folgenden JSON-Code in einer Datei mit dem Namen partiql.json. ``` [ { "Statement": "EXISTS(SELECT * FROM \"Music\" where Artist='No One You Know' and SongTitle='Call Me Today' and Awards is MISSING)" }, { "Statement": "INSERT INTO Music value {'Artist':?,'SongTitle':'?'}", "Parameters": [{\"S\": \"Acme Band\"}, {\"S\": \"Best Song\"}] }, { "Statement": "UPDATE \"Music\" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL Rocks'" } ] ``` 1. Führen Sie in der Eingabeaufforderung den folgenden Befehl aus. ``` aws dynamodb execute-transaction --transact-statements file://partiql.json ``` ------ #### [ Java ] ``` public class DynamoDBPartiqlTransaction { public static void main(String[] args) { // Create the DynamoDB Client with the region you want AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-2"); try { // Create ExecuteTransactionRequest ExecuteTransactionRequest executeTransactionRequest = createExecuteTransactionRequest(); ExecuteTransactionResult executeTransactionResult = dynamoDB.executeTransaction(executeTransactionRequest); System.out.println("ExecuteTransaction successful."); // Handle executeTransactionResult } catch (Exception e) { handleExecuteTransactionErrors(e); } } private static AmazonDynamoDB createDynamoDbClient(String region) { return AmazonDynamoDBClientBuilder.standard().withRegion(region).build(); } private static ExecuteTransactionRequest createExecuteTransactionRequest() { ExecuteTransactionRequest request = new ExecuteTransactionRequest(); // Create statements List statements = getPartiQLTransactionStatements(); request.setTransactStatements(statements); return request; } private static List getPartiQLTransactionStatements() { List statements = new ArrayList(); statements.add(new ParameterizedStatement() .withStatement("EXISTS(SELECT * FROM "Music" where Artist='No One You Know' and SongTitle='Call Me Today' and Awards is MISSING)")); statements.add(new ParameterizedStatement() .withStatement("INSERT INTO "Music" value {'Artist':'?','SongTitle':'?'}") .withParameters(new AttributeValue("Acme Band"),new AttributeValue("Best Song"))); statements.add(new ParameterizedStatement() .withStatement("UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL Rocks'")); return statements; } // Handles errors during ExecuteTransaction execution. Use recommendations in error messages below to add error handling specific to // your application use-case. private static void handleExecuteTransactionErrors(Exception exception) { try { throw exception; } catch (TransactionCanceledException tce) { System.out.println("Transaction Cancelled, implies a client issue, fix before retrying. Error: " + tce.getErrorMessage()); } catch (TransactionInProgressException tipe) { System.out.println("The transaction with the given request token is already in progress, consider changing " + "retry strategy for this type of error. Error: " + tipe.getErrorMessage()); } catch (IdempotentParameterMismatchException ipme) { System.out.println("Request rejected because it was retried with a different payload but with a request token that was already used, " + "change request token for this payload to be accepted. Error: " + ipme.getErrorMessage()); } catch (Exception e) { handleCommonErrors(e); } } private static void handleCommonErrors(Exception exception) { try { throw exception; } catch (InternalServerErrorException isee) { System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage()); } catch (RequestLimitExceededException rlee) { System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " + "retrying. Error: " + rlee.getErrorMessage()); } catch (ProvisionedThroughputExceededException ptee) { System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " + "Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " + ptee.getErrorMessage()); } catch (ResourceNotFoundException rnfe) { System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage()); } catch (AmazonServiceException ase) { System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " + "service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " + "configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage()); } catch (AmazonClientException ace) { System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " + "service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+ "Error: " + ace.getMessage()); } catch (Exception e) { System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage()); } } } ``` ------ Das folgende Beispiel zeigt die verschiedenen Rückgabewerte, wenn DynamoDB-Elemente mit unterschiedlichen Bedingungen liest, die in der WHERE-Klausel angegeben sind. ------ #### [ AWS CLI ] 1. Speichern Sie den folgenden JSON-Code in einer Datei mit dem Namen partiql.json. ``` [ // Item exists and projected attribute exists { "Statement": "SELECT * FROM "Music" WHERE Artist='No One You Know' and SongTitle='Call Me Today'" }, // Item exists but projected attributes do not exist { "Statement": "SELECT non_existent_projected_attribute FROM "Music" WHERE Artist='No One You Know' and SongTitle='Call Me Today'" }, // Item does not exist { "Statement": "SELECT * FROM "Music" WHERE Artist='No One I Know' and SongTitle='Call You Today'" } ] ``` 1. Folgenden Befehl in der Eingabeaufforderung eingeben. ``` aws dynamodb execute-transaction --transact-statements file://partiql.json ``` 1. Die folgende Antwort wird ausgegeben: ``` { "Responses": [ // Item exists and projected attribute exists { "Item": { "Artist":{ "S": "No One You Know" }, "SongTitle":{ "S": "Call Me Today" } } }, // Item exists but projected attributes do not exist { "Item": {} }, // Item does not exist {} ] } ``` ------ # Ausführen von Batchoperationen mit PartiQL für DynamoDB In diesem Abschnitt wird die Verwendung von Stapel-Anweisungen mit PartiQL für DynamoDB beschrieben. **Anmerkung** Der gesamte Stapel muss entweder aus Leseanweisungen oder Schreibanweisungen bestehen; Sie können nicht beides in einem Stapel mischen. `BatchExecuteStatement` und `BatchWriteItem` können nicht mehr als 25 Anweisungen pro Stapel ausführen. `BatchExecuteStatement` verwendet `BatchGetItem`, was eine Liste von Primärschlüsseln in separaten Anweisungen verarbeitet. **Topics** + [Syntax](#ql-reference.multiplestatements.batching.syntax) + [Parameters](#ql-reference.multiplestatements.batching.parameters) + [Beispiele](#ql-reference.multiplestatements.batching.examples) ## Syntax ``` [ { "Statement": "SELECT pk FROM ProblemSet WHERE pk = 'p#9StkWHYTxm7x2AqSXcrfu7' AND sk = 'info'" }, { "Statement": "SELECT pk FROM ProblemSet WHERE pk = 'p#isC2ChceGbxHgESc4szoTE' AND sk = 'info'" } ] ``` ``` [ { "Statement":" statement ", "Parameters":[ { " parametertype " : " parametervalue " }, ...] } , ... ] ``` ## Parameters ***statement*** (Erforderlich) Eine unterstützte PartiQL für DynamoDB-Anweisung. + Der gesamte Stapel muss entweder aus Leseanweisungen oder Schreibanweisungen bestehen; Sie können nicht beides in einem Stapel mischen. + `BatchExecuteStatement` und `BatchWriteItem` können nicht mehr als 25 Anweisungen pro Stapel ausführen. ***parametertype*** (Optional) Ein DynamoDB-Typ, wenn Parameter bei der Angabe der PartiQL-Anweisung verwendet wurden. ***parametervalue*** (Optional) Ein Parameterwert, wenn Parameter bei der Angabe der PartiQL-Anweisung verwendet wurden. ## Beispiele ------ #### [ AWS CLI ] 1. Speichern Sie den folgenden JSON in einer Datei namens partiql.json ``` [ { "Statement": "INSERT INTO Music VALUE {'Artist':?,'SongTitle':?}", "Parameters": [{"S": "Acme Band"}, {"S": "Best Song"}] }, { "Statement": "UPDATE Music SET AwardsWon=1, AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" } ] ``` 1. Führen Sie in der Eingabeaufforderung den folgenden Befehl aus. ``` aws dynamodb batch-execute-statement --statements file://partiql.json ``` ------ #### [ Java ] ``` public class DynamoDBPartiqlBatch { public static void main(String[] args) { // Create the DynamoDB Client with the region you want AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-2"); try { // Create BatchExecuteStatementRequest BatchExecuteStatementRequest batchExecuteStatementRequest = createBatchExecuteStatementRequest(); BatchExecuteStatementResult batchExecuteStatementResult = dynamoDB.batchExecuteStatement(batchExecuteStatementRequest); System.out.println("BatchExecuteStatement successful."); // Handle batchExecuteStatementResult } catch (Exception e) { handleBatchExecuteStatementErrors(e); } } private static AmazonDynamoDB createDynamoDbClient(String region) { return AmazonDynamoDBClientBuilder.standard().withRegion(region).build(); } private static BatchExecuteStatementRequest createBatchExecuteStatementRequest() { BatchExecuteStatementRequest request = new BatchExecuteStatementRequest(); // Create statements List statements = getPartiQLBatchStatements(); request.setStatements(statements); return request; } private static List getPartiQLBatchStatements() { List statements = new ArrayList(); statements.add(new BatchStatementRequest() .withStatement("INSERT INTO Music value {'Artist':'Acme Band','SongTitle':'PartiQL Rocks'}")); statements.add(new BatchStatementRequest() .withStatement("UPDATE Music set AwardDetail.BillBoard=[2020] where Artist='Acme Band' and SongTitle='PartiQL Rocks'")); return statements; } // Handles errors during BatchExecuteStatement execution. Use recommendations in error messages below to add error handling specific to // your application use-case. private static void handleBatchExecuteStatementErrors(Exception exception) { try { throw exception; } catch (Exception e) { // There are no API specific errors to handle for BatchExecuteStatement, common DynamoDB API errors are handled below handleCommonErrors(e); } } private static void handleCommonErrors(Exception exception) { try { throw exception; } catch (InternalServerErrorException isee) { System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage()); } catch (RequestLimitExceededException rlee) { System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " + "retrying. Error: " + rlee.getErrorMessage()); } catch (ProvisionedThroughputExceededException ptee) { System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " + "Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " + ptee.getErrorMessage()); } catch (ResourceNotFoundException rnfe) { System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage()); } catch (AmazonServiceException ase) { System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " + "service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " + "configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage()); } catch (AmazonClientException ace) { System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " + "service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+ "Error: " + ace.getMessage()); } catch (Exception e) { System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage()); } } } ``` ------ # IAM-Sicherheitsrichtlinien mit PartiQL für DynamoDB Die folgenden Berechtigungen sind erforderlich: + Um Elemente mit PartiQL für DynamoDB zu lesen, müssen Sie über die `dynamodb:PartiQLSelect`-Berechtigung für die Tabelle oder den Index verfügen. + Um Elemente mit PartiQL für DynamoDB einzufügen, müssen Sie über die `dynamodb:PartiQLInsert`-Berechtigung für die Tabelle oder den Index verfügen. + Um Elemente mit PartiQL für DynamoDB zu aktualisieren, müssen Sie über die `dynamodb:PartiQLUpdate`-Berechtigung für die Tabelle oder den Index verfügen. + Um Elemente mit PartiQL für DynamoDB zu löschen, müssen Sie über die `dynamodb:PartiQLDelete`-Berechtigung für die Tabelle oder den Index verfügen. ## Beispiel: Alle PartiQL for DynamoDB-Anweisungen (Select/Insert/Update/Delete) in einer Tabelle zulassen Mit der folgenden IAM-Richtlinie werden alle PartiQL für DynamoDB-Anweisungen in einer Tabelle erteilt. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ] } ] } ``` ------ ## Beispiel: PartiQL für DynamoDB-Auswahlanweisungen für eine Tabelle zulassen Mit der folgenden IAM-Richtlinie werden die Berechtigungen zum Ausführen der `select`-Anweisung für eine bestimmte Tabelle erteilt ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ] } ] } ``` ------ ## Beispiel: PartiQL für DynamoDB-Einfügeanweisungen für einen Index zulassen Mit der folgenden IAM-Richtlinie werden die Berechtigungen zum Ausführen des `insert`-Anweisung auf einen bestimmten Index. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music/index/index1" ] } ] } ``` ------ ## Beispiel: PartiQL für DynamoDB-Transaktionsanweisungen nur für eine Tabelle zulassen Mit der folgenden IAM-Richtlinie werden die Berechtigungen nur zum Ausführen transaktionaler Anweisungen für eine bestimmte Tabelle erteilt. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ], "Condition":{ "StringEquals":{ "dynamodb:EnclosingOperation":[ "ExecuteTransaction" ] } } } ] } ``` ------ ## Beispiel: Erlauben Sie PartiQL für nicht-transaktionale DynamoDB-Lese- und Schreibvorgänge und blockieren Sie PartiQL-transaktionale Lese- und Schreibvorgänge in einer Tabelle. Die folgende IAM-Richtlinie gewährt Berechtigungen zum Ausführen von nicht-transaktionalen Lese-/Schreibvorgängen in PartiQL für DynamoDB, während transaktionale Lese-/Schreibvorgänge in PartiQL für DynamoDB blockiert werden. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Deny", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ], "Condition":{ "StringEquals":{ "dynamodb:EnclosingOperation":[ "ExecuteTransaction" ] } } }, { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ] } ] } ``` ------ ## Beispiel: In PartiQL für DynamoDB Select-Anweisungen erlauben und vollständige Tabellenscan-Anweisungen verweigern Mit der folgenden IAM-Richtlinie werden die Berechtigungen zum Ausführen der `select`-Anweisung für eine bestimmte Tabelle beim Blockieren von `select`-Anweisungen, die zu einem vollständigen Tabellenscan führen. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Deny", "Action":[ "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/WatchList" ], "Condition":{ "Bool":{ "dynamodb:FullTableScan":[ "true" ] } } }, { "Effect":"Allow", "Action":[ "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/WatchList" ] } ] } ``` ------