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 lettura di dati in una tabella
<a name="SQLtoNoSQL.ReadData"></a>

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
<a name="SQLtoNoSQL.ReadData.SingleItem"></a>

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

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

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
<a name="SQLtoNoSQL.ReadData.Query"></a>

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

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

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
<a name="SQLtoNoSQL.ReadData.Scan"></a>

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

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

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

------