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à.
# Amazon DynamoDB: come funziona
Nelle seguenti sezioni viene riportata una panoramica dei componenti del servizio Amazon DynamoDB e di come interagiscono tra loro.
**Topics**
+ [Cheat sheet per DynamoDB](CheatSheet.md)
+ [Componenti principali di Amazon DynamoDB](HowItWorks.CoreComponents.md)
+ [API DynamoDB](HowItWorks.API.md)
+ [Tipi di dati e regole di denominazione supportati in Amazon DynamoDB](HowItWorks.NamingRulesDataTypes.md)
+ [Classi di tabella DynamoDB](HowItWorks.TableClasses.md)
+ [Partizioni e distribuzione dei dati in DynamoDB](HowItWorks.Partitions.md)
+ [Come passare da SQL a NoSQL](SQLtoNoSQL.md)
+ [Risorse e strumenti di apprendimento di Amazon DynamoDB](AdditionalResources.md)
# Cheat sheet per DynamoDB
Questo cheat sheet fornisce un riferimento rapido per lavorare con Amazon DynamoDB e le sue varie applicazioni. AWS SDKs
## Configurazione iniziale dell’
1. [Iscriviti](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.SignUpForAWS) per. AWS
1. [Ottenimento di una chiave di accesso AWS](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.GetCredentials) per accedere a DynamoDB in modo programmatico.
1. [Configurazione delle credenziali DynamoDB](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.ConfigureCredentials).
**Consulta anche:**
+ [Configurazione di DynamoDB (servizio Web)](SettingUp.DynamoWebService.html)
+ [Nozioni di base su DynamoDB](GettingStartedDynamoDB.html)
+ [Panoramica di base dei componenti principali](HowItWorks.CoreComponents.html)
## SDK o CLI
Scegli l'[SDK](sdk-general-information-section.html) preferito o configurare l'[AWS CLI](/cli/latest/index.html).
**Nota**
Quando usi Windows, una barra rovesciata (\$1) che non è contenuta in un preventivo viene considerata una restituzione. AWS CLI Inoltre, è necessario evitare le virgolette e le parentesi tra virgolette all'interno di altre virgolette. Per un esempio, consulta la scheda **Windows** in "Creazione di una tabella" nella sezione seguente.
**Consulta anche:**
+ [AWS CLI con DynamoDB](Tools.CLI.html)
+ [Nozioni di base su DynamoDB - fase 2](getting-started-step-2.html)
## Operazioni di base
Questa sezione fornisce il codice per le attività di base di DynamoDB. Per ulteriori informazioni su queste attività, vedere [Guida introduttiva a DynamoDB](GettingStarted.html) e. AWS SDKs
### Creare una tabella
------
#### [ Default ]
```
aws dynamodb create-table \
--table-name Music \
--attribute-definitions \
AttributeName=Artist,AttributeType=S \
AttributeName=SongTitle,AttributeType=S \
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
--billing-mode PAY_PER_REQUEST \
--table-class STANDARD
```
------
#### [ Windows ]
```
aws dynamodb create-table ^
--table-name Music ^
--attribute-definitions ^
AttributeName=Artist,AttributeType=S ^
AttributeName=SongTitle,AttributeType=S ^
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE ^
--billing-mode PAY_PER_REQUEST ^
--table-class STANDARD
```
------
### Scrittura di elementi su una tabella
```
aws dynamodb put-item \ --table-name Music \ --item file://item.json
```
### Lettura di elementi da una tabella
```
aws dynamodb get-item \ --table-name Music \ --item file://item.json
```
### Eliminazione di elementi da una tabella
```
aws dynamodb delete-item --table-name Music --key file://key.json
```
### Eseguire una query su una tabella
```
aws dynamodb query --table-name Music
--key-condition-expression "ArtistName=:Artist and SongName=:Songtitle"
```
### Eliminazione di una tabella
```
aws dynamodb delete-table --table-name Music
```
### Elenco dei nomi delle tabelle
```
aws dynamodb list-tables
```
## Regole di denominazione
+ Tutti i nomi devono essere codificati in UTF-8 e fanno distinzione tra maiuscole e minuscole.
+ I nomi delle tabelle e i nomi degli indici devono avere una lunghezza compresa tra 3 e 255 caratteri e possono contenere solo i seguenti caratteri:
+ `a-z`
+ `A-Z`
+ `0-9`
+ `_` (carattere di sottolineatura)
+ `-`(trattino)
+ `.` (punto)
+ I nomi degli attributi devono contenere almeno un carattere e non devono superare i 64 KB.
Per ulteriori informazioni, consulta [Regole di denominazione](HowItWorks.NamingRulesDataTypes.html).
## Nozioni di base sulle quote del servizio
**Unità di lettura e scrittura**
+ **Unità di capacità di lettura (RCU)**: una lettura ad elevata consistenza di lettura al secondo o due letture a consistenza finale al secondo, per elementi di dimensioni fino a 4 KB.
+ **Unità di capacità di scrittura (WCU)**: una scrittura al secondo per elementi di dimensioni fino a 1 KB.
**Limiti della tabella**
+ **Dimensioni della tabella**: non vi è un limite pratico sulle dimensioni della tabella. Le tabelle non hanno restrizioni in termini di numero di item o di byte.
+ **Numero di tabelle**: per ogni AWS account, esiste una quota iniziale di 2.500 tabelle per regione. AWS
+ **Limite di dimensione della pagina per query e scansione**: esiste un limite di 1 MB per pagina, per query o scansione. Se i parametri della query o l'operazione di scansione su una tabella generano più di 1 MB di dati, DynamoDB restituisce gli elementi corrispondenti iniziali. Restituisce anche una proprietà `LastEvaluatedKey` che è possibile utilizzare in una nuova richiesta per leggere la pagina successiva.
**Indici**
+ **Indici secondari locali (LSIs)**: è possibile definire un massimo di cinque indici secondari locali. LSIs sono utili principalmente quando un indice deve avere una forte coerenza con la tabella di base.
+ **Indici secondari globali (GSIs)**: esiste una quota predefinita di 20 indici secondari globali per tabella.
+ **Attributi degli indici secondari globali proiettati per tabella**: è possibile proiettare un massimo di 100 attributi in tutti gli indici secondari locali e globali di una tabella. Tale approccio si applica solo agli attributi proiettati specificati dall'utente.
**Chiavi di partizione**
+ La lunghezza minima del valore di una chiave di partizione è di 1 byte. La lunghezza massima è 2048 byte.
+ Non vi è un limite pratico relativo al numero dei valori di chiavi di partizione distinte, sia per le tabelle che per gli indici secondari.
+ La lunghezza minima del valore di una chiave di ordinamento è di 1 byte. La lunghezza massima è 1024 byte.
+ In generale, non vi è un limite pratico relativo al numero dei valori delle chiavi di ordinamento distinte per ogni valore della chiave di partizione. Fanno eccezione le tabelle con indici secondari.
Per ulteriori informazioni sugli indici secondari, sulla progettazione delle chiavi di partizione e delle chiavi di ordinamento, consulta [Best practice](best-practices.html).
**Limiti per i tipi di dati di uso comune**
+ **Stringa**: la lunghezza di una stringa è vincolata dal limite massimo della dimensione dell'elemento, che è di 400 KB. Le stringhe sono Unicode con codifica binaria UTF-8.
+ **Numero**: un numero può avere fino a 38 cifre di precisione e può essere positivo, negativo o zero.
+ **Binario**: la lunghezza di un dato binario è vincolata dal limite massimo della dimensione dell'elemento, che è di 400 KB. Le applicazioni che funzionano con gli attributi di tipo binario devono codificare i dati nel formato Base64 prima di inviarli a DynamoDB.
Per un elenco completo dei tipi di dati supportati, consulta [Tipi di dati](HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes). Per ulteriori informazioni, consulta anche [Service Quotas](ServiceQuotas.html#limits-items).
### Elementi, attributi e parametri di espressione
La dimensione massima di un elemento in DynamoDB è 400 KB, che include sia la lunghezza binaria del nome dell'attributo (lunghezza UTF-8) che le lunghezze binarie dei valori dell'attributo (lunghezza UTF-8). Il nome attributo viene conteggiato per il limite di dimensione.
Non vi è alcun limite al numero di valori in un attributo List, Map o Set purché l'elemento contenente i valori rientri nel limite di dimensione dell'elemento di 400 KB.
Per i parametri di espressione, la lunghezza massima di qualsiasi stringa di espressione è di 4 KB.
Per ulteriori informazioni sulle dimensioni degli elementi, sugli attributi e sui parametri di espressione, consulta [Service Quotas](ServiceQuotas.html#limits-items).
## Ulteriori informazioni
+ [Sicurezza](security.html)
+ [Monitoraggio e registrazione](monitoring.html)
+ [Utilizzo di flussi](streamsmain.html)
+ [Backup-and-Restore.html](Backup-and-Restore.html)
+ [Integrazione con altri servizi AWS](OtherServices.html)
+ [Documentazione di riferimento dell'API](/amazondynamodb/latest/APIReference/Welcome.html)
+ [Centro di architettura: best practice per i database](https://aws.amazon.com/architecture/databases/)
+ [Tutorial video](https://youtu.be/Mw8wCj0gkRc)
+ [Forum DynamoDB](https://repost.aws/search/questions?globalSearch=dynamodb)
# Componenti principali di Amazon DynamoDB
In DynamoDB, le tabelle, le voci e gli attributi sono i componenti principali da utilizzare. Una *tabella* è una raccolta di *elementi* e ogni elemento è una raccolta di *attributi*. DynamoDB utilizza le chiavi primarie per identificare in modo univoco ciascun elemento in una tabella. Per catturare gli eventi di modifica dei dati nelle tabelle DynamoDB è possibile utilizzare DynamoDB Streams.
Esistono dei limiti in DynamoDB. Per ulteriori informazioni, consulta [Quote in Amazon DynamoDB](ServiceQuotas.md).
Il seguente video ti fornirà un'introduzione a tabelle, elementi ed attributi.
[Tabelle, elementi e attributi](https://www.youtube.com/embed/Mw8wCj0gkRc)
## Tabelle, elementi e attributi
![\[Ogni tabella DynamoDB contiene zero o più elementi composti da uno o più attributi.\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/images/HowItWorksTables-2024.png)
Di seguito sono elencati i componenti di base di DynamoDB:
+ **Tabelle**: analogamente ad altri sistemi di database, DynamoDB memorizza i dati in tabelle. Una *tabella* è una raccolta di dati. Ad esempio, vedi la tabella di esempio chiamata *People* che puoi utilizzare per memorizzare le informazioni di contatto personali su amici, familiari o chiunque altro ti interessi. Potresti avere anche una tabella *Cars* per memorizzare le informazioni sui veicoli guidati dalle persone.
+ **Elementi**: ogni tabella contiene zero o più elementi. Un *item* è un set di attributi identificabili in modo univoco tra tutti gli altri item. Nella tabella *People*, ogni item rappresenta una persona. Per la tabella *Cars*, ogni item rappresenta un veicolo. Gli elementi in DynamoDB sono simili per molti aspetti alle righe, ai record o alle tuple in altri sistemi di database. In DynamoDB, non c'è limite al numero di elementi che è possibile memorizzare in una tabella.
+ **Attributi**: ogni elemento è composto da uno o più attributi. Un *attributo* è un elemento dati fondamentale che non ha bisogno di essere ulteriormente suddiviso. Ad esempio, un elemento in una tabella *Persone* contiene attributi denominati *PersonID*, *LastName*FirstName**, e così via. Per una tabella *Department*, un elemento potrebbe avere attributi come *DepartmentID*, *Name*, *Manager* e così via. Gli attributi in DynamoDB sono simili per molti aspetti ai campi o alle colonne presenti in altri sistemi di database.
Il diagramma seguente mostra una tabella denominata *People* con alcuni item e attributi di esempio.
```
People
{
"PersonID": 101,
"LastName": "Smith",
"FirstName": "Fred",
"Phone": "555-4321"
}
{
"PersonID": 102,
"LastName": "Jones",
"FirstName": "Mary",
"Address": {
"Street": "123 Main",
"City": "Anytown",
"State": "OH",
"ZIPCode": 12345
}
}
{
"PersonID": 103,
"LastName": "Stephens",
"FirstName": "Howard",
"Address": {
"Street": "123 Main",
"City": "London",
"PostalCode": "ER3 5K8"
},
"FavoriteColor": "Blue"
}
```
Tieni presente quanto segue sulla tabella *People*:
+ Ogni item nella tabella ha un identificatore univoco, o chiave primaria, che distingue l'item da tutti gli altri nella tabella. Nella tabella *People*, la chiave primaria consiste in un attributo (*PersonID*).
+ Oltre alla chiave primaria, la tabella *People* è schematica, il che significa che né gli attributi né i loro tipi di dati devono essere definiti in anticipo. Ogni item può avere i propri attributi distinti.
+ La maggior parte degli attributi è *scalare*, il che significa che possono avere un solo valore. Le stringhe e i numeri sono esempi comuni di scalari.
+ Alcuni elementi hanno un attributo nidificato (*Indirizzo*). DynamoDB supporta gli attributi nidificati fino a un massimo di 32 livelli di profondità.
Di seguito è riportata un'altra tabella di esempio denominata *Music* che puoi utilizzare per tenere traccia della tua raccolta musicale.
```
Music
{
"Artist": "No One You Know",
"SongTitle": "My Dog Spot",
"AlbumTitle": "Hey Now",
"Price": 1.98,
"Genre": "Country",
"CriticRating": 8.4
}
{
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road",
"AlbumTitle": "Somewhat Famous",
"Genre": "Country",
"CriticRating": 8.4,
"Year": 1984
}
{
"Artist": "The Acme Band",
"SongTitle": "Still in Love",
"AlbumTitle": "The Buck Starts Here",
"Price": 2.47,
"Genre": "Rock",
"PromotionInfo": {
"RadioStationsPlaying": [
"KHCR",
"KQBX",
"WTNR",
"WJJH"
],
"TourDates": {
"Seattle": "20150622",
"Cleveland": "20150630"
},
"Rotation": "Heavy"
}
}
{
"Artist": "The Acme Band",
"SongTitle": "Look Out, World",
"AlbumTitle": "The Buck Starts Here",
"Price": 0.99,
"Genre": "Rock"
}
```
Tieni presente quanto segue sulla tabella *Music*:
+ La chiave primaria per *Music* è composta da due attributi (*Artista* e *SongTitle*). Ogni item nella tabella deve avere questi due attributi. La combinazione di *Artista* e *SongTitle*distingue ogni elemento della tabella da tutti gli altri.
+ Oltre alla chiave primaria, la tabella *Music* è schematica, il che significa che né gli attributi né i loro tipi di dati devono essere definiti in anticipo. Ogni item può avere i propri attributi distinti.
+ Uno degli elementi ha un attributo nidificato (*PromotionInfo*), che contiene altri attributi nidificati. DynamoDB supporta gli attributi nidificati fino a un massimo di 32 livelli di profondità.
Per ulteriori informazioni, consulta [Utilizzo di tabelle e dati in DynamoDB](WorkingWithTables.md).
## Chiave primaria
Quando crei una tabella, oltre al nome della tabella, è necessario specificare la chiave primaria della tabella. La chiave primaria identifica in modo univoco ogni elemento della tabella, in modo che due elementi non possano avere la stessa chiave.
DynamoDB supporta due diversi tipi di chiavi primarie:
+ **Chiave di partizione**: una chiave primaria semplice, composta da un attributo noto come *chiave di partizione*.
DynamoDB utilizza il valore della chiave di partizione come input per una funzione hash interna. L'output dalla funzione hash determina la partizione (spazio di archiviazione fisico interno a DynamoDB) in cui verrà memorizzato l'elemento.
In una tabella che ha solo una chiave di partizione, non è possibile che due item abbiano lo stesso valore di chiave di partizione.
La tabella *People* descritta in [Tabelle, elementi e attributi](#HowItWorks.CoreComponents.TablesItemsAttributes) è un esempio di una tabella con una chiave primaria semplice (*PersonID*). È possibile accedere direttamente a qualsiasi elemento nella tabella *Persone* fornendo il *PersonId*valore per tale elemento.
+ **Chiave di partizione e chiave di ordinamento**: indicati come* chiave primaria composita*, questo tipo di chiave è costituito da due attributi. Il primo attributo è la *chiave di partizione* e il secondo attributo è la *chiave di ordinamento*.
DynamoDB utilizza il valore della chiave di partizione come input per una funzione hash interna. L'output dalla funzione hash determina la partizione (spazio di archiviazione fisico interno a DynamoDB) in cui verrà memorizzato l'elemento. Tutti gli elementi con lo stesso valore della chiave di partizione vengono memorizzati insieme, in ordine per valore di chiave di ordinamento.
In una tabella che ha una chiave di partizione e una chiave di ordinamento, è possibile che più elementi abbiano lo stesso valore della chiave di partizione. Tuttavia, questi elementi devono avere valori delle chiavi di ordinamento diversi.
La tabella *Music* descritta in [Tabelle, elementi e attributi](#HowItWorks.CoreComponents.TablesItemsAttributes) è un esempio di tabella con una chiave primaria composita (*Artist* and *SongTitle*). È possibile accedere direttamente a qualsiasi elemento della tabella *Musica*, se si forniscono l'*Artista* e *SongTitle*i valori per tale elemento.
Una chiave primaria composita offre maggiore flessibilità durante la query sui dati. Ad esempio, se si fornisci solo il valore per *Artist*, DynamoDB recupera tutti i brani di quell'artista. Per recuperare solo un sottoinsieme di brani di un particolare artista, puoi fornire un valore per *Artista* insieme a un intervallo di valori per. *SongTitle*
**Nota**
La chiave di partizione di un item è anche nota come *attributo hash*. Il termine *attributo hash* deriva dall'uso di una funzione hash interna in DynamoDB che distribuisce uniformemente gli elementi di dati tra le partizioni, in base ai valori delle chiavi delle partizioni.
La chiave di ordinamento di un item è anche nota come *attributo di intervallo*. Il termine *attributo di intervallo* deriva dal modo in cui DynamoDB memorizza gli elementi con la stessa chiave di partizione fisicamente vicini, ordinati in base al valore della chiave di ordinamento.
Ogni attributo chiave primaria deve essere scalare (ovvero può contenere solo un singolo valore). Gli unici tipi di dati consentiti per gli attributi della chiave primaria sono stringa, numero o binario. Non ci sono restrizioni di questo tipo per altri attributi non di chiave.
## Indici secondari
Puoi creare uno o più indici secondari su una tabella. Un *indice secondario* consente di eseguire query sui dati nella tabella utilizzando una chiave alternativa, oltre alle query sulla chiave primaria. DynamoDB non richiede l'utilizzo di indici, ma offre maggiore flessibilità alle applicazioni durante l'esecuzione di query sui dati. Dopo aver creato un indice secondario su una tabella, puoi leggere i dati dall'indice più o meno allo stesso modo della tabella.
DynamoDB supporta due diversi tipi di indici:
+ Indice secondario globale: un indice con una chiave di partizione e una chiave di ordinamento che possono essere differenti da quelle presenti sulla tabella. I valori della chiave primaria negli indici secondari globali non devono necessariamente essere univoci.
+ Indice secondario locale: un indice con la stessa chiave di partizione della tabella ma con una chiave di ordinamento diversa.
In DynamoDB, gli indici secondari globali GSIs () sono indici che coprono l'intera tabella e consentono di eseguire query su tutte le chiavi di partizione. Gli indici secondari locali (LSIs) sono indici che hanno la stessa chiave di partizione della tabella di base ma una chiave di ordinamento diversa.
Ogni tabella in DynamoDB ha una quota di 20 indici secondari globali (quota predefinita) e 5 indici secondari locali.
Nella tabella *Music* di esempio mostrata in precedenza, è possibile interrogare gli elementi di dati per *Artista* (chiave di partizione) o per *Artista* e *SongTitle*(chiave di partizione e chiave di ordinamento). E se volessi interrogare i dati anche per *genere* e? *AlbumTitle* Per fare ciò, potreste creare un indice su *Genre* e *AlbumTitle*quindi interrogare l'indice più o meno allo stesso modo in cui interroghereste la tabella *Music*.
Il diagramma seguente mostra la tabella *Music* di esempio, con un nuovo indice chiamato *GenreAlbumTitle*. Nell'indice, *Genre* è la chiave di partizione e *AlbumTitle*la chiave di ordinamento.
| Tabella musicale | *GenreAlbumTitle* |
| --- | --- |
|
{
"Artist": "No One You Know",
"SongTitle": "My Dog Spot",
"AlbumTitle": "Hey Now",
"Price": 1.98,
"Genre": "Country",
"CriticRating": 8.4
}
|
{
"Genre": "Country",
"AlbumTitle": "Hey Now",
"Artist": "No One You Know",
"SongTitle": "My Dog Spot"
}
|
|
{
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road",
"AlbumTitle": "Somewhat Famous",
"Genre": "Country",
"CriticRating": 8.4,
"Year": 1984
}
|
{
"Genre": "Country",
"AlbumTitle": "Somewhat Famous",
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road"
}
|
|
{
"Artist": "The Acme Band",
"SongTitle": "Still in Love",
"AlbumTitle": "The Buck Starts Here",
"Price": 2.47,
"Genre": "Rock",
"PromotionInfo": {
"RadioStationsPlaying": {
"KHCR",
"KQBX",
"WTNR",
"WJJH"
},
"TourDates": {
"Seattle": "20150622",
"Cleveland": "20150630"
},
"Rotation": "Heavy"
}
}
|
{
"Genre": "Rock",
"AlbumTitle": "The Buck Starts Here",
"Artist": "The Acme Band",
"SongTitle": "Still In Love"
}
|
|
{
"Artist": "The Acme Band",
"SongTitle": "Look Out, World",
"AlbumTitle": "The Buck Starts Here",
"Price": 0.99,
"Genre": "Rock"
}
|
{
"Genre": "Rock",
"AlbumTitle": "The Buck Starts Here",
"Artist": "The Acme Band",
"SongTitle": "Look Out, World"
}
|
Nota quanto segue sull'*GenreAlbumTitle*indice:
+ Ogni indice appartiene a una tabella chiamata la *tabella di base* dell'indice. Nell'esempio precedente, *Music è la* tabella di base per l'*GenreAlbumTitle*indice.
+ DynamoDB conserva gli indici automaticamente. Quando si aggiunge, aggiorna o elimina un elemento nella tabella di base, DynamoDB aggiunge, aggiorna o elimina l'elemento corrispondente in tutti gli indici che appartengono a quella tabella.
+ Quando crei un indice, puoi specificare quali attributi verranno copiati o *proiettati*, dalla tabella di base all'indice. Come minimo, DynamoDB proietta gli attributi della chiave dalla tabella di base nell'indice. Questo è il caso di `GenreAlbumTitle`, in cui vengono proiettati solo gli attributi della chiave della tabella `Music` nell'indice.
È possibile eseguire una query nell'*GenreAlbumTitle*indice per trovare tutti gli album di un particolare genere (ad esempio, tutti gli album *Rock*). Puoi eseguire la query sull'indice per trovare tutti gli album di un determinato genere (ad esempio, tutti gli album *Country* con il titolo che inizia con la lettera H).
Per ulteriori informazioni, consulta [Miglioramento dell’accesso ai dati con gli indici secondari in DynamoDB](SecondaryIndexes.md).
## DynamoDB Streams
DynamoDB Streams è una funzionalità opzionale che cattura gli eventi di modifica dei dati nelle tabelle DynamoDB. I dati relativi a questi eventi vengono visualizzati nel flusso pressoché in tempo reale e nell'ordine in cui si sono verificati gli eventi.
Ogni evento è rappresentato da un *record di flusso*. Se su una tabella viene abilitato un flusso, DynamoDB Streams scrive un record di flusso ogni volta che si verifica uno dei seguenti eventi:
+ Una nuova voce viene aggiunta alla tabella, il flusso acquisisce un'immagine dell'intera voce, inclusi tutti i suoi attributi.
+ Una voce viene aggiornata, il flusso acquisisce l'immagine "prima" e "dopo" della modifica di qualsiasi attributo nella voce.
+ Una voce viene eliminata dalla tabella, il flusso acquisisce un'immagine dell'intera voce prima che venga cancellata.
Ogni record di flusso contiene anche il nome della tabella, la data e l'ora dell'evento e altri metadati. I record di flusso hanno una durata di 24 ore e dopo vengono automaticamente rimossi dal flusso.
Puoi utilizzare DynamoDB Streams AWS Lambda insieme per creare *un codice trigger che viene eseguito automaticamente ogni volta che un* evento di interesse viene visualizzato in uno stream. Ad esempio, considera la tabella *Customers* contenente le informazioni sui clienti di un'azienda. Supponiamo di voler inviare una e-mail di benvenuto a ogni nuovo cliente. È possibile abilitare un flusso su quella tabella e quindi associare il flusso a una funzione Lambda. La funzione Lambda viene eseguita ogni volta che viene visualizzato un nuovo record di flusso, ma vengono elaborati solo i nuovi elementi aggiunti alla tabella *Customers*. Per ogni elemento che ha un attributo `EmailAddress`, la funzione Lambda richiama Amazon Simple Email Service (Amazon SES) per inviare un messaggio e-mail a quell'indirizzo.
![\[Integrazione dei flussi DynamoDB e Lambda per inviare automaticamente un’e-mail di benvenuto ai nuovi clienti.\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/images/HowItWorksStreams.png)
**Nota**
In questo esempio, l'ultimo cliente, Craig Roe, non riceverà un messaggio e-mail perché non ha un `EmailAddress`.
Oltre ai trigger, DynamoDB Streams consente soluzioni potenti come la replica dei dati all'interno e AWS tra le regioni, le viste materializzate dei dati nelle tabelle DynamoDB, l'analisi dei dati utilizzando le viste materializzate Kinesis e molto altro.
Per ulteriori informazioni, consulta [Acquisizione dei dati di modifica per DynamoDB Streams](Streams.md).
# API DynamoDB
Per utilizzare Amazon DynamoDB, la propria applicazione deve usare alcune semplici operazioni API. Di seguito è riportato un riepilogo delle operazioni organizzate per categoria.
**Nota**
Per l'elenco completo delle operazioni, consulta la [Documentazione di riferimento dell'API Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/Welcome.html).
**Topics**
+ [Piano di controllo](#HowItWorks.API.ControlPlane)
+ [Piano dati](#HowItWorks.API.DataPlane)
+ [DynamoDB Streams](#HowItWorks.API.Streams)
+ [Transazioni](#HowItWorks.API.Transactions)
## Piano di controllo
Le operazioni del *piano di controllo* consentono di creare e gestire le tabelle DynamoDB. Ti permettono anche di utilizzare indici, flussi e altri oggetti che dipendono dalle tabelle.
+ `CreateTable`: crea una nuova tabella. Se si desidera, è possibile creare uno o più indici secondari e abilitare DynamoDB Streams per la tabella.
+ `DescribeTable`: restituisce informazioni su una tabella, come lo schema della chiave primaria, le impostazioni di velocità effettiva e le informazioni sugli indici.
+ `ListTables`: restituisce i nomi di tutte le tabelle in un elenco.
+ `UpdateTable`: modifica le impostazioni di una tabella o dei relativi indici, crea o rimuove nuovi indici su una tabella o modifica le impostazioni di DynamoDB Streams per una tabella.
+ `DeleteTable`: rimuove una tabella e tutti i relativi oggetti dipendenti da DynamoDB.
## Piano dati
Le operazioni *piano dei dati* consentono di eseguire operazioni di creazione, lettura, aggiornamento ed eliminazione (chiamate anche *CRUD*) sui dati in una tabella. Alcune operazioni del piano dati consentono inoltre di leggere i dati da un indice secondario.
Puoi utilizzare[PartiQL: un linguaggio di query compatibile con SQL per Amazon DynamoDB](ql-reference.md), per eseguire queste operazioni CRUD oppure puoi utilizzare il classico CRUD di DynamoDB che separa ogni operazione in una chiamata API distinta. APIs
### PartiQL: un linguaggio di query compatibile con SQL
+ `ExecuteStatement`: legge più elementi da una tabella. È inoltre possibile scrivere o aggiornare un singolo elemento da una tabella. Quando si scrive o si aggiorna un singolo elemento, è necessario specificare gli attributi della chiave primaria.
+ `BatchExecuteStatement`: scrive, aggiorna o legge più elementi da una tabella. Questa operazione è più efficiente di `ExecuteStatement` perché l'applicazione ha bisogno solo di un singolo viaggio di andata e ritorno sulla rete per scrivere o leggere gli elementi.
### Classico APIs
#### Creazione dei dati
+ `PutItem`: scrive un singolo elemento in una tabella. È necessario specificare gli attributi della chiave primaria, ma non è necessario specificare altri attributi.
+ `BatchWriteItem`: scrive fino a 25 elementi in una tabella. Questa operazione è più efficiente della chiamata ripetuta di `PutItem` perché la tua applicazione ha bisogno solo di un singolo round trip di rete per scrivere gli elementi.
#### Lettura dei dati
+ `GetItem`: recupera un singolo elemento da una tabella. È necessario specificare la chiave primaria per l'item desiderato. Puoi recuperare l'intero item o solo un sottoinsieme dei suoi attributi.
+ `BatchGetItem`: richiama fino a 100 elementi da una o più tabelle. Questa operazione è più efficiente della chiamata ripetuta di `GetItem` perché la tua applicazione ha bisogno solo di un singolo round trip di rete per leggere gli elementi.
+ `Query`: recupera tutti gli elementi che hanno una chiave di partizione specifica. È necessario specificare il valore della chiave di partizione. Puoi recuperare gli interi item o solo un sottoinsieme dei loro attributi. Facoltativamente, puoi applicare una condizione ai valori delle chiavi di ordinamento, in modo da recuperare solo un sottoinsieme di dati con la stessa chiave di partizione. Puoi utilizzare questa operazione su una tabella, a condizione che la tabella abbia sia una chiave di partizione che una chiave di ordinamento. Puoi anche utilizzare questa operazione su un indice, a condizione che l'indice abbia sia una chiave di partizione che una chiave di ordinamento.
+ `Scan`: recupera tutti gli elementi nella tabella o nell'indice specificati. Puoi recuperare gli interi item o solo un sottoinsieme dei loro attributi. Facoltativamente, puoi applicare una condizione di filtro per restituire solo i valori che ti interessano e scartare il resto.
#### Aggiornamento dei dati
+ `UpdateItem`: modifica uno o più attributi in un elemento. Dovrai specificare la chiave primaria per l'item che vuoi modificare. Puoi aggiungere nuovi attributi e modificare o rimuovere gli attributi esistenti. Puoi inoltre eseguire aggiornamenti condizionali, in modo che l'aggiornamento abbia esito positivo solo quando viene soddisfatta una condizione definita dall'utente. Facoltativamente, puoi implementare un contatore atomico che incrementa o decrementa un attributo numerico senza interferire con altre richieste di scrittura.
#### Eliminazione di dati
+ `DeleteItem`: elimina un singolo elemento da una tabella. Dovrai specificare la chiave primaria per l'item che vuoi eliminare.
+ `BatchWriteItem`: elimina fino a 25 elementi da una o più tabelle. Questa operazione è più efficiente della chiamata ripetuta di `DeleteItem` perché la tua applicazione ha bisogno solo di un singolo round trip di rete per eliminare gli elementi.
**Nota**
È possibile utilizzare `BatchWriteItem` sia per creare che per eliminare i dati.
## DynamoDB Streams
Le operazioni di *DynamoDB Streams* consentono di abilitare o disabilitare un flusso su una tabella e consentire l'accesso ai record di modifica dei dati contenuti in un flusso.
+ `ListStreams`: restituisce un elenco di tutti i flussi o solo il flusso per una tabella specifica.
+ `DescribeStream`: restituisce le informazioni su un flusso, come ad esempio il suo Amazon Resource Name (ARN) e dove l'applicazione può iniziare a leggere i primi record di flusso.
+ `GetShardIterator`: restituisce un *iteratore di partizioni* che è una struttura dati che l'applicazione utilizza per recuperare i record dal flusso.
+ `GetRecords`: recupera uno o più record di flusso, utilizzando un determinato iteratore di partizioni.
## Transazioni
La *transazioni* forniscono atomicità, coerenza, isolamento e durabilità (ACID), consentendoti di mantenere più facilmente dati corretti nelle applicazioni.
È possibile utilizzare[PartiQL: un linguaggio di query compatibile con SQL per Amazon DynamoDB](ql-reference.md), per eseguire operazioni transazionali oppure è possibile utilizzare il classico CRUD di DynamoDB APIs che separa ogni operazione in una chiamata API distinta.
### PartiQL: un linguaggio di query compatibile con SQL
+ `ExecuteTransaction`— Un'operazione in batch che consente le operazioni CRUD su più elementi all'interno e tra tabelle con un risultato garantito. all-or-nothing
### Classico APIs
+ `TransactWriteItems`— Un'operazione in batch che consente di `Put` `Delete` eseguire operazioni su più elementi sia all'interno che tra tabelle diverse con un all-or-nothing risultato garantito. `Update`
+ `TransactGetItems`: un'operazione in batch che consente alle operazioni `Get` di recuperare più elementi da una o più tabelle.
# Tipi di dati e regole di denominazione supportati in Amazon DynamoDB
In questa sezione vengono descritte le regole di denominazione in Amazon DynamoDB e i vari tipi di dati supportati da DynamoDB. Sono presenti limiti che si applicano ai tipi di dati. Per ulteriori informazioni, consulta [Tipi di dati](Constraints.md#limits-data-types).
**Topics**
+ [Regole di denominazione](#HowItWorks.NamingRules)
+ [Tipi di dati](#HowItWorks.DataTypes)
+ [Descrittori del tipo di dati](#HowItWorks.DataTypeDescriptors)
## Regole di denominazione
Le tabelle, gli attributi e altri oggetti in DynamoDB devono avere un nome. I nomi devono essere significativi e concisi, ad esempio nomi come *Prodotti*, *Libri* e *Autori* sono auto-esplicativi.
Di seguito sono illustrate le regole di denominazione per DynamoDB:
+ Tutti i nomi devono essere codificati in UTF-8 e rispettano la differenza tra maiuscole e minuscole.
+ I nomi delle tabelle e i nomi degli indici devono avere una lunghezza compresa tra 3 e 255 caratteri e possono contenere solo i seguenti caratteri:
+ `a-z`
+ `A-Z `
+ ` 0-9 `
+ `_` (carattere di sottolineatura)
+ `-` (trattino)
+ `.` (punto)
+ I nomi degli attributi devono contenere almeno un carattere e non devono superare i 64 KB. Una best practice consiste nel mantenere i nomi degli attributi i più brevi possibile. Questo aiuta a ridurre le unità di richiesta di lettura utilizzate, poiché i nomi degli attributi sono inclusi nella misurazione dell'utilizzo dell'archiviazione e della velocità di trasmissione effettiva.
Di seguito sono elencate le eccezioni. Questi nomi di attributo non devono superare i 255 caratteri:
+ Nomi delle chiavi di partizione degli indici secondari
+ Nomi delle chiavi di ordinamento degli indici secondari
+ I nomi degli attributi proiettati specificati dall'utente (applicabile solo agli indici secondari locali).
### Parole riservate e caratteri speciali
DynamoDB ha una lista di parole riservate e caratteri speciali. Per un elenco completo, consulta [Parole riservate in DynamoDB](ReservedWords.md). Inoltre, i seguenti caratteri hanno un significato speciale in DynamoDB: **\$1** (cancelletto) e **:** (due punti).
Sebbene DynamoDB consenta di utilizzare le parole riservate e i caratteri speciali per i nomi, consigliamo di evitare di farlo perché comporta la definizione di variabili segnaposto ogni volta che questi nomi vengono utilizzati in un'espressione. Per ulteriori informazioni, consulta [Nomi di attributi di espressione (alias) in DynamoDB](Expressions.ExpressionAttributeNames.md).
## Tipi di dati
DynamoDB supporta molti tipi di dati diversi per gli attributi all'interno di una tabella. Possono essere classificati come segue:
+ **Tipi scalari**: un tipo scalare può rappresentare esattamente un valore. I tipi scalari sono numero, stringa, binario, booleano e null.
+ **Tipi di documento**: un tipo di documento può rappresentare una struttura complessa con attributi nidificati, ad esempio in un documento JSON. I tipi di documento sono elenco e mappa.
+ **Tipi di set**: un tipo di set può rappresentare più valori scalari. I tipi di set sono set di stringhe, set di numeri e set di binari.
Quando si crea una tabella o un indice secondario, è necessario specificare i nomi e i tipi di dati di ciascun attributo di chiave primaria (chiave di partizione e chiave di ordinamento). Inoltre, ogni attributo chiave primaria deve essere definito come tipo stringa, numero o binario.
DynamoDB è un database NoSQL *senza schema*. Ciò significa che, oltre agli attributi della chiave primaria, non è necessario definire attributi o tipi di dati quando si creano tabelle. In confronto, i database relazionali richiedono di definire i nomi e i tipi di dati di ogni colonna quando crei una tabella.
Le seguenti sono descrizioni di ciascun tipo di dati, insieme a esempi in formato JSON.
### Tipi scalari
I tipi scalari sono numero, stringa, binario, booleano e null.
#### Numero
I numeri possono essere positivi, negativi o zero. I numeri possono avere una precisione fino a 38 cifre. Il superamento di questo limite comporta un'eccezione. Se è necessaria una maggiore precisione di quella a 38 cifre, è possibile utilizzare le stringhe.
+ Intervallo positivo: da 1E-130 a 9.9999999999999999999999999999999999999E\$1125
+ Intervallo negativo: da -9.9999999999999999999999999999999999999E\$1125 a -1E-130
In DynamoDB, i numeri sono rappresentati come lunghezza variabile. Gli zero iniziali e finali vengono tagliati.
Tutti i numeri vengono inviati a DynamoDB attraverso la rete come stringhe in modo da aumentare al massimo la compatibilità tra linguaggi e librerie. Tuttavia, DynamoDB li tratta come attributi di tipo number per operazioni matematiche.
Puoi utilizzare il tipo di dati numero per rappresentare una data o un timestamp. Un modo per eseguire questa operazione consiste nell'utilizzare il tempo epoch, ovvero il numero di secondi trascorsi dalle 00:00:00 UTC del 1° gennaio 1970. Ad esempio, il tempo epoca (Unix epoch) `1437136300` rappresenta le 12:31:40 UTC del 17 luglio 2015.
Per ulteriori informazioni, vedere [http://en.wikipedia. org/wiki/Unix\$1ora.](http://en.wikipedia.org/wiki/Unix_time)
#### Stringa
Le stringhe sono Unicode con codifica binaria UTF-8. La lunghezza minima di una stringa può essere pari a zero se l'attributo non viene utilizzato come chiave per un indice o una tabella ed è vincolato dal limite di dimensione massima dell'elemento DynamoDB pari a 400 KB.
Le seguenti limitazioni addizionali si applicano agli attributi della chiave primaria che sono definiti come tipo string:
+ Per una chiave primaria semplice, la lunghezza massima del valore del primo attributo (la chiave di partizione) è 2.048 bytes.
+ Per una chiave primaria composita, la lunghezza massima del valore del secondo attributo (la chiave di ordinamento) è 1.024 byte.
DynamoDB raccoglie e confronta le stringhe utilizzando i byte della codifica di stringa UTF-8 sottostante. Ad esempio, "`a`" (0x61) è maggiore di "`A`" (0x41) e "`¿`" (0xC2BF) è maggiore di "`z`" (0x7A).
Puoi utilizzare il tipo di dati stringa per rappresentare una data o un timestamp. Un modo per farlo è utilizzando le stringhe ISO 8601, come mostrato in questi esempi:
+ `2016-02-15`
+ `2015-12-21T17:42:34Z`
+ `20150311T122706Z`
Per ulteriori informazioni, consulta [http://en.wikipedia. org/wiki/ISO\$18601](http://en.wikipedia.org/wiki/ISO_8601).
**Nota**
A differenza dei database relazionali tradizionali, DynamoDB non supporta a livello nativo dati di tipo data/ora. Può invece risultare utile per archiviare i dati di data e ora come tipo di dati numerici, utilizzando il formato Unix Epoch.
#### Binario
Gli attributi di tipo binario possono memorizzare qualsiasi tipo di dati binari, ad esempio testi compressi, dati crittografati o immagini. Quando DynamoDB confronta i valori binari tratta ciascun byte dei dati binari come non firmato.
La lunghezza di un attributo binario può essere zero, se l'attributo non viene utilizzato come chiave per un indice o una tabella ed è vincolato dal limite di dimensione massima dell'elemento DynamoDB pari a 400 KB.
Se definisci un attributo di chiave primaria come attributo di tipo binario, si applicano i seguenti vincoli aggiuntivi:
+ Per una chiave primaria semplice, la lunghezza massima del valore del primo attributo (la chiave di partizione) è 2.048 bytes.
+ Per una chiave primaria composita, la lunghezza massima del valore del secondo attributo (la chiave di ordinamento) è 1.024 byte.
Le applicazioni devono codificare i valori binari in formato codificato Base64 prima di inviarli a DynamoDB. Quando vengono ricevuti questi valori, DynamoDB decodifica i dati in una matrice di byte non firmata e li usa come lunghezza dell'attributo binario.
L'esempio seguente è un attributo binario che utilizza il testo con codifica Base64:
```
dGhpcyB0ZXh0IGlzIGJhc2U2NC1lbmNvZGVk
```
#### Booleano
Un attributo di tipo booleano può memorizzare `true` o `false`.
#### Null
Null rappresenta un attributo con uno stato sconosciuto o non definito.
### Tipi di documento
I tipi di documento sono elenco e mappa. Questi tipi di dati possono essere annidati l'uno nell'altro per rappresentare strutture dati complesse fino a una profondità di 32 livelli.
Non esiste alcun limite al numero di valori in un elenco o in una mappa, purché l'elemento contenente i valori rientri nel limite di dimensione dell'elemento di DynamoDB (400 KB).
Un valore di attributo può essere una stringa vuota o un valore binario se l'attributo non viene utilizzato per una tabella o una chiave dell'indice. Il valore attributo non può essere un set vuoto (String Set, Number Set o Binary Set), tuttavia sono consentite liste e mappe vuote. Valori String e Binary vuoti sono consentiti all'interno di elenchi e mappe. Per ulteriori informazioni, consulta [Attributes](Constraints.md#limits-attributes).
#### List
Un attributo di tipo elenco può memorizzare una raccolta di valori ordinata. Gli elenchi sono racchiusi tra parentesi quadre: `[ ... ]`
Un elenco è simile a una matrice JSON. Non ci sono restrizioni sui tipi di dati che possono essere memorizzati in un elemento di elenco e gli elementi di un elemento di elenco non devono essere dello stesso tipo.
L'esempio seguente mostra un elenco che contiene due stringhe e un numero:
```
FavoriteThings: ["Cookies", "Coffee", 3.14159]
```
**Nota**
DynamoDB consente di utilizzare i singoli elementi all'interno di elenchi, anche se tali elementi sono profondamente annidati. Per ulteriori informazioni, consulta [Utilizzo di espressioni in DynamoDB](Expressions.md).
#### Eseguire la mappatura
Un attributo di tipo mappa può memorizzare una raccolta di coppie nome-valore non ordinata. Le mappe sono racchiuse tra parentesi graffe: `{ ... }`
Una mappa è simile a un oggetto JSON. Non ci sono restrizioni sui tipi di dati che possono essere memorizzati in un elemento di mappa e gli elementi in una mappa non devono essere dello stesso tipo.
Le mappe sono ideali per la memorizzazione di documenti JSON in DynamoDB. L'esempio seguente mostra una mappa che contiene una stringa, un numero e un elenco annidato che contiene un'altra mappa.
```
{
Day: "Monday",
UnreadEmails: 42,
ItemsOnMyDesk: [
"Coffee Cup",
"Telephone",
{
Pens: { Quantity : 3},
Pencils: { Quantity : 2},
Erasers: { Quantity : 1}
}
]
}
```
**Nota**
DynamoDB consente di utilizzare i singoli elementi all'interno di mappe, anche se tali elementi sono profondamente annidati. Per ulteriori informazioni, consulta [Utilizzo di espressioni in DynamoDB](Expressions.md).
### Set
DynamoDB supporta tipi che rappresentano set di valori number, string o binary. Tutti gli elementi di un set devono essere dello stesso tipo. Ad esempio, un attributo di tipo Number Set può contenere solo numeri, String Set può contenere solo stringhe e così via.
Non esiste alcun limite al numero di valori in un set, purché l'elemento contenente i valori rientri nel limite di dimensione dell'elemento di DynamoDB (400 KB).
Ogni valore all'interno di un set deve essere univoco. L'ordine dei valori all'interno di un set non viene mantenuto. Pertanto, le tue applicazioni non devono fare affidamento su nessun ordine di elementi particolare all'interno del set. DynamoDB non supporta set vuoti, tuttavia, all'interno di un set sono consentiti stringhe vuote e valori binari.
L'esempio seguente mostra un set di stringhe, un set di numeri e un set binario:
```
["Black", "Green", "Red"]
[42.2, -19, 7.5, 3.14]
["U3Vubnk=", "UmFpbnk=", "U25vd3k="]
```
## Descrittori del tipo di dati
Il protocollo API DynamoDB di basso livello utilizza *descrittori del tipo di dati* come token che indicano a DynamoDB come interpretare ogni attributo.
Di seguito è riportato un elenco completo dei descrittori del tipo di dati di DynamoDB:
+ **`S`**: String
+ **`N`**: Number
+ **`B`**: binario
+ **`BOOL`**: Boolean
+ **`NULL`**: null
+ **`M`**: Map
+ **`L`**: list
+ **`SS`**: set string
+ **`NS`**: set numerico
+ **`BS`**: set binario
# Classi di tabella DynamoDB
DynamoDB offre due classi di tabelle progettate per aiutarti a ottimizzare i costi. La classe di tabella DynamoDB Standard è quella predefinita ed è consigliata per la maggior parte dei carichi di lavoro. La classe di tabella DynamoDB Standard-Infrequent Access (DynamoDB Standard (accesso infrequente)) è ottimizzata per le tabelle in cui l'archiviazione è il costo principale. Ad esempio, le tabelle che archiviano dati a cui si accede raramente, come i registri delle applicazioni, i vecchi post sui social media, la cronologia degli ordini di e-commerce e i risultati di gioco precedenti, sono buoni candidati per la classe di tabella Standard (accesso infrequente). Per i dettagli sui prezzi, consulta [Prezzi di Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/on-demand/).
Ogni tabella DynamoDB è associata a una classe di tabella (DynamoDB Standard, per impostazione predefinita). Tutti gli indici secondari associati alla tabella utilizzano la stessa classe di tabella. Ogni classe di tabella offre prezzi diversi per l'archiviazione dati e le richieste di lettura e scrittura. Puoi selezionare la classe di tabella più conveniente per la tua tabella in base ai relativi modelli di utilizzo di archiviazione e throughput.
La scelta di una classe di tabella non è permanente: puoi modificare questa impostazione utilizzando la Console di gestione AWS AWS CLI o l'SDK. AWS DynamoDB supporta anche la gestione della classe di tabelle AWS CloudFormation utilizzando tabelle a regione singola e tabelle globali. Per ulteriori informazioni sulla selezione della classe di tabella, consulta [Considerazioni sulla scelta di una classe di tabella in DynamoDB](WorkingWithTables.tableclasses.md).
# Partizioni e distribuzione dei dati in DynamoDB
Amazon DynamoDB memorizza i dati nelle partizioni. Una *partizione* è un'allocazione di storage per una tabella, supportata da unità a stato solido (SSDs) e replicata automaticamente su più zone di disponibilità all'interno di una regione. AWS La gestione delle partizioni è gestita interamente da DynamoDB: non è mai necessario gestire le partizioni da soli.
Quando crei una tabella, lo stato iniziale della tabella è `CREATING`. Durante questa fase, DynamoDB assegna partizioni sufficienti alla tabella in modo che possa gestire i requisiti di velocità effettiva assegnata. Puoi iniziare a scrivere e leggere i dati della tabella dopo che lo stato della tabella diventa `ACTIVE`.
DynamoDB alloca partizioni aggiuntive a una tabella nelle seguenti situazioni:
+ Se aumenti le impostazioni di throughput assegnato della tabella oltre quelle supportate dalle partizioni esistenti.
+ Se una partizione esistente esaurisce la capacità ed è necessario più spazio di storage.
La gestione delle partizioni avviene automaticamente in background ed è trasparente per le tue applicazioni. La tua tabella rimane disponibile e supporta completamente i requisiti di throughput assegnati.
Per ulteriori dettagli, consultare [Progettazione delle chiavi di partizione](bp-partition-key-design.md).
Anche gli indici secondari globali in DynamoDB sono costituiti da partizioni. I dati in un indice secondario globale sono memorizzati separatamente dai dati della tabella di base, ma le partizioni dell'indice si comportano in modo simile alle partizioni della tabella.
## Distribuzione dei dati: chiave di partizione
Se la tabella ha una chiave primaria semplice (solo chiave di partizione), DynamoDB memorizza e recupera ciascun elemento in base al valore della chiave di partizione.
Per scrivere un elemento nella tabella, DynamoDB utilizza il valore della chiave di partizione come input per una funzione hash interna. Il valore di output dalla funzione hash determina la partizione in cui verrà memorizzato l'item.
Per leggere un elemento della tabella, è necessario specificare il valore della chiave di partizione per l'elemento. DynamoDB utilizza questo valore come input per la funzione hash, producendo così la partizione in cui è possibile trovare l'elemento.
Il diagramma seguente mostra una tabella denominata *Pets* con più partizioni. La chiave primaria della tabella è *AnimalType*(viene mostrato solo questo attributo chiave). DynamoDB utilizza la funzione hash per determinare dove memorizzare un nuovo elemento, in questo caso in base al valore hash della stringa *Dog*. Tieni presenti che gli elementi non sono memorizzati in ordine. La posizione di ciascun item è determinata dal valore hash della chiave di partizione.
![\[Distribuzione degli elementi della tabella di DynamoDB tra le partizioni in base al valore hash della chiave di partizione.\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/images/HowItWorksPartitionKey.png)
**Nota**
DynamoDB è ottimizzato per una distribuzione uniforme degli elementi sulle partizioni di una tabella, indipendentemente dal numero di partizioni presenti. Ti consigliamo di scegliere una chiave di partizione che possa avere un numero elevato di valori distinti rispetto al numero di item nella tabella.
## Distribuzione dei dati: chiave di partizione e chiave di ordinamento
Se la tabella ha una chiave primaria composita (chiave di partizione e chiave di ordinamento), DynamoDB calcola il valore hash della chiave di partizione come descritto in [Distribuzione dei dati: chiave di partizione](#HowItWorks.Partitions.SimpleKey). Tuttavia, tende a mantenere gli elementi che hanno lo stesso valore della chiave di partizione vicini e ordinati in base al valore dell’attributo della chiave di ordinamento. L’insieme di elementi che hanno lo stesso valore della chiave di partizione è denominato raccolta di elementi. Le raccolte di elementi sono ottimizzate per il recupero efficiente degli intervalli di elementi all’interno della raccolta. Se la tabella non ha indici secondari locali, DynamoDB suddividerà automaticamente la raccolta di elementi su tutte le partizioni necessarie per archiviare i dati e garantire il throughput di lettura e scrittura.
Per scrivere un elemento nella tabella, DynamoDB calcola il valore hash della chiave di partizione per determinare quale partizione lo deve contenere. In quella partizione, diversi item potrebbero avere lo stesso valore della chiave di partizione. Pertanto, DynamoDB memorizza l'elemento tra gli altri con la stessa chiave di partizione, in ordine crescente e per chiave di ordinamento.
Per leggere un elemento della tabella, è necessario specificare il valore della chiave di partizione e della chiave di ordinamento. DynamoDB calcola il valore hash della chiave di partizione, producendo la partizione in cui è possibile trovare l'elemento.
Se gli elementi desiderati hanno lo stesso valore della chiave di partizione è possibile leggere più elementi dalla tabella in una singola operazione (`Query`). DynamoDB restituisce tutti gli elementi con tale valore della chiave di partizione. Facoltativamente, puoi applicare una condizione alla chiave di ordinamento in modo che restituisca solo gli elementi all'interno di un determinato intervallo di valori.
Supponiamo che la tabella *Pets* abbia una chiave primaria composita composta da *AnimalType*(chiave di partizione) e *Name* (chiave di ordinamento). Il seguente diagramma mostra DynamoDB che scrive un elemento con un valore della chiave di partizione uguale a *Dog* e un valore della chiave di ordinamento uguale a *Fido*.
![\[DynamoDB archivia un elemento con una chiave di partizione composita e ordina l’elemento utilizzando il valore dell’attributo chiave di ordinamento.\]](http://docs.aws.amazon.com/it_it/amazondynamodb/latest/developerguide/images/HowItWorksPartitionKeySortKey.png)
Per leggere lo stesso elemento dalla tabella *Pets*, DynamoDB calcola il valore hash di *Dog*, producendo la partizione in cui sono memorizzati questi elementi. DynamoDB esegue quindi la scansione dei valori degli attributi della chiave di ordinamento finché non trova *Fido*.
Per leggere tutti gli elementi con un *AnimalType*of *Dog*, puoi eseguire un'`Query`operazione senza specificare una condizione di chiave di ordinamento. Come impostazione predefinita, le voci vengono restituite nell'ordine in cui sono memorizzate (ovvero in ordine crescente per chiave di ordinamento). Facoltativamente, puoi richiedere l'ordine decrescente.
Per eseguire la query solo di alcune voci *Dog*, puoi applicare una condizione alla chiave di ordinamento (ad esempio, solo le voci *Dog* dove *Name* inizia con una lettera compresa nell'intervallo da `A` a `K`).
**Nota**
In una tabella DynamoDB, non esiste un limite superiore per il numero di valori delle chiavi di ordinamento distinti per valore di chiave di partizione. Se c'è bisogno di memorizzare miliardi di elementi *Dog* nella tabella *Pets*, DynamoDB assegna automaticamente l'archiviazione sufficiente per gestire questo requisito.
# 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"
}
```
# Risorse e strumenti di apprendimento di Amazon DynamoDB
Puoi utilizzare le seguenti risorse aggiuntive per comprendere e utilizzare DynamoDB.
**Topics**
+ [Strumenti per la codifica e la visualizzazione](#AdditionalResources.Tools)
+ [Articoli di linee guida prescrittive](#AdditionalResources.PrescriptiveGuidance)
+ [Articoli del Knowledge Center](#AdditionalResources.KnowledgeCenter)
+ [Post di blog, repository e guide](#AdditionalResources.Guides)
+ [Presentazioni di modellazione dei dati e di modelli di progettazione](#AdditionalResources.DataModeling)
+ [Corsi di formazione](#AdditionalResources.Training)
## Strumenti per la codifica e la visualizzazione
Puoi utilizzare i seguenti strumenti di codifica e visualizzazione per utilizzare DynamoDB:
+ [NoSQL Workbench per Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.html): uno strumento visivo unificato che consente di progettare, creare, eseguire query e gestire tabelle DynamoDB. Fornisce funzionalità di modellazione e visualizzazione dei dati e sviluppo di query.
+ [Dynobase](https://dynobase.dev/): uno strumento desktop che facilita la visualizzazione e le operazioni con tabelle DynamoDB, la creazione di codice delle applicazioni e la modifica dei record con la convalida in tempo reale.
+ [DynamoDB](https://github.com/jeremydaly/dynamodb-toolbox) Toolbox — Un progetto di Jeremy Daly che fornisce utili utilità per lavorare con la modellazione dei dati e Node.js. JavaScript
+ [DynamoDB Streams Processor](https://github.com/jeremydaly/dynamodb-streams-processor): uno strumento semplice che facilita notevolmente le operazioni con i [flussi DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html).
## Articoli di linee guida prescrittive
AWS Prescriptive Guidance fornisce strategie, guide e modelli collaudati per accelerare i tuoi progetti. Queste risorse sono state sviluppate da esperti di AWS tecnologia e dalla comunità globale di AWS partner, sulla base di anni di esperienza nell'aiutare i clienti a raggiungere i propri obiettivi aziendali.
**Modellazione e migrazione dei dati**
+ [Un modello di dati gerarchico in DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-hierarchical-data-model/introduction.html)
+ [Modellazione dei dati con DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-data-modeling/welcome.html)
+ [Migrare un database Oracle su DynamoDB utilizzando AWS DMS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.html)
**Tabelle globali**
+ [Utilizzo delle tabelle globali di Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-global-tables/introduction.html)
**Serverless**
+ [Implementa il modello di saga serverless con AWS Step Functions](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/implement-the-serverless-saga-pattern-by-using-aws-step-functions.html)
**Architettura SaaS**
+ [Manage tenants across multiple SaaS products on a single control plane](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/manage-tenants-across-multiple-saas-products-on-a-single-control-plane.html) (Gestione dei tenant su più prodotti SaaS su un unico piano di controllo (control-plane))
+ [Tenant onboarding in SaaS architecture for the silo model using C\$1 and AWS CDK](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) (Integrazione dei tenant nell'architettura SaaS per il modello a silo con C\$1 e AWS CDK)
**Protezione e spostamento dei dati**
+ [Configurazione dell'accesso multi-account in Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)
+ [Opzioni di copia completa della tabella per DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-full-table-copy-options/)
+ [Strategia di ripristino di emergenza per database su AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/strategy-database-disaster-recovery/)
**Miscellaneous** (Varie)
+ [Aiuto per l'applicazione di tag in DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/help-enforce-dynamodb-tagging.html)
**Procedure guidate video delle linee guida prescrittive**
+ [Utilizzo dell'architettura serverless per creare pipeline di dati](https://youtu.be/JiWHomdh1oI?)
+ [Novartis - Buying Engine: AI-powered Procurement Portal](https://youtu.be/vp8oPiHN4cA)
+ [Veritiv: abilita Insights per prevedere la domanda di vendita sui data lake AWS](https://youtu.be/jg85DzUZ9Ac)
+ [mimik: Utilizzo dell'Hybrid Edge Cloud per AWS supportare Edge Microservice Mesh](https://youtu.be/-S-R7MWRpaI)
+ [Change Data Capture with Amazon DynamoDB](https://youtu.be/6YVjzD-70p4)
Per ulteriori articoli e video sulle linee guida prescrittive per DynamoDB, consulta le [Linee guida prescrittive.](https://tiny.amazon.com/fiui3cog/ForinternaldemoofnewpageExternalURLwillbeneededforlive)
## Articoli del Knowledge Center
Gli articoli e i video del AWS Knowledge Center riguardano le domande e le richieste più frequenti che riceviamo dai AWS clienti. Di seguito sono riportati alcuni articoli attuali del Knowledge Center su attività specifiche relative a DynamoDB:
**Ottimizzazione dei costi**
+ [Come posso ottimizzare i costi con Amazon DynamoDB?](https://repost.aws/knowledge-center/dynamodb-optimize-costs)
**Limitazione della larghezza di banda della rete e latenza**
+ [Come faccio a risolvere i problemi di latenza elevata su una tabella Amazon DynamoDB?](https://repost.aws/knowledge-center/dynamodb-high-latency)
+ [Perché la tabella DynamoDB viene limitata nella larghezza di banda della rete?](https://repost.aws/knowledge-center/dynamodb-table-throttled)
+ [Perché la tabella DynamoDB on demand viene limitata nella larghezza di banda della rete?](https://repost.aws/knowledge-center/on-demand-table-throttling-dynamodb)
**Paginazione**
+ [Come posso implementare la paginazione in DynamoDB](https://repost.aws/knowledge-center/dynamodb-implement-pagination)
**Transazioni**
+ [Perché la mia chiamata API `TransactWriteItems` non riesce in DynamoDB](https://repost.aws/knowledge-center/dynamodb-transactwriteitems)
**Risoluzione dei problemi**
[]()
+ [Come posso risolvere i problemi relativi al dimensionamento automatico di DynamoDB?](https://repost.aws/knowledge-center/dynamodb-auto-scaling)
+ [Come posso risolvere gli errori HTTP 4XX in DynamoDB](https://repost.aws/knowledge-center/usererrors-dynamodb-table)
Per ulteriori articoli e video su DynamoDB, consulta gli [articoli del Knowledge Center](https://repost.aws/search/knowledge-center?globalSearch=dynamodb).
## Post di blog, repository e guide
Oltre alla [Guida per gli sviluppatori di DynamoDB](Introduction.md), sono disponibili molte risorse utili per utilizzare DynamoDB. Ecco alcuni post di blog, repository e guide selezionati per utilizzare DynamoDB:
+ AWS [https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/dotnet](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/dotnet)
+ [Il libro DynamoDB](https://www.dynamodbbook.com/): una guida completa di DeBrie Alex che insegna un [approccio](https://twitter.com/alexbdebrie) strategico alla modellazione dei dati con DynamoDB.
+ Guida [DynamoDB](https://www.dynamodbguide.com/): una guida aperta di DeBrie Alex che illustra i concetti [di](https://twitter.com/alexbdebrie) base e le funzionalità avanzate del database DynamoDB NoSQL.
+ [How to switch from RDBMS to DynamoDB in 20 easy steps](https://www.jeremydaly.com/how-to-switch-from-rdbms-to-dynamodb-in-20-easy-steps/) (Come passare da RDBMS a DynamoDB in 20 semplici fasi): un elenco di fasi utili per l'apprendimento della modellazione dei dati di [Jeremy Daly](https://twitter.com/jeremy_daly).
+ Cheat sheet di [ JavaScript DocumentClient DynamoDB: un cheat](https://github.com/dabit3/dynamodb-documentclient-cheat-sheet) sheet per aiutarti a iniziare a creare applicazioni con DynamoDB in un Node.js o in un ambiente. JavaScript
+ [DynamoDB Core Concept Videos](https://www.youtube.com/playlist?list=PLJo-rJlep0EDNtcDeHDMqsXJcuKMcrC5F) (Video relativi ai concetti fondamentali di DynamoDB): questa playlist illustra molti dei concetti fondamentali di DynamoDB.
## Presentazioni di modellazione dei dati e di modelli di progettazione
Puoi utilizzare le seguenti risorse sulla modellazione dei dati e sui modelli di progettazione per ottenere il massimo da DynamoDB:
+ [AWS re:Invent 2019: modellazione dei dati con DynamoDB](https://www.youtube.com/watch?v=DIQVJqiSUkE)
+ Una conferenza di [Alex DeBrie](https://twitter.com/alexbdebrie) che ti aiuta a iniziare con i principi della modellazione dei dati DynamoDB.
+ [AWS re:Invent 2020: Modellazione dei dati con DynamoDB — Parte 1](https://www.youtube.com/watch?v=fiP2e-g-r4g)
+ [AWS re:Invent 2020: Modellazione dei dati con DynamoDB — Parte 2](https://www.youtube.com/watch?v=0uLF1tjI_BI)
+ [AWS re:Invent 2017: modelli di progettazione avanzati](https://www.youtube.com/watch?v=jzeKPKpucS0)
+ [AWS re:Invent 2018: modelli di progettazione avanzati](https://www.youtube.com/watch?v=HaEPXoXVf2k)
+ [AWS re:Invent 2019: modelli di progettazione avanzati](https://www.youtube.com/watch?v=6yqfmXiZTlM)
+ Jeremy Daly condivide i suoi [12 consigli chiave](https://www.jeremydaly.com/takeaways-from-dynamodb-deep-dive-advanced-design-patterns-dat403/) di questa sessione.
+ [AWS re:Invent 2020: DynamoDB advanced design patterns – Part 1](https://www.youtube.com/watch?v=MF9a1UNOAQo&index=1) (Modelli di progettazione avanzata DynamoDB Parte 1)
+ [AWS re:Invent 2020: modelli di progettazione avanzati per DynamoDB — Parte 2](https://www.youtube.com/watch?v=_KNrRdWD25M&index=2)
+ [Orari d'ufficio di DynamoDB su Twitch](https://amazondynamodbofficehrs.splashthat.com/)
**Nota**
Ogni sessione copre diversi casi d'uso ed esempi.
## Corsi di formazione
Esistono diversi corsi di formazione e opzioni didattiche per ulteriori informazioni su DynamoDB. Ecco alcuni esempi:
+ [Sviluppo con Amazon DynamoDB](https://www.aws.training/Details/Curriculum?id=65583): progettato per portarti AWS dal principiante all'esperto nello sviluppo di applicazioni reali con modellazione dei dati per Amazon DynamoDB.
+ [Corso DynamoDB Deep-Dive](https://www.pluralsight.com/courses/aws-dynamodb-deep-dive-2019): un corso di Pluralsight.
+ [Amazon DynamoDB: creazione di applicazioni basate su database NoSQL — Un corso del team di formazione](https://www.edx.org/course/amazon-dynamodb-building-nosql-database-driven-app) e certificazione ospitato su edX. AWS