# Amazon DynamoDB: como funciona
As seções a seguir fornecem uma visão geral dos componentes do serviço Amazon DynamoDB e como eles interagem.
**Topics**
+ [Folha de dicas para o DynamoDB](CheatSheet.md)
+ [Componentes principais do Amazon DynamoDB](HowItWorks.CoreComponents.md)
+ [API do DynamoDB](HowItWorks.API.md)
+ [Tipos de dados compatíveis e regras de nomenclatura no Amazon DynamoDB](HowItWorks.NamingRulesDataTypes.md)
+ [Classes de tabelas do DynamoDB](HowItWorks.TableClasses.md)
+ [Partições e distribuição de dados no DynamoDB](HowItWorks.Partitions.md)
+ [Saiba como passar do SQL para o NoSQL](SQLtoNoSQL.md)
+ [Recursos e ferramentas de aprendizado do Amazon DynamoDB](AdditionalResources.md)
# Folha de dicas para o DynamoDB
Esta folha de dicas fornece uma referência rápida para trabalhar com o Amazon DynamoDB e seus vários AWS SDKs.
## Configuração inicial
1. [Cadastre-se no AWS](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.SignUpForAWS).
1. [Obtenha uma chave de acesso da AWS](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.GetCredentials) (usada para acessar o DynamoDB de forma programática).
1. [Configure suas credenciais do DynamoDB](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.ConfigureCredentials).
**Consulte também:**
+ [Configurar o DynamoDB (serviço da Web)](SettingUp.DynamoWebService.html)
+ [Conceitos básicos do DynamoDB](GettingStartedDynamoDB.html)
+ [Visão geral básica dos componentes principais](HowItWorks.CoreComponents.html)
## SDK ou CLI
Escolha seu [SDK](sdk-general-information-section.html) preferido ou configure a [AWS CLI](/cli/latest/index.html).
**nota**
Quando você usa a AWS CLI no Windows, uma barra invertida (\$1) que não esteja dentro de uma cotação será tratada como um retorno de carro. Além disso, você deve escapar de todas as aspas e chaves dentro de outras aspas. Como exemplo, consulte a guia **Windows** em “Criar uma tabela” na próxima seção.
**Consulte também:**
+ [AWS CLI com o DynamoDB](Tools.CLI.html)
+ [Conceitos básicos do DynamoDB: etapa 2](getting-started-step-2.html)
## Ações básicas
Esta seção fornece código para tarefas básicas do DynamoDB. Para obter mais informações sobre essas tarefas, consulte [Conceitos básicos do DynamoDB e dos AWS SDKs](GettingStarted.html).
### Criar uma tabela
------
#### [ 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
```
------
### Gravar um item em uma tabela
```
aws dynamodb put-item \ --table-name Music \ --item file://item.json
```
### Ler um item de uma tabela
```
aws dynamodb get-item \ --table-name Music \ --item file://item.json
```
### Excluir um item de uma tabela
```
aws dynamodb delete-item --table-name Music --key file://key.json
```
### Consultar uma tabela
```
aws dynamodb query --table-name Music
--key-condition-expression "ArtistName=:Artist and SongName=:Songtitle"
```
### Excluir uma tabela
```
aws dynamodb delete-table --table-name Music
```
### Listar nomes de tabela
```
aws dynamodb list-tables
```
## Regras de nomenclatura
+ Todos os nomes devem ser codificados usando UTF-8 e diferenciam maiúsculas de minúsculas.
+ Nomes de tabelas e nomes de índices devem ter entre 3 e 255 caracteres e podem conter somente os seguintes caracteres:
+ `a-z`
+ `A-Z`
+ `0-9`
+ `_` (sublinhado)
+ `-` (hífen)
+ `.` (ponto)
+ Os nomes de atributos devem ter pelo menos um caractere e no mínimo 64 KB.
Para obter mais informações, consulte [Regras de nomenclatura](HowItWorks.NamingRulesDataTypes.html).
## Noções básicas de cota de serviço
**Unidades de leitura e gravação**
+ **Unidade de capacidade de leitura (RCU)**: uma leitura altamente consistente por segundo, ou duas leituras finais consistentes por segundo, para itens até 4 KB de tamanho.
+ **Unidade de capacidade de gravação (WCU)**: uma gravação por segundo para itens de até 1 KB de tamanho.
**Limites da tabela**
+ **Tamanho da tabela**: não há limite prático para o tamanho de uma tabela. As tabelas não são limitadas em termos de número de itens ou de bytes.
+ **Número de tabelas**: para qualquer conta da AWS, há uma cota inicial de 2,5 mil tabelas por região da AWS.
+ **Limite de tamanho de página para consulta e verificação**: há um limite de 1 MB por página, por consulta ou verificação. Se os seus parâmetros de consulta ou operação de verificação em uma tabela resultarem em mais de 1 MB de dados, o DynamoDB retornará os itens correspondentes iniciais. Ele também retorna uma propriedade `LastEvaluatedKey` que pode ser usada em uma nova solicitação para ler a próxima página.
**Índices**
+ **Índices secundários locais (LSIs)**: é possível definir um máximo de cinco índices secundários locais. Os LSIs são úteis principalmente quando um índice deve ter uma consistência alta com a tabela-base.
+ **Índices secundários globais (GSIs)**: há uma cota padrão de 20 índices secundários globais por tabela.
+ **Atributos de índices secundários projetados por tabela**: é possível projetar um total de até 100 atributos em todos os índices secundários locais e globais de uma tabela. Isso se aplica somente a atributos projetados especificados pelo usuário.
**Chaves de partição**
+ O tamanho mínimo de um valor de chave de partição é 1 byte. O comprimento máximo é de 2048 bytes.
+ Não há um limite prático para o número de valores de chave de partição distintos, para tabelas ou para índices secundários.
+ O tamanho mínimo de um valor de chave de classificação é 1 byte. O comprimento máximo é de 1024 bytes.
+ Em geral, não há limite prático para o número de valores de chave de classificação distintos por valor de chave de partição. Há exceção para tabelas com índices secundários.
Para obter mais informações sobre índices secundários, design de chave de partição e design de chave de classificação, consulte [Práticas recomendadas](best-practices.html).
**Limites para tipos de dados comumente usados**
+ **String**: o tamanho de uma string é restrito pelo tamanho de item máximo de 400 KB. Strings são Unicode com codificação binária UTF-8.
+ **Número**: um número pode ter até 38 dígitos de precisão, e pode ser positivo, negativo ou zero.
+ **Binário**: o tamanho de um binário é restrito pelo tamanho de item máximo de 400 KB. As aplicações que funcionam com atributos binários devem codificar os dados em formato base64 antes de enviá-los para o DynamoDB.
Para obter uma lista dos tipos de dados compatíveis, consulte [Tipos de dados](HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes). Para obter mais informações, consulte [Service quotas](ServiceQuotas.html#limits-items).
### Itens, atributos e parâmetros de expressão
O tamanho de item máximo no DynamoDB é 400 KB, o que inclui o tamanho binário do nome do atributo (tamanho UTF-8) e os tamanhos binários do valor dos atributo (tamanho UTF-8). O nome do atributo conta para o limite de tamanho.
Não há limite para o número de valores em uma lista, um mapa ou um conjunto, desde que o item que contenha os valores permaneça no limite de tamanho de item de 400 KB.
Para os parâmetros de expressão, o tamanho máximo de qualquer string de expressão é 4 KB.
Para obter mais informações sobre tamanho do item, atributos e parâmetros de expressão, consulte [Service quotas](ServiceQuotas.html#limits-items).
## Mais informações
+ [Segurança do](security.html)
+ [Monitorar e registrar](monitoring.html)
+ [Trabalhar com fluxos](streamsmain.html)
+ [Backups](Backup-and-Restore.html) e [recuperação pontual](Point-in-time-recovery.html)
+ [Integrar-se a outros serviços da AWS](OtherServices.html)
+ [Referência de API](/amazondynamodb/latest/APIReference/Welcome.html)
+ [Centro de arquitetura: práticas recomendadas de banco de dados](https://aws.amazon.com/architecture/databases/)
+ [Vídeos de tutorial](https://youtu.be/Mw8wCj0gkRc)
+ [Fórum do DynamoDB](https://repost.aws/search/questions?globalSearch=dynamodb)
# Componentes principais do Amazon DynamoDB
No DynamoDB, tabelas, itens e atributos são os componentes principais com que você trabalha. Uma *tabela* é uma coleção de *itens*, e cada item é uma coleção de *atributos*. O DynamoDB utiliza chaves primárias para identificar de modo exclusivo cada item em uma tabela. Você pode usar o DynamoDB Streams para capturar eventos de modificação de dados em tabelas do DynamoDB.
No entanto, há limites no DynamoDB. Para obter mais informações, consulte [Cotas no Amazon DynamoDB](ServiceQuotas.md).
O vídeo a seguir apresenta uma introdução sobre tabelas globais, itens e atributos.
[Tabelas, itens e atributos](https://www.youtube.com/embed/Mw8wCj0gkRc)
## Tabelas, itens e atributos
![\[Cada tabela do DynamoDB contém zero ou mais itens compostos por um ou mais atributos.\]](http://docs.aws.amazon.com/pt_br/amazondynamodb/latest/developerguide/images/HowItWorksTables-2024.png)
Estes são os componentes básicos do DynamoDB:
+ **Tabelas**: semelhante a outros sistemas de banco de dados, o DynamoDB armazena dados em tabelas. Uma *tabela* é uma coleção de dados. Por exemplo, consulte a tabela de exemplo *People* que você pode usar para armazenar informações pessoais de contato de amigos, familiares ou qualquer outra pessoa de interesse. Você também poder ter uma tabela *Cars* para armazenar informações sobre os veículos que as pessoas dirigem.
+ **Items**: cada tabela contém zero ou mais itens. Um *item* é um grupo de atributos identificável exclusivamente entre todos os outros itens. Na tabela *People* de exemplo, cada item representa uma pessoa. Na tabela *Cars*, cada item representa um veículo. Os itens no DynamoDB são semelhantes de muitas formas a linhas, registros ou tuplas em outros sistemas de banco de dados. No DynamoDB, não há limite para o número de itens que você pode armazenar em uma tabela.
+ **Atributos**: cada item é composto por um ou mais atributos. Um *atributo* é um elemento de dados fundamental, algo que não precisa ser dividido ainda mais. Por exemplo, um item na tabela *People* contém os atributos *PersonID*, *LastName*, *FirstName* etc. Em uma tabela *Department*, um item pode ter atributos, como *DepartmentID*, *Name*, *Manager* etc. Os atributos no DynamoDB se parecem de várias maneiras com campos ou colunas em outros sistemas de banco de dados.
O diagrama a seguir mostra uma tabela *People* com alguns itens e atributos de exemplo.
```
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"
}
```
Observe o seguinte sobre a tabela *People*:
+ Cada item da tabela tem um identificador exclusivo, ou chave primária, que o distingue de todos os outros na tabela. Na tabela *People*, a chave primária consiste em um único atributo (*PersonID*).
+ Além da chave primária, a tabela *People* não tem esquema, o que significa que não é necessário definir seus atributos e tipos de dados previamente. Cada item pode ter seus próprios atributos distintos.
+ A maioria dos atributos é *escalar*, o que significa que podem ter apenas um valor. Strings e números são exemplos comuns de escalares.
+ Alguns itens têm um atributo aninhado (*Address*). O DynamoDB oferece suporte a atributos aninhados com até 32 níveis de profundidade.
Veja a seguir outra tabela de exemplo chamada *Music*, que você pode usar para controlar sua coleção de músicas.
```
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"
}
```
Observe o seguinte sobre a tabela *Music*:
+ A chave primária da tabela *Music* é composta por dois atributos (*Artist* e *SongTitle*). Cada item da tabela deve ter esses dois atributos. A combinação de *Artist* e *SongTitle* distingue cada item da tabela de todos os outros.
+ Além da chave primária, a tabela *Music* não tem esquema, o que significa que nem os atributos nem seus tipos de dados precisam ser definidos previamente. Cada item pode ter seus próprios atributos distintos.
+ Um dos itens tem um atributo aninhado (*PromotionInfo*) que contém outros atributos aninhados. O DynamoDB oferece suporte a atributos aninhados com até 32 níveis de profundidade.
Para obter mais informações, consulte [Trabalhar com tabelas e dados no DynamoDB](WorkingWithTables.md).
## Chave primária
Ao criar uma tabela, além do nome dela, você deve especificar a chave primária da tabela. A chave primária identifica exclusivamente cada item na tabela, de modo que não possa haver dois itens com a mesma chave.
O DynamoDB é compatível com dois tipos diferentes de chaves primárias:
+ **Chave de partição**: uma chave primária simples, formada por um atributo conhecido como a *chave de partição*.
O DynamoDB usa o valor da chave de partição como entrada para uma função de hash interna. A saída da função de hash determina a partição (armazenamento físico interno do DynamoDB) em que o item será armazenado.
Em uma tabela que possui somente uma chave de partição, dois itens não podem ter o mesmo valor de chave de partição.
A tabela *People* descrita em [Tabelas, itens e atributos](#HowItWorks.CoreComponents.TablesItemsAttributes) é um exemplo de uma tabela com uma chave primária simples (*PersonID*). Você pode acessar diretamente qualquer item na tabela *People* fornecendo o valor *PersonId* desse item.
+ **Chave de partição e chave de classificação**: conhecidas como *chave primária composta*, esse tipo de chave é formado por dois atributos. O primeiro atributo é a *chave de partição*, e o segundo atributo é a *chave de classificação*.
O DynamoDB usa o valor da chave de partição como entrada para uma função de hash interna. A saída da função de hash determina a partição (armazenamento físico interno do DynamoDB) em que o item será armazenado. Todos os itens com o mesmo valor de chave de partição são armazenados juntos, na ordem classificada por valor de chave de classificação.
Em uma tabela que tenha uma chave de partição e uma chave de classificação, vários itens podem ter o mesmo valor de chave de partição. No entanto, esses itens devem ter valores de chave de classificação diferentes.
A tabela *Music* descrita em [Tabelas, itens e atributos](#HowItWorks.CoreComponents.TablesItemsAttributes) é um exemplo de uma tabela com chave primária composta (*Artist* e *SongTitle*). Você poderá acessar diretamente qualquer item da tabela *Music*, se fornecer os valores *Artist* e *SongTitle* desse item.
Uma chave primária composta oferece flexibilidade adicional ao consultar dados. Por exemplo, se você fornecer somente o valor de *Artist*, o DynamoDB recuperará todas as músicas desse artista. Para recuperar apenas um subconjunto de músicas de um determinado artista, você pode fornecer um valor para *Artist* com um intervalo de valores de *SongTitle*.
**nota**
A chave de partição de um item também é conhecida como seu *atributo de hash*. O termo *atributo de hash* é derivado do uso de uma função de hash interna no DynamoDB que distribui uniformemente os itens de dados entre partições com base em seus valores de chave de partição.
A chave de classificação de um item também é conhecida como seu *atributo de intervalo*. O termo *atributo de intervalo* deriva da forma como o DynamoDB armazena itens fisicamente próximos com a mesma chave de partição, classificados em ordem de valor da chave de classificação.
Cada atributo de chave primária deve ser um escalar (o que significa que ele só pode conter um valor). Os únicos tipos de dados permitidos para atributos de chave primária são string, número ou binário. Essas restrições não existem para outros atributos não relacionados a chaves.
## Índices secundários
É possível criar um ou mais índices secundários em uma tabela. Um *índice secundário* permite consultar os dados na tabela usando uma chave alternativa, além de consultas com base na chave primária. O DynamoDB não exige que você use índices, mas eles conferem às aplicações mais flexibilidade durante a consulta dos dados. Depois de criar um índice secundário em uma tabela, você pode ler os dados do índice da mesma maneira que faz na tabela.
O DynamoDB aceita dois tipos de índices:
+ Índice secundário global: um índice com uma chave de partição e uma chave de classificação que podem ser diferentes daquelas contidas na tabela. Os valores da chave primária em um índice secundário global não precisam ser exclusivos.
+ Índice secundário local: um índice que tem a mesma chave de partição que a tabela, mas uma chave de classificação diferente.
No DynamoDB, os índices secundários globais (GSIs) são índices que abrangem toda a tabela, permitindo que você faça consultas em todas as chaves de partição. Índices secundários locais (LSIs) são índices com a mesma chave de partição que a tabela base, mas uma chave de classificação diferente.
Cada tabela no DynamoDB tem uma cota de 20 índices secundários globais (cota padrão) e 5 índices secundários locais.
Na tabela *Music* de exemplo mostrada anteriormente, é possível consultar itens de dados por *Artist* (chave de partição) ou por *Artist* e *SongTitle* (chave de partição e chave de classificação). E se você também quiser consultar os dados por *Genre* e *AlbumTitle*? Para fazer isso, você pode criar um índice em *Genre* e *AlbumTitle* e, em seguida, consultar esse índice da mesma forma como consulta a tabela *Music*.
O diagrama a seguir mostra a tabela *Music* de exemplo, com um novo índice chamado *GenreAlbumTitle*. No índice, *Genre* é a chave de partição e *AlbumTitle* é a chave de classificação.
| Tabela de música | *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"
}
|
Observe o seguinte sobre o índice *GenreAlbumTitle*:
+ Cada índice pertence a uma tabela, que é chamada de *tabela-base* para o índice. No exemplo anterior, *Music* é a tabela-base do índice *GenreAlbumTitle*.
+ O DynamoDB mantém os índices automaticamente. Quando você adiciona, atualiza ou exclui um item na tabela-base, o DynamoDB adiciona, atualiza ou exclui o item correspondente em quaisquer índices que pertençam a essa tabela.
+ Ao criar um índice, você especifica quais atributos serão copiados, ou *projetados*, da tabela-base para o índice. No mínimo, o DynamoDB projeta os atributos de chave da tabela-base no índice. Este é o caso com `GenreAlbumTitle`, em que somente os atributos de chave da tabela `Music` são projetados no índice.
Você pode consultar o índice *GenreAlbumTitle* para localizar todos os álbuns de um gênero específico (por exemplo, todos os álbuns de *Rock*). Você também pode consultar o índice para localizar todos os álbuns de um gênero específico que tenham determinados títulos de álbum (por exemplo, todos os álbuns *Country* com títulos que começam com a letra H).
Para obter mais informações, consulte [Melhorar o acesso aos dados com índices secundários no DynamoDB](SecondaryIndexes.md).
## DynamoDB Streams
O DynamoDB Streams é um recurso opcional que captura eventos de modificação de dados em tabelas do DynamoDB. Os dados sobre esses eventos são exibidos no fluxo quase em tempo real e na ordem em que os eventos ocorreram.
Cada evento é representado por um *registro de fluxo*. Se você habilitar um fluxo em uma tabela, o DynamoDB Streams gravará um registro de fluxo sempre que um dos seguintes eventos ocorrer:
+ Um novo item é adicionado à tabela: o fluxo captura uma imagem de todo o item, inclusive todos os atributos.
+ Um item é atualizado: o fluxo captura as imagens “antes” e “depois” de todos os atributos que tenham sido modificados no item.
+ Um item é excluído da tabela: o fluxo captura uma imagem de todo o item antes de ter sido excluído.
Cada registro de fluxo também contém o nome da tabela, o carimbo de data/hora do evento e outros metadados. Registros de fluxo tem um tempo de vida de 24 horas; depois disso, eles são automaticamente removidos do fluxo.
Você pode usar o DynamoDB Streams junto com o AWS Lambda para criar um *acionador*, um código que é executado automaticamente sempre que um evento de interesse aparece em um fluxo. Por exemplo, considere uma tabela *Customers* que contém informações sobre os clientes de uma empresa. Suponhamos que você queira enviar um e-mail de “boas-vindas” a cada novo cliente. Você pode habilitar um fluxo nessa tabela e depois associá-lo a uma função do Lambda. A função do Lambda seria executada sempre que um novo registro de fluxo aparecesse, mas processaria somente os novos itens adicionados à tabela *Customers*. Para qualquer item que tenha um atributo `EmailAddress`, a função do Lambda invocaria o Amazon Simple Email Service (Amazon SES) para enviar um e-mail a esse endereço.
![\[Integração do DynamoDB Streams e do Lambda para enviar automaticamente um e-mail de boas-vindas a novos clientes.\]](http://docs.aws.amazon.com/pt_br/amazondynamodb/latest/developerguide/images/HowItWorksStreams.png)
**nota**
Neste exemplo, o último cliente, Craig Roe, não receberá um e-mail, pois não tem um `EmailAddress`.
Além de acionadores, o DynamoDB Streams possibilita implementar soluções poderosas, como a replicação de dados dentro e entre regiões da AWS, visualizações materializadas de dados em tabelas do DynamoDB, análise de dados usando visualizações materializadas do Kinesis e muito mais.
Para obter mais informações, consulte [Capturar dados de alterações para o DynamoDB Streams](Streams.md).
# API do DynamoDB
Para trabalhar com o Amazon DynamoDB, a aplicação deve usar algumas operações de API simples. Veja a seguir um resumo dessas operações, organizadas por categoria.
**nota**
Para obter uma lista completa de operações de API, consulte a [Referência de API do Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/Welcome.html).
**Topics**
+ [Ambiente de gerenciamento](#HowItWorks.API.ControlPlane)
+ [Plano de dados](#HowItWorks.API.DataPlane)
+ [DynamoDB Streams](#HowItWorks.API.Streams)
+ [Transações](#HowItWorks.API.Transactions)
## Ambiente de gerenciamento
As operações do *ambiente de gerenciamento* permitem criar e gerenciar tabelas do DynamoDB. Elas também permitem que você trabalhe com índices, fluxos e outros objetos que são dependentes de tabelas.
+ `CreateTable`: cria uma nova tabela. Opcionalmente, você pode criar um ou mais índices secundários e habilitar o DynamoDB Streams para a tabela.
+ `DescribeTable`: retorna informações sobre uma tabela, como seu esquema de chaves primárias, configurações de throughput e informações de índice.
+ `ListTables`: retorna os nomes de todas as suas tabelas em uma lista.
+ `UpdateTable`: modifica as configurações de uma tabela ou de seus índices, cria ou remove novos índices em uma tabela ou modifica as configurações do DynamoDB Streams para uma tabela.
+ `DeleteTable`: remove uma tabela e todos os seus objetos dependentes do DynamoDB.
## Plano de dados
As operações do *plano de dados* permitem criar, ler, atualizar e excluir (também chamadas de *CRUD*) nos dados de uma tabela. Algumas das operações de plano de dados também permitem que você leia dados de um índice secundário.
Você pode usar o [PartiQL: uma linguagem de consultas compatível com SQL para o Amazon DynamoDB](ql-reference.md) para executar essas operações CRUD ou pode usar as APIs CRUD clássicas do DynamoDB que separam cada operação em uma chamada de API distinta.
### PartiQL: uma linguagem de consultas compatível com SQL
+ `ExecuteStatement`: lê vários itens de uma tabela. Você também pode gravar ou atualizar um único item de uma tabela. Ao gravar ou atualizar um único item, é necessário especificar os atributos de chave primária.
+ `BatchExecuteStatement`: grava, atualiza ou lê vários itens de uma tabela. Isso é mais eficiente do que `ExecuteStatement`, pois sua aplicação precisa apenas de uma única viagem de ida e volta na rede para gravar ou ler os itens.
### APIs clássicas
#### Criar dados
+ `PutItem`: grava um único item em uma tabela. Você deve especificar os atributos de chave primária, mas não precisa especificar outros atributos.
+ `BatchWriteItem`: grava até 25 itens em uma tabela. Isso é mais eficiente do que chamar `PutItem` várias vezes, pois seu aplicativo precisa apenas de uma única viagem de ida e volta na rede para gravar os itens.
#### Leitura de dados
+ `GetItem`: recupera um único item de uma tabela. É necessário especificar a chave primária do item desejado. É possível recuperar o item inteiro ou apenas um subconjunto dos seus atributos.
+ `BatchGetItem`: recupera até 100 itens de uma ou mais tabelas. Isso é mais eficiente do que chamar `GetItem` várias vezes, pois seu aplicativo precisa apenas de uma única viagem de ida e volta na rede para ler os itens.
+ `Query`: recupera todos os itens que têm uma chave de partição específica. Você deve especificar o valor da chave de partição. É possível recuperar itens inteiros, ou apenas um subconjunto dos seus atributos. Se desejar, é possível aplicar uma condição aos valores de chaves de classificação, para recuperar somente um subconjunto dos dados que têm a mesma chave de partição. Essa operação pode ser usada em uma tabela, desde que essa tabela tenha uma chave de partição e uma chave de classificação. Ela também pode ser usada em um índice, desde que esse índice tenha uma chave de partição e uma chave de classificação.
+ `Scan`: recupera todos os itens na tabela ou no índice especificado. É possível recuperar itens inteiros, ou apenas um subconjunto dos seus atributos. Opcionalmente, você pode aplicar uma condição de filtragem para retornar apenas os valores de interesse e descartar o restante.
#### Atualização de dados
+ `UpdateItem`: modifica um ou mais atributos em um item. É necessário especificar a chave primária do item que você deseja modificar. É possível adicionar novos atributos e modificar ou remover atributos existentes. Também é possível realizar atualizações condicionais, para que a atualização apenas seja bem-sucedida quando o uma condição definida pelo usuário for atendida. Opcionalmente, você pode implementar um contador atômico, que incrementa ou diminui um atributo numérico sem interferir em outras solicitações de gravação.
#### Excluir dados
+ `DeleteItem`: exclui um único item de uma tabela. É necessário especificar a chave primária do item que você deseja excluir.
+ `BatchWriteItem`: exclui até 25 itens de uma ou mais tabelas. Isso é mais eficiente do que chamar `DeleteItem` várias vezes, pois seu aplicativo precisa apenas de uma única viagem de ida e volta na rede para excluir os itens.
**nota**
Você pode usar `BatchWriteItem` para criar e excluir dados.
## DynamoDB Streams
As operações do *DynamoDB Streams* permitem que você habilite ou desabilite um fluxo em uma tabela e permitem o acesso a registros de modificação de dados contidos em um fluxo.
+ `ListStreams`: retorna uma lista de todos os seus fluxos ou somente o fluxo para uma tabela específica.
+ `DescribeStream`: retorna informações sobre um fluxo, como seu nome do recurso da Amazon (ARN) e onde sua aplicação pode começar a ler os primeiro registros de fluxo.
+ `GetShardIterator`:retorna um *iterador de fragmentos*, uma estrutura de dados que sua aplicação usa para recuperar os registros de fluxo.
+ `GetRecords`: recupera um ou mais registros de fluxo, usando um determinado iterador de fragmentos.
## Transações
*Transações* fornecem atomicidade, consistência, isolamento e durabilidade (ACID), permitindo que você mantenha a exatidão dos dados em suas aplicações com mais facilidade.
Você pode usar o [PartiQL: uma linguagem de consultas compatível com SQL para o Amazon DynamoDB](ql-reference.md) para executar operações transacionais ou pode usar as APIs CRUD clássicas do DynamoDB que separam cada operação em uma chamada de API distinta.
### PartiQL: uma linguagem de consultas compatível com SQL
+ `ExecuteTransaction`: uma operação em lote que permite operações CRUD em vários itens dentro e entre tabelas com um resultado garantido de tudo ou nada.
### APIs clássicas
+ `TransactWriteItems`: uma operação em lote que permite operações `Put`, `Update` e `Delete` em vários itens dentro e entre tabelas com um resultado garantido de tudo ou nada.
+ `TransactGetItems`: uma operação em lote que permite que operações `Get` recuperem vários itens de uma ou mais tabelas.
# Tipos de dados compatíveis e regras de nomenclatura no Amazon DynamoDB
Esta seção descreve as regras de nomenclatura do Amazon DynamoDB e os vários tipos de dados compatíveis com o DynamoDB. Há limites que se aplicam a tipos de dados. Para obter mais informações, consulte [Tipos de dados](Constraints.md#limits-data-types).
**Topics**
+ [Regras de nomenclatura](#HowItWorks.NamingRules)
+ [Tipos de dados](#HowItWorks.DataTypes)
+ [Descritores de tipo de dados](#HowItWorks.DataTypeDescriptors)
## Regras de nomenclatura
Tabelas, atributos e outros objetos no DynamoDB devem ter nomes. Os nomes devem ser concisos e significativos; por exemplo, nomes como *Products*, *Books* e *Authors* são autoexplicativos.
Estas são as regras de nomenclatura do DynamoDB:
+ Todos os nomes devem ser codificados usando UTF-8 e diferenciam maiúsculas de minúsculas.
+ Nomes de tabelas e nomes de índices devem ter entre 3 e 255 caracteres e podem conter somente os seguintes caracteres:
+ `a-z`
+ `A-Z `
+ ` 0-9 `
+ `_` (sublinhado)
+ `-` (traço)
+ `.` (ponto)
+ Os nomes de atributos devem ter pelo menos um caractere e no mínimo 64 KB. Manter os nomes dos atributos o mais curtos possível é considerada uma prática recomendada. Isso ajuda a reduzir as unidades de solicitação de leitura consumidas, pois os nomes dos atributos são incluídos na medição do uso do armazenamento e do throughput.
Veja as exceções a seguir. Estes nomes de atributo não devem ser maiores do que 255 caracteres:
+ Nomes de chave de partição de índices secundários
+ Nomes de chave de classificação de índices secundários
+ Nomes de qualquer atributo projetado especificado pelo usuário (aplicável apenas a índices secundários locais)
### Palavras reservadas e caracteres especiais
O DynamoDB tem uma lista de palavras reservadas e caracteres especiais. Para obter uma lista completa, consulte [Palavras reservadas no DynamoDB](ReservedWords.md). Além disso, os seguintes caracteres têm um significado especial no DynamoDB: **\$1** (hash) e **:** (dois-pontos).
Embora o DynamoDB permita usar essas palavras reservadas e caracteres especiais nos nomes, é recomendável evitar, pois será necessário definir variáveis de espaço reservado sempre que esses nomes forem utilizados em uma expressão. Para obter mais informações, consulte [Nomes (aliases) de atributo de expressão no DynamoDB](Expressions.ExpressionAttributeNames.md).
## Tipos de dados
O DynamoDB oferece suporte a vários tipos de dados diferentes para atributos dentro de uma tabela. Eles podem ser categorizados da seguinte maneira:
+ **Tipos escalares**: um tipo escalar pode representar exatamente um valor. Os tipos escalares são número, string, binário, booliano e nulo.
+ **Tipos de documento**: um tipo de documento pode representar uma estrutura complexa com atributos aninhados, como aqueles que você encontraria em um documento JSON. Os tipos de documentos são lista e mapa.
+ **Tipos de conjuntos**: um tipo de conjunto pode representar vários valores escalares. Os tipos de conjuntos são conjunto de strings, conjunto de números e conjunto de binários.
Ao criar uma tabela ou um índice secundário, você deve especificar os nomes e os tipos de dados de cada atributo de chave primária (chave de partição e chave de classificação). Além disso, cada atributo de chave primária deve ser definido como o tipo string, número ou binário.
O DynamoDB é um banco de dados NoSQL *sem esquema*. Isso significa que, além dos atributos de chave primária, não é necessário definir nenhum atributo nem tipos de dados ao criar tabelas. Por comparação, bancos de dados relacionais exigem que você defina os nomes e os tipos de dados de cada coluna ao criar uma tabela.
As seguintes descrições representam cada tipo de dados, juntamente com exemplos no formato JSON.
### Tipos escalares
Os tipos escalares são número, string, binário, booliano e nulo.
#### Número
Números podem ser positivos, negativo ou zero. Os números podem ter uma precisão de até 38 dígitos. Se esse limite for excedido, uma exceção será gerada. Se precisar de uma precisão maior do que 38 dígitos, você poderá usar strings.
+ Intervalo positivo: 1E-130 a 9,9999999999999999999999999999999999999E\$1125
+ Intervalo negativo: -9.9999999999999999999999999999999999999E\$1125 a -1E-130
No DynamoDB, os números são representados como tamanho variável. Zeros iniciais e finais são cortados.
Todos os números são enviados pela rede ao DynamoDB como strings para maximizar a compatibilidade entre linguagens e bibliotecas. No entanto, o DynamoDB os trata como atributos numéricos para operações matemáticas.
É possível usar o tipo de dados Número para representar uma data ou um carimbo de data/hora. Uma maneira de fazer isso é usando o tempo epoch, o número de segundos desde 00:00:00 UTC em 1.° de janeiro de 1970. Por exemplo, o tempo epoch `1437136300` representa 12:31:40 PM UTC em 17 de julho de 2015.
Para obter mais informações, consulte [http://en.wikipedia.org/wiki/Unix\$1time](http://en.wikipedia.org/wiki/Unix_time).
#### String
Strings são Unicode com codificação binária UTF-8. O tamanho mínimo de uma string poderá ser zero se o atributo não for usado como uma chave para um índice ou uma tabela e ser restrito pelo limite máximo de tamanho de item do DynamoDB de 400 KB.
As seguintes restrições adicionais se aplicam aos atributos de chave primária definidos como string de tipo:
+ Para uma chave primária simples, o comprimento máximo do valor do primeiro atributo (a chave de partição) é 2048 bytes.
+ Para uma chave primária composta, o comprimento máximo do valor do segundo atributo (a chave de classificação) é 1024 bytes.
O DynamoDB agrupa e compara strings usando os bytes da codificação de strings UTF-8 subjacente. Por exemplo, “`a`” (0x61) é maior que “`A`” (0x41) e “`¿`” (0xC2BF) é maior que “`z`” (0x7A).
É possível usar o tipo de dados string para representar uma data ou um carimbo de data/hora. Uma maneira de fazer isso é usando strings ISO 8601, conforme mostrado nestes exemplos:
+ `2016-02-15`
+ `2015-12-21T17:42:34Z`
+ `20150311T122706Z`
Para obter mais informações, consulte [http://en.wikipedia.org/wiki/ISO\$18601](http://en.wikipedia.org/wiki/ISO_8601).
**nota**
Ao contrário dos bancos de dados relacionais convencionais, o DynamoDB não comporta nativamente um tipo de dados de data e hora. Em vez disso, pode ser útil armazenar dados de data e hora como um tipo de dado numérico, usando o horário Unix epoch.
#### Binário
Atributos do tipo Binário podem armazenar quaisquer dados binários, como texto compactado, dados criptografados ou imagens. Sempre que o DynamoDB compara valores binários, ele trata cada byte dos dados binários como sem sinal.
O tamanho de um atributo binário poderá ser zero, se o atributo não for usado como uma chave para um índice ou uma tabela, e ser restrito pelo limite máximo de tamanho de item do DynamoDB de 400 KB.
Se você definir um atributo de chave primária como um atributo do tipo Binário, as seguintes restrições adicionais serão aplicáveis:
+ Para uma chave primária simples, o comprimento máximo do valor do primeiro atributo (a chave de partição) é 2048 bytes.
+ Para uma chave primária composta, o comprimento máximo do valor do segundo atributo (a chave de classificação) é 1024 bytes.
Suas aplicações deverão codificar valores binários no formato codificado em base64 antes que eles sejam enviados ao DynamoDB. Após o recebimento desses valores, o DynamoDB decodifica os dados em uma matriz de bytes sem sinal e a utiliza como o comprimento do atributo binário.
O exemplo a seguir é um atributo binário usando texto codificado em base64.
```
dGhpcyB0ZXh0IGlzIGJhc2U2NC1lbmNvZGVk
```
#### Booleano
Um atributo do tipo Booliano pode armazenar `true` ou `false`.
#### Nulo
Nulo representa um atributo com um estado desconhecido ou indefinido.
### Tipos de documentos
Os tipos de documentos são lista e mapa. Esses tipos de dados podem ser aninhados entre si para representar estruturas de dados complexas com até 32 níveis de profundidade.
Não há limite para o número de valores em uma lista ou em um mapa, desde que o item que contém os valores caiba no limite de tamanho de item do DynamoDB (400 KB).
Um valor de atributo poderá ser um valor binário vazio se o atributo não for usado para uma tabela ou chave de índice. Um valor de atributo não pode ser um conjunto vazio (conjunto de strings, conjunto de números e conjunto binário). No entanto, listas e mapas vazios são permitidos. Valores binários e de string vazios são permitidos dentro de listas e mapas. Para obter mais informações, consulte [Atributos](Constraints.md#limits-attributes).
#### Lista
Um atributo do tipo Lista pode armazenar uma coleção ordenada de valores. Listas são delimitadas por colchetes: `[ ... ]`
Uma lista é semelhante a uma matriz JSON. Não há restrições quanto aos tipos de dados que podem ser armazenados em um elemento de lista, e os elementos de um elemento de lista não precisam ser do mesmo tipo.
O exemplo a seguir mostra uma lista que contém duas strings e um número.
```
FavoriteThings: ["Cookies", "Coffee", 3.14159]
```
**nota**
O DynamoDB permite que você trabalhe com elementos individuais em listas, mesmo que esses elementos estejam profundamente aninhados. Para obter mais informações, consulte [Usar expressões no DynamoDB](Expressions.md).
#### Mapa
Um atributo do tipo Mapa pode armazenar uma coleção não ordenada de pares de nome/valor. Mapas são delimitados por chaves: `{ ... }`
Um mapa é semelhante a um objeto JSON. Não há restrições quanto aos tipos de dados que podem ser armazenados em um elemento de mapa, e os elementos de um mapa não precisam ser do mesmo tipo.
Mapas são ideais para armazenar documentos JSON no DynamoDB. O exemplo a seguir mostra um mapa que contém uma string, um número e uma lista aninhada que contém outro mapa.
```
{
Day: "Monday",
UnreadEmails: 42,
ItemsOnMyDesk: [
"Coffee Cup",
"Telephone",
{
Pens: { Quantity : 3},
Pencils: { Quantity : 2},
Erasers: { Quantity : 1}
}
]
}
```
**nota**
O DynamoDB permite que você trabalhe com elementos individuais em mapas, mesmo se esses elementos estiverem profundamente aninhados. Para obter mais informações, consulte [Usar expressões no DynamoDB](Expressions.md).
### Conjuntos
O DynamoDB oferece suporte a tipos que representam conjuntos de valores de número, string ou binário. Todos os elementos de um conjunto devem ser do mesmo tipo. Por exemplo, um conjunto de números só pode conter números, um conjunto de strings pode conter apenas strings.
Não há limite para o número de valores em um conjunto, desde que o item que contém os valores não ultrapasse o limite de tamanho de item do DynamoDB (400 KB).
Cada valor dentro de um conjunto deve ser exclusivo. A ordem dos valores em um conjunto não é preservada. Portanto, seus aplicativos não devem depender de nenhuma ordem específica de elementos no conjunto. O DynamoDB não oferece suporte a conjuntos vazios. No entanto, valores binários e de string vazios são permitidos dentro de um conjunto.
O exemplo a seguir mostra um conjunto de strings, um conjunto de números e um conjunto de binários:
```
["Black", "Green", "Red"]
[42.2, -19, 7.5, 3.14]
["U3Vubnk=", "UmFpbnk=", "U25vd3k="]
```
## Descritores de tipo de dados
O protocolo de API do DynamoDB de baixo nível usa *descritores de tipos de dados* como tokens que informam ao DynamoDB como interpretar cada atributo.
Veja a seguir uma lista completa dos descritores de tipos de dados do DynamoDB:
+ **`S`** – string
+ **`N`** – número
+ **`B`** – binário
+ **`BOOL`** – booliano
+ **`NULL`** – nulo
+ **`M`** – mapa
+ **`L`** – lista
+ **`SS`** – conjunto de strings
+ **`NS`** – conjunto de números
+ **`BS`** – conjunto binário
# Classes de tabelas do DynamoDB
O DynamoDB apresenta duas classes de tabela projetadas para ajudar você a otimizar o custo. A classe de tabela Standard do DynamoDB é a padrão e é recomendada para a grande maioria das workloads. A classe de tabela do DynamoDB Standard-Infrequent Access (DynamoDB Standard-IA) é otimizada para tabelas em que o armazenamento é o custo dominante. Por exemplo, tabelas que armazenam dados acessados com pouca frequência, como logs da aplicação, postagens antigas de mídia social, histórico de pedidos de comércio eletrônico e antigas conquistas de jogos, são bons candidatos para a classe de tabela Standard-IA. Para obter detalhes de preço, consulte [Definição de preço do Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/on-demand/).
Cada tabela do DynamoDB está associada a uma classe de tabela (por padrão, DynamoDB Standard). Todos os índices secundários associados à tabela usam a mesma classe de tabela. Cada classe de tabela oferece preços diferentes para armazenamento de dados, bem como para solicitações de leitura e gravação. Você pode selecionar a classe de tabela mais econômica para sua tabela com base nos padrões de uso de armazenamento e do throughput.
A escolha de uma classe de tabela não é permanente — você pode alterar essa configuração usando o Console de gerenciamento da AWS, a CLI do AWS, ou o SDK do AWS. O DynamoDB também permite o gerenciamento de sua classe de tabela usando o AWS CloudFormation para tabelas de região única e tabelas globais. Para saber mais sobre como selecionar sua classe de tabela, consulte [Considerações ao escolher uma classe de tabela no DynamoDB](WorkingWithTables.tableclasses.md).
# Partições e distribuição de dados no DynamoDB
O Amazon DynamoDB armazena dados em partições. Uma *partição* é uma alocação de armazenamento para uma tabela, com suporte de SSDs (unidades de estado sólido) e automaticamente replicada em várias zonas de disponibilidade em uma região da AWS. O gerenciamento de partições é feito inteiramente pelo DynamoDB; você nunca precisará gerenciar partições por conta própria.
Quando você cria uma tabela, seu estado inicial é `CREATING`. Durante essa fase, o DynamoDB aloca partições suficientes para a tabela, para que ela possa lidar com suas necessidades de throughput provisionado. Você pode começar a gravar e ler dados da tabela depois que o status da tabela mudar para `ACTIVE`.
O DynamoDB alocará partições adicionais em uma tabela nas seguintes situações:
+ Se você aumentar as configurações de throughput provisionado da tabela além do que as partições existentes podem suportar.
+ Se uma partição existente for ocupada até a capacidade máxima e mais espaço de armazenamento for necessário.
O gerenciamento de partições ocorre automaticamente em segundo plano e é transparente para as aplicações. Sua tabela permanece disponível durante todo o processo e oferece suporte total para os seus requisitos de throughput provisionado.
Para obter mais detalhes, consulte [Design de chave de partição](bp-partition-key-design.md).
Os índices secundários globais no DynamoDB também são compostos por partições. Os dados em um índice secundário global são armazenados separadamente dos dados em sua tabela-base, mas as partições de índice se comportam da mesma forma que partições de tabela.
## Distribuição de dados: chave de partição
Se a sua tabela tiver uma chave primária simples (somente uma chave de partição), o DynamoDB armazenará e recuperará cada item com base em seu valor de chave de partição.
Para gravar um item na tabela, o DynamoDB usa o valor da chave de partição como entrada para uma função de hash interna. O valor de saída da função de hash determina a partição na qual o item será armazenado.
Para ler um item da tabela, você deve especificar o valor da chave de partição desse item. O DynamoDB usa esse valor como entrada para sua função de hash, resultando na partição na qual o item pode ser encontrado.
O diagrama a seguir mostra uma tabela chamada *Pets*, que se estende por várias partições. A chave primária da tabela é *AnimalType* (somente esse atributo de chave é mostrado). O DynamoDB usa sua função de hash para determinar onde armazenar um novo item, neste caso, com base no valor de hash da string *Dog*. Observe que os itens não são armazenados na ordem classificada. A localização de cada item é determinada pelo valor de hash de sua chave de partição.
![\[Distribuição do DynamoDB de itens de tabela entre partições com base no valor de hash da chave de partição.\]](http://docs.aws.amazon.com/pt_br/amazondynamodb/latest/developerguide/images/HowItWorksPartitionKey.png)
**nota**
O DynamoDB é otimizado para distribuição uniforme de itens entre partições de uma tabela, independentemente de quantas partições possam existir. Recomendamos que você escolha uma chave de partição que possa ter um grande número de valores distintos em relação ao número de itens da tabela.
## Distribuição de dados: chave de partição e chave de classificação
Se a tabela tiver uma chave primária composta (chave de partição e chave de classificação), o DynamoDB calculará o valor de hash da chave de partição da mesma forma que descrito em [Distribuição de dados: chave de partição](#HowItWorks.Partitions.SimpleKey). No entanto, ele tende a manter os itens que têm o mesmo valor de chave de partição próximos e ordenados pelo valor do atributo da chave de classificação. O conjunto de itens que têm o mesmo valor da chave de partição é chamado de coleção de itens. As coleções de itens são otimizadas para a recuperação eficiente de intervalos de itens dentro da coleção. Se sua tabela não tiver índices secundários locais, o DynamoDB dividirá automaticamente sua coleção de itens em quantas partições forem necessárias para armazenar os dados e fornecer o throughput de leitura e gravação.
Para gravar um item na tabela, o DynamoDB calcula o valor de hash da chave de partição a fim de determinar qual partição deve conter esse item. Nessa partição, vários itens poderiam ter o mesmo valor de chave de partição. Portanto, o DynamoDB armazena o item entre os outros com a mesma chave de partição, em ordem ascendente por chave de classificação.
Para ler um item da tabela, você deve especificar seu valor de chave de partição e seu valor de chave de classificação. O DynamoDB calcula o valor de hash da chave de partição, resultando na partição na qual o item pode ser encontrado.
É possível ler vários itens de tabela em uma única operação (`Query`), desde que os itens desejados tenham o mesmo valor de chave de partição. O DynamoDB retorna todos os itens com esse valor de chave de partição. Opcionalmente, você pode aplicar uma condição à chave de classificação para que ela retorne somente os itens em um determinado intervalo de valores.
Suponhamos que a tabela *Pets* possua uma chave primária composta que consiste em *AnimalType* (chave de partição) e *Name* (chave de classificação). O diagrama a seguir mostra o DynamoDB gravando um item com um valor de chave de partição *Dog* e um valor de chave de classificação *Fido*.
![\[O DynamoDB armazena um item com uma chave de partição composta e classifica esse item usando o valor do atributo da chave de classificação.\]](http://docs.aws.amazon.com/pt_br/amazondynamodb/latest/developerguide/images/HowItWorksPartitionKeySortKey.png)
Para ler esse mesmo item na tabela *Pets*, o DynamoDB calcula o valor de hash de *Dog*, gerando assim a partição na qual esses itens estão armazenados. Em seguida, o DynamoDB verifica os valores de atributo de chave de classificação até encontrar *Fido*.
Para ler todos os itens com um *AnimalType* de *Dog*, você pode emitir uma operação `Query` sem especificar uma condição de chave de classificação. Por padrão, os itens são retornados na ordem em que são armazenados (ou seja, em ordem crescente por chave de classificação). Existe a opção de solicitar a ordem decrescente em vez disso.
Para consultar somente alguns itens de *Dog*, você pode aplicar uma condição à chave de classificação (por exemplo, apenas os itens *Dog* em que *Name* comece com uma letra que esteja dentro do intervalo de `A` a `K`).
**nota**
Em uma tabela do DynamoDB, não há limite superior quanto ao número de valores de chave de classificação distintos por valor de chave de partição. Se for necessário armazenar bilhões de itens *Dog* na tabela *Pets*, o DynamoDB alocará automaticamente armazenamento suficiente para atender a esse requisito.
# 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"
}
```
# Recursos e ferramentas de aprendizado do Amazon DynamoDB
É possível usar os recursos adicionais a seguir para conhecer o DynamoDB e trabalhar com ele.
**Topics**
+ [Ferramentas para codificação e visualização](#AdditionalResources.Tools)
+ [Artigos de Recomendações](#AdditionalResources.PrescriptiveGuidance)
+ [Artigos do Centro de Conhecimentos](#AdditionalResources.KnowledgeCenter)
+ [Postagens em blogs, repositórios e guias](#AdditionalResources.Guides)
+ [Apresentações sobre modelagem de dados e padrões de design](#AdditionalResources.DataModeling)
+ [Cursos de treinamento](#AdditionalResources.Training)
## Ferramentas para codificação e visualização
É possível usar as seguintes ferramentas de codificação e visualização para trabalhar com o DynamoDB:
+ [NoSQL Workbench para Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.html): uma ferramenta visual unificada que ajuda a projetar, criar, consultar e gerenciar tabelas do DynamoDB. Ela fornece recursos de modelagem de dados, visualização de dados e desenvolvimento de consultas.
+ [Dynobase](https://dynobase.dev/): uma ferramenta de desktop que facilita a visualização e o trabalho com tabelas do DynamoDB, a criação de código de aplicação e a edição de registros com validação em tempo real.
+ [DynamoDB Toolbox](https://github.com/jeremydaly/dynamodb-toolbox): um projeto de Jeremy Daly que fornece utilitários ideais para trabalhar com modelagem de dados e JavaScript e Node.js.
+ [Processador de fluxos do DynamoDB](https://github.com/jeremydaly/dynamodb-streams-processor): uma ferramenta simples que torna extremamente fácil trabalhar com [fluxos do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html).
## Artigos de Recomendações
O recurso Recomendações da AWS fornece estratégias, guias e padrões comprovados para ajudar a acelerar seus projetos. Esses recursos foram desenvolvidos por especialistas em tecnologia da AWS e pela comunidade global de parceiros da AWS, com base em seus vários anos de experiência ajudando os clientes a alcançar seus objetivos empresariais.
**Modelagem e migração de dados**
+ [Um modelo de dados hierárquico no DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-hierarchical-data-model/introduction.html)
+ [Modelagem de dados com o DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-data-modeling/welcome.html)
+ [Migrar um banco de dados Oracle para o DynamoDB usando o AWS DMS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.html)
**Tabelas globais**
+ [Usar as tabelas globais do Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-global-tables/introduction.html)
**sem servidor**
+ [Implementar o padrão de saga sem servidor com o AWS Step Functions](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/implement-the-serverless-saga-pattern-by-using-aws-step-functions.html)
**Arquitetura de SaaS**
+ [Gerenciar locatários em vários produtos de SaaS em um único ambiente de gerenciamento](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/manage-tenants-across-multiple-saas-products-on-a-single-control-plane.html)
+ [Integração de locatários na arquitetura de SaaS para o modelo de silo usando C\$1 e o 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)
**Proteção e movimentação de dados**
+ [Configurar o acesso entre contas ao Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html)
+ [Opções completas de cópia de tabela para o DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-full-table-copy-options/)
+ [Estratégia de recuperação de desastres para bancos de dados na AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/strategy-database-disaster-recovery/)
**Diversos**
+ [Ajude a aplicar a marcação no DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/help-enforce-dynamodb-tagging.html)
**Demonstração em vídeo das recomendações**
+ [Usar a arquitetura sem servidor para criar pipelines de dados](https://youtu.be/JiWHomdh1oI?)
+ [Novartis - – mecanismo de compra: portal de compras baseado em IA](https://youtu.be/vp8oPiHN4cA)
+ [Veritiv: habilite insights para prever a demanda de vendas em data lakes da AWS](https://youtu.be/jg85DzUZ9Ac)
+ [mimik: nuvem de borda híbrida que utiliza a AWS para atender à malha de microsserviços de borda](https://youtu.be/-S-R7MWRpaI)
+ [Alterar a captura de dados com o Amazon DynamoDB](https://youtu.be/6YVjzD-70p4)
Para ver mais artigos e vídeos de recomendações para o DynamoDB, consulte [Recomendações](https://tiny.amazon.com/fiui3cog/ForinternaldemoofnewpageExternalURLwillbeneededforlive).
## Artigos do Centro de Conhecimentos
Os artigos e vídeos do Centro de Conhecimentos da AWS abrangem as perguntas e solicitações mais frequentes que recebemos dos clientes da AWS. Veja a seguir alguns artigos atuais do Centro de Conhecimentos sobre tarefas específicas relacionadas ao DynamoDB:
**Otimização de custos**
+ [Como otimizo os custos com o Amazon DynamoDB?](https://repost.aws/knowledge-center/dynamodb-optimize-costs)
**Controle de utilização e latência**
+ [Como posso solucionar problemas de alta latência em uma tabela do Amazon DynamoDB?](https://repost.aws/knowledge-center/dynamodb-high-latency)
+ [Por que minha tabela do DynamoDB está com controle de utilização?](https://repost.aws/knowledge-center/dynamodb-table-throttled)
+ [Por que minha tabela sob demanda do DynamoDB está com controle de utilização?](https://repost.aws/knowledge-center/on-demand-table-throttling-dynamodb)
**Paginação**
+ [Como implementar a paginação no DynamoDB](https://repost.aws/knowledge-center/dynamodb-implement-pagination)
**Transações**
+ [Por que minha chamada de API `TransactWriteItems` falha no DynamoDB](https://repost.aws/knowledge-center/dynamodb-transactwriteitems)
**Solução de problemas do**
[]()
+ [Como resolver problemas com o ajuste de escala automático do DynamoDB?](https://repost.aws/knowledge-center/dynamodb-auto-scaling)
+ [Como solucionar erros HTTP 4XX no DynamoDB](https://repost.aws/knowledge-center/usererrors-dynamodb-table)
Para ver mais artigos e vídeos sobre o DynamoDB, consulte os artigos do [Centro de Conhecimentos](https://repost.aws/search/knowledge-center?globalSearch=dynamodb).
## Postagens em blogs, repositórios e guias
Além do [Guia do desenvolvedor do DynamoDB](Introduction.md), há muitos recursos úteis para trabalhar com o DynamoDB. Veja abaixo algumas publicações de blog, repositórios e guias selecionados para trabalhar com o DynamoDB:
+ AWSrepositório de [Exemplos de código do DynamoDB](https://github.com/aws-samples/aws-dynamodb-examples) em várias linguagens do SDK do AWS: [Node.js,](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/node.js) [Java,](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/java) [Python,](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/python) [.Net,](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/dotnet) [Go](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/golang) e [Rust](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/rust).
+ [The DynamoDB Book](https://www.dynamodbbook.com/): um guia abrangente de [Alex DeBrie](https://twitter.com/alexbdebrie) que ensina uma abordagem orientada por estratégias para modelagem de dados com o DynamoDB.
+ [DynamoDB Guide](https://www.dynamodbguide.com/): um guia aberto de [Alex DeBrie](https://twitter.com/alexbdebrie) que explica os conceitos básicos e recursos avançados do banco de dados NoSQL do DynamoDB.
+ [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/): uma lista de etapas úteis para aprender sobre a modelagem de dados de [Jeremy Daly](https://twitter.com/jeremy_daly).
+ [Página de dicas do DynamoDB JavaScript DocumentClient](https://github.com/dabit3/dynamodb-documentclient-cheat-sheet): dicas para ajudar você a começar a criar aplicações com o DynamoDB em um ambiente Node.js ou JavaScript.
+ [Vídeos dos principais conceitos do DynamoDB](https://www.youtube.com/playlist?list=PLJo-rJlep0EDNtcDeHDMqsXJcuKMcrC5F): essa playlist aborda muitos dos principais conceitos do DynamoDB.
## Apresentações sobre modelagem de dados e padrões de design
É possível usar os seguintes recursos sobre modelagem de dados e padrões de design para aproveitar ao máximo o DynamoDB:
+ [AWS re:Invent 2019: Data modeling with DynamoDB](https://www.youtube.com/watch?v=DIQVJqiSUkE)
+ Uma palestra de [Alex DeBrie](https://twitter.com/alexbdebrie) que apresenta os princípios da modelagem de dados do DynamoDB.
+ [AWS re:Invent 2020: Modelagem de dados com o DynamoDB – Parte 1](https://www.youtube.com/watch?v=fiP2e-g-r4g)
+ [AWS re:Invent 2020: Modelagem de dados com o DynamoDB – Parte 2](https://www.youtube.com/watch?v=0uLF1tjI_BI)
+ [AWS re:Invent 2017: Advanced design patterns](https://www.youtube.com/watch?v=jzeKPKpucS0)
+ [AWS re:Invent 2018: Advanced design patterns](https://www.youtube.com/watch?v=HaEPXoXVf2k)
+ [AWS re:Invent 2019: Advanced design patterns](https://www.youtube.com/watch?v=6yqfmXiZTlM)
+ Jeremy Daly compartilha [12 key takeaways](https://www.jeremydaly.com/takeaways-from-dynamodb-deep-dive-advanced-design-patterns-dat403/) nesta sessão.
+ [AWS re:Invent 2020: Padrões de design avançado do DynamoDB – Parte 1](https://www.youtube.com/watch?v=MF9a1UNOAQo&index=1)
+ [AWS re:Invent 2020: Padrões de design avançado do DynamoDB – Parte 2](https://www.youtube.com/watch?v=_KNrRdWD25M&index=2)
+ [DynamoDB Office Hours on Twitch](https://amazondynamodbofficehrs.splashthat.com/)
**nota**
Cada sessão abrange diferentes casos de uso e exemplos.
## Cursos de treinamento
Há muitos cursos de treinamento e opções educacionais diferentes para aprender mais sobre o DynamoDB. Veja aqui alguns exemplos atuais:
+ [Desenvolvimento com o Amazon DynamoDB](https://www.aws.training/Details/Curriculum?id=65583): projetado pela AWS para levar você de iniciante a especialista em desenvolvimento de aplicações do mundo real com modelagem de dados para o Amazon DynamoDB.
+ [DynamoDB deep dive course](https://www.pluralsight.com/courses/aws-dynamodb-deep-dive-2019): um curso da Pluralsight.
+ [Amazon DynamoDB: desenvolvendo aplicações guiadas por banco de dados NoSQL](https://www.edx.org/course/amazon-dynamodb-building-nosql-database-driven-app): um curso da equipe AWS Training and Certification realizado no edX.