# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao ler dados de uma tabela
<a name="SQLtoNoSQL.ReadData"></a>

Com o SQL, você usa a instrução `SELECT` para recuperar uma ou mais linhas de uma tabela. Use a cláusula `WHERE` para determinar os dados que são retornados para você.

Esse recurso é diferente ao usar o Amazon DynamoDB, que oferece as seguintes operações para leitura de dados:
+ `ExecuteStatement` recupera um ou vários itens de uma tabela. `BatchExecuteStatement` recupera vários itens de tabelas diferentes em uma única operação. Ambas as operações usam [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), uma linguagem de consulta compatível com SQL.
+ `GetItem`: recupera um único item de uma tabela. Esta é a maneira mais eficiente de ler um único item, pois ele dá acesso direto à localização física do item. (O DynamoDB também oferece a operação `BatchGetItem`, permitindo que você realize até 100 chamadas `GetItem` em uma única operação.)
+ `Query`: recupera todos os itens que têm uma chave de partição específica. Nesses itens, você pode aplicar uma condição à chave de classificação e recuperar apenas um subconjunto dos dados. `Query` fornece acesso rápido e eficiente às partições em que os dados são armazenados. (Para ter mais informações, consulte [Partições e distribuição de dados no DynamoDB](HowItWorks.Partitions.md).)
+ `Scan`: recupera todos os itens da tabela especificada. (Essa operação não deve ser usada com tabelas grandes, pois ela pode consumir grandes quantidades de recursos do sistema.)

**nota**  
Com um banco de dados relacional, você pode usar a instrução `SELECT` para juntar os dados de várias tabelas e retornar os resultados. Junções são fundamentais para o modelo relacional. Para garantir que as junções sejam executadas de forma eficiente, o banco de dados e suas aplicações devem ter a performance ajustada de forma contínua. O DynamoDB é um banco de dados NoSQL não relacional que não é compatível com junções de tabelas. Em vez disso, os aplicativos leem dados de uma tabela por vez. 

As seções a seguir descrevem diferentes casos de uso para a leitura de dados e como executar essas tarefas com um banco de dados relacional e com o DynamoDB.

**Topics**
+ [Diferenças na leitura de um item usando a respectiva chave primária](SQLtoNoSQL.ReadData.SingleItem.md)
+ [Diferenças na consulta de uma tabela](SQLtoNoSQL.ReadData.Query.md)
+ [Diferenças na varredura de uma tabela](SQLtoNoSQL.ReadData.Scan.md)

# Diferenças na leitura de um item usando a respectiva chave primária
<a name="SQLtoNoSQL.ReadData.SingleItem"></a>

Um padrão de acesso comuns para bancos de dados é ler um único item de uma tabela. Você deve especificar a chave primária do item que deseja.

