# Saiba como passar do SQL para o NoSQL
Se você é um desenvolvedor de aplicativos, talvez tenha alguma experiência no uso do sistema de gerenciamento de banco de dados relacional (RDBMS) e Structured Query Language (SQL). Ao começar a trabalhar com o Amazon DynamoDB, você encontrará muita similaridades, mas também muitas diferenças. *NoSQL* é um termo usado para descrever os sistemas de bancos de dados não relacionais altamente disponíveis, dimensionáveis e otimizados para alta performance. Em vez de usar o modelo relacional, os bancos de dados NoSQL (como o DynamoDB) usam modelos alternativos para o gerenciamento de dados, como pares de chave-valor ou armazenamento de documentos. Para obter mais informações, consulte [O que é NoSQL?](https://aws.amazon.com/nosql).
Oferece suporte a [PartiQL](https://partiql.org/) do Amazon DynamoDB, uma linguagem de consulta compatível com SQL de código aberto que facilita a consulta de dados com eficiência, independentemente do local ou do formato em que estejam armazenados. Com PartiQL, é possível processar facilmente dados estruturados de bancos de dados relacionais, dados semiestruturados e aninhados em formatos de dados abertos e até mesmo dados sem esquema no NoSQL ou em bancos de dados de documentos que permitam atributos diferentes para linhas diferentes. Para obter mais informações, consulte [Linguagem de consultas PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html).
As seções a seguir descrevem tarefas comuns de banco de dados, comparando e contrastando instruções SQL com as operações equivalentes do DynamoDB.
**nota**
Os exemplos de SQL nesta seção são compatíveis com o RDBMS MySQL.
Os exemplos do DynamoDB desta seção mostram o nome da operação do DynamoDB, junto com os parâmetros dessa operação no formato JSON.
**Topics**
+ [
# Escolher entre relacional (SQL) e NoSQL
](SQLtoNoSQL.WhyDynamoDB.md)
+ [
# Diferenças no acesso a um banco de dados relacional (SQL) e ao DynamoDB
](SQLtoNoSQL.Accessing.md)
+ [
# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao criar uma tabela
](SQLtoNoSQL.CreateTable.md)
+ [
# Diferenças entre obter informações de tabela de um banco de dados relacional (SQL) e do DynamoDB
](SQLtoNoSQL.GetTableInfo.md)
+ [
# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao gravar dados em uma tabela
](SQLtoNoSQL.WriteData.md)
+ [
# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao ler dados de uma tabela
](SQLtoNoSQL.ReadData.md)
+ [
# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao gerenciar índices
](SQLtoNoSQL.Indexes.md)
+ [
# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao modificar dados de uma tabela
](SQLtoNoSQL.UpdateData.md)
+ [
# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao excluir dados de uma tabela
](SQLtoNoSQL.DeleteData.md)
+ [
# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao remover uma tabela
](SQLtoNoSQL.RemoveTable.md)
# Escolher entre relacional (SQL) e NoSQL
Atualmente, os aplicativos têm exigências maiores do que nunca. Por exemplo, um jogo online pode começar com apenas alguns usuários e uma pequena quantidade de dados. No entanto, se o jogo obtiver sucesso, ele poderá facilmente superar os recursos do sistema de gerenciamento de banco de dados subjacente. É comum que aplicativos baseados na web tenham centenas, milhares ou milhões de usuários simultâneos, com terabytes ou mais de novos dados gerados por dia. Os bancos de dados para tais aplicativos devem lidar com dezenas (ou centenas) de milhares de leituras e gravações por segundo.
O Amazon DynamoDB é perfeitamente adequado para esses tipo de workloads. Como um desenvolvedor, você pode começar pequeno e aumentar gradualmente sua utilização conforme a aplicação se tornar mais popular. O DynamoDB escala perfeitamente para lidar com quantidades muito grandes de dados e um número muito grande de usuários.
Para obter mais informações sobre a modelagem tradicional de banco de dados relacional e como adaptá-la para o DynamoDB, consulte [Práticas recomendadas para modelagem de dados relacionais no DynamoDB](bp-relational-modeling.md).
A tabela a seguir mostra algumas diferenças gerais entre um sistema de gerenciamento de banco de dados relacional (RDBMS) e o DynamoDB.
****
| Característica | Sistema de gerenciamento de banco de dados relacional (RDBMS) | Amazon DynamoDB |
| --- | --- | --- |
| Workloads ideais | Consultas ad hoc; data warehouse; OLAP (processamento analítico online). | Aplicativos em escala da web, incluindo redes sociais, jogos, compartilhamento de mídia e Internet das Coisas (IoT). |
| Modelo de dados | O modelo relacional exige um esquema bem definido, onde os dados são normalizados em tabelas, linhas e colunas. Além disso, todos os relacionamentos são definidos entre tabelas, colunas, índices e outros elementos de banco de dados. | O DynamoDB é sem esquema. Cada tabela deve ter uma chave primária para identificar exclusivamente cada item de dados, mas não há restrições semelhantes em outros atributos não chave. O DynamoDB pode gerenciar dados estruturados ou semiestruturados, incluindo documentos JSON. |
| Acesso aos dados | SQL é o padrão para armazenar e recuperar dados. Os bancos de dados relacionais oferecem um conjunto completo de ferramentas para simplificar o desenvolvimento de aplicativos para banco de dados, mas todas essas ferramentas usam o SQL. | Você pode usar o Console de gerenciamento da AWS, a AWS CLI ou o NoSQL WorkBench para trabalhar com o DynamoDB e executar tarefas ad hoc. A linguagem [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), uma linguagem de consultas compatível com SQL, permite selecionar, inserir, atualizar e excluir dados no DynamoDB. As aplicações podem utilizar os kits de desenvolvimento de software (SDKs) da AWS para trabalhar com o DynamoDB usando interfaces baseadas em objeto, centradas em documentos ou de baixo nível. |
| desempenho | Os bancos de dados relacionais são otimizados para armazenamento, portanto, a performance geralmente depende do subsistema de disco. Os desenvolvedores e os administradores de banco de dados devem otimizar as consultas, os índices e as estruturas de tabela para obter a máxima performance. | O DynamoDB é otimizado para computação, portanto, a performance é principalmente uma função do hardware subjacente e da latência de rede. Como um serviço gerenciado, o DynamoDB protege você e suas aplicações contra esses detalhes de implementação para que você possa se concentrar em projetar e construir aplicações robustas e de alta performance. |
| Escalabilidade | É mais fácil aumentar a escala com hardware mais rápido. Também é possível que as tabelas de banco de dados se expandam em vários hosts em um sistema distribuído, mas isso exige investimentos adicionais. Os bancos de dados relacionais têm tamanhos máximos para o número e o tamanho dos arquivos, o que impõe limites superiores na escalabilidade. | O DynamoDB é projetado para aumentar a escala horizontalmente usando clusters distribuídos de hardware. Esse design permite aumentar o throughput sem aumentar a latência. Os clientes especificam seus requisitos de throughput e o DynamoDB aloca recursos suficientes para atender a esses requisitos. Não há limites superiores no número de itens por tabela, nem no tamanho total da tabela. |
# Diferenças no acesso a um banco de dados relacional (SQL) e ao DynamoDB
Para que seu aplicativo possa acessar um banco de dados, ele deve ser *autenticado* para garantir que o aplicativo tenha permissão para usar o banco de dados. Ele deve ser *autorizado* para que o aplicativo possa realizar somente as ações para as quais tem permissões.
O diagrama a seguir mostra a interação do cliente com um banco de dados relacional e com o Amazon DynamoDB.
![\[Interação com bancos de dados relacionais e NoSQL.\]](http://docs.aws.amazon.com/pt_br/amazondynamodb/latest/developerguide/images/SQLtoNoSQL.png)
A tabela a seguir tem mais detalhes sobre tarefas de interação com o cliente.
****
| Característica | Sistema de gerenciamento de banco de dados relacional (RDBMS) | Amazon DynamoDB |
| --- | --- | --- |
| Ferramentas para acessar o banco de dados | A maioria dos bancos de dados relacionais fornecem uma interface de linha de comando (CLI), para que você possa inserir instruções SQL ad hoc e visualizar os resultados imediatamente. | Na maioria dos casos, você grava o código da aplicação. Você também pode usar o Console de gerenciamento da AWS, a AWS Command Line Interface (AWS CLI) ou o NoSQL Workbench para enviar solicitações ad hoc ao DynamoDB e visualizar os resultados. A linguagem [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), uma linguagem de consultas compatível com SQL, permite selecionar, inserir, atualizar e excluir dados no DynamoDB. |
| Conexão ao banco de dados | Um programa de aplicação estabelece e mantém uma conexão de rede com o banco de dados. Quando o aplicativo terminar, ele encerra a conexão. | O DynamoDB é um serviço da Web, e as interações com ele são sem estado. Os aplicativos não precisam manter conexões de rede persistentes. Em vez disso, a interação com o DynamoDB ocorre via solicitações e respostas HTTP(S). |
| autenticação do | Uma aplicação não pode se conectar ao banco de dados até ser autenticado. O RDBMS pode realizar a autenticação em si, ou pode passar essa tarefa para o sistema operacional host ou um serviço de diretório. | Cada solicitação para o DynamoDB deve ser acompanhada por uma assinatura de criptografia, que autentica essa determinada solicitação. Os AWS SDKs fornecem toda a lógica necessária para a criação de assinaturas e a assinatura de solicitações. Para obter mais informações, consulte [Assinar solicitações de API da AWS](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) no Referência geral da AWS. |
| Autorização | Os aplicativos podem executar somente as ações para as quais tenham sido autorizados. Os administradores de banco de dados ou os proprietários de aplicativos podem usar as instruções SQL GRANT e REVOKE para controlar o acesso aos objetos de banco de dados (tais como tabelas), dados (como linhas em uma tabela), ou a habilidade de emitir determinadas instruções SQL. | No DynamoDB, a autorização é controlada pelo AWS Identity and Access Management (IAM). Você pode escrever uma política do IAM para conceder permissões em um recurso do DynamoDB (como uma tabela), depois permitir que os usuários e os perfis usem essa política. O IAM também oferece controle de acesso minucioso para itens de dados individuais em tabelas do DynamoDB. Para obter mais informações, consulte [Gerenciamento de identidade e acesso no Amazon DynamoDB](security-iam.md). |
| Envio de uma solicitação | O aplicativo emite uma instrução SQL para cada operação de banco de dados que ele deseja executar. Após o recebimento da instrução SQL, o RDBMS verifica a sintaxe, cria um plano para realizar a operação e, em seguida, executa o plano. | A aplicação envia solicitações HTTP(S) para o DynamoDB. As solicitações contêm o nome da operação do DynamoDB a ser executada, juntamente com parâmetros. O DynamoDB executa a solicitação imediatamente. |
| Recebimento de uma resposta | O RDBMS retorna os resultados da instrução SQL. Se houver um erro, o RDBMS retorna um status e uma mensagem de erro. | O DynamoDB retorna uma resposta HTTP(S) contendo os resultados da operação. Se houver um erro, o DynamoDB retornará um status e mensagens de erro HTTP. |
# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao criar uma tabela
As tabelas são as estruturas de dados fundamentais em bancos de dados relacionais e no Amazon DynamoDB. Um Relational Database Management System (RDBMS – Sistema de gerenciamento de banco de dados relacional) exige que você defina o esquema da tabela ao criá-la. Por outro lado, as tabelas do DynamoDB não têm esquemas: além da chave primária, não é necessário definir nenhum atributo ou tipo de dados extras ao criar uma tabela.
A seção a seguir compara como você criaria uma tabela com o SQL e como a criaria com o DynamoDB.
**Topics**
+ [
## Criar uma tabela com o SQL
](#SQLtoNoSQL.CreateTable.SQL)
+ [
## Criar uma tabela com o DynamoDB
](#SQLtoNoSQL.CreateTable.DynamoDB)
## Criar uma tabela com o SQL
Com o SQL, você usa a instrução `CREATE TABLE` para criar uma tabela, conforme mostrado no exemplo a seguir.
```
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)
);
```
A chave primária dessa tabela consiste em *Artist* e *SongTitle*.
Você deve definir todas as colunas e os tipos de dados da tabela, e a chave primária da tabela. (Você pode usar a instrução `ALTER TABLE` para alterar essas definições mais tarde, se necessário.)
Muitas implementações de SQL permitem que você defina especificações de armazenamento para a sua tabela, como parte da instrução `CREATE TABLE`. A não ser que você indique de outra forma, a tabela é criada com configurações de armazenamento padrão. Em um ambiente de produção, um administrador de banco de dados pode ajudar a determinar os parâmetros de armazenamento ideais.
## Criar uma tabela com o DynamoDB
Use a operação `CreateTable` para criar uma tabela de modo provisionado, especificando parâmetros conforme mostrado abaixo:
```
{
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
}
}
```
A chave primária dessa tabela consiste em *Artist* (chave de partição) e *SongTitle* (chave de classificação).
Você deve fornecer os parâmetros a seguir para `CreateTable`:
+ `TableName`: nome da tabela.
+ `KeySchema`: os atributos que são usados para a chave primária. Para obter mais informações, consulte [Tabelas, itens e atributos](HowItWorks.CoreComponents.md#HowItWorks.CoreComponents.TablesItemsAttributes) e [Chave primária](HowItWorks.CoreComponents.md#HowItWorks.CoreComponents.PrimaryKey).
+ `AttributeDefinitions`: os tipos de dados dos atributos de esquema de chaves.
+ `ProvisionedThroughput (for provisioned tables)`: o número de leituras e gravações por segundo que você precisa para esta tabela. O DynamoDB reserva recursos do sistema e de armazenamento suficientes para que seus requisitos de throughput sejam sempre atendidos. Você pode usar a operação `UpdateTable` para alterar essas configurações mais tarde, se necessário. Você não precisa especificar os requisitos de armazenamento de uma tabela porque a alocação de armazenamento é gerenciada inteiramente pelo DynamoDB.
# Diferenças entre obter informações de tabela de um banco de dados relacional (SQL) e do DynamoDB
Você pode verificar se uma tabela foi criada de acordo com suas especificações. Em um banco de dados relacional, todo o esquema da tabela é mostrado. As tabelas do Amazon DynamoDB não têm esquemas, portanto, somente os atributos de chave primária são mostrados.
**Topics**
+ [
## Obter informações sobre uma tabela com o SQL
](#SQLtoNoSQL.GetTableInfo.SQL)
+ [
## Obter informações sobre uma tabela no DynamoDB
](#SQLtoNoSQL.GetTableInfo.DynamoDB)
## Obter informações sobre uma tabela com o SQL
A maioria dos sistemas de gerenciamento de bancos de dados relacionais (RDBMS) permitem que você descreva a estrutura de uma tabela – colunas, tipos de dados, definição de chave primária, e assim por diante. Não há nenhuma maneira padrão de fazer isso no SQL. No entanto, muitos sistemas de banco de dados fornecem um comando `DESCRIBE`. Veja a seguir um exemplo do MySQL.
```
DESCRIBE Music;
```
Isso retorna a estrutura de sua tabela, com todos os nomes de colunas, tipos de dados e tamanhos.
```
+------------+-------------+------+-----+---------+-------+
| 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 | |
+------------+-------------+------+-----+---------+-------+
```
A chave primária dessa tabela consiste em *Artist* e *SongTitle*.
## Obter informações sobre uma tabela no DynamoDB
O DynamoDB tem uma operação `DescribeTable`, que é semelhante. O único parâmetro é o nome da tabela.
```
{
TableName : "Music"
}
```
A resposta de `DescribeTable` é semelhante ao seguinte.
```
{
"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` também retorna informações sobre índices na tabela, configurações de throughput provisionado, uma contagem aproximada de itens e outros metadados.
# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao gravar dados em uma tabela
As tabelas de bancos de dados relacionais contêm *linhas* de dados. As linhas são compostas de *colunas*. As tabelas do Amazon DynamoDB contêm *itens*. Os itens são compostos de *atributos*.
Esta seção descreve como gravar uma linha (ou item) em uma tabela.
**Topics**
+ [
## Gravar dados em uma tabela com o SQL
](#SQLtoNoSQL.WriteData.SQL)
+ [
## Gravar dados em uma tabela no DynamoDB
](#SQLtoNoSQL.WriteData.DynamoDB)
## Gravar dados em uma tabela com o SQL
A tabela em um banco de dados relacional é uma estrutura de dados bidimensional composta por linhas e colunas. Alguns sistemas de gerenciamento de banco de dados também fornecem suporte para dados semiestruturados, geralmente com tipos de dados nativos JSON ou XML. No entanto, os detalhes de implementação variam entre fornecedores.
No SQL, você usa a instrução `INSERT` para adicionar uma linha a uma tabela.
```
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}'
);
```
A chave primária dessa tabela consiste em *Artist* e *SongTitle*. Você deve especificar valores para essas colunas.
**nota**
Este exemplo usa a coluna *Tags* para armazenar dados semiestruturados sobre as músicas na tabela *Music*. A coluna *Tags* está definida como tipo TEXT, que pode armazenar até 65.535 caracteres em MySQL.
## Gravar dados em uma tabela no DynamoDB
No Amazon DynamoDB, é possível 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 adicionar um item a uma tabela.
------
#### [ DynamoDB API ]
Com a API do DynamoDB, você usa a operação `PutItem` para adicionar um item a uma tabela.
```
{
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
}
}
}
```
A chave primária dessa tabela consiste em *Artist* e *SongTitle*. Você deve especificar valores para esses atributos.
Aqui estão algumas coisas importantes para saber sobre este exemplo de `PutItem`:
+ O DynamoDB oferece suporte nativo a documentos usando JSON. Isso torna o DynamoDB ideal para armazenar dados semiestruturados, como *Tags*. Você também pode recuperar e manipular dados de dentro de documentos JSON.
+ A tabela *Music* não tem atributos predefinidos, além da chave primária (*Artist* e *SongTitle*).
+ A maioria dos bancos de dados SQL são orientados a transação. Quando você emite uma instrução `INSERT`, as modificações de dados não são permanentes até que você execute uma instrução `COMMIT`. Com o Amazon DynamoDB, os efeitos de uma operação `PutItem` são permanentes quando o DynamoDB responde com um código de status HTTP 200 (`OK`).
A seguir há alguns outros exemplos de `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**
Além de `PutItem`, o DynamoDB comporta uma operação `BatchWriteItem` para gravar vários itens ao mesmo tempo.
------
#### [ PartiQL for DynamoDB ]
Com PartiQL, você usa a operação `ExecuteStatement` para adicionar um item a uma tabela, usando a instrução `Insert` PartiQL.
```
INSERT into Music value {
'Artist': 'No One You Know',
'SongTitle': 'Call Me Today',
'AlbumTitle': 'Somewhat Famous',
'Year' : '2015',
'Genre' : 'Acme'
}
```
A chave primária dessa tabela consiste em *Artist* e *SongTitle*. Você deve especificar valores para esses atributos.
**nota**
Para obter exemplos de código que usam `Insert` e `ExecuteStatement`, consulte [Instruções Insert em PartiQL para DynamoDB](ql-reference.insert.md).
------
# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao ler dados de uma tabela
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
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
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
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
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
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
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
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
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
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).
------
# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao gerenciar índices
Índices dão a você acesso a padrões de consulta alternativos, e você pode agilizar as consultas. Esta seção compara e contrasta a criação e o uso de índices no SQL e no Amazon DynamoDB.
Caso esteja usando um banco de dados relacional ou o DynamoDB, você deve ser criterioso com a criação do índice. Sempre que uma gravação ocorre em uma tabela, todos os índices da tabela devem ser atualizados. Em um ambiente que exige muita gravação com tabelas grandes, isso pode consumir grandes quantidades de recursos do sistema. Em um ambiente somente leitura ou em sua maioria de leitura, essa não é uma grande preocupação. Entretanto, você deve garantir que os índices estejam realmente sendo usados por seu aplicativo, e não simplesmente ocupando espaço.
**Topics**
+ [
## Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao criar um índice
](#SQLtoNoSQL.Indexes.Creating)
+ [
## Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao consultar e varrer um índice
](#SQLtoNoSQL.Indexes.QueryAndScan)
## Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao criar um índice
Compare a instrução `CREATE INDEX` em SQL com a operação `UpdateTable` no Amazon DynamoDB.
**Topics**
+ [
### Criar um índice com o SQL
](#SQLtoNoSQL.Indexes.Creating.SQL)
+ [
### Criar um índice no DynamoDB
](#SQLtoNoSQL.Indexes.Creating.DynamoDB)
### Criar um índice com o SQL
Em um banco de dados relacional, índice é uma estrutura de dados que permite realizar consultas rápidas em diferentes colunas em uma tabela. Você pode usar a instrução SQL `CREATE INDEX` para adicionar um índice a uma tabela existente, especificando as colunas a serem indexadas. Após a criação do índice, você pode consultar os dados na tabela como sempre, mas agora o banco de dados pode usar o índice para localizar rapidamente as linhas especificadas na tabela, em vez de verificar toda a tabela.
Depois que você cria um índice, o banco de dados o mantém para você. Sempre que você modifica os dados na tabela, o índice é modificado automaticamente para refletir as alterações da tabela.
No MySQL, você pode criar um índice da forma a seguir.
```
CREATE INDEX GenreAndPriceIndex
ON Music (genre, price);
```
### Criar um índice no DynamoDB
No DynamoDB você pode criar e usar um *índice secundário* para atender a objetivos semelhantes.
Os índices no DynamoDB são diferentes dos seus equivalentes relacionais. Ao criar um índice secundário, você deve especificar os atributos de chave: uma chave de partição e uma chave de classificação. Depois de criar o índice secundário, você pode usar a operação `Query` ou `Scan` da mesma forma como faria com uma tabela. O DynamoDB não tem um otimizador de consultas. Portanto, um índice secundário é usado apenas quando você usa a operação `Query` ou `Scan`.
O DynamoDB aceita dois tipos diferentes de índices:
+ Os índices secundários globais: a chave primária do índice pode ser qualquer dois atributos de sua tabela.
+ Índices secundários locais: a chave de partição do índice deve ser a mesma que a chave de partição de sua tabela. No entanto, a chave de classificação pode ser qualquer outro atributo.
O DynamoDB garante que os dados em um índice secundário sejam finais consistentes com sua tabela. Você pode solicitar operações `Query` ou `Scan` altamente consistentes em uma tabela ou em um índice secundário local. No entanto, índices secundários globais somente oferecem suporte à consistência eventual.
É possível adicionar um índice secundário global a uma tabela existente usando a operação `UpdateTable` e especificando `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
}
}
}
]
}
```
Você deve fornecer os parâmetros a seguir para `UpdateTable`:
+ `TableName`: a tabela à qual o índice será associado.
+ `AttributeDefinitions`: os tipos de dados dos atributos de esquema de chaves do índice.
+ `GlobalSecondaryIndexUpdates`: detalhes sobre o índice que você deseja criar:
+ `IndexName`: um nome para o índice.
+ `KeySchema`: os atributos que são usados para a chave primária do índice.
+ `Projection`: atributos da tabela que são copiados para o índice. Neste caso, `ALL` significa que todos os atributos são copiados.
+ `ProvisionedThroughput (for provisioned tables)`: o número de leituras e gravações por segundo que são necessários para este índice. (Isso é separado das configurações de throughput provisionado da tabela.)
Parte dessa operação envolve backfilling de dados da tabela para o novo índice. Durante o backfilling, a tabela permanece disponível. No entanto, o índice não está pronto até que seu atributo `Backfilling` mude de verdadeiro para falso. Você pode usar a operação `DescribeTable` para visualizar esse atributo.
## Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao consultar e varrer um índice
Compare a consulta e a verificação de um índice usando a instrução SELECT em SQL com as operações `Query` e `Scan` no Amazon DynamoDB.
**Topics**
+ [
### Consultar e verificar um índice com o SQL
](#SQLtoNoSQL.Indexes.QueryAndScan.SQL)
+ [
### Consultar e verificar um índice no DynamoDB
](#SQLtoNoSQL.Indexes.QueryAndScan.DynamoDB)
### Consultar e verificar um índice com o SQL
Em um banco de dados relacional, você não trabalha diretamente com índices. Em vez disso, você consulta tabelas, emitindo instruções `SELECT`, e o otimizador de consultas pode fazer uso de índices.
Um *otimizador de consultas* é um componente do sistema de gerenciamento de banco de dados relacional (RDBMS - relational database management system) que avalia os índices disponíveis e determina se eles podem ser usados para agilizar uma consulta. Se os índices puderem ser usados para acelerar uma consulta, o RDBMS acessará o índice primeiro e, em seguida, o usará para localizar os dados na tabela.
Estas são algumas instruções SQL que podem usar *GenreAndPriceIndex* para melhorar a performance. Presumimos que a tabela *Music* tenha dados suficientes para que o otimizador de consultas decida usar esse índice, em vez de simplesmente verificar a tabela inteira.
```
/* 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;
```
### Consultar e verificar um índice no DynamoDB
No DynamoDB, execute as operações `Query` e `Scan` diretamente no índice, como faria em uma tabela. É possível 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 ou verificar o índice. Você deve especificar `TableName` e `IndexName`.
As seguintes são algumas consultas sobre *GenreAndPriceIndex* no DynamoDB. (O esquema de chaves desse índice consiste em *Genre* e *Price*.)
------
#### [ DynamoDB API ]
```
// All of the rock songs
{
TableName: "Music",
IndexName: "GenreAndPriceIndex",
KeyConditionExpression: "Genre = :genre",
ExpressionAttributeValues: {
":genre": "Rock"
},
};
```
Este exemplo usa uma `ProjectionExpression` para indicar que somente alguns dos atributos, em vez de todos eles, são exibidos nos resultados.
```
// 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"
};
```
Veja a seguir uma verificação em *GenreAndPriceIndex*.
```
// Return all of the data in the index
{
TableName: "Music",
IndexName: "GenreAndPriceIndex"
}
```
------
#### [ PartiQL for DynamoDB ]
Com PartiQL, use a instrução `Select` PartiQL para realizar consultas e varreduras no índice.
```
// 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
```
Veja a seguir uma verificação em *GenreAndPriceIndex*.
```
// Return all of the data in the index
SELECT *
FROM Music.GenreAndPriceIndex
```
**nota**
Para obter exemplos de códigos que usam `Select`, consulte [Instruções Select em PartiQL para DynamoDB](ql-reference.select.md).
------
# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao modificar dados de uma tabela
A linguagem SQL fornece a instrução `UPDATE` para modificar dados. O Amazon DynamoDB usa a operação `UpdateItem` para realizar tarefas semelhantes.
**Topics**
+ [
## Modificar dados em uma tabela com o SQL
](#SQLtoNoSQL.UpdateData.SQL)
+ [
## Modificar dados em uma tabela no DynamoDB
](#SQLtoNoSQL.UpdateData.DynamoDB)
## Modificar dados em uma tabela com o SQL
No SQL, você usa a instrução `UPDATE` para modificar uma ou mais linhas. A cláusula `SET` especifica novos valores para uma ou mais colunas, e a cláusula `WHERE` determina quais linhas são modificadas. Veja um exemplo a seguir.
```
UPDATE Music
SET RecordLabel = 'Global Records'
WHERE Artist = 'No One You Know' AND SongTitle = 'Call Me Today';
```
Se nenhuma linha corresponder à cláusula `WHERE`, a instrução `UPDATE` não terá efeito.
## Modificar dados em uma tabela no DynamoDB
No 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 modificar um único item. Caso deseje modificar vários itens, você deve usar várias operações.
------
#### [ DynamoDB API ]
Com a API do DynamoDB, use a operação `UpdateItem` para modificar um único item.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET RecordLabel = :label",
ExpressionAttributeValues: {
":label": "Global Records"
}
}
```
Você deve especificar os atributos `Key` do item a ser modificado, e uma `UpdateExpression` para especificar valores de atributo. `UpdateItem` comporta-se como uma operação “upsert”. O item será atualizado se existir na tabela. Do contrário, um novo item será adicionado (inserido).
`UpdateItem` oferece suporte a *gravações condicionais*, nas quais a operação será bem-sucedida apenas se uma `ConditionExpression` específica for verdadeira. Por exemplo, a operação `UpdateItem` a seguir não realiza a atualização, a menos que o preço da música seja maior ou igual 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` também oferece suporte a *contadores atômicos* ou a atributos do tipo `Number` que podem ser aumentados ou reduzidos. Os contadores atômicos são semelhantes de muitas maneiras a geradores de sequências, colunas de identidade ou campos de incremento automático em bancos de dados SQL.
Veja a seguir um exemplo de uma operação `UpdateItem` para inicializar um novo atributo (*Plays*) e controlar o número de vezes em que uma música é reproduzida.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET Plays = :val",
ExpressionAttributeValues: {
":val": 0
},
ReturnValues: "UPDATED_NEW"
}
```
O parâmetro `ReturnValues` é definido como `UPDATED_NEW`, o que retorna os novos valores de todos os atributos que foram atualizados. Neste caso, ele retorna 0 (zero).
Sempre que alguém reproduzir essa música, podemos usar a operação `UpdateItem` a seguir para aumentar *Plays* por um.
```
{
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 ]
Com PartiQL, use a operação `ExecuteStatement` para modificar um item em uma tabela, usando a instrução `Update` PartiQL.
A chave primária dessa tabela consiste em *Artist* e *SongTitle*. Você deve especificar valores para esses atributos.
```
UPDATE Music
SET RecordLabel ='Global Records'
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
Também é possível modificar vários campos de uma só vez, como no exemplo a seguir.
```
UPDATE Music
SET RecordLabel = 'Global Records'
SET AwardsWon = 10
WHERE Artist ='No One You Know' AND SongTitle='Call Me Today'
```
`Update` também oferece suporte a *contadores atômicos* ou a atributos do tipo `Number` que podem ser aumentados ou reduzidos. Os contadores atômicos são semelhantes de muitas maneiras a geradores de sequências, colunas de identidade ou campos de incremento automático em bancos de dados SQL.
Veja a seguir um exemplo de instrução `Update` para inicializar um novo atributo (*Plays*) para controlar o número de vezes em que uma música foi reproduzida.
```
UPDATE Music
SET Plays = 0
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
Sempre que alguém reproduzir essa música, poderemos usar a instrução `Update` a seguir para aumentar *Plays* (Reproduções) em um.
```
UPDATE Music
SET Plays = Plays + 1
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
**nota**
Para obter exemplos de código que usam `Update` e `ExecuteStatement`, consulte [Instruções Update em PartiQL para DynamoDB](ql-reference.update.md).
------
# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao excluir dados de uma tabela
No SQL, a instrução `DELETE` remove uma ou mais linhas de uma tabela. O Amazon DynamoDB usa a operação `DeleteItem` para excluir um item de cada vez.
**Topics**
+ [
## Excluir dados de uma tabela com o SQL
](#SQLtoNoSQL.DeleteData.SQL)
+ [
## Excluir dados de uma tabela no DynamoDB
](#SQLtoNoSQL.DeleteData.DynamoDB)
## Excluir dados de uma tabela com o SQL
No SQL, você usa a instrução `DELETE` para excluir uma ou mais linhas. A cláusula `WHERE` determina as linhas que você deseja modificar. Veja um exemplo a seguir.
```
DELETE FROM Music
WHERE Artist = 'The Acme Band' AND SongTitle = 'Look Out, World';
```
Você pode modificar a cláusula `WHERE` para excluir várias linhas. Por exemplo, é possível excluir todas as músicas de um determinado artista, conforme mostrado no exemplo a seguir.
```
DELETE FROM Music WHERE Artist = 'The Acme Band'
```
## Excluir dados de uma tabela no DynamoDB
No 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 excluir um único item. Caso deseje modificar vários itens, você deve usar várias operações.
------
#### [ DynamoDB API ]
Com a API do DynamoDB, use a operação `DeleteItem` para excluir dados de uma tabela, um item de cada vez. Você deve especificar os valores de chave primária do item.
```
{
TableName: "Music",
Key: {
Artist: "The Acme Band",
SongTitle: "Look Out, World"
}
}
```
**nota**
Além do `DeleteItem`, o Amazon DynamoDB comporta uma operação `BatchWriteItem` para excluir vários itens ao mesmo tempo.
`DeleteItem` oferece suporte a *gravações condicionais*, nas quais a operação será bem-sucedida apenas se uma `ConditionExpression` específica for verdadeira. Por exemplo, a operação `DeleteItem` a seguir exclui o item somente se ele tiver um atributo *RecordLabel*.
```
{
TableName: "Music",
Key: {
Artist: "The Acme Band",
SongTitle: "Look Out, World"
},
ConditionExpression: "attribute_exists(RecordLabel)"
}
```
------
#### [ PartiQL for DynamoDB ]
Com PartiQL, use a instrução `Delete` por meio da operação `ExecuteStatement` para excluir dados de uma tabela, um item de cada vez. Você deve especificar os valores de chave primária do item.
A chave primária dessa tabela consiste em *Artist* e *SongTitle*. Você deve especificar valores para esses atributos.
```
DELETE FROM Music
WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks'
```
Você também pode especificar condições adicionais para a operação. A operação `DELETE` a seguir somente excluirá o item se ele tiver mais de 11 *Awards* (Prêmios).
```
DELETE FROM Music
WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks' AND Awards > 11
```
**nota**
Para obter exemplos de código que usam `DELETE` e `ExecuteStatement`, consulte [Instruções Delete em PartiQL para DynamoDB](ql-reference.delete.md).
------
# Diferenças entre um banco de dados relacional (SQL) e o DynamoDB ao remover uma tabela
No SQL, você usa a instrução `DROP TABLE` para remover uma tabela. No Amazon DynamoDB, você usa a operação `DeleteTable`.
**Topics**
+ [
## Remover uma tabela com o SQL
](#SQLtoNoSQL.RemoveTable.SQL)
+ [
## Remover uma tabela no DynamoDB
](#SQLtoNoSQL.RemoveTable.DynamoDB)
## Remover uma tabela com o SQL
Quando você não precisar mais de uma tabela e quiser descartá-la permanentemente, use a instrução `DROP TABLE` no SQL.
```
DROP TABLE Music;
```
Depois que uma tabela é eliminada, ela não pode ser recuperada. (Alguns bancos de dados relacionais permitem que você desfaça uma operação `DROP TABLE`, mas essa funcionalidade é específica do fornecedor e não é amplamente implementada.)
## Remover uma tabela no DynamoDB
No DynamoDB, `DeleteTable` é uma operação semelhante. No exemplo a seguir, a tabela é excluída permanentemente.
```
{
TableName: "Music"
}
```