Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # PartiQL: un linguaggio di query compatibile con SQL per Amazon DynamoDB Amazon DynamoDB supporta [PartiQL](https://partiql.org/), un linguaggio di query compatibile con SQL, per selezionare, inserire, aggiornare ed eliminare i dati in Amazon DynamoDB. Utilizzando PartiQL, è possibile interagire facilmente con le tabelle DynamoDB ed eseguire query ad hoc utilizzando NoSQL Workbench e Console di gestione AWS DynamoDB for PartiQL. AWS Command Line Interface APIs Le operazioni PartiQL forniscono la stessa disponibilità, latenza e prestazioni delle altre operazioni del piano dati di DynamoDB. Nelle sezioni seguenti viene descritta l'implementazione DynamoDB di PartiQL. **Topics** + [Che cos'è PartiQL?](#ql-reference.what-is) + [PartiQL in Amazon DynamoDB](#ql-reference.what-is) + [Nozioni di base](ql-gettingstarted.md) + [Tipi di dati](ql-reference.data-types.md) + [Istruzioni](ql-reference.statements.md) + [Funzioni](ql-functions.md) + [Operatori](ql-operators.md) + [Transazioni](ql-reference.multiplestatements.transactions.md) + [Operazioni batch](ql-reference.multiplestatements.batching.md) + [Policy IAM](ql-iam.md) ## Che cos'è PartiQL? *PartiQL* consente l'accesso alle query compatibile con SQL su più archivi dati contenenti dati strutturati, semistrutturati e nidificati. È ampiamente utilizzato in Amazon ed è ora disponibile come parte di molti AWS servizi, incluso DynamoDB. Per la specifica PartiQL e un tutorial sul linguaggio delle query di base, consulta la [Documentazione di PartiQL](https://partiql.org/docs.html). **Nota** Amazon DynamoDB supporta un *sottoinsieme* del linguaggio di query [PartiQL](https://partiql.org/). Amazon DynamoDB non supporta il formato dati [Amazon Ion](http://amzn.github.io/ion-docs/) o i letterali Amazon Ion. ## PartiQL in Amazon DynamoDB Per eseguire query PartiQL in DynamoDB, è possibile utilizzare: + La console DynamoDB + NoSQL Workbench + Il AWS Command Line Interface ()AWS CLI + Il DynamoDB APIs Per informazioni sull'utilizzo di questi metodi per accedere a DynamoDB, consulta [Accesso a DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AccessingDynamoDB.html). # Nozioni di base su PartiQL per DynamoDB Questa sezione descrive come utilizzare PartiQL per DynamoDB dalla console Amazon DynamoDB, the () e DynamoDB. AWS Command Line Interface AWS CLI APIs Nei seguenti esempi, la tabella DynamoDB definita nel tutorial [Nozioni di base su DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) è un prerequisito. [Per informazioni sull'utilizzo della console DynamoDB o DynamoDB per accedere a DynamoDB AWS Command Line Interface, vedere Accesso a APIs DynamoDB.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AccessingDynamoDB.html) Per [scaricare](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.settingup.html) e utilizzare [NoSQL Workbench](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.html) per creare istruzioni [PartiQL per DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), seleziona **Operazioni PartiQL** nell'angolo in alto a destra dell'[Operation builder](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.querybuilder.operationbuilder.html) di NoSQL Workbench per DynamoDB. ------ #### [ Console ] ![\[Interfaccia dell’editor PartiQL che mostra il risultato dell’esecuzione dell’operazione Query sulla tabella Musica.\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/images/partiqlgettingstarted.png) 1. Accedi Console di gestione AWS e apri la console DynamoDB all'indirizzo. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/) 1. Nel pannello di navigazione sul lato sinistro della console seleziona **Editor PartiQL**. 1. Seleziona la tabella **Music**. 1. Scegli **Esegui query sulla tabella**. Questa azione genera una query che non determinerà una scansione completa della tabella. 1. Sostituisci `partitionKeyValue` con il valore stringa `Acme Band`. Sostituisci `sortKeyValue` con il valore stringa `Happy Day`. 1. Scegli il pulsante **Esegui**. 1. È possibile visualizzare i risultati della query scegliendo i pulsanti **Vista tabella** o **Vista JSON**. ------ #### [ NoSQL workbench ] ![\[Interfaccia NoSQL Workbench. Mostra un’istruzione PartiQL SELECT che è possibile eseguire sulla tabella Musica.\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/images/workbench/partiql.single.png) 1. Scegli **Istruzione PartiQL**. 1. Specifica la seguente [istruzione SELECT (SELEZIONA)](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html) PartiQL. ``` SELECT * FROM Music WHERE Artist=? and SongTitle=? ``` 1. Per specificare un valore per i parametri `Artist` e `SongTitle`: 1. Scegli **Parametri di richiesta facoltativi**. 1. Scegli **Aggiungi nuovi parametri**. 1. Scegli il tipo di attributo **string** e il valore `Acme Band`. 1. Ripeti i passaggi b e c, quindi scegli il tipo **string** e il valore `PartiQL Rocks`. 1. Per generare codice, selezionare **Generate code (Genera codice)**. Selezionare la lingua desiderata dalle schede visualizzate. È possibile copiare questo codice e utilizzarlo nell'applicazione. 1. Per eseguire l'operazione immediatamente, seleziona **Esegui**. ------ #### [ AWS CLI ] 1. Crea un elemento nella tabella `Music` utilizzando l'istruzione INSERT (INSERISCI) PartiQL. ``` aws dynamodb execute-statement --statement "INSERT INTO Music \ VALUE \ {'Artist':'Acme Band','SongTitle':'PartiQL Rocks'}" ``` 1. Recupera un elemento dalla tabella Music utilizzando l'istruzione SELECT (SELEZIONA) PartiQL. ``` aws dynamodb execute-statement --statement "SELECT * FROM Music \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` 1. Aggiorna un elemento nella tabella `Music` utilizzando l'istruzione UPDATE (AGGIORNA) PartiQL. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardsWon=1 \ SET AwardDetail={'Grammys':[2020, 2018]} \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Aggiungi un valore di elenco per un elemento nella tabella `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Rimuovi un valore di elenco per un elemento nella tabella `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ REMOVE AwardDetail.Grammys[2] \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Aggiungi un nuovo membro della mappa per un elemento nella tabella `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardDetail.BillBoard=[2020] \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Aggiungi un nuovo attributo del set di stringhe per un elemento nella tabella `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET BandMembers =<<'member1', 'member2'>> \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Aggiungi un attributo del set di stringhe per un elemento nella tabella `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET BandMembers =set_add(BandMembers, <<'newmember'>>) \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` 1. Elimina un elemento dalla tabella `Music` utilizzando l'istruzione DELETE (ELIMINA) PartiQL. ``` 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()); } } } ``` ------ ## Utilizzo di istruzioni parametrizzate Invece di incorporare i valori direttamente in una stringa di istruzioni PartiQL, è possibile utilizzare i segnaposto con punto interrogativo `?` () e fornire i valori separatamente nel campo. `Parameters` Ciascuno `?` viene sostituito dal valore del parametro corrispondente, nell'ordine in cui vengono forniti. L'uso di istruzioni con parametri è una buona pratica perché separa la struttura delle istruzioni dai valori dei dati, semplificando la lettura e il riutilizzo delle istruzioni. Inoltre, evita la necessità di formattare manualmente ed eliminare i valori degli attributi nella stringa dell'istruzione. Le istruzioni con parametri sono supportate nelle operazioni `ExecuteStatement` e`BatchExecuteStatement`. `ExecuteTransaction` Gli esempi seguenti recuperano un elemento dalla `Music` tabella utilizzando valori parametrizzati per la chiave di partizione e la chiave di ordinamento. ------ #### [ 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'} ] ) ``` ------ **Nota** L'esempio Java nella precedente sezione introduttiva utilizza dappertutto istruzioni con parametri. Il `getPartiQLParameters()` metodo crea l'elenco dei parametri e ogni istruzione utilizza `?` segnaposto anziché valori in linea. # Tipi di dati PartiQL per DynamoDB Nella tabella seguente sono elencati i tipi di dati che è possibile utilizzare con PartiQL per DynamoDB. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/ql-reference.data-types.html) ## Esempi Nell'istruzione seguente viene illustrato come inserire i seguenti tipi di dati: `String`, `Number`, `Map`, `List`, `Number Set` e `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'>> } ``` La seguente istruzione illustra come inserire nuovi elementi nei tipi `Map`, `List`, `Number Set` e `String Set` e come modificare il valore di un tipo `Number`. ``` 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' ``` La seguente istruzione illustra come rimuovere gli elementi dai tipi `Map`, `List`, `Number Set` e `String Set` e come modificare il valore di un tipo `Number`. ``` 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' ``` Per ulteriori informazioni, consulta [Tipi di dati di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes). # Istruzioni PartiQL per DynamoDB Amazon DynamoDB supporta le seguenti istruzioni PartiQL. **Nota** DynamoDB non supporta tutte le istruzioni PartiQL. Questo riferimento fornisce esempi di sintassi di base ed esempi di utilizzo delle istruzioni PartiQL eseguite manualmente utilizzando AWS CLI o. APIs Il *linguaggio di manipolazione dei dati* (DML, Data Manipulation Language) è l'insieme di istruzioni PartiQL utilizzate per gestire i dati nelle tabelle DynamoDB. Le istruzioni DML vengono utilizzate per aggiungere, modificare o eliminare i dati in una tabella. Sono supportate le seguenti istruzioni DML e del linguaggio di query: + [Istruzioni SELECT PartiQL per DynamoDB](ql-reference.select.md) + [Istruzioni UPDATE PartiQL per DynamoDB](ql-reference.update.md) + [Istruzioni INSERT PartiQL per DynamoDB](ql-reference.insert.md) + [Istruzioni DELETE PartiQL per DynamoDB](ql-reference.delete.md) Anche [Esecuzione di transazioni con PartiQL per DynamoDB](ql-reference.multiplestatements.transactions.md) e [Esecuzione di operazioni in batch con PartiQL per DynamoDB](ql-reference.multiplestatements.batching.md) sono supportati da PartiQL per DynamoDB. # Istruzioni SELECT PartiQL per DynamoDB Utilizza l'istruzione `SELECT` per recuperare i dati da una tabella in Amazon DynamoDB. L’uso di un’istruzione `SELECT` può comportare una scansione completa della tabella se non si fornisce una condizione di uguaglianza o IN con una chiave di partizione nella clausola WHERE. L'operazione di scansione esamina ogni elemento per i valori richiesti e può utilizzare la velocità effettiva assegnata per una tabella o un indice di grandi dimensioni in un'unica operazione. Se desideri evitare la scansione completa della tabella in PartiQL, è possibile: + Crea le tue istruzioni `SELECT` per non provocare scansioni complete della tabella assicurandoti che la [condizione della clausola WHERE (DOVE)](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html#ql-reference.select.parameters) sia configurata di conseguenza. + Disabilitare le scansioni di tabelle complete utilizzando la policy IAM specificata in [Esempio: Consentire le istruzioni Select e rifiutare le istruzioni di scansione completa della tabella in PartiQL per DynamoDB](ql-iam.md#access-policy-ql-iam-example6), nella Guida per gli sviluppatori di DynamoDB. Per ulteriori informazioni, consulta la sezione [Best practice per eseguire query e scansioni di dati](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-query-scan.html) nella Guida per gli sviluppatori di DynamoDB. **Topics** + [Sintassi](#ql-reference.select.syntax) + [Parameters](#ql-reference.select.parameters) + [Esempi](#ql-reference.select.examples) ## Sintassi ``` SELECT expression [, ...] FROM table[.index] [ WHERE condition ] [ [ORDER BY key [DESC|ASC] , ...] ``` ## Parameters ***expression*** (Obbligatorio) Una proiezione formata dal carattere jolly `*` o un elenco di proiezione di uno o più nomi di attributi o percorsi di documento dal set di risultati. Un'espressione può essere costituita da chiamate a [Utilizzo delle funzioni PartiQL con DynamoDB](ql-functions.md) o da campi modificati da [Operatori PartiQL aritmetici, di confronto e logici per DynamoDB](ql-operators.md). ***table*** (Obbligatorio) Il nome della tabella per cui eseguire la query. ***index*** (Facoltativo) Il nome dell'indice su cui eseguire una query. È necessario aggiungere virgolette doppie al nome della tabella e al nome dell'indice quando si esegue una query su un indice. ``` SELECT * FROM "TableName"."IndexName" ``` ***condition*** (Facoltativo) I criteri di selezione per la query. Per garantire che una istruzione `SELECT` non comporti una scansione completa della tabella, la condizione della clausola `WHERE` deve specificare una chiave di partizione. Utilizza l'operatore di uguaglianza o IN. Ad esempio, in presenza di una tabella `Orders` con una chiave di partizione `OrderID` e altri attributi non chiave, tra cui `Address`, le istruzioni seguenti non comportano una scansione completa della tabella: ``` 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] ``` Le seguenti istruzioni `SELECT`, tuttavia, provocheranno una scansione completa della tabella: ``` SELECT * FROM "Orders" WHERE OrderID > 1 SELECT * FROM "Orders" WHERE Address='some address' SELECT * FROM "Orders" WHERE OrderID = 100 OR Address='some address' ``` ***key*** (Facoltativo) Una chiave hash o una chiave di ordinamento da utilizzare per ordinare i risultati restituiti. L'ordine di default è crescente (`ASC`); specifica `DESC` se desideri che i risultati vengano rigenerati in ordine decrescente. **Nota** Se si omette la clausola `WHERE`, saranno recuperati tutti gli elementi della tabella. ## Esempi La seguente query restituisce un elemento, se esistente, dalla tabella `Orders` specificando la chiave di partizione, `OrderID`, e utilizzando l'operatore di uguaglianza. ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID = 1 ``` La seguente query restituisce tutti gli elementi nella tabella `Orders` che hanno una chiave di partizione specifica, `OrderID`, i valori che utilizzano l'operatore OR. ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID = 1 OR OrderID = 2 ``` La seguente query restituisce tutti gli elementi nella tabella `Orders` che hanno una chiave di partizione specifica, `OrderID`, i valori che utilizzano l'operatore IN. I risultati restituiti sono in ordine decrescente, in base al valore dell'attributo della chiave `OrderID`. ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID IN [1, 2, 3] ORDER BY OrderID DESC ``` La seguente query mostra una scansione completa della tabella che restituisce tutti gli elementi dalla tabella `Orders` che hanno un `Total` maggiore di 500, dove `Total` è un attributo non chiave. ``` SELECT OrderID, Total FROM "Orders" WHERE Total > 500 ``` La seguente query mostra una scansione completa della tabella che restituisce tutti gli elementi dalla tabella `Orders` in un intervallo di ordinamento `Total` specifico, utilizzando l'operatore IN e un attributo non chiave `Total`. ``` SELECT OrderID, Total FROM "Orders" WHERE Total IN [500, 600] ``` La seguente query mostra una scansione completa della tabella che restituisce tutti gli elementi dalla tabella `Orders` in un intervallo di ordinamento `Total` specifico, utilizzando l'operatore BETWEEN e un attributo non chiave `Total`. ``` SELECT OrderID, Total FROM "Orders" WHERE Total BETWEEN 500 AND 600 ``` La seguente query restituisce la prima data in cui è stato utilizzato un dispositivo firestick specificando la chiave di partizione `CustomerID` e la chiave di ordinamento `MovieID` nella condizione clausola WHERE (DOVE) e utilizzando percorsi documento nella clausola SELECT (SELEZIONA). ``` SELECT Devices.FireStick.DateWatched[0] FROM WatchList WHERE CustomerID= 'C1' AND MovieID= 'M1' ``` La seguente query mostra una scansione completa della tabella che restituisce l'elenco degli elementi in cui un dispositivo firestick è stato utilizzato per la prima volta dopo il 12/12/19 utilizzando percorsi di documento nella condizione della clausola WHERE (DOVE). ``` SELECT Devices FROM WatchList WHERE Devices.FireStick.DateWatched[0] >= '12/24/19' ``` # Istruzioni UPDATE PartiQL per DynamoDB Utilizza l'istruzione `UPDATE` per modificare il valore di uno o più attributi all'interno di un elemento in una tabella Amazon DynamoDB. **Nota** È possibile aggiornare solo un elemento alla volta; non è possibile emettere una singola istruzione PartiQL DynamoDB che aggiorna più elementi. Per informazioni sull'aggiornamento di più elementi, consulta [Esecuzione di transazioni con PartiQL per DynamoDB](ql-reference.multiplestatements.transactions.md) o [Esecuzione di operazioni in batch con PartiQL per DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Sintassi](#ql-reference.update.syntax) + [Parameters](#ql-reference.update.parameters) + [Valore restituito](#ql-reference.update.return) + [Esempi](#ql-reference.update.examples) ## Sintassi ``` UPDATE table [SET | REMOVE] path [= data] […] WHERE condition [RETURNING returnvalues] ::= [ALL OLD | MODIFIED OLD | ALL NEW | MODIFIED NEW] * ``` ## Parameters ***table*** (Obbligatorio) La tabella contenente i dati da modificare. ***path*** (Obbligatorio) Un nome attributo o un percorso di documento da creare o modificare. ***data*** (Obbligatorio) Un valore di attributo o il risultato di un'operazione. Le operazioni supportate da utilizzare con SET sono: + LIST\$1APPEND: aggiunge un valore a un tipo di elenco. + SET\$1ADD: aggiunge un valore a un numero o un set di stringhe. + SET\$1DELETE: rimuove un valore da un numero o un set di stringhe. ***condition*** (Obbligatorio) I criteri di selezione per l'elemento da modificare. Questa condizione deve essere risolta in un singolo valore di chiave primaria. ***returnvalues*** (Facoltativo) Utilizza `returnvalues` se desideri ottenere gli attributi dell'elemento come appaiono prima o dopo l'aggiornamento. I valori validi sono: + `ALL OLD *`: restituisce tutti gli attributi dell'elemento come apparivano prima dell'operazione di aggiornamento. + `MODIFIED OLD *`: restituisce solo gli attributi aggiornati come apparivano prima dell'operazione di aggiornamento. + `ALL NEW *`: restituisce tutti gli attributi dell'elemento come appaiono dopo l'operazione di aggiornamento. + `MODIFIED NEW *`: restituisce solo gli attributi aggiornati come appaiono dopo l'operazione `UpdateItem`. ## Valore restituito Questa istruzione non restituisce un valore a meno che non sia stato specificato il parametro `returnvalues`. **Nota** Se la clausola WHERE (DOVE) dell'istruzione UPDATE (AGGIORNA) non restituisce true per alcun elemento nella tabella DynamoDB, viene restituito `ConditionalCheckFailedException`. ## Esempi Aggiorna un valore dell'attributo in un elemento esistente. Se l'attributo non esiste, ne verrà creato uno. La seguente query aggiorna un elemento nella tabella `"Music"` aggiungendo un attributo di tipo number (`AwardsWon`) e un attributo di tipo map (`AwardDetail`). ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` È possibile aggiungere `RETURNING ALL OLD *` per riportare gli attributi così come apparivano prima dell'operazione `Update`. ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' RETURNING ALL OLD * ``` Restituisce quanto segue: ``` { "Items": [ { "Artist": { "S": "Acme Band" }, "SongTitle": { "S": "PartiQL Rocks" } } ] } ``` È possibile aggiungere `RETURNING ALL NEW *` per riportare gli attributi così come apparivano dopo l'operazione `Update`. ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' RETURNING ALL NEW * ``` Restituisce quanto segue: ``` { "Items": [ { "AwardDetail": { "M": { "Grammys": { "L": [ { "N": "2020" }, { "N": "2018" } ] } } }, "AwardsWon": { "N": "1" } } ] } ``` La seguente query aggiorna un elemento nella tabella `"Music"` aggiungendolo a un elenco `AwardDetail.Grammys`. ``` UPDATE "Music" SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` La seguente query aggiorna un elemento nella tabella `"Music"` rimuovendolo da un elenco `AwardDetail.Grammys`. ``` UPDATE "Music" REMOVE AwardDetail.Grammys[2] WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` La seguente query aggiorna un elemento nella tabella `"Music"` aggiungendo `BillBoard` alla mappa `AwardDetail`. ``` UPDATE "Music" SET AwardDetail.BillBoard=[2020] WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` La seguente query aggiorna un elemento nella tabella `"Music"` aggiungendo l'attributo del set di stringhe `BandMembers`. ``` UPDATE "Music" SET BandMembers =<<'member1', 'member2'>> WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` La seguente query aggiorna un elemento nella tabella `"Music"` aggiungendo `newbandmember` al set di stringhe `BandMembers`. ``` UPDATE "Music" SET BandMembers =set_add(BandMembers, <<'newbandmember'>>) WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` # Istruzioni DELETE PartiQL per DynamoDB Utilizza l'istruzione `DELETE` per eliminare un elemento esistente dalla tabella Amazon DynamoDB. **Nota** È possibile eliminare un solo elemento alla volta. Non è possibile emettere una singola istruzione DynamoDB PartiQL che elimina più elementi. Per informazioni sull'aggiornamento di più elementi, consulta [Esecuzione di transazioni con PartiQL per DynamoDB](ql-reference.multiplestatements.transactions.md) o [Esecuzione di operazioni in batch con PartiQL per DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Sintassi](#ql-reference.delete.syntax) + [Parameters](#ql-reference.delete.parameters) + [Valore restituito](#ql-reference.delete.return) + [Esempi](#ql-reference.delete.examples) ## Sintassi ``` DELETE FROM table WHERE condition [RETURNING returnvalues] ::= ALL OLD * ``` ## Parameters ***table*** (Obbligatorio) La tabella DynamoDB contenente l'elemento da eliminare. ***condition*** (Obbligatorio) I criteri di selezione per l'elemento da eliminare. Questa condizione deve essere risolta in un singolo valore di chiave primaria. ***returnvalues*** (Facoltativo) Utilizza `returnvalues` se desideri ottenere gli attributi dell'elemento come apparivano prima dell'eliminazione. I valori validi sono: + `ALL OLD *`: viene restituito il contenuto del vecchio elemento. ## Valore restituito Questa istruzione non restituisce un valore a meno che non sia stato specificato il parametro `returnvalues`. **Nota** Se la tabella DynamoDB non dispone di alcun elemento con la stessa chiave primaria di quella dell'elemento per il quale viene emessa l'istruzione DELETE (ELIMINA), viene restituito SUCCESS (ESITO POSITIVO) con 0 elementi eliminati. Se la tabella ha un elemento con la stessa chiave primaria, ma la condizione nella clausola WHERE (DOVE) dell'istruzione DELETE (ELIMINA) restituisce valore false, viene restituito il parametro `ConditionalCheckFailedException`. ## Esempi La query seguente elimina un elemento nella tabella `"Music"`. ``` DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks' ``` È possibile aggiungere il parametro `RETURNING ALL OLD *` per restituire i dati che sono stati eliminati. ``` DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks' RETURNING ALL OLD * ``` L'istruzione `Delete` ora restituisce quanto segue: ``` { "Items": [ { "Artist": { "S": "Acme Band" }, "SongTitle": { "S": "PartiQL Rocks" } } ] } ``` # Istruzioni INSERT PartiQL per DynamoDB Utilizza l'istruzione `INSERT` per aggiungere un elemento a una tabella in Amazon DynamoDB. **Nota** È possibile inserire un solo elemento alla volta; non è possibile emettere una singola istruzione PartiQL DynamoDB che inserisce più elementi. Per informazioni sull'inserimento di più elementi, consulta [Esecuzione di transazioni con PartiQL per DynamoDB](ql-reference.multiplestatements.transactions.md) o [Esecuzione di operazioni in batch con PartiQL per DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Sintassi](#ql-reference.insert.syntax) + [Parameters](#ql-reference.insert.parameters) + [Valore restituito](#ql-reference.insert.return) + [Esempi](#ql-reference.insert.examples) ## Sintassi Inserisci un singolo elemento. ``` INSERT INTO table VALUE item ``` ## Parameters ***table*** (Obbligatorio) La tabella in cui si desidera inserire i dati. La tabella deve già essere presente. ***item*** (Obbligatorio) Un elemento DynamoDB valido rappresentato come [tupla PartiQL](https://partiql.org/docs.html). È necessario specificare solo *un* elemento e tenere presente che ciascun nome di attributo nell'elemento fa distinzione tra maiuscole e minuscole e può essere riportato con virgolette *singole* (`'...'`) in PartiQL. Anche i valori stringa sono riportati con virgolette *singole* (`'...'`) in PartiQL. ## Valore restituito Questa istruzione non restituisce alcun valore. **Nota** Se nella tabella DynamoDB è già presente un elemento con la stessa chiave primaria della chiave primaria dell'elemento da inserire, viene restituito `DuplicateItemException`. ## Esempi ``` INSERT INTO "Music" value {'Artist' : 'Acme Band','SongTitle' : 'PartiQL Rocks'} ``` # Utilizzo delle funzioni PartiQL con DynamoDB PartiQL in Amazon DynamoDB supporta le seguenti varianti incorporate di funzioni standard SQL. **Nota** Tutte le funzioni SQL non incluse in questo elenco non sono attualmente supportate in DynamoDB. ## Funzioni di aggregazione + [Utilizzo della funzione SIZE con PartiQL per Amazon DynamoDB](ql-functions.size.md) ## Funzioni condizionali + [Utilizzo della funzione EXISTS con PartiQL per DynamoDB](ql-functions.exists.md) + [Utilizzo della funzione ATTRIBUTE\$1TYPE con PartiQL per DynamoDB](ql-functions.attribute_type.md) + [Utilizzo della funzione BEGINS\$1WITH con PartiQL per DynamoDB](ql-functions.beginswith.md) + [Utilizzo della funzione CONTAINS con PartiQL per DynamoDB](ql-functions.contains.md) + [Utilizzo della funzione MISSING con PartiQL per DynamoDB](ql-functions.missing.md) # Utilizzo della funzione EXISTS con PartiQL per DynamoDB È possibile utilizzare EXISTS (ESISTE) per eseguire la stessa funzione che `ConditionCheck` esegue nell'API [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems). La funzione EXISTS (ESISTE) può essere utilizzata solo nelle transazioni. Dato un valore, restituisce `TRUE` se il valore è una raccolta non vuota. In caso contrario, restituisce `FALSE`. **Nota** Questa funzione può essere utilizzata solo nelle operazioni transazionali. ## Sintassi ``` EXISTS ( statement ) ``` ## Argomenti *Istruzione* (Obbligatorio) L'istruzione SELECT (SELEZIONA) valutata dalla funzione. L'istruzione SELECT (SELEZIONA) deve specificare una chiave primaria completa e un'altra condizione. ## Tipo restituito `bool` ## Esempi ``` EXISTS( SELECT * FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks') ``` # Utilizzo della funzione BEGINS\$1WITH con PartiQL per DynamoDB Restituisce `TRUE` se l'attributo specificato inizia con una particolare sottostringa. ## Sintassi ``` begins_with(path, value ) ``` ## Argomenti *path* (Obbligatorio) Il nome attributo o il percorso del documento da utilizzare. *value* (Obbligatorio) La stringa da cercare. ## Tipo restituito `bool` ## Esempi ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND begins_with("Address", '7834 24th') ``` # Utilizzo della funzione MISSING con PartiQL per DynamoDB Restituisce `TRUE` se l'elemento non contiene l'attributo specificato. Con questa funzione possono essere utilizzati solo gli operatori di uguaglianza e disuguaglianza. ## Sintassi ``` attributename IS | IS NOT MISSING ``` ## Argomenti *attributename* (Obbligatorio) Il nome dell'attributo da utilizzare. ## Tipo restituito `bool` ## Esempi ``` SELECT * FROM Music WHERE "Awards" is MISSING ``` # Utilizzo della funzione ATTRIBUTE\$1TYPE con PartiQL per DynamoDB Restituisce `TRUE` se l'attributo del percorso specificato è di un particolare tipo di dati. ## Sintassi ``` attribute_type( attributename, type ) ``` ## Argomenti *attributename* (Obbligatorio) Il nome dell'attributo da utilizzare. *tipo* (Obbligatorio) Il tipo di attributo da controllare. Per visualizzare un elenco di valori validi, consulta [attribute\$1type](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) di DynamoDB. ## Tipo restituito `bool` ## Esempi ``` SELECT * FROM "Music" WHERE attribute_type("Artist", 'S') ``` # Utilizzo della funzione CONTAINS con PartiQL per DynamoDB Restituisce `TRUE` se l'attributo specificato dal percorso è uno dei seguenti: + Una stringa che contiene una particolare sottostringa. + Un set che contiene un particolare determinato elemento. Per ulteriori informazioni, consulta la funzione [contains](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) di DynamoDB. ## Sintassi ``` contains( path, substring ) ``` ## Argomenti *path* (Obbligatorio) Il nome attributo o il percorso del documento da utilizzare. *sottostringa* (Obbligatorio) La sottostringa dell'attributo o il membro del set da controllare. Per ulteriori informazioni, consulta la funzione [contains](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) di DynamoDB. ## Tipo restituito `bool` ## Esempi ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND contains("Address", 'Kirkland') ``` # Utilizzo della funzione SIZE con PartiQL per Amazon DynamoDB Restituisce un numero che rappresenta le dimensioni di un attributo (in byte). I seguenti sono tipi di dati validi per l'utilizzo con size. Per ulteriori informazioni, consulta la funzione [size](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) di DynamoDB. ## Sintassi ``` size( path) ``` ## Argomenti *path* (Obbligatorio) Il nome attributo o il percorso del documento. Per i tipi supportati, consulta la funzione [size](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) di DynamoDB. ## Tipo restituito `int` ## Esempi ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND size("Image") >300 ``` # Operatori PartiQL aritmetici, di confronto e logici per DynamoDB PartiQL in Amazon DynamoDB supporta i seguenti [operatori SQL standard](https://www.w3schools.com/sql/sql_operators.asp). **Nota** Tutti gli operatori SQL che non sono inclusi in questo elenco non sono attualmente supportati in DynamoDB. ## Operatori aritmetici **** | Operatore | Description | | --- | --- | | \$1 | Add (Aggiungi) | | - | Subtract | ## Operatori di confronto **** | Operatore | Description | | --- | --- | | = | Equal to | | <> | Not Equal to | | \$1= | Not Equal to | | > | Greater than | | < | Less than | | >= | Greater than or equal to | | <= | Less than or equal to | ## Operatori logici **** | Operatore | Description | | --- | --- | | AND | TRUE se tutte le condizioni separate da AND sono TRUE | | BETWEEN | `TRUE` se l’operando è all’interno dell’intervallo di confronti. Questo operatore include il limite inferiore e superiore degli operandi su cui viene applicato. | | IN | `TRUE`se l'operando è uguale a uno di un elenco di espressioni (con un massimo di 50 valori di attributi hash o un massimo di 100 valori di attributi non chiave). I risultati vengono restituiti in pagine contenenti un massimo di 10 elementi. Se l'`IN`elenco contiene più valori, è necessario utilizzare quello `NextToken` restituito nella risposta per recuperare le pagine successive. | | IS | TRUE se l'operando è un dato tipo di dati PartiQL, inclusoNULL o MISSING | | NOT | Inverte il valore di una determinata espressione booleana | | OR | TRUE se una delle condizioni separate da OR è TRUE | Per ulteriori informazioni sull’utilizzo degli operatori logici, consulta [Realizzazione di confronti](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.Comparators) e [Valutazioni logiche](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.LogicalEvaluations). # Esecuzione di transazioni con PartiQL per DynamoDB In questa sezione viene descritto come utilizzare le transazioni con PartiQL per DynamoDB. Le transazioni PartiQL sono limitate a 100 istruzioni totali (operazioni). Per ulteriori informazioni sulle transazioni DynamoDB, consulta [Gestione di flussi di lavoro complessi con transazioni DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html). **Nota** L'intera transazione deve essere costituita da istruzioni di lettura o di scrittura. Non puoi combinare entrambe in un'unica transazione. La funzione EXISTS è un'eccezione. È possibile utilizzarlo per verificare la condizione degli attributi specifici dell'elemento in modo simile al funzionamento `ConditionCheck` dell'[TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems)API. **Topics** + [Sintassi](#ql-reference.multiplestatements.transactions.syntax) + [Parameters](#ql-reference.multiplestatements.transactions.parameters) + [Valori restituiti](#ql-reference.multiplestatements.transactions.return) + [Esempi](#ql-reference.multiplestatements.transactions.examples) ## Sintassi ``` [ { "Statement":" statement ", "Parameters":[ { " parametertype " : " parametervalue " }, ...] } , ... ] ``` ## Parameters ***statement*** (Obbligatorio) Un'istruzione supportata PartiQL per DynamoDB. L'intera transazione deve essere costituita da istruzioni di lettura o di scrittura. Non puoi combinare entrambe in un'unica transazione. ***parametertype*** (Facoltativo) Un tipo DynamoDB, se durante la specifica dell'istruzione PartiQL sono stati utilizzati dei parametri. ***parametervalue*** (Facoltativo) Il valore di un parametro se durante la specifica dell'istruzione PartiQL sono stati utilizzati dei parametri. ## Valori restituiti Questa istruzione non restituisce alcun valore per le operazioni di scrittura (INSERT, UPDATE o DELETE). Tuttavia, restituisce valori diversi per le operazioni di lettura (SELECT) in base alle condizioni specificate nella clausola WHERE. **Nota** Se una qualsiasi delle singole operazioni INSERT, UPDATE o DELETE restituisce un errore, le transazioni verranno annullate con l'eccezione `TransactionCanceledException` e il codice motivo dell'annullamento includerà gli errori delle singole operazioni. ## Esempi L'esempio seguente esegue più istruzioni come transazione. ------ #### [ AWS CLI ] 1. Salva il codice JSON seguente in un file chiamato 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. Esegui il comando seguente al prompt dei comandi. ``` 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()); } } } ``` ------ L'esempio seguente mostra i diversi valori restituiti quando DynamoDB legge elementi con condizioni diverse specificate nella clausola WHERE. ------ #### [ AWS CLI ] 1. Salva il codice JSON seguente in un file chiamato 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. Esegui il comando seguente in un prompt dei comandi. ``` aws dynamodb execute-transaction --transact-statements file://partiql.json ``` 1. Viene restituita la risposta seguente: ``` { "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 {} ] } ``` ------ # Esecuzione di operazioni in batch con PartiQL per DynamoDB In questa sezione viene descritto come utilizzare le istruzioni in batch con PartiQL per DynamoDB. **Nota** L'intera transazione deve essere costituita da istruzioni di lettura o di scrittura; non è possibile combinare entrambe le istruzioni in un batch. `BatchExecuteStatement` e `BatchWriteItem` possono eseguire al massimo 25 istruzioni per batch. `BatchExecuteStatement` utilizza `BatchGetItem`, che richiede un elenco di chiavi primarie in istruzioni separate. **Topics** + [Sintassi](#ql-reference.multiplestatements.batching.syntax) + [Parameters](#ql-reference.multiplestatements.batching.parameters) + [Esempi](#ql-reference.multiplestatements.batching.examples) ## Sintassi ``` [ { "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*** (Obbligatorio) Un'istruzione supportata PartiQL per DynamoDB. + L'intera transazione deve essere costituita da istruzioni di lettura o di scrittura; non è possibile combinare entrambe le istruzioni in un batch. + `BatchExecuteStatement` e `BatchWriteItem` possono eseguire al massimo 25 istruzioni per batch. ***parametertype*** (Facoltativo) Un tipo DynamoDB, se durante la specifica dell'istruzione PartiQL sono stati utilizzati dei parametri. ***parametervalue*** (Facoltativo) Il valore di un parametro se durante la specifica dell'istruzione PartiQL sono stati utilizzati dei parametri. ## Esempi ------ #### [ AWS CLI ] 1. Salvataggio del JSON seguente in un file chiamato 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. Esegui il comando seguente al prompt dei comandi. ``` 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()); } } } ``` ------ # Policy di sicurezza IAM con PartiQL per DynamoDB Sono richieste le seguenti autorizzazioni: + Per leggere gli elementi utilizzando PartiQL per DynamoDB, è necessario disporre dell'autorizzazione `dynamodb:PartiQLSelect` sulla tabella o sull'indice. + Per inserire gli elementi utilizzando PartiQL per DynamoDB, è necessario disporre dell'autorizzazione `dynamodb:PartiQLInsert` sulla tabella o sull'indice. + Per aggiornare gli elementi utilizzando PartiQL per DynamoDB, è necessario disporre dell'autorizzazione `dynamodb:PartiQLUpdate` sulla tabella o sull'indice. + Per inserire gli elementi utilizzando PartiQL per DynamoDB, è necessario disporre dell'autorizzazione `dynamodb:PartiQLDelete` sulla tabella o sull'indice. ## Esempio: consentire tutte le istruzioni PartiQL for DynamoDB () su una tabella Select/Insert/Update/Delete La seguente policy IAM concede le autorizzazioni per eseguire tutte le istruzioni PartiQL per DynamoDB su una tabella specifica. ------ #### [ 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" ] } ] } ``` ------ ## Esempio: Consentire le istruzioni SELECT (SELEZIONA) PartiQL per DynamoDB su una tabella La seguente policy IAM concede le autorizzazioni per eseguire l'istruzione `select` su una tabella specifica. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ] } ] } ``` ------ ## Esempio: Consentire le istruzioni INSERT PartiQL per DynamoDB su un indice La seguente policy IAM concede le autorizzazioni per eseguire l'istruzione `insert` su un indice specifico. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music/index/index1" ] } ] } ``` ------ ## Esempio: Consentire le istruzioni transazionali PartiQL per DynamoDB solo su una tabella La seguente policy IAM concede le autorizzazioni per eseguire le istruzioni transazionali su una tabella specifica. ------ #### [ 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" ] } } } ] } ``` ------ ## Esempio: Consentire letture e scritture non transazionali di PartiQL per DynamoDB e bloccare le istruzioni transazionali di letture e scritture transazionali di PartiQL su una tabella. La seguente policy IAM concede le autorizzazioni per eseguire letture e le scritture non transazionali PartiQL per DynamoDB bloccando le letture e le scritture transazionali PartiQL per DynamoDB. ------ #### [ 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" ] } ] } ``` ------ ## Esempio: Consentire le istruzioni Select e rifiutare le istruzioni di scansione completa della tabella in PartiQL per DynamoDB La seguente policy IAM concede le autorizzazioni per eseguire l'istruzione `select` su una tabella specifica durante il blocco delle istruzioni `select` che determinano una scansione completa della tabella. ------ #### [ 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" ] } ] } ``` ------