**Topics**
+ [Ler um item usando a respectiva chave primária com o SQL](#SQLtoNoSQL.ReadData.SingleItem.SQL)
+ [Ler um item usando a respectiva chave primária no DynamoDB](#SQLtoNoSQL.ReadData.SingleItem.DynamoDB)

## Ler um item usando a respectiva chave primária com o SQL
<a name="SQLtoNoSQL.ReadData.SingleItem.SQL"></a>

No SQL, você usa a instrução `SELECT` para recuperar dados de uma tabela. Você pode solicitar uma ou mais colunas no resultado (ou todas elas, se você usar o operador `*`). A cláusula `WHERE` determina quais linhas devem ser retornadas.

A seguinte é uma instrução `SELECT` para recuperar uma única linha da tabela *Music*. A cláusula `WHERE` especifica os valores de chave primária.

```
SELECT *
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```

É possível modificar a consulta para recuperar somente um subconjunto de colunas.

```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```

Observe que a chave primária dessa tabela consiste em *Artist* e *SongTitle*.

## Ler um item usando a respectiva chave primária no DynamoDB
<a name="SQLtoNoSQL.ReadData.SingleItem.DynamoDB"></a>

No Amazon DynamoDB, você pode usar a API do DynamoDB ou do [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (uma linguagem de consultas compatível com SQL) para ler um item de uma tabela.

------
#### [ DynamoDB API ]

Com a API do DynamoDB, você usa a operação `PutItem` para adicionar um item a uma tabela.

O DynamoDB fornece a operação `GetItem` para recuperar um item por meio da respectiva chave primária. `GetItem` é altamente eficiente, pois dá acesso direto à localização física do item. (Para ter mais informações, consulte [Partições e distribuição de dados no DynamoDB](HowItWorks.Partitions.md).)

Por padrão, `GetItem` retorna todo o item com todos os seus atributos.

```
{
    TableName: "Music",
    Key: {
        "Artist": "No One You Know",
        "SongTitle": "Call Me Today"
    }
}
```

É possível adicionar um parâmetro `ProjectionExpression` para retornar apenas alguns dos atributos.

```
{
    TableName: "Music",
    Key: {
        "Artist": "No One You Know",
        "SongTitle": "Call Me Today"
    },
    "ProjectionExpression": "AlbumTitle, Year, Price"
}
```

Observe que a chave primária dessa tabela consiste em *Artist* e *SongTitle*.

A operação `GetItem` do DynamoDB é muito eficiente. Ela usa os valores da chave primária para determinar o local de armazenamento exato do item em questão e recupera-o diretamente dali. A instrução SQL `SELECT` é similarmente eficiente, no caso da recuperação de itens por valores de chave primária.

A instrução SQL `SELECT` é compatível com muitos tipos de consultas e verificações de tabela. O DynamoDB oferece funcionalidade semelhante com suas operações `Query` e `Scan`, que são descritas em [Diferenças na consulta de uma tabela](SQLtoNoSQL.ReadData.Query.md) e [Diferenças na varredura de uma tabela](SQLtoNoSQL.ReadData.Scan.md).

A instrução SQL `SELECT` pode realizar junções de tabela, permitindo que você recupere dados de várias tabelas ao mesmo tempo. As junções são mais eficazes onde as tabelas de banco de dados são normalizadas e os relacionamentos entre as tabelas são claros. No entanto, se você juntar muitas tabelas em uma instrução `SELECT`, a performance do aplicativo pode ser afetada. Você pode resolver esses problemas usando replicação de banco de dados, visualizações materializadas ou regravações de consulta.

O DynamoDB é um banco de dados não relacional e não oferece suporte a junções de tabela. Se você estiver migrando uma aplicação existente de um banco de dados relacional para o DynamoDB, será necessário desnormalizar o seu modelo de dados para eliminar a necessidade de junções.

------
#### [ PartiQL for DynamoDB ]

Com PartiQL, você usa a operação `ExecuteStatement` para ler um item de uma tabela, usando a instrução `Select` PartiQL.

```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```

Observe que a chave primária dessa tabela consiste em Artist e SongTitle. 

**nota**  
 A instrução Select PartiQL também pode ser usada para consultar ou digitalizar uma tabela do DynamoDB

Para obter exemplos de código que usam `Select` e `ExecuteStatement`, consulte [Instruções Select em PartiQL para DynamoDB](ql-reference.select.md).

------

# Diferenças na consulta de uma tabela
<a name="SQLtoNoSQL.ReadData.Query"></a>

Outro padrão de acesso comum é a leitura de vários itens de uma tabela, com base em seus critérios de consulta.

**Topics**
+ [Criar uma tabela com o SQL](#SQLtoNoSQL.ReadData.Query.SQL)
+ [Consultar uma tabela no DynamoDB](#SQLtoNoSQL.ReadData.Query.DynamoDB)

## Criar uma tabela com o SQL
<a name="SQLtoNoSQL.ReadData.Query.SQL"></a>

O uso da instrução `SELECT` do SQL permite consultar colunas-chave, colunas que não são chave ou qualquer combinação. A cláusula `WHERE` determina quais linhas são retornadas, conforme mostrado nos exemplos a seguir.

```
/* 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;
```

Observe que a chave primária dessa tabela consiste em *Artist* e *SongTitle*.

## Consultar uma tabela no DynamoDB
<a name="SQLtoNoSQL.ReadData.Query.DynamoDB"></a>

No Amazon DynamoDB, você pode usar a API do DynamoDB ou do [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (uma linguagem de consultas compatível com SQL) para consultar um item de uma tabela.

------
#### [ DynamoDB API ]

Com o Amazon DynamoDB, você pode usar a operação `Query` para recuperar dados de forma semelhante. A operação `Query` oferece acesso rápido e eficiente aos locais físicos onde os dados estão armazenados. Para obter mais informações, consulte [Partições e distribuição de dados no DynamoDB](HowItWorks.Partitions.md).

É possível usar a `Query` com qualquer tabela ou índice secundário. É possível especificar uma condição de igualdade para o valor da chave de partição e, se desejar, fornecer outra condição, se definida, ao atributo da chave de classificação.

O parâmetro `KeyConditionExpression` especifica os valores de chave que você deseja consultar. Você pode usar uma `FilterExpression` opcional para remover determinados itens dos resultados antes que eles sejam retornados para você.

No DynamoDB, você deve usar `ExpressionAttributeValues` como espaços reservados em parâmetros de expressão (como `KeyConditionExpression` e `FilterExpression`). Isso é análogo ao uso de *variáveis de ligação* em bancos de dados relacionais, onde você substitui os valores reais na instrução `SELECT` em tempo de execução.

Observe que a chave primária dessa tabela consiste em *Artist* e *SongTitle*.

A seguir há alguns exemplos de `Query` no DynamoDB.

```
// 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**  
Como `FilterExpression` é aplicada depois que a `Query` lê itens correspondentes, isso não reduz a capacidade de leitura consumida. Sempre que possível, modele os dados para que as condições de intervalo usem `KeyConditionExpression` na chave de classificação para melhorar a eficiência das consultas. Para obter mais informações, consulte [Consultar tabelas no DynamoDB](Query.md).

------
#### [ PartiQL for DynamoDB ]

Com o PartiQL, é possível realizar uma consulta usando a operação `ExecuteStatement` e a instrução `Select` na chave de partição.

```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know'
```

Usar a instrução `SELECT` desse modo retornará todas as músicas associadas a este `Artist` específico.

Para obter exemplos de código que usam `Select` e `ExecuteStatement`, consulte [Instruções Select em PartiQL para DynamoDB](ql-reference.select.md).

------

# Diferenças na varredura de uma tabela
<a name="SQLtoNoSQL.ReadData.Scan"></a>

No SQL, uma instrução `SELECT` sem uma cláusula `WHERE` retornará cada linha em uma tabela. No Amazon DynamoDB, a operação `Scan` faz a mesma coisa. Em ambos os casos, é possível recuperar todos os itens ou somente alguns deles.

Se você estiver usando um banco de dados SQL ou um NoSQL, as verificações devem ser usadas com moderação, pois elas podem consumir grandes quantidades de recursos do sistema. Às vezes, uma verificação é apropriada (como a verificação de uma pequena tabela) ou inevitável (como a execução de uma exportação de dados em massa). No entanto, como uma regra geral, você deve projetar seus aplicativos para evitar a execução de verificações. Para obter mais informações, consulte [Consultar tabelas no DynamoDB](Query.md).

**nota**  
Fazer uma exportação em massa também cria pelo menos um arquivo por partição. Todos os itens em cada arquivo são do espaço de chave com hash dessa partição específica.

**Topics**
+ [Verificar uma tabela com o SQL](#SQLtoNoSQL.ReadData.Scan.SQL)
+ [Verificar uma tabela no DynamoDB](#SQLtoNoSQL.ReadData.Scan.DynamoDB)

## Verificar uma tabela com o SQL
<a name="SQLtoNoSQL.ReadData.Scan.SQL"></a>

Ao usar o SQL, você pode verificar uma tabela e recuperar todos os respectivos dados usando uma instrução `SELECT` sem especificar uma cláusula `WHERE`. Você pode solicitar uma ou mais colunas no resultado. Ou é possível solicitar todas elas se usar o caractere curinga (\$1).

Veja a seguir exemplos do uso de uma instrução `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;
```

## Verificar uma tabela no DynamoDB
<a name="SQLtoNoSQL.ReadData.Scan.DynamoDB"></a>

No Amazon DynamoDB, você pode usar a API do DynamoDB ou do [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (uma linguagem de consultas compatível com SQL) para executar uma operação de verificação em uma tabela.

------
#### [ DynamoDB API ]

Com a API do DynamoDB, use a operação `Scan` para retornar um ou mais itens e atributos de item ao acessar cada item em uma tabela ou um índice secundário.

```
// Return all of the data in the table
{
    TableName:  "Music"
}
```

```
// Return all of the values for Artist and Title
{
    TableName:  "Music",
    ProjectionExpression: "Artist, Title"
}
```

A operação `Scan` também oferece um parâmetro `FilterExpression`, que pode ser usado para descartar itens que você não deseja que sejam exibidos nos resultados. Uma `FilterExpression` é aplicada após a verificação ser realizada, mas antes que os resultados sejam retornados para você. (Isso não é recomendado com tabelas grandes: você ainda será cobrado por toda a ação `Scan`, mesmo se apenas alguns itens correspondentes forem retornados.)

------
#### [ PartiQL for DynamoDB ]

Com PartiQL, você executa uma varredura usando a operação `ExecuteStatement` para retornar todo o conteúdo de uma tabela usando a instrução `Select`.

```
SELECT AlbumTitle, Year, Price
FROM Music
```

Observe que esta instrução retornará todos os itens para a tabela Music. 

Para obter exemplos de código que usam `Select` e `ExecuteStatement`, consulte [Instruções Select em PartiQL para DynamoDB](ql-reference.select.md).

------