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à.

# Differenze tra un database relazionale (SQL) e DynamoDB durante la modifica di dati in una tabella
<a name="SQLtoNoSQL.UpdateData"></a>

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

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

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).

------