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à.
# Come passare da SQL a NoSQL
Se sei uno sviluppatore di applicazioni, potresti avere una certa esperienza nell'uso dei sistemi di gestione di database relazionali (RDBMS) e Structured Query Language (SQL). Quando si inizia a lavorare con Amazon DynamoDB, è possibile che siano riscontrate molte somiglianze, ma anche molte cose diverse. *NoSQL* è un termine usato per descrivere i sistemi di database non relazionali altamente disponibili, scalabili e ottimizzati per prestazioni elevate. Anziché il modello relazionale, i database NoSQL (ad esempio DynamoDB) utilizzano modelli alternativi per la gestione dei dati, ad esempio, coppie chiave-valore o archiviazione di documenti. Per ulteriori informazioni, consulta [Che cos'è NoSQL?](https://aws.amazon.com/nosql).
Amazon DynamoDB supporta [PartiQL](https://partiql.org/), un linguaggio di query open source compatibile con SQL che semplifica la query dei dati in modo efficiente, indipendentemente da dove o in quale formato sono memorizzati. Con PartiQL, è possibile elaborare facilmente dati strutturati da database relazionali, dati semi-strutturati e nidificati in formati open data e persino dati senza schema in database NoSQL o documenti che consentono attributi diversi per righe diverse. Per ulteriori informazioni, consulta [Linguaggio di query PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html).
Le seguenti sezioni descrivono le attività comuni dei database, confrontando le istruzioni SQL con le equivalenti operazioni DynamoDB.
**Nota**
Gli esempi SQL in questa sezione sono compatibili con MySQL RDBMS.
Gli esempi DynamoDB in questa sezione mostrano il nome dell'operazione DynamoDB insieme ai parametri per l'operazione in formato JSON.
**Topics**
+ [
# Scelta tra relazionale (SQL) e NoSQL
](SQLtoNoSQL.WhyDynamoDB.md)
+ [
# Differenze nell’accesso a un database relazionale (SQL) e a DynamoDB
](SQLtoNoSQL.Accessing.md)
+ [
# Differenze tra un database relazionale (SQL) e DynamoDB durante la creazione di una tabella
](SQLtoNoSQL.CreateTable.md)
+ [
# Differenze tra l’ottenimento di informazioni sulle tabelle da un database relazionale (SQL) e DynamoDB
](SQLtoNoSQL.GetTableInfo.md)
+ [
# Differenze tra un database relazionale (SQL) e DynamoDB durante la scrittura di dati in una tabella
](SQLtoNoSQL.WriteData.md)
+ [
# Differenze tra un database relazionale (SQL) e DynamoDB durante la lettura di dati in una tabella
](SQLtoNoSQL.ReadData.md)
+ [
# Differenze tra un database relazionale (SQL) e DynamoDB nella gestione degli indici
](SQLtoNoSQL.Indexes.md)
+ [
# Differenze tra un database relazionale (SQL) e DynamoDB durante la modifica di dati in una tabella
](SQLtoNoSQL.UpdateData.md)
+ [
# Differenze tra un database relazionale (SQL) e DynamoDB durante l’eliminazione di dati da una tabella
](SQLtoNoSQL.DeleteData.md)
+ [
# Differenze tra un database relazionale (SQL) e DynamoDB durante la rimozione di una tabella
](SQLtoNoSQL.RemoveTable.md)
# Scelta tra relazionale (SQL) e NoSQL
Le applicazioni di oggi hanno requisiti più impegnativi che mai. Ad esempio, un gioco online potrebbe iniziare con pochi utenti e una piccola quantità di dati. Tuttavia, se il gioco ha successo, può facilmente superare le risorse del sistema di gestione del database sottostante. Non è raro che le applicazioni Web abbiano centinaia, migliaia o milioni di utenti simultanei, con terabyte di nuovi dati generati al giorno. I database per tali applicazioni devono gestire decine (o centinaia) di migliaia di letture e scritture al secondo.
Amazon DynamoDB è adatto per questi tipi di carichi di lavoro. Gli sviluppatori possono iniziare con una piccola quantità e aumentare gradualmente l'utilizzo man mano che l'applicazione diventa più popolare. DynamoDB si adatta perfettamente per gestire quantità di dati molto grandi e un numero molto elevato di utenti.
Per ulteriori informazioni sulla modellazione di database relazionali tradizionali e su come adattarla per DynamoDB, consulta [Best practice per la modellazione dei dati relazionali in DynamoDB](bp-relational-modeling.md).
La seguente tabella mostra alcune differenze dettagliate tra un sistema di gestione di database relazionali (RDBMS) e DynamoDB.
****
| Caratteristica | Sistema di gestione di database relazionali (RDBMS) | Amazon DynamoDB |
| --- | --- | --- |
| Carichi di lavoro ottimali | Query ad hoc, data warehousing, OLAP (Online Analytical Processing). | Applicazioni Web-scale, inclusi i social network, i giochi, la condivisione di file multimediali e IoT (Internet of Things). |
| Modello di dati | Il modello relazionale richiede uno schema ben definito, in cui i dati vengono normalizzati in tabelle, righe e colonne. Inoltre, tutte le relazioni sono definite tra tabelle, colonne, indici e altri elementi del database. | DynamoDB è privo di schema. Ogni tabella deve avere una chiave primaria per identificare in modo univoco ciascun item di dati, ma non esistono vincoli simili su altri attributi non di chiave. può gestire dati strutturati o semi strutturati, inclusi i documenti JSON. DynamoDB può gestire dati strutturati o semistrutturati, inclusi documenti JSON. |
| Accesso ai dati | SQL è lo standard per memorizzare e recuperare i dati. I database relazionali offrono un ampio set di strumenti per semplificare lo sviluppo di applicazioni basate su database, ma tutti questi strumenti utilizzano SQL. | È possibile utilizzare il Console di gestione AWS AWS CLI, the o WorkBench NoSQL per lavorare con DynamoDB ed eseguire attività ad hoc. [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un linguaggio di query compatibile con SQL, consente di selezionare, inserire, aggiornare ed eliminare i dati in DynamoDB. Le applicazioni possono utilizzare i kit di sviluppo AWS software (SDKs) per lavorare con DynamoDB utilizzando interfacce basate su oggetti, incentrate sui documenti o di basso livello. |
| Prestazioni | I database relazionali sono ottimizzati per lo storage, quindi le prestazioni generalmente dipendono dal sottosistema del disco. Gli sviluppatori e gli amministratori di database devono ottimizzare le query, gli indici e le strutture delle tabelle per ottenere prestazioni ottimali. | DynamoDB è ottimizzato per il calcolo, quindi le prestazioni sono principalmente una funzione dell'hardware sottostante e della latenza di rete. Come servizio gestito, DynamoDB isola l'utente e le sue applicazioni da questi dettagli di implementazione, in modo da potersi concentrare sulla progettazione e sulla realizzazione di applicazioni solide e con prestazioni elevate. |
| Dimensionamento | È più facile applicare il dimensionamento con hardware più veloce. È anche possibile che le tabelle del database si estendano su più host in un sistema distribuito, ma ciò richiede ulteriori investimenti. I database relazionali hanno dimensioni massime per il numero e la dimensione dei file che impongono limiti superiori alla scalabilità. | DynamoDB è progettato per aumentare orizzontalmente usando cluster distribuiti di hardware. Questo progetto consente un maggiore throughput senza una maggiore latenza. I clienti specificano i requisiti di velocità effettiva e DynamoDB assegna risorse sufficienti per soddisfare tali requisiti. Non ci sono limiti superiori per il numero di item per tabella, né per la dimensione totale della tabella. |
# Differenze nell’accesso a un database relazionale (SQL) e a DynamoDB
Per consentire all'applicazione di accedere a un database, deve essere *autenticata* per assicurarsi che possa utilizzare il database. Deve essere *autorizzata* in modo da poter eseguire solo le operazioni per le quali dispone di autorizzazioni.
Il diagramma seguente mostra l'interazione del client con un database relazionale e con Amazon DynamoDB.
![\[Interazione con database relazionali e NoSQL\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/images/SQLtoNoSQL.png)
La seguente tabella contiene ulteriori dettagli sulle attività di interazione del client:
****
| Caratteristica | Sistema di gestione di database relazionali (RDBMS) | Amazon DynamoDB |
| --- | --- | --- |
| Strumento per l'accesso al database | La maggior parte dei database relazionali fornisce un'interfaccia a riga di comando (CLI) per permetterti di immettere istruzioni SQL ad hoc e vedere immediatamente i risultati. | Nella maggior parte dei casi, scrivi il codice dell'applicazione. Puoi anche utilizzare Console di gestione AWS, the AWS Command Line Interface (AWS CLI) o NoSQL Workbench per inviare richieste ad hoc a DynamoDB e visualizzare i risultati. [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un linguaggio di query compatibile con SQL, consente di selezionare, inserire, aggiornare ed eliminare i dati in DynamoDB. |
| Connessione al database | Un programma applicativo stabilisce e mantiene una connessione di rete con il database. Al termine dell'applicazione, termina anche la connessione. | DynamoDB è un servizio Web che offre interazioni stateless. Le applicazioni non hanno bisogno di mantenere connessioni di rete persistenti. L'interazione con DynamoDB invece si verifica utilizzando richieste e risposte HTTP(S). |
| Autenticazione | Un'applicazione non può connettersi al database finché non viene autenticata. RDBMS può eseguire l'autenticazione autonomamente oppure eseguire l'offload di questa attività sul sistema operativo host o su un servizio di directory. | Ogni richiesta a DynamoDB deve essere accompagnata da una firma crittografica che autentica la specifica richiesta. AWS SDKsForniscono tutta la logica necessaria per creare firme e richieste di firma. Per ulteriori informazioni, consulta [Firmare le richieste AWS API](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) in. Riferimenti generali di AWS |
| Autorizzazione | Le applicazioni possono eseguire solo operazioni per le quali sono state autorizzate. Gli amministratori di database o i proprietari di applicazioni possono utilizzare le istruzioni SQL GRANT e REVOKE per controllare l'accesso agli oggetti del database (come le tabelle), ai dati (come le righe all'interno di una tabella) o la possibilità di emettere alcune istruzioni SQL. | In DynamoDB, l'autorizzazione è gestita AWS Identity and Access Management da (IAM). È possibile scrivere una policy IAM per concedere le autorizzazioni su una risorsa DynamoDB (ad esempio una tabella), quindi consentire agli utenti e ai ruoli di utilizzare tale policy. IAM offre anche un controllo di accesso a granulometria fine per singoli elementi di dati nelle tabelle DynamoDB. Per ulteriori informazioni, consulta [Identity and Access Management per Amazon DynamoDB](security-iam.md). |
| Invio di una richiesta | L'applicazione emette un'istruzione SQL per ogni operazione di database che desidera eseguire. Alla ricezione dell'istruzione SQL, RDBMS verifica la sintassi, crea un piano per l'esecuzione dell'operazione ed esegue il piano. | L'applicazione invia le richieste HTTP(S) a DynamoDB. Le richieste contengono il nome dell'operazione da eseguire insieme ai parametri. DynamoDB esegue immediatamente la richiesta. |
| Ricezione di una risposta | RDBMS restituisce i risultati dell'istruzione SQL. Se si verifica un errore, RDBMS restituisce uno stato e un messaggio di errore. | DynamoDB restituisce una risposta HTTP(S) contenente i risultati dell'operazione. Se si verifica un errore, DynamoDB restituisce uno stato e messaggi di errore HTTP. |
# Differenze tra un database relazionale (SQL) e DynamoDB durante la creazione di una tabella
Le tabelle sono le strutture di dati fondamentali nei database relazionali e in Amazon DynamoDB. Un sistema di gestione di database relazionali (RDBMS) richiede la definizione dello schema della tabella al momento della sua creazione. Le tabelle DynamoDB invece sono prive di schema Oltre alla chiave primaria, non è necessario definire alcun attributo o tipo di dati extra al momento della creazione della tabella.
La sezione seguente confronta il modo in cui creeresti una tabella con SQL con il modo in cui la creeresti con DynamoDB.
**Topics**
+ [
## Creazione di una tabella con SQL
](#SQLtoNoSQL.CreateTable.SQL)
+ [
## Creazione di una tabella con DynamoDB
](#SQLtoNoSQL.CreateTable.DynamoDB)
## Creazione di una tabella con SQL
Con SQL useresti l'istruzione `CREATE TABLE` per creare una tabella, come illustrato nell'esempio seguente.
```
CREATE TABLE Music (
Artist VARCHAR(20) NOT NULL,
SongTitle VARCHAR(30) NOT NULL,
AlbumTitle VARCHAR(25),
Year INT,
Price FLOAT,
Genre VARCHAR(10),
Tags TEXT,
PRIMARY KEY(Artist, SongTitle)
);
```
La chiave principale di questa tabella è costituita da *Artist* e. *SongTitle*
Dovrai definire tutte le colonne e i tipi di dati della tabella e la chiave primaria della tabella. Puoi usare l'istruzione `ALTER TABLE` per modificare queste definizioni successivamente, se necessario.
Molte implementazioni SQL ti consentono di definire le specifiche di storage per la tua tabella, come parte dell'istruzione `CREATE TABLE`. Se non diversamente indicato, la tabella viene creata con le impostazioni di storage predefinite. In un ambiente di produzione, un amministratore di database può aiutare a determinare i parametri di storage ottimali.
## Creazione di una tabella con DynamoDB
Utilizza l'operazione `CreateTable` per creare una tabella con modalità assegnata, specificando i parametri come illustrato di seguito:
```
{
TableName : "Music",
KeySchema: [
{
AttributeName: "Artist",
KeyType: "HASH" //Partition key
},
{
AttributeName: "SongTitle",
KeyType: "RANGE" //Sort key
}
],
AttributeDefinitions: [
{
AttributeName: "Artist",
AttributeType: "S"
},
{
AttributeName: "SongTitle",
AttributeType: "S"
}
],
ProvisionedThroughput: { // Only specified if using provisioned mode
ReadCapacityUnits: 1,
WriteCapacityUnits: 1
}
}
```
La chiave primaria per questa tabella è composta da *Artist* (chiave di partizione) e *SongTitle*(chiave di ordinamento).
Dovrai fornire i seguenti parametri a `CreateTable`:
+ `TableName`: il nome della tabella.
+ `KeySchema`— Attributi utilizzati per la chiave primaria. Per ulteriori informazioni, consultare [Tabelle, elementi e attributi](HowItWorks.CoreComponents.md#HowItWorks.CoreComponents.TablesItemsAttributes) e [Chiave primaria](HowItWorks.CoreComponents.md#HowItWorks.CoreComponents.PrimaryKey).
+ `AttributeDefinitions`— Tipi di dati per gli attributi chiave dello schema.
+ `ProvisionedThroughput (for provisioned tables)`— Numero di letture e scritture al secondo necessarie per questa tabella. DynamoDB riserva risorse di storage e di sistema sufficienti in modo che i requisiti di throughput siano sempre soddisfatti. Puoi usare l'operazione `UpdateTable` per modificare queste definizioni successivamente, se necessario. Non è necessario specificare i requisiti di archiviazione di una tabella perché l'allocazione dello spazio di archiviazione è gestita interamente da DynamoDB.
# Differenze tra l’ottenimento di informazioni sulle tabelle da un database relazionale (SQL) e DynamoDB
Puoi verificare se una tabella è stata creata in base alle tue specifiche. In un database relazionale viene visualizzato tutto lo schema della tabella. Le tabelle Amazon DynamoDB sono prive di schema, perciò vengono mostrati solo gli attributi della chiave primaria.
**Topics**
+ [
## Ottenimento di informazioni su una tabella con SQL
](#SQLtoNoSQL.GetTableInfo.SQL)
+ [
## Ottenimento di informazioni su una tabella in DynamoDB
](#SQLtoNoSQL.GetTableInfo.DynamoDB)
## Ottenimento di informazioni su una tabella con SQL
La maggior parte dei sistemi di gestione dei database relazionali (RDBMS) consente di descrivere la struttura di una tabella, ovvero colonne, tipi di dati, definizione della chiave primaria e così via. Non esiste un metodo standard per fornire la descrizione in SQL. Tuttavia, molti sistemi di database forniscono un comando `DESCRIBE`. Di seguito è riportato un esempio da MySQL.
```
DESCRIBE Music;
```
Viene restituita la struttura della tabella, con tutti i nomi di colonna, i tipi di dati e le dimensioni.
```
+------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+------------+-------------+------+-----+---------+-------+
| Artist | varchar(20) | NO | PRI | NULL | |
| SongTitle | varchar(30) | NO | PRI | NULL | |
| AlbumTitle | varchar(25) | YES | | NULL | |
| Year | int(11) | YES | | NULL | |
| Price | float | YES | | NULL | |
| Genre | varchar(10) | YES | | NULL | |
| Tags | text | YES | | NULL | |
+------------+-------------+------+-----+---------+-------+
```
La chiave principale di questa tabella è costituita da *Artist* e. *SongTitle*
## Ottenimento di informazioni su una tabella in DynamoDB
DynamoDB dispone di un'operazione `DescribeTable`, che è simile. L'unico parametro è il nome della tabella.
```
{
TableName : "Music"
}
```
La risposta di `DescribeTable` sarà simile alla seguente.
```
{
"Table": {
"AttributeDefinitions": [
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}
],
"TableName": "Music",
"KeySchema": [
{
"AttributeName": "Artist",
"KeyType": "HASH" //Partition key
},
{
"AttributeName": "SongTitle",
"KeyType": "RANGE" //Sort key
}
],
...
```
`DescribeTable` restituisce anche informazioni sugli indici sulla tabella, le impostazioni del throughput assegnato, un conteggio approssimativo degli elementi e altri metadati.
# Differenze tra un database relazionale (SQL) e DynamoDB durante la scrittura di dati in una tabella
Le tabelle dei database relazionali contengono *righe* di dati. Le righe sono costituiti da*columns*. Le tabelle Amazon DynamoDB contengono*ELEMENTO*. gli elementi sono costituiti da *attributi*.
In questa sezione viene descritto come scrivere una riga o un item in una tabella.
**Topics**
+ [
## Scrittura dei dati in una tabella con SQL
](#SQLtoNoSQL.WriteData.SQL)
+ [
## Scrittura dei dati in una tabella in DynamoDB
](#SQLtoNoSQL.WriteData.DynamoDB)
## Scrittura dei dati in una tabella con SQL
Una tabella in un database relazionale è una struttura di dati bidimensionale composta da righe e colonne. Alcuni sistemi di gestione di database forniscono anche il supporto per dati semi-strutturati, solitamente con tipi di dati JSON o XML nativi. Tuttavia, i dettagli di implementazione variano tra i fornitori.
In SQL, userai l'istruzione `INSERT` per aggiungere una riga a una tabella.
```
INSERT INTO Music
(Artist, SongTitle, AlbumTitle,
Year, Price, Genre,
Tags)
VALUES(
'No One You Know', 'Call Me Today', 'Somewhat Famous',
2015, 2.14, 'Country',
'{"Composers": ["Smith", "Jones", "Davis"],"LengthInSeconds": 214}'
);
```
La chiave principale di questa tabella è costituita da *Artist* e. *SongTitle* Dovrai specificare i valori per queste colonne.
**Nota**
Questo esempio utilizza la colonna *Tags* per memorizzare dati semistrutturati sulle canzoni nella tabella *Music*. La colonna *Tags* è definita come di tipo TEXT e pertanto può memorizzare fino a 65.535 caratteri in MySQL.
## Scrittura dei dati in una tabella in DynamoDB
In Amazon DynamoDB, puoi utilizzare l’API DynamoDB, o [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un linguaggio di query compatibile con SQL, per aggiungere un elemento a una tabella.
------
#### [ DynamoDB API ]
Con l'API DynamoDB, si utilizza l’operazione `PutItem` per aggiungere un elemento a una tabella.
```
{
TableName: "Music",
Item: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today",
"AlbumTitle":"Somewhat Famous",
"Year": 2015,
"Price": 2.14,
"Genre": "Country",
"Tags": {
"Composers": [
"Smith",
"Jones",
"Davis"
],
"LengthInSeconds": 214
}
}
}
```
La chiave principale di questa tabella è costituita da *Artist* e. *SongTitle* Dovrai specificare i valori per questi attributi.
Ecco alcune cose fondamentali da sapere su questo `PutItem` di esempio:
+ DynamoDB fornisce il supporto nativo per i documenti utilizzando JSON. Questo rende DynamoDB ideale per l'archiviazione dei dati semistrutturati, ad esempio *Tag*. Puoi anche recuperare e modificare i dati dai documenti JSON.
+ La tabella *Music* non ha attributi predefiniti, tranne la chiave primaria (*Artista* e *SongTitle*).
+ La maggior parte dei database SQL è basata sulle transazioni. Quanto emetti un'istruzione `INSERT`, le modifiche dei dati non sono permanenti fino a quando non emetti un'istruzione `COMMIT`. Con Amazon DynamoDB, gli effetti di un'operazione `PutItem` diventano permanenti quando DynamoDB risponde con un codice di stato HTTP 200 (`OK`).
Di seguito vengono riportati altri esempi di `PutItem`.
```
{
TableName: "Music",
Item: {
"Artist": "No One You Know",
"SongTitle": "My Dog Spot",
"AlbumTitle":"Hey Now",
"Price": 1.98,
"Genre": "Country",
"CriticRating": 8.4
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road",
"AlbumTitle":"Somewhat Famous",
"Genre": "Country",
"CriticRating": 8.4,
"Year": 1984
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "The Acme Band",
"SongTitle": "Still In Love",
"AlbumTitle":"The Buck Starts Here",
"Price": 2.47,
"Genre": "Rock",
"PromotionInfo": {
"RadioStationsPlaying":[
"KHCR", "KBQX", "WTNR", "WJJH"
],
"TourDates": {
"Seattle": "20150625",
"Cleveland": "20150630"
},
"Rotation": "Heavy"
}
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "The Acme Band",
"SongTitle": "Look Out, World",
"AlbumTitle":"The Buck Starts Here",
"Price": 0.99,
"Genre": "Rock"
}
}
```
**Nota**
Oltre a `PutItem`, DynamoDB supporta un'operazione `BatchWriteItem` per la scrittura di più elementi contemporaneamente.
------
#### [ PartiQL for DynamoDB ]
Con PartiQL, utilizzi l’operazione `ExecuteStatement` per aggiungere un elemento a una tabella, utilizzando la dichiarazione `Insert` PartiQL.
```
INSERT into Music value {
'Artist': 'No One You Know',
'SongTitle': 'Call Me Today',
'AlbumTitle': 'Somewhat Famous',
'Year' : '2015',
'Genre' : 'Acme'
}
```
La chiave primaria di questa tabella è composta da *Artist* e *SongTitle*. Dovrai specificare i valori per questi attributi.
**Nota**
Per esempi di codice che utilizzano `Insert` e `ExecuteStatement`, consulta [Istruzioni INSERT PartiQL per DynamoDB](ql-reference.insert.md).
------
# Differenze tra un database relazionale (SQL) e DynamoDB durante la lettura di dati in una tabella
Con SQL, userai l'istruzione `SELECT` per recuperare una o più righe da una tabella. Utilizza la clausola `WHERE` per determinare i dati che vengono restituiti.
Ciò è diverso dall'utilizzo di Amazon DynamoDB che fornisce le seguenti operazioni per la lettura dei dati:
+ `ExecuteStatement` recupera uno o più elementi da una tabella. `BatchExecuteStatement` recupera più elementi da tabelle diverse in un'unica operazione. Entrambe queste operazioni utilizzano [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un linguaggio di query compatibile con SQL.
+ `GetItem`: recupera un singolo elemento da una tabella. Questo è il modo più efficiente per leggere un singolo item, perché fornisce accesso diretto a una posizione fisica dell'item. (DynamoDB fornisce anche il`BatchGetItem`operazione, che consente di eseguire fino a 100`GetItem`In un'unica operazione.)
+ `Query`: recupera tutti gli elementi che hanno una chiave di partizione specifica. In questi item è possibile applicare una condizione alla chiave di ordinamento e recuperare solo un sottoinsieme dei dati. `Query` offre accesso rapido ed efficace alle partizioni in cui i dati vengono memorizzati. Per ulteriori informazioni, consulta [Partizioni e distribuzione dei dati in DynamoDB](HowItWorks.Partitions.md).
+ `Scan`: recupera tutti gli elementi nella tabella o nell'indice specificati. Questa operazione non deve essere utilizzata con tabelle di grandi dimensioni in quanto può consumare notevoli quantità di risorse di sistema.
**Nota**
Con un database relazionale puoi utilizzare l'istruzione `SELECT` per eseguire il join dei dati di più tabelle e restituire i risultati. I join sono fondamentali per il modello relazionale. Per garantire che i join vengano eseguiti in modo efficiente, il database e le applicazioni devono essere ottimizzati per le prestazioni su base continuativa. DynamoDB è un database NoSQL non relazionale che non supporta join di tabelle. Le applicazioni leggono i dati da una tabella alla volta.
Nelle sezioni seguenti vengono descritti diversi casi d'uso per la lettura dei dati e le operazioni da intraprendere per eseguire queste attività con un database relazionale e con DynamoDB.
**Topics**
+ [
# Differenze nella lettura di un elemento usando la chiave primaria
](SQLtoNoSQL.ReadData.SingleItem.md)
+ [
# Differenze nell’esecuzione di query su una tabella
](SQLtoNoSQL.ReadData.Query.md)
+ [
# Differenze nella scansione di una tabella
](SQLtoNoSQL.ReadData.Scan.md)
# Differenze nella lettura di un elemento usando la chiave primaria
Un modello di accesso comune per i database consiste nel leggere un singolo item da una tabella. Dovrai specificare la chiave primaria dell'item desiderato.
**Topics**
+ [
## Lettura di un elemento usando la chiave primaria con SQL
](#SQLtoNoSQL.ReadData.SingleItem.SQL)
+ [
## Lettura di un elemento usando la chiave primaria in DynamoDB
](#SQLtoNoSQL.ReadData.SingleItem.DynamoDB)
## Lettura di un elemento usando la chiave primaria con SQL
In SQL, userai l'istruzione `SELECT` per recuperare i dati da una tabella. Puoi richiedere una o più colonne nel risultato (o tutte se usi l'operatore `*`). La clausola `WHERE` determina le righe da restituire.
La seguente è un'istruzione `SELECT` per recuperare una singola riga dalla tabella *Music*. La clausola `WHERE` specifica i valori delle chiavi primarie.
```
SELECT *
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```
Puoi modificare questa query per recuperare solo un sottoinsieme delle colonne:
```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```
*Tieni presente che la chiave primaria per questa tabella è costituita da Artist e. *SongTitle**
## Lettura di un elemento usando la chiave primaria in DynamoDB
In Amazon DynamoDB, puoi utilizzare l’API DynamoDB, o [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un linguaggio di query compatibile con SQL, per leggere un elemento da una tabella.
------
#### [ DynamoDB API ]
Con l'API DynamoDB, si utilizza l’operazione `PutItem` per aggiungere un elemento a una tabella.
DynamoDB offre l'operazione `GetItem` per il recupero di un elemento tramite la propria chiave primaria. `GetItem` è altamente efficiente perché fornisce accesso diretto a una posizione fisica dell'elemento. Per ulteriori informazioni, consulta [Partizioni e distribuzione dei dati in DynamoDB](HowItWorks.Partitions.md).
Per impostazione predefinita, `GetItem` restituisce l'intero item con tutti gli attributi.
```
{
TableName: "Music",
Key: {
"Artist": "No One You Know",
"SongTitle": "Call Me Today"
}
}
```
Puoi aggiungere un parametro `ProjectionExpression` per restituire solo alcuni degli attributi.
```
{
TableName: "Music",
Key: {
"Artist": "No One You Know",
"SongTitle": "Call Me Today"
},
"ProjectionExpression": "AlbumTitle, Year, Price"
}
```
Tieni presente che la chiave primaria di questa tabella è costituita da *Artist* e. *SongTitle*
L'operazione `GetItem` di DynamoDB è molto efficiente. Utilizza i valori delle chiavi primarie per determinare l'esatta posizione di archiviazione dell'elemento in questione e lo recupera direttamente da quella posizione. L'istruzione SQL `SELECT` è altrettanto efficiente per recuperare gli elementi tramite i valori delle chiavi primarie.
L'SQL`SELECT`supporta molti tipi di query e scansioni di tabelle. DynamoDB offre una funzionalità simile con le operazioni `Query` e`Scan`, che sono descritte in [Differenze nell’esecuzione di query su una tabella](SQLtoNoSQL.ReadData.Query.md) e [Differenze nella scansione di una tabella](SQLtoNoSQL.ReadData.Scan.md).
L'istruzione SQL `SELECT` può eseguire join di tabelle, consentendo di recuperare i dati da più tabelle contemporaneamente. I join sono più efficaci laddove le tabelle del database sono normalizzate e le relazioni tra le tabelle sono chiare. Tuttavia, se esegui il join di troppe tabelle in una sola istruzione `SELECT`, le prestazioni dell'applicazione possono risultare compromesse. Puoi risolvere questi problemi utilizzando la replica del database, le viste materializzate o le riscritture delle query.
DynamoDB è un database non relazionale e non supporta i join di tabella. Se si sta eseguendo la migrazione di un'applicazione esistente da un database relazionale a DynamoDB, è necessario denormalizzare il modello di dati per eliminare la necessità delle operazioni join.
------
#### [ PartiQL for DynamoDB ]
Con PartiQL, utilizzi l’operazione `ExecuteStatement` per leggere un elemento da una tabella, utilizzando la dichiarazione `Select` PartiQL.
```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```
Nota che la chiave primaria di questa tabella è composta da Artist e SongTitle.
**Nota**
L'istruzione select PartiQL può essere utilizzata anche per eseguire query o scansione di una tabella DynamoDB
Per esempi di codice che utilizzano `Select` e `ExecuteStatement`, consulta [Istruzioni SELECT PartiQL per DynamoDB](ql-reference.select.md).
------
# Differenze nell’esecuzione di query su una tabella
Un altro modello di accesso comune è la lettura di più item da una tabella, in base ai criteri di query.
**Topics**
+ [
## Esecuzione di query su una tabella con SQL
](#SQLtoNoSQL.ReadData.Query.SQL)
+ [
## Esecuzione di query su una tabella in DynamoDB
](#SQLtoNoSQL.ReadData.Query.DynamoDB)
## Esecuzione di query su una tabella con SQL
Quando usi l'istruzione SQL `SELECT` puoi eseguire query su colonne chiave, colonne non chiave o una combinazione di esse. La clausola `WHERE` determina quali righe vengono restituite, come mostrato negli esempi seguenti.
```
/* Return a single song, by primary key */
SELECT * FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today';
```
```
/* Return all of the songs by an artist */
SELECT * FROM Music
WHERE Artist='No One You Know';
```
```
/* Return all of the songs by an artist, matching first part of title */
SELECT * FROM Music
WHERE Artist='No One You Know' AND SongTitle LIKE 'Call%';
```
```
/* Return all of the songs by an artist, only if the price is less than 1.00 */
SELECT * FROM Music
WHERE Artist='No One You Know'
AND Price < 1.00;
```
Nota che la chiave primaria di questa tabella è composta da *Artist* e *SongTitle*.
## Esecuzione di query su una tabella in DynamoDB
In Amazon DynamoDB, puoi utilizzare l’API DynamoDB, o [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un linguaggio di query compatibile con SQL, per eseguire una query di un elemento da una tabella.
------
#### [ DynamoDB API ]
Con Amazon DynamoDB puoi usare l'operazione `Query` per recuperare i dati in modo simile. L'operazione `Query` fornisce un accesso rapido ed efficiente alle posizioni fisiche in cui sono archiviati i dati. Per ulteriori informazioni, consulta [Partizioni e distribuzione dei dati in DynamoDB](HowItWorks.Partitions.md).
È possibile utilizzare `Query` con qualsiasi tabella o indice secondario. Dovrai specificare una condizione di uguaglianza per il valore della chiave di partizione e facoltativamente fornire un'altra condizione per l'attributo della chiave di ordinamento, se definito.
Il parametro `KeyConditionExpression` specifica i valori delle chiavi su cui vuoi eseguire la query. Puoi utilizzare un `FilterExpression` facoltativo per rimuovere determinati item dai risultati prima che vengano restituiti.
In DynamoDB, è necessario utilizzare `ExpressionAttributeValues` come segnaposto nei parametri delle espressioni (come `KeyConditionExpression` e`FilterExpression`). Questo comportamento è analogo all'uso delle *variabili di associazione* nei database relazionali in cui sostituisci i valori effettivi nell'istruzione `SELECT` al runtime.
Nota che la chiave primaria di questa tabella è composta da *Artist* e *SongTitle*.
Di seguito vengono riportati altri esempi di `Query`.
```
// Return a single song, by primary key
{
TableName: "Music",
KeyConditionExpression: "Artist = :a and SongTitle = :t",
ExpressionAttributeValues: {
":a": "No One You Know",
":t": "Call Me Today"
}
}
```
```
// Return all of the songs by an artist
{
TableName: "Music",
KeyConditionExpression: "Artist = :a",
ExpressionAttributeValues: {
":a": "No One You Know"
}
}
```
```
// Return all of the songs by an artist, matching first part of title
{
TableName: "Music",
KeyConditionExpression: "Artist = :a and begins_with(SongTitle, :t)",
ExpressionAttributeValues: {
":a": "No One You Know",
":t": "Call"
}
}
```
```
// Return all of the songs by an artist, only if the price is less than 1.00
{
TableName: "Music",
KeyConditionExpression: "Artist = :a",
FilterExpression: "Price < :p",
ExpressionAttributeValues: {
":a": "No One You Know",
":p": 1.00
}
}
```
**Nota**
A `FilterExpression` viene applicato dopo le `Query` letture corrispondenti agli elementi, quindi non riduce la capacità di lettura consumata. Ove possibile, modella i dati in modo che le condizioni dell'intervallo vengano utilizzate `KeyConditionExpression` sulla chiave di ordinamento per query efficienti. Per ulteriori informazioni, consulta [Esecuzione di query in DynamoDB](Query.md).
------
#### [ PartiQL for DynamoDB ]
Con PartiQL, puoi eseguire una query utilizzando l'operazione `ExecuteStatement` e l’istruzione `Select` sulla chiave di partizione.
```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know'
```
L’utilizzo della dichiarazione `SELECT` in questo modo restituisce tutte le canzoni associate a questo particolare `Artist`.
Per esempi di codice che utilizzano `Select` e `ExecuteStatement`, consulta [Istruzioni SELECT PartiQL per DynamoDB](ql-reference.select.md).
------
# Differenze nella scansione di una tabella
In SQL, un'istruzione `SELECT` senza una clausola `WHERE` restituirà ogni riga di una tabella. In Amazon DynamoDB, l'operazione `Scan` fa la stessa cosa. In entrambi i casi, puoi recuperare tutti gli elementi o solo alcuni di essi.
Se stai utilizzando un database SQL o NoSQL, le scansioni devono essere utilizzate con parsimonia perché possono consumare grandi quantità di risorse di sistema. A volte una scansione è appropriata (come la scansione di una piccola tabella) o inevitabile (come ad esempio un'esportazione di massa di dati). Tuttavia, come regola generale, devi progettare le applicazioni in modo da evitare di eseguire le scansioni. Per ulteriori informazioni, consulta [Esecuzione di query in DynamoDB](Query.md).
**Nota**
L'esecuzione di un'esportazione in blocco crea anche almeno 1 file per partizione. Tutti gli elementi di ogni file provengono dal keyspace con hash di quella particolare partizione.
**Topics**
+ [
## Scansione di una tabella con SQL
](#SQLtoNoSQL.ReadData.Scan.SQL)
+ [
## Scansione di una tabella in DynamoDB
](#SQLtoNoSQL.ReadData.Scan.DynamoDB)
## Scansione di una tabella con SQL
Utilizzando SQL, puoi scansionare una tabella e recuperare tutti i dati usando un'istruzione `SELECT` senza specificare una clausola `WHERE`. Puoi richiedere una o più colonne nel risultato. In alternativa, puoi richiedere tutte le colonne se usi il carattere jolly (\$1).
Di seguito vengono illustrati alcuni esempi di utilizzo dell'istruzione `SELECT`.
```
/* Return all of the data in the table */
SELECT * FROM Music;
```
```
/* Return all of the values for Artist and Title */
SELECT Artist, Title FROM Music;
```
## Scansione di una tabella in DynamoDB
In Amazon DynamoDB, puoi utilizzare l’API DynamoDB, o [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un linguaggio di query compatibile con SQL, per eseguire una scansione su una tabella.
------
#### [ DynamoDB API ]
Con l’API di DynamoDB, puoi utilizzare l’operazione `Scan` per restituire una o più voci e i relativi attributi accedendo a ogni voce in una tabella o un indice secondario.
```
// Return all of the data in the table
{
TableName: "Music"
}
```
```
// Return all of the values for Artist and Title
{
TableName: "Music",
ProjectionExpression: "Artist, Title"
}
```
L'operazione `Scan` fornisce anche il parametro `FilterExpression` che puoi utilizzare per scartare gli elementi che non vuoi visualizzare nei risultati. Un `FilterExpression` viene applicato dopo la scansione dell'intera tabella, ma prima che i risultati ti vengano restituiti. ti viene comunque addebitato l'intero `Scan`, anche se vengono restituiti solo pochi item corrispondenti.
------
#### [ PartiQL for DynamoDB ]
Con PartiQL, esegui una scansione utilizzando l’operazione `ExecuteStatement` per restituire tutti i contenuti di una tabella utilizzando la dichiarazione `Select`.
```
SELECT AlbumTitle, Year, Price
FROM Music
```
Si noti che questa istruzione restituirà tutti gli elementi per nella tabella Music.
Per esempi di codice che utilizzano `Select` e `ExecuteStatement`, consulta [Istruzioni SELECT PartiQL per DynamoDB](ql-reference.select.md).
------
# Differenze tra un database relazionale (SQL) e DynamoDB nella gestione degli indici
Gli indici consentono di accedere a modelli di query alternativi e possono velocizzare le query. In questa sezione viene eseguito il confronto delle operazioni di creazione e utilizzo dell'indice in SQL e in Amazon DynamoDB.
Che si stia utilizzando un database relazionale o DynamoDB, è necessario eseguire con attenzione la creazione dell'indice. Ogni volta che una scrittura si verifica su una tabella, tutti gli indici della tabella devono essere aggiornati. In un ambiente di scrittura con tabelle di grandi dimensioni, questa operazione può consumare grandi quantità di risorse di sistema. In un ambiente di sola lettura o pressoché di sola lettura, questa operazione non costituisce un problema, ma devi assicurarti che gli indici vengano effettivamente utilizzati dall'applicazione e non occupino semplicemente spazio.
**Topics**
+ [
## Differenze tra un database relazionale (SQL) e DynamoDB durante la creazione di una tabella
](#SQLtoNoSQL.Indexes.Creating)
+ [
## Differenze tra un database relazionale (SQL) e DynamoDB durante l’esecuzione di query e scansione di una tabella
](#SQLtoNoSQL.Indexes.QueryAndScan)
## Differenze tra un database relazionale (SQL) e DynamoDB durante la creazione di una tabella
Confrontare l'istruzione `CREATE INDEX` in SQL con l'operazione `UpdateTable` in Amazon DynamoDB.
**Topics**
+ [
### Creazione di un indice con SQL
](#SQLtoNoSQL.Indexes.Creating.SQL)
+ [
### Creazione di un indice in DynamoDB
](#SQLtoNoSQL.Indexes.Creating.DynamoDB)
### Creazione di un indice con SQL
In un database relazionale, un indice è una struttura di dati che ti consente di eseguire query veloci su colonne diverse in una tabella. Puoi utilizzare l'istruzione SQL `CREATE INDEX` per aggiungere un indice a una tabella esistente, specificando le colonne da indicizzare. Dopo aver creato l'indice, puoi eseguire una query sui dati della tabella come di consueto, ma ora il database può utilizzare l'indice per trovare rapidamente le righe specificate nella tabella anziché eseguire la scansione dell'intera tabella.
Dopo aver creato un indice, il database lo gestisce automaticamente. Ogni volta che modifichi i dati nella tabella, l'indice viene modificato automaticamente per riflettere le modifiche nella tabella.
In MySQL, puoi creare un indice simile al seguente.
```
CREATE INDEX GenreAndPriceIndex
ON Music (genre, price);
```
### Creazione di un indice in DynamoDB
In *, puoi creare e usare un * per scopi simili.
Gli indici in DynamoDB sono diversi dalle rispettive controparti relazionali. Quando crei un indice secondario globale, specifica una chiave di partizione e opzionalmente una chiave di ordinamento. Dopo aver creato l'indice secondario, è possibile`Query`o`Scan`proprio come faresti con un tavolo. DynamoDB non dispone di un ottimizzatore di query, quindi un indice secondario viene utilizzato solo quando`Query`o`Scan`esso.
DynamoDB supporta due diversi tipi di indici:
+ Indici secondari globali: la chiave primaria dell'indice può essere qualsiasi due attributi della relativa tabella.
+ Indici secondari locali: la chiave di partizione dell'indice deve essere uguale a quella della chiave di partizione della tabella. Tuttavia, la chiave di ordinamento può essere un qualsiasi altro attributo.
assicura che i dati in un sono consistenti con la tabella. Puoi richiedere operazioni `Query` o `Scan` ad elevata consistenza su una tabella o un indice secondario locale. Tuttavia, gli indici secondari globali supportano solo la consistenza finale.
È possibile aggiungere un indice secondario globale a una tabella esistente utilizzando l'operazione `UpdateTable` e specificando `GlobalSecondaryIndexUpdates`.
```
{
TableName: "Music",
AttributeDefinitions:[
{AttributeName: "Genre", AttributeType: "S"},
{AttributeName: "Price", AttributeType: "N"}
],
GlobalSecondaryIndexUpdates: [
{
Create: {
IndexName: "GenreAndPriceIndex",
KeySchema: [
{AttributeName: "Genre", KeyType: "HASH"}, //Partition key
{AttributeName: "Price", KeyType: "RANGE"}, //Sort key
],
Projection: {
"ProjectionType": "ALL"
},
ProvisionedThroughput: { // Only specified if using provisioned mode
"ReadCapacityUnits": 1,"WriteCapacityUnits": 1
}
}
}
]
}
```
Dovrai fornire i seguenti parametri a `UpdateTable`:
+ `TableName`— La tabella a cui verrà associato l'indice.
+ `AttributeDefinitions`— I tipi di dati per gli attributi dello schema chiave dell'indice.
+ `GlobalSecondaryIndexUpdates`— Dettagli sull'indice che desideri creare:
+ `IndexName`: un nome per l'indice.
+ `KeySchema`— Gli attributi utilizzati per la chiave primaria dell'indice.
+ `Projection` - Specifica gli attributi che vengono copiati (proiettati) dalla tabella nell'indice. In questo caso, `ALL` significa che tutti gli attributi sono copiati.
+ `ProvisionedThroughput (for provisioned tables)`— Il numero di letture e scritture al secondo necessarie per questo indice. Questo valore è separato dalle impostazioni di throughput assegnato dalla tabella.
Parte di questa operazione comporta la compilazione dei dati dalla tabella nel nuovo indice. Durante la compilazione la tabella rimane disponibile. Tuttavia, l'indice non è pronto fino a quando l'attributo `Backfilling` cambia da true a false. Puoi utilizzare l'operazione `DescribeTable` per visualizzare questo attributo.
## Differenze tra un database relazionale (SQL) e DynamoDB durante l’esecuzione di query e scansione di una tabella
Confrontare l'esecuzione di query e scansione di un indice usando l'istruzione SELECT (SELEZIONA) in SQL con le operazioni `Query` e `Scan` in Amazon DynamoDB.
**Topics**
+ [
### Esecuzione di query e scansione di un indice con SQL
](#SQLtoNoSQL.Indexes.QueryAndScan.SQL)
+ [
### Esecuzione di query e scansione di un indice in DynamoDB
](#SQLtoNoSQL.Indexes.QueryAndScan.DynamoDB)
### Esecuzione di query e scansione di un indice con SQL
In un database relazionale, non si lavora direttamente con gli indici. Si eseguono invece query sulle tabelle emettendo istruzioni `SELECT` in modo che l'ottimizzatore di query possa fare uso di qualsiasi indice.
Un *ottimizzatore di query* è un componente dei sistemi di gestione di database relazionali (RDBMS) che valuta gli indici disponibili e determina se possono essere utilizzati per accelerare una query. Se gli indici possono essere utilizzati per accelerare una query, RDBMS accede prima all'indice e quindi lo utilizza per individuare i dati nella tabella.
Ecco alcune istruzioni SQL che possono essere utilizzate *GenreAndPriceIndex*per migliorare le prestazioni. Supponiamo che la tabella *Music* contenga i dati sufficienti che l'ottimizzatore di query decida di usare questo indice, piuttosto che scansionare l'intera tabella.
```
/* All of the rock songs */
SELECT * FROM Music
WHERE Genre = 'Rock';
```
```
/* All of the cheap country songs */
SELECT Artist, SongTitle, Price FROM Music
WHERE Genre = 'Country' AND Price < 0.50;
```
### Esecuzione di query e scansione di un indice in DynamoDB
In DynamoDB, le operazioni `Query` e `Scan` vengono eseguite direttamente sull'indice, nello stesso modo in cui vengono eseguite su una tabella. Puoi utilizzare l'API DynamoDB o [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un linguaggio di query compatibile con SQL, per eseguire query o effettuare la scansione dell'indice. Devi specificare `TableName` e `IndexName`.
Di seguito sono riportate alcune domande su *GenreAndPriceIndex*DynamoDB. Lo schema della chiave per l'indice è composto dagli attributi *Genre* e *Price*.
------
#### [ DynamoDB API ]
```
// All of the rock songs
{
TableName: "Music",
IndexName: "GenreAndPriceIndex",
KeyConditionExpression: "Genre = :genre",
ExpressionAttributeValues: {
":genre": "Rock"
},
};
```
Questo esempio utilizza un `ProjectionExpression` per indicare che si vogliono solo alcuni degli attributi, piuttosto che tutti, nei risultati.
```
// All of the cheap country songs
{
TableName: "Music",
IndexName: "GenreAndPriceIndex",
KeyConditionExpression: "Genre = :genre and Price < :price",
ExpressionAttributeValues: {
":genre": "Country",
":price": 0.50
},
ProjectionExpression: "Artist, SongTitle, Price"
};
```
Di seguito è riportata una scansione in corso. *GenreAndPriceIndex*
```
// Return all of the data in the index
{
TableName: "Music",
IndexName: "GenreAndPriceIndex"
}
```
------
#### [ PartiQL for DynamoDB ]
Con PartiQL, puoi utilizzare l’istruzione `Select` PartiQL per eseguire query e scansioni sull'indice.
```
// All of the rock songs
SELECT *
FROM Music.GenreAndPriceIndex
WHERE Genre = 'Rock'
```
```
// All of the cheap country songs
SELECT *
FROM Music.GenreAndPriceIndex
WHERE Genre = 'Rock' AND Price < 0.50
```
Quanto segue è una scansione in corso *GenreAndPriceIndex*.
```
// Return all of the data in the index
SELECT *
FROM Music.GenreAndPriceIndex
```
**Nota**
Per esempi di codice che utilizzano `Select`, consulta [Istruzioni SELECT PartiQL per DynamoDB](ql-reference.select.md).
------
# Differenze tra un database relazionale (SQL) e DynamoDB durante la modifica di dati in una tabella
Il linguaggio SQL fornisce il`UPDATE`per la modifica dei dati. Amazon DynamoDB utilizza l'`UpdateItem`per eseguire attività simili.
**Topics**
+ [
## Modifica dei dati in una tabella con SQL
](#SQLtoNoSQL.UpdateData.SQL)
+ [
## Modifica dei dati in una tabella in DynamoDB
](#SQLtoNoSQL.UpdateData.DynamoDB)
## Modifica dei dati in una tabella con SQL
In SQL, usi l'istruzione `UPDATE` per modificare una o più righe. La clausola `SET` specifica i nuovi valori per una o più colonne e la clausola `WHERE` determina quali righe vengono modificate. Di seguito è riportato un esempio di :
```
UPDATE Music
SET RecordLabel = 'Global Records'
WHERE Artist = 'No One You Know' AND SongTitle = 'Call Me Today';
```
Se nessuna riga corrisponde alla clausola `WHERE`, l'istruzione `UPDATE` non ha alcun effetto.
## Modifica dei dati in una tabella in DynamoDB
In DynamoDB, puoi utilizzare l'API DynamoDB o [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un linguaggio di query compatibile con SQL, per modificare un singolo elemento. Se vuoi modificare più elementi, devi utilizzare più operazioni.
------
#### [ DynamoDB API ]
Con l’API DynamoDB, l'operazione `UpdateItem` viene utilizzata per modificare un singolo elemento.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET RecordLabel = :label",
ExpressionAttributeValues: {
":label": "Global Records"
}
}
```
È necessario specificare gli attributi `Key` dell'elemento da modificare e `UpdateExpression` per specificare i valori degli attributi. `UpdateItem` si comporta come un'operazione "upsert". L'elemento viene aggiornato se è presente nella tabella, ma in caso contrario viene aggiunto (inserito) un nuovo elemento.
`UpdateItem` supporta le *scritture condizionali*, in cui l'operazione ha esito positivo solo se una specifica `ConditionExpression` restituisce true. Ad esempio, la seguente operazione `UpdateItem` non esegue l'aggiornamento a meno che il prezzo della canzone non sia maggiore o uguale a 2,00.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET RecordLabel = :label",
ConditionExpression: "Price >= :p",
ExpressionAttributeValues: {
":label": "Global Records",
":p": 2.00
}
}
```
`UpdateItem` supporta anche i *contatori atomici* o gli attributi di tipo `Number` che possono essere incrementati o decrementati. I contatori atomici sono simili per molti versi ai generatori di sequenza, alle colonne di identità o ai campi a incremento automatico dei database SQL.
Di seguito è riportato un esempio di un'operazione `UpdateItem` per inizializzare un nuovo attributo (*Plays*) per tenere traccia del numero di volte in cui una canzone viene riprodotta.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET Plays = :val",
ExpressionAttributeValues: {
":val": 0
},
ReturnValues: "UPDATED_NEW"
}
```
Il parametro `ReturnValues` è impostato su `UPDATED_NEW` che restituisce i nuovi valori degli attributi aggiornati. In questo caso restituisce 0 (zero).
Ogni volta che qualcuno riproduce questa canzone, possiamo usare la seguente operazione `UpdateItem` per incrementare *Plays* di uno.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET Plays = Plays + :incr",
ExpressionAttributeValues: {
":incr": 1
},
ReturnValues: "UPDATED_NEW"
}
```
------
#### [ PartiQL for DynamoDB ]
Con PartiQL, utilizzi l’operazione `ExecuteStatement` per modificare un elemento in una tabella, utilizzando la dichiarazione `Update` PartiQL.
*La chiave principale di questa tabella è costituita da Artist e. *SongTitle** Dovrai specificare i valori per questi attributi.
```
UPDATE Music
SET RecordLabel ='Global Records'
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
È inoltre possibile modificare più campi contemporaneamente, come nell'esempio seguente.
```
UPDATE Music
SET RecordLabel = 'Global Records'
SET AwardsWon = 10
WHERE Artist ='No One You Know' AND SongTitle='Call Me Today'
```
`Update` supporta anche i *contatori atomici* o gli attributi di tipo `Number` che possono essere incrementati o decrementati. I contatori atomici sono simili per molti versi ai generatori di sequenza, alle colonne di identità o ai campi a incremento automatico dei database SQL.
Di seguito è riportato un esempio di una dichiarazione `Update` per inizializzare un nuovo attributo (*Plays*) per tenere traccia del numero di volte in cui una canzone viene riprodotta.
```
UPDATE Music
SET Plays = 0
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
Ogni volta che qualcuno riproduce questa canzone, possiamo usare la seguente dichiarazione `Update` per incrementare *Plays* di uno.
```
UPDATE Music
SET Plays = Plays + 1
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
**Nota**
Per esempi di codice che utilizzano `Update` e `ExecuteStatement`, consulta [Istruzioni UPDATE PartiQL per DynamoDB](ql-reference.update.md).
------
# Differenze tra un database relazionale (SQL) e DynamoDB durante l’eliminazione di dati da una tabella
Con SQL, userai l'istruzione `DELETE` per recuperare una o più righe da una tabella. Amazon DynamoDB utilizza l'operazione `DeleteItem` per eliminare un elemento alla volta.
**Topics**
+ [
## Eliminazione dei dati da una tabella con SQL
](#SQLtoNoSQL.DeleteData.SQL)
+ [
## Eliminazione dei dati da una tabella in DynamoDB
](#SQLtoNoSQL.DeleteData.DynamoDB)
## Eliminazione dei dati da una tabella con SQL
In SQL, usi l'istruzione `DELETE` per eliminare una o più righe. La clausola `WHERE` determina le righe che vuoi modificare. Di seguito è riportato un esempio di :
```
DELETE FROM Music
WHERE Artist = 'The Acme Band' AND SongTitle = 'Look Out, World';
```
Puoi modificare la clausola `WHERE` per eliminare più righe. Ad esempio, potresti eliminare tutti i brani di un artista particolare, come mostrato nell'esempio seguente.
```
DELETE FROM Music WHERE Artist = 'The Acme Band'
```
## Eliminazione dei dati da una tabella in DynamoDB
In DynamoDB, puoi utilizzare l'API DynamoDB o [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un linguaggio di query compatibile con SQL, per eliminare un singolo elemento. Se vuoi modificare più elementi, devi utilizzare più operazioni.
------
#### [ DynamoDB API ]
Con l’API DynamoDB, utilizzi l'operazione `DeleteItem` per eliminare i dati da una tabella, un elemento alla volta. Devi specificare i valori delle chiavi primarie dell'item.
```
{
TableName: "Music",
Key: {
Artist: "The Acme Band",
SongTitle: "Look Out, World"
}
}
```
**Nota**
Oltre a `DeleteItem`, Amazon DynamoDB supporta un'operazione `BatchWriteItem` per l'eliminazione di più elementi contemporaneamente.
`DeleteItem` supporta le *scritture condizionali*, in cui l'operazione ha esito positivo solo se una specifica `ConditionExpression` restituisce true. Ad esempio, la seguente `DeleteItem` operazione elimina l'elemento solo se ha un attributo. *RecordLabel*
```
{
TableName: "Music",
Key: {
Artist: "The Acme Band",
SongTitle: "Look Out, World"
},
ConditionExpression: "attribute_exists(RecordLabel)"
}
```
------
#### [ PartiQL for DynamoDB ]
Con PartiQL, puoi utilizzare la dichiarazione `Delete` attraverso l’operazione `ExecuteStatement` per eliminare i dati da una tabella, un elemento alla volta. Devi specificare i valori delle chiavi primarie dell'item.
La chiave principale di questa tabella è costituita da *Artist* e *SongTitle*. Dovrai specificare i valori per questi attributi.
```
DELETE FROM Music
WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks'
```
Puoi anche specificare ulteriori condizioni per l’operazione. La seguente operazione `DELETE` elimina l'elemento solo se ha più di 11 *Awards (Premi)*.
```
DELETE FROM Music
WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks' AND Awards > 11
```
**Nota**
Per esempi di codice che utilizzano `DELETE` e `ExecuteStatement`, consulta [Istruzioni DELETE PartiQL per DynamoDB](ql-reference.delete.md).
------
# Differenze tra un database relazionale (SQL) e DynamoDB durante la rimozione di una tabella
In SQL, userai l'istruzione `DROP TABLE` per rimuovere una tabella. In Amazon DynamoDB, si utilizza il`DeleteTable`operazione.
**Topics**
+ [
## Rimozione di una tabella con SQL
](#SQLtoNoSQL.RemoveTable.SQL)
+ [
## Rimozione di una tabella in DynamoDB
](#SQLtoNoSQL.RemoveTable.DynamoDB)
## Rimozione di una tabella con SQL
Quando non hai più bisogno di una tabella e vuoi eliminarla definitivamente, usa l'istruzione `DROP TABLE` in SQL.
```
DROP TABLE Music;
```
Dopo che una tabella è stata eliminata, non può più essere ripristinata. Alcuni database relazionali consentono di annullare un'operazione `DROP TABLE`, ma questa è una funzionalità specifica del fornitore e non è sempre implementata.
## Rimozione di una tabella in DynamoDB
In DynamoDB, `DeleteTable` è un'operazione simile. Nell'esempio seguente, la tabella viene eliminata in modo permanente.
```
{
TableName: "Music"
}
```