# PartiQL: uma linguagem de consultas compatível com SQL para o Amazon DynamoDB O Amazon DynamoDB oferece suporte a [PartiQL](https://partiql.org/), uma linguagem de consultas compatível com SQL, para selecionar, inserir, atualizar e excluir dados no Amazon DynamoDB. Usando PartiQL, você pode interagir facilmente com tabelas do DynamoDB e executar consultas ad hoc usando o Console de gerenciamento da AWS, o NoSQL Workbench, a AWS Command Line Interfacee as APIs do DynamoDB para PartiQL. As operações PartiQL fornecem as mesmas disponibilidade, latência e performance que as outras operações de plano de dados do DynamoDB. As seções a seguir descrevem a implementação de PartiQL do DynamoDB. **Topics** + [O que é PartiQL?](#ql-reference.what-is) + [PartiQL no Amazon DynamoDB](#ql-reference.what-is) + [Introdução](ql-gettingstarted.md) + [Tipos de dados](ql-reference.data-types.md) + [Declarações](ql-reference.statements.md) + [Funções](ql-functions.md) + [Operadores](ql-operators.md) + [Transações](ql-reference.multiplestatements.transactions.md) + [Operações em lote](ql-reference.multiplestatements.batching.md) + [Políticas do IAM](ql-iam.md) ## O que é PartiQL? A linguagem *PartiQL* garante acesso de consultas compatíveis com SQL em vários armazenamentos de dados que contêm dados estruturados, dados semiestruturados e dados aninhados. Ela é amplamente utilizada na Amazon e agora está disponível como parte de muitos serviços da AWS, incluindo o DynamoDB. Para obter a especificação da PartiQL e um tutorial sobre a linguagem de consulta principal, consulte a [Documentação da PartiQL](https://partiql.org/docs.html). **nota** O Amazon DynamoDB oferece suporte a um *subconjunto* da linguagem de consultas [PartiQL](https://partiql.org/). O Amazon DynamoDB não é compatível com o formato de dados [Amazon Ion](http://amzn.github.io/ion-docs/) nem com liderais do Amazon Ion. ## PartiQL no Amazon DynamoDB Para executar consultas PartiQL no DynamoDB, você pode usar: + O console do DynamoDB + O NoSQL Workbench + A AWS Command Line Interface (AWS CLI) + As APIs do DynamoDB Para obter informações sobre como usar esses métodos para acessar o DynamoDB, consulte [Acesso ao DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AccessingDynamoDB.html). # Conceitos básicos de PartiQL para DynamoDB Esta seção descreve como usar PartiQL para DynamoDB via console do Amazon DynamoDB, AWS Command Line Interface (AWS CLI) e APIs do DynamoDB. Nos exemplos a seguir, a tabela do DynamoDB definida no tutorial [Conceitos básicos do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) é um pré-requisito. Para obter informações sobre como usar o console do DynamoDB, a AWS Command Line Interface ou as APIs do DynamoDB para acessar o DynamoDB, consulte [Acesso ao DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AccessingDynamoDB.html). Para [baixar](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.settingup.html) e usar o [NoSQL Workbench](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.html) para criar instruções em [PartiQL para DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), escolha **PartiQL Operations** (Operações PartiQL) no canto superior direito do [Criador de operações](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.querybuilder.operationbuilder.html) do NoSQL Workbench para DynamoDB. ------ #### [ Console ] ![\[Interface do Editor PartiQL que mostra o resultado da execução da operação de consulta na tabela Music.\]](http://docs.aws.amazon.com/pt_br/amazondynamodb/latest/developerguide/images/partiqlgettingstarted.png) 1. Faça login no Console de gerenciamento da AWS e abra o console do DynamoDB em [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/). 1. No painel de navegação, no lado esquerdo do console, selecione **PartiQL editor** (Editor de PartiQL). 1. Escolha a tabela **Music**. 1. Escolha **Query table** (Consultar tabela). Essa ação gera uma consulta que não resultará em uma varredura de tabela completa. 1. Substitua `partitionKeyValue` pelo valor da string `Acme Band`. Substitua `sortKeyValue` pelo valor da string `Happy Day`. 1. Selecione o botão **Run (Executar)**. 1. Você pode visualizar os resultados da consulta escolhendo a opção **Table view** (Visualização da tabela ou **JSON view** (Visualização de JSON). ------ #### [ NoSQL workbench ] ![\[Interface do NoSQL Workbench. Ela mostra uma declaração PartiQL SELECT que você pode executar na tabela Music.\]](http://docs.aws.amazon.com/pt_br/amazondynamodb/latest/developerguide/images/workbench/partiql.single.png) 1. Escolha **PartiQL statement** (Instrução PartiQL). 1. Insira a seguinte [instrução SELECT](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html) PartiQL ``` SELECT * FROM Music WHERE Artist=? and SongTitle=? ``` 1. Para especificar um valor para os parâmetros `Artist` e `SongTitle`: 1. Escolha **Optional request parameters** (Parâmetros de solicitação opcionais). 1. Escolha **Add new parameters** (Adicionar novos parâmetros). 1. Escolha o tipo de atributo **string** e o valor `Acme Band`. 1. Repita as etapas b e c e escolha o tipo **string** e o valor `PartiQL Rocks`. 1. Se desejar gerar código, escolha **Generate code** (Gerar código). Selecione a linguagem desejada nas guias exibidas. Agora você pode copiar esse código e usá-lo na sua aplicação. 1. Se desejar que a operação seja executada imediatamente, escolha **Run** (Executar). ------ #### [ AWS CLI ] 1. Crie um item na tabela `Music` usando a instrução PartiQL INSERT. ``` aws dynamodb execute-statement --statement "INSERT INTO Music \ VALUE \ {'Artist':'Acme Band','SongTitle':'PartiQL Rocks'}" ``` 1. Recupere um item da tabela Music usando a instrução PartiQL SELECT. ``` aws dynamodb execute-statement --statement "SELECT * FROM Music \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` 1. Atualize um item na tabela `Music` usando a instrução PartiQL UPDATE. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardsWon=1 \ SET AwardDetail={'Grammys':[2020, 2018]} \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Adicione um valor de lista para um item na tabela `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Remova um valor de lista para um item na tabela `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ REMOVE AwardDetail.Grammys[2] \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Adicione um novo membro de mapa para um item na tabela `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET AwardDetail.BillBoard=[2020] \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Adicione um novo atributo de conjunto de strings para um item na tabela `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET BandMembers =<<'member1', 'member2'>> \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` Atualize um atributo de conjunto de strings para um item na tabela `Music`. ``` aws dynamodb execute-statement --statement "UPDATE Music \ SET BandMembers =set_add(BandMembers, <<'newmember'>>) \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` 1. Exclua um item da tabela `Music` usando a instrução PartiQL DELETE. ``` aws dynamodb execute-statement --statement "DELETE FROM Music \ WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" ``` ------ #### [ Java ] ``` import java.util.ArrayList; import java.util.List; import com.amazonaws.AmazonClientException; import com.amazonaws.AmazonServiceException; import software.amazon.dynamodb.AmazonDynamoDB; import software.amazon.dynamodb.AmazonDynamoDBClientBuilder; import software.amazon.dynamodb.model.AttributeValue; import software.amazon.dynamodb.model.ConditionalCheckFailedException; import software.amazon.dynamodb.model.ExecuteStatementRequest; import software.amazon.dynamodb.model.ExecuteStatementResult; import software.amazon.dynamodb.model.InternalServerErrorException; import software.amazon.dynamodb.model.ItemCollectionSizeLimitExceededException; import software.amazon.dynamodb.model.ProvisionedThroughputExceededException; import software.amazon.dynamodb.model.RequestLimitExceededException; import software.amazon.dynamodb.model.ResourceNotFoundException; import software.amazon.dynamodb.model.TransactionConflictException; public class DynamoDBPartiQGettingStarted { public static void main(String[] args) { // Create the DynamoDB Client with the region you want AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-1"); try { // Create ExecuteStatementRequest ExecuteStatementRequest executeStatementRequest = new ExecuteStatementRequest(); List parameters= getPartiQLParameters(); //Create an item in the Music table using the INSERT PartiQL statement processResults(executeStatementRequest(dynamoDB, "INSERT INTO Music value {'Artist':?,'SongTitle':?}", parameters)); //Retrieve an item from the Music table using the SELECT PartiQL statement. processResults(executeStatementRequest(dynamoDB, "SELECT * FROM Music where Artist=? and SongTitle=?", parameters)); //Update an item in the Music table using the UPDATE PartiQL statement. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist=? and SongTitle=?", parameters)); //Add a list value for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) where Artist=? and SongTitle=?", parameters)); //Remove a list value for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music REMOVE AwardDetail.Grammys[2] where Artist=? and SongTitle=?", parameters)); //Add a new map member for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music set AwardDetail.BillBoard=[2020] where Artist=? and SongTitle=?", parameters)); //Add a new string set attribute for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET BandMembers =<<'member1', 'member2'>> where Artist=? and SongTitle=?", parameters)); //update a string set attribute for an item in the Music table. processResults(executeStatementRequest(dynamoDB, "UPDATE Music SET BandMembers =set_add(BandMembers, <<'newmember'>>) where Artist=? and SongTitle=?", parameters)); //Retrieve an item from the Music table using the SELECT PartiQL statement. processResults(executeStatementRequest(dynamoDB, "SELECT * FROM Music where Artist=? and SongTitle=?", parameters)); //delete an item from the Music Table processResults(executeStatementRequest(dynamoDB, "DELETE FROM Music where Artist=? and SongTitle=?", parameters)); } catch (Exception e) { handleExecuteStatementErrors(e); } } private static AmazonDynamoDB createDynamoDbClient(String region) { return AmazonDynamoDBClientBuilder.standard().withRegion(region).build(); } private static List getPartiQLParameters() { List parameters = new ArrayList(); parameters.add(new AttributeValue("Acme Band")); parameters.add(new AttributeValue("PartiQL Rocks")); return parameters; } private static ExecuteStatementResult executeStatementRequest(AmazonDynamoDB client, String statement, List parameters ) { ExecuteStatementRequest request = new ExecuteStatementRequest(); request.setStatement(statement); request.setParameters(parameters); return client.executeStatement(request); } private static void processResults(ExecuteStatementResult executeStatementResult) { System.out.println("ExecuteStatement successful: "+ executeStatementResult.toString()); } // Handles errors during ExecuteStatement execution. Use recommendations in error messages below to add error handling specific to // your application use-case. private static void handleExecuteStatementErrors(Exception exception) { try { throw exception; } catch (ConditionalCheckFailedException ccfe) { System.out.println("Condition check specified in the operation failed, review and update the condition " + "check before retrying. Error: " + ccfe.getErrorMessage()); } catch (TransactionConflictException tce) { System.out.println("Operation was rejected because there is an ongoing transaction for the item, generally " + "safe to retry with exponential back-off. Error: " + tce.getErrorMessage()); } catch (ItemCollectionSizeLimitExceededException icslee) { System.out.println("An item collection is too large, you\'re using Local Secondary Index and exceeded " + "size limit of items per partition key. Consider using Global Secondary Index instead. Error: " + icslee.getErrorMessage()); } catch (Exception e) { handleCommonErrors(e); } } private static void handleCommonErrors(Exception exception) { try { throw exception; } catch (InternalServerErrorException isee) { System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage()); } catch (RequestLimitExceededException rlee) { System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " + "retrying. Error: " + rlee.getErrorMessage()); } catch (ProvisionedThroughputExceededException ptee) { System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " + "Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " + ptee.getErrorMessage()); } catch (ResourceNotFoundException rnfe) { System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage()); } catch (AmazonServiceException ase) { System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " + "service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " + "configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage()); } catch (AmazonClientException ace) { System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " + "service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+ "Error: " + ace.getMessage()); } catch (Exception e) { System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage()); } } } ``` ------ ## Usar instruções parametrizadas Em vez de incorporar valores diretamente em uma string de instrução PartiQL, é possível usar espaços reservados com ponto de interrogação (`?`) e fornecer os valores separadamente no campo `Parameters`. Cada `?` é substituído pelo valor do parâmetro correspondente, na ordem em que é fornecido. Usar instruções parametrizadas é uma prática recomendada porque separa a estrutura da instrução dos valores dos dados, facilitando a leitura e a reutilização das instruções. Isso também evita a necessidade de formatar e escapar manualmente dos valores dos atributos na string da instrução. É possível usar instruções parametrizadas nas operações `ExecuteStatement`, `BatchExecuteStatement` e `ExecuteTransaction`. Os exemplos a seguir recuperam um item da tabela `Music` usando valores parametrizados para a chave de partição e a chave de classificação. ------ #### [ AWS CLI parameterized ] ``` aws dynamodb execute-statement \ --statement "SELECT * FROM \"Music\" WHERE Artist=? AND SongTitle=?" \ --parameters '[{"S": "Acme Band"}, {"S": "PartiQL Rocks"}]' ``` ------ #### [ Java parameterized ] ``` List parameters = new ArrayList<>(); parameters.add(new AttributeValue("Acme Band")); parameters.add(new AttributeValue("PartiQL Rocks")); ExecuteStatementRequest request = new ExecuteStatementRequest() .withStatement("SELECT * FROM Music WHERE Artist=? AND SongTitle=?") .withParameters(parameters); ExecuteStatementResult result = dynamoDB.executeStatement(request); ``` ------ #### [ Python parameterized ] ``` response = dynamodb_client.execute_statement( Statement="SELECT * FROM Music WHERE Artist=? AND SongTitle=?", Parameters=[ {'S': 'Acme Band'}, {'S': 'PartiQL Rocks'} ] ) ``` ------ **nota** O exemplo Java na seção de introdução anterior sempre usa instruções parametrizadas. O método `getPartiQLParameters()` cria a lista de parâmetros e cada instrução usa `?` como espaço reservado em vez de valores em linha. # Tipos de dados de PartiQL para DynamoDB A tabela a seguir lista os tipos de dados que você pode usar com a linguagem PartiQL para DynamoDB. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/amazondynamodb/latest/developerguide/ql-reference.data-types.html) ## Exemplos A instrução a seguir demonstra como inserir os seguintes tipos de dados: `String`, `Number`, `Map`, `List`, `Number Set` e `String Set`. ``` INSERT INTO TypesTable value {'primarykey':'1', 'NumberType':1, 'MapType' : {'entryname1': 'value', 'entryname2': 4}, 'ListType': [1,'stringval'], 'NumberSetType':<<1,34,32,4.5>>, 'StringSetType':<<'stringval','stringval2'>> } ``` A instrução a seguir demonstra como inserir novos elementos nos tipos `Map`, `List`, `Number Set` e `String Set` e alterar o valor de um tipo `Number`. ``` UPDATE TypesTable SET NumberType=NumberType + 100 SET MapType.NewMapEntry=[2020, 'stringvalue', 2.4] SET ListType = LIST_APPEND(ListType, [4, <<'string1', 'string2'>>]) SET NumberSetType= SET_ADD(NumberSetType, <<345, 48.4>>) SET StringSetType = SET_ADD(StringSetType, <<'stringsetvalue1', 'stringsetvalue2'>>) WHERE primarykey='1' ``` A instrução a seguir demonstra como remover elementos dos tipos `Map`, `List`, `Number Set` e `String Set` e alterar o valor de um tipo `Number`. ``` UPDATE TypesTable SET NumberType=NumberType - 1 REMOVE ListType[1] REMOVE MapType.NewMapEntry SET NumberSetType = SET_DELETE( NumberSetType, <<345>>) SET StringSetType = SET_DELETE( StringSetType, <<'stringsetvalue1'>>) WHERE primarykey='1' ``` Para obter mais informações, consulte [Tipos de dados do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes). # Instruções em PartiQL para DynamoDB O Amazon DynamoDB oferece suporte às instruções PartiQL a seguir. **nota** O DynamoDB não oferece suporte a todas as instruções PartiQL. Esta referência apresenta a sintaxe básica e fornece exemplos de uso de instruções PartiQL que você deve executar manualmente usando o AWS CLI ou APIs. *Linguagem de manipulação de dados* (DML) é o conjunto de instruções PartiQL que você usa para gerenciar dados em tabelas do DynamoDB. Você usa instruções DML para adicionar, modificar ou excluir dados em uma tabela. As seguintes instruções de linguagem DML e consultas são aceitas: + [Instruções Select em PartiQL para DynamoDB](ql-reference.select.md) + [Instruções Update em PartiQL para DynamoDB](ql-reference.update.md) + [Instruções Insert em PartiQL para DynamoDB](ql-reference.insert.md) + [Instruções Delete em PartiQL para DynamoDB](ql-reference.delete.md) [Executar transações com PartiQL para DynamoDB](ql-reference.multiplestatements.transactions.md) e [Executar operações em lote com PartiQL para DynamoDB](ql-reference.multiplestatements.batching.md) também são compatíveis com a linguagem PartiQL para DynamoDB. # Instruções Select em PartiQL para DynamoDB Use a instrução `SELECT` para recuperar dados de uma tabela no Amazon DynamoDB. O uso da declaração `SELECT` poderá gerar uma verificação completa da tabela se uma condição de igualdade ou IN com uma chave de partição não for fornecida na cláusula WHERE. Uma operação de verificação examina todos os itens com os valores solicitados e pode usar o throughput provisionado para uma tabela ou índice grande em uma única operação. Se desejar evitar a verificação completa da tabela em PartiQL, você pode: + Criar suas instruções `SELECT` para não resultar em verificações completas de tabela, certificando-se de que a [condição da cláusula WHERE](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.select.html#ql-reference.select.parameters) seja configurada de acordo. + Desativar verificações completas de tabela usando a política do IAM especificada em [Exemplo: permitir instruções Select e negar instruções de verificação de tabela completa em PartiQL para DynamoDB](ql-iam.md#access-policy-ql-iam-example6), conforme descrito no Guia do desenvolvedor do DynamoDB. Para obter mais informações, consulte [Melhores práticas para consulta e verificação de dados](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-query-scan.html) no Guia do desenvolvedor do DynamoDB. **Topics** + [Sintaxe](#ql-reference.select.syntax) + [Parâmetros](#ql-reference.select.parameters) + [Exemplos](#ql-reference.select.examples) ## Sintaxe ``` SELECT expression [, ...] FROM table[.index] [ WHERE condition ] [ [ORDER BY key [DESC|ASC] , ...] ``` ## Parâmetros ***expressão*** (Obrigatório) Uma projeção formada a partir do curinga `*` ou uma lista de projeção de um ou mais nomes de atributos ou caminhos de documentos do conjunto de resultados. Uma expressão pode consistir em chamadas para [Usar funções PartiQL com o DynamoDB](ql-functions.md) ou campos que são modificados por [Operadores aritméticos, comparativos e lógicos de PartiQL para DynamoDB](ql-operators.md). ***table*** (Obrigatório) O nome da tabela a ser consultada. ***Índice do*** (Opcional) O nome do índice para consultar. É necessário adicionar aspas duplas ao nome da tabela e ao nome do índice ao consultar um índice. ``` SELECT * FROM "TableName"."IndexName" ``` ***Condição*** (Opcional) Os critérios de seleção para a consulta. Para garantir que uma instrução `SELECT` não resulte em uma verificação completa da tabela, a condição da cláusula `WHERE` deverá especificar uma chave de partição. Use o operador de igualdade ou IN. Por exemplo, se você tiver uma tabela `Orders` com uma partição `OrderID` e outros atributos não chave, incluindo um `Address`, as seguintes instruções não resultarão em uma varredura completa da tabela: ``` SELECT * FROM "Orders" WHERE OrderID = 100 SELECT * FROM "Orders" WHERE OrderID = 100 and Address='some address' SELECT * FROM "Orders" WHERE OrderID = 100 or OrderID = 200 SELECT * FROM "Orders" WHERE OrderID IN [100, 300, 234] ``` As instruções `SELECT` a seguir, no entanto, resultarão em uma varredura completa da tabela: ``` SELECT * FROM "Orders" WHERE OrderID > 1 SELECT * FROM "Orders" WHERE Address='some address' SELECT * FROM "Orders" WHERE OrderID = 100 OR Address='some address' ``` ***key*** (Opcional) Uma chave de hash ou uma chave de classificação a ser usada para ordenar os resultados retornados. A ordem padrão é crescente (`ASC`). Especifique `DESC` se desejar que os resultados sejam retornados em ordem decrescente. **nota** Se você omitir a cláusula `WHERE`, todos os itens da tabela serão recuperados. ## Exemplos A consulta a seguir retorna um item, se houver, da tabela `Orders` mediante a especificação da chave de partição `OrderID` e o uso do operador de igualdade. ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID = 1 ``` A consulta a seguir retorna todos os itens na tabela `Orders` que têm uma chave de partição específica, `OrderID`, valores usando o operador OR. ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID = 1 OR OrderID = 2 ``` A consulta a seguir retorna todos os itens na tabela `Orders` que têm uma chave de partição específica, `OrderID`, valores usando o operador IN. Os resultados retornados estão em ordem decrescente, com base no valor de atributo de chave `OrderID`. ``` SELECT OrderID, Total FROM "Orders" WHERE OrderID IN [1, 2, 3] ORDER BY OrderID DESC ``` A consulta a seguir mostra uma varredura de tabela completa que retorna todos os itens da tabela `Orders`que têm uma `Total` maior que 500, onde `Total` é um atributo não chave. ``` SELECT OrderID, Total FROM "Orders" WHERE Total > 500 ``` A consulta a seguir mostra uma varredura de tabela completa que retorna todos os itens da tabela `Orders` em um intervalo de ordem `Total` específico, usando o operador IN e um atributo não chave `Total`. ``` SELECT OrderID, Total FROM "Orders" WHERE Total IN [500, 600] ``` A consulta a seguir mostra uma varredura de tabela completa que retorna todos os itens da tabela `Orders` em um intervalo de ordem `Total` específico, usando o operador BETWEEN e um atributo não chave `Total`. ``` SELECT OrderID, Total FROM "Orders" WHERE Total BETWEEN 500 AND 600 ``` A consulta a seguir retorna a primeira data em que um dispositivo firestick foi usado para observar mediante a especificação da chave de partição `CustomerID` e da chave de classificação `MovieID` na condição da cláusula WHERE e usando caminhos de documento na cláusula SELECT. ``` SELECT Devices.FireStick.DateWatched[0] FROM WatchList WHERE CustomerID= 'C1' AND MovieID= 'M1' ``` A consulta a seguir mostra uma verificação de tabela completa que retorna a lista de itens em que um dispositivo firestick foi usado pela primeira vez após 24/12/19 usando caminhos de documento na condição da cláusula WHERE. ``` SELECT Devices FROM WatchList WHERE Devices.FireStick.DateWatched[0] >= '12/24/19' ``` # Instruções Update em PartiQL para DynamoDB Use a instrução `UPDATE` para modificar o valor de um ou mais atributos em um item em uma tabela do Amazon DynamoDB. **nota** Você só pode atualizar um item de cada vez; não é possível emitir uma única instrução PartiQL do DynamoDB para atualizar vários itens. Para obter informações sobre como atualizar vários itens, consulte [Executar transações com PartiQL para DynamoDB](ql-reference.multiplestatements.transactions.md) ou [Executar operações em lote com PartiQL para DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Sintaxe](#ql-reference.update.syntax) + [Parâmetros](#ql-reference.update.parameters) + [Valor de retorno](#ql-reference.update.return) + [Exemplos](#ql-reference.update.examples) ## Sintaxe ``` UPDATE table [SET | REMOVE] path [= data] […] WHERE condition [RETURNING returnvalues] ::= [ALL OLD | MODIFIED OLD | ALL NEW | MODIFIED NEW] * ``` ## Parâmetros ***table*** (Obrigatório) A tabela que contém os dados a serem modificados. ***caminho*** (Obrigatório) Um nome de atributo ou caminho de documento a ser criado ou modificado. ***data*** (Obrigatório) Um valor de atributo ou o resultado de uma operação. As operações com suporte a serem usadas com SET: + LIST\$1APPEND: adiciona um valor a um tipo de lista. + SET\$1ADD: adiciona um valor a um conjunto de números ou strings. + SET\$1DELETE: remove um valor de um conjunto de números ou strings. ***Condição*** (Obrigatório) Os critérios de seleção para o item a ser modificado. Essa condição deve ser resolvida em um único valor de chave primária. ***returnvalues*** (Opcional) Use `returnvalues` se desejar obter os atributos de item como eles aparecem antes ou depois de serem atualizados. Os valores válidos são: + `ALL OLD *`: retorna todos os atributos do item como eles apareciam antes da operação de atualização. + `MODIFIED OLD *`: retorna somente os atributos atualizados como eles apareciam antes da operação de atualização. + `ALL NEW *`: retorna todos os atributos do item como eles aparecem após a operação de atualização. + `MODIFIED NEW *` : retorna somente os atributos atualizados como eles aparecem após a operação `UpdateItem`. ## Valor de retorno Esta instrução não retornará um valor a menos que o parâmetro `returnvalues` seja especificado. **nota** Se a cláusula WHERE da instrução UPDATE não for avaliada como true para nenhum item na tabela do DynamoDB, `ConditionalCheckFailedException` será retornado. ## Exemplos Atualiza um valor de atributo em um item existente. Se o atributo não existir, ele será criado. A consulta a seguir atualiza um item na tabela `"Music"` adicionando um atributo do tipo Number (`AwardsWon`) e um atributo do tipo Map (`AwardDetail`). ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` Você pode adicionar `RETURNING ALL OLD *` para retornar os atributos como eles apareceram antes da operação `Update`. ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' RETURNING ALL OLD * ``` Isso retorna o seguinte: ``` { "Items": [ { "Artist": { "S": "Acme Band" }, "SongTitle": { "S": "PartiQL Rocks" } } ] } ``` Você pode adicionar `RETURNING ALL NEW *` para retornar os atributos como eles apareceram depois da operação `Update`. ``` UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' RETURNING ALL NEW * ``` Isso retorna o seguinte: ``` { "Items": [ { "AwardDetail": { "M": { "Grammys": { "L": [ { "N": "2020" }, { "N": "2018" } ] } } }, "AwardsWon": { "N": "1" } } ] } ``` A consulta a seguir atualiza um item na tabela `"Music"` anexando-o a uma lista `AwardDetail.Grammys`. ``` UPDATE "Music" SET AwardDetail.Grammys =list_append(AwardDetail.Grammys,[2016]) WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` A consulta a seguir atualiza um item na tabela `"Music"` removendo-o de uma lista `AwardDetail.Grammys`. ``` UPDATE "Music" REMOVE AwardDetail.Grammys[2] WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` A consulta a seguir atualiza um item na tabela `"Music"` adicionando `BillBoard` ao mapa `AwardDetail`. ``` UPDATE "Music" SET AwardDetail.BillBoard=[2020] WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` A consulta a seguir atualiza um item na tabela `"Music"` adicionando o atributo de conjunto de strings `BandMembers`. ``` UPDATE "Music" SET BandMembers =<<'member1', 'member2'>> WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` A consulta a seguir atualiza um item na tabela `"Music"` adicionando `newbandmember` ao conjunto de strings `BandMembers`. ``` UPDATE "Music" SET BandMembers =set_add(BandMembers, <<'newbandmember'>>) WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks' ``` # Instruções Delete em PartiQL para DynamoDB Use a instrução `DELETE` para excluir um item existente da tabela do Amazon DynamoDB. **nota** É possível excluir apenas um item de cada vez. Você não pode emitir uma única instrução PartiQL do DynamoDB para excluir vários itens. Para obter informações sobre como excluir vários itens, consulte [Executar transações com PartiQL para DynamoDB](ql-reference.multiplestatements.transactions.md) ou [Executar operações em lote com PartiQL para DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Sintaxe](#ql-reference.delete.syntax) + [Parâmetros](#ql-reference.delete.parameters) + [Valor de retorno](#ql-reference.delete.return) + [Exemplos](#ql-reference.delete.examples) ## Sintaxe ``` DELETE FROM table WHERE condition [RETURNING returnvalues] ::= ALL OLD * ``` ## Parâmetros ***table*** (Obrigatório) A tabela do DynamoDB que contém o item a ser excluído. ***Condição*** (Obrigatório) Os critérios de seleção para o item a ser excluído; essa condição deve ser resolvida para um único valor de chave primária. ***returnvalues*** (Opcional) Use `returnvalues` se desejar obter os atributos do item como eles apareciam antes de ser excluídos. Os valores válidos são: + `ALL OLD *`: o conteúdo do item antigo é retornado. ## Valor de retorno Esta instrução não retornará um valor a menos que o parâmetro `returnvalues` seja especificado. **nota** Se a tabela do DynamoDB não tiver nenhum item com a mesma chave primária que a do item para o qual a instrução DELETE foi emitida, SUCESS será retornado com 0 itens excluídos. Se a tabela tiver um item com a mesma chave primária, mas a condição na cláusula WHERE da instrução DELETE for avaliada como false, `ConditionalCheckFailedException` será retornado. ## Exemplos A consulta a seguir exclui um item da tabela `"Music"`. ``` DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks' ``` Você pode adicionar o parâmetro `RETURNING ALL OLD *` para retornar os dados que foram excluídos. ``` DELETE FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks' RETURNING ALL OLD * ``` A instrução `Delete` agora retorna o seguinte: ``` { "Items": [ { "Artist": { "S": "Acme Band" }, "SongTitle": { "S": "PartiQL Rocks" } } ] } ``` # Instruções Insert em PartiQL para DynamoDB Use a instrução `INSERT` para adicionar um item a uma tabela no Amazon DynamoDB. **nota** Você só pode inserir um item de cada vez; não é possível emitir uma única instrução PartiQL do DynamoDB para inserir vários itens. Para obter informações sobre como inserir vários itens, consulte [Executar transações com PartiQL para DynamoDB](ql-reference.multiplestatements.transactions.md) ou [Executar operações em lote com PartiQL para DynamoDB](ql-reference.multiplestatements.batching.md). **Topics** + [Sintaxe](#ql-reference.insert.syntax) + [Parâmetros](#ql-reference.insert.parameters) + [Valor de retorno](#ql-reference.insert.return) + [Exemplos](#ql-reference.insert.examples) ## Sintaxe Insira um único item. ``` INSERT INTO table VALUE item ``` ## Parâmetros ***table*** (Obrigatório) A tabela na qual você deseja inserir os dados. A tabela já deve existir. ***item*** (Obrigatório) Um item válido do DynamoDB representado como uma [tupla PartiQL](https://partiql.org/docs.html). Você só deve especificar *um* item, e cada nome de atributo no item diferencia maiúsculas e minúsculas e pode ser indicado com aspas *simples* (`'...'`) na linguagem PartiQL. Os valores de string também são denotados com aspas *simples* (`'...'`) em PartiQL. ## Valor de retorno Esta instrução não retorna nenhum valor. **nota** Se a tabela do DynamoDB já tiver um item com a mesma chave primária da chave primária do item que está sendo inserido, `DuplicateItemException` será retornado. ## Exemplos ``` INSERT INTO "Music" value {'Artist' : 'Acme Band','SongTitle' : 'PartiQL Rocks'} ``` # Usar funções PartiQL com o DynamoDB A linguagem PartiQL no Amazon DynamoDB é compatível com as seguintes variantes integradas de funções padrão SQL. **nota** As funções SQL que não fazem parte desta lista não são aceitas no DynamoDB. ## Funções agregadas + [Usar a função SIZE com PartiQL para Amazon DynamoDB](ql-functions.size.md) ## Funções condicionais + [Usar a função EXISTS com PartiQL para DynamoDB](ql-functions.exists.md) + [Usar a função ATTRIBUTE\$1TYPE com PartiQL para DynamoDB](ql-functions.attribute_type.md) + [Usar a função BEGINS\$1WITH com PartiQL para DynamoDB](ql-functions.beginswith.md) + [Usar a função CONTAINS com PartiQL para DynamoDB](ql-functions.contains.md) + [Usar a função MISSING com PartiQL para DynamoDB](ql-functions.missing.md) # Usar a função EXISTS com PartiQL para DynamoDB Você pode usar EXISTS para executar a mesma função que `ConditionCheck` na API [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems). A função EXISTS só pode ser usada em transações. Sendo fornecido um valor, a função retornará `TRUE` se o valor for uma coleção não vazia. Caso contrário, gera `FALSE`. **nota** Essa função só pode ser usada em operações transacionais. ## Sintaxe ``` EXISTS ( statement ) ``` ## Argumentos *instrução * (Obrigatório) A instrução SELECT que a função avalia. A instrução SELECT deve especificar uma chave primária completa e alguma outra condição. ## Tipo de retorno `bool` ## Exemplos ``` EXISTS( SELECT * FROM "Music" WHERE "Artist" = 'Acme Band' AND "SongTitle" = 'PartiQL Rocks') ``` # Usar a função BEGINS\$1WITH com PartiQL para DynamoDB Retorna `TRUE` quando o atributo especificado começa com uma substring específica. ## Sintaxe ``` begins_with(path, value ) ``` ## Argumentos *path* (Obrigatório) O nome do atributo ou o caminho do documento a ser usado. *value* (Obrigatório) A string a ser pesquisada. ## Tipo de retorno `bool` ## Exemplos ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND begins_with("Address", '7834 24th') ``` # Usar a função MISSING com PartiQL para DynamoDB Retorna `TRUE` quando o item não contém o atributo especificado. Somente operadores de igualdade e desigualdade podem ser usados com esta função. ## Sintaxe ``` attributename IS | IS NOT MISSING ``` ## Argumentos *attributename* (Obrigatório) O nome do atributo a ser procurado. ## Tipo de retorno `bool` ## Exemplos ``` SELECT * FROM Music WHERE "Awards" is MISSING ``` # Usar a função ATTRIBUTE\$1TYPE com PartiQL para DynamoDB Retorna `TRUE` quando o atributo no caminho especificado é de um tipo de dados específico. ## Sintaxe ``` attribute_type( attributename, type ) ``` ## Argumentos *attributename* (Obrigatório) O nome do atributo a ser usado. *tipo* (Obrigatório) O tipo de atributo a ser verificado. Para obter uma lista de valores válidos, consulte [attribute\$1type](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) do DynamoDB. ## Tipo de retorno `bool` ## Exemplos ``` SELECT * FROM "Music" WHERE attribute_type("Artist", 'S') ``` # Usar a função CONTAINS com PartiQL para DynamoDB Retorna `TRUE` quando o atributo especificado pelo caminho é um dos seguintes: + Uma String que contém uma substring específica. + Um Set que contém um elemento específico dentro do conjunto. Para obter mais informações, consulte a função [contains](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) do DynamoDB. ## Sintaxe ``` contains( path, substring ) ``` ## Argumentos *path* (Obrigatório) O nome do atributo ou o caminho do documento a ser usado. *substring* (Obrigatório) A substring do atributo ou o membro do conjunto a ser verificado. Para obter mais informações, consulte a função [contains](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) do DynamoDB. ## Tipo de retorno `bool` ## Exemplos ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND contains("Address", 'Kirkland') ``` # Usar a função SIZE com PartiQL para Amazon DynamoDB Retorna um número que representa o tamanho de um atributo em bytes. Veja a seguir os tipos de dados válidos para uso com SIZE. Para obter mais informações, consulte a função [size](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) do DynamoDB. ## Sintaxe ``` size( path) ``` ## Argumentos *path* (Obrigatório) O nome do atributo ou o caminho do documento. Para obter os tipos compatíveis, consulte a função [size](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.OperatorsAndFunctions.html#Expressions.OperatorsAndFunctions.Functions) do DynamoDB. ## Tipo de retorno `int` ## Exemplos ``` SELECT * FROM "Orders" WHERE "OrderID"=1 AND size("Image") >300 ``` # Operadores aritméticos, comparativos e lógicos de PartiQL para DynamoDB A linguagem PartiQL no Amazon DynamoDB oferece suporte às [instruções SQL padrão](https://www.w3schools.com/sql/sql_operators.asp) a seguir. **nota** Os operadores SQL que não fazem parte desta lista não são aceitas no DynamoDB. ## Operadores aritméticos **** | Operador | Descrição | | --- | --- | | \$1 | Adicionar | | - | Subtrair | ## Operadores de comparação **** | Operador | Descrição | | --- | --- | | = | Igual a | | <> | Não é igual a | | \$1= | Não é igual a | | > | Maior que | | < | Menor que | | >= | Maior ou igual a | | <= | Menor ou igual a | ## Operadores lógicos **** | Operador | Descrição | | --- | --- | | AND | TRUE se todas as condições separadas por AND forem TRUE | | BETWEEN | `TRUE` se o operando estiver dentro do intervalo de comparações. Esse operador inclui os limites inferior e superior dos operandos nos quais você o aplica. | | IN | `TRUE` se o operando for igual a um dos valores de uma lista de expressões (no máximo cinquenta valores de atributo hash ou no máximo cem valores de atributo que não sejam chaves). Os resultados são exibidos em páginas com até dez itens. Se a lista `IN` contiver mais valores, será necessário usar o `NextToken` exibido na resposta para recuperar as páginas subsequentes. | | IS | TRUE se o operando for um determinado tipo de dados PartiQL, incluindo NULL ou MISSING | | NOT | Reverte o valor de uma determinada expressão booleana | | OR | TRUE se qualquer uma das condições separadas por OR for TRUE | Para obter mais informações sobre como usar operadores lógicos, consulte [Fazer comparações](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.Comparators) e [Avaliações lógicas](Expressions.OperatorsAndFunctions.md#Expressions.OperatorsAndFunctions.LogicalEvaluations). # Executar transações com PartiQL para DynamoDB Esta seção descreve como usar transações com a linguagem PartiQL para DynamoDB. As transações PartiQL são limitadas a 100 instruções (ações) no total. Para obter mais informações sobre transações do DynamoDB, consulte [Gerenciar fluxos de trabalho complexos com transações do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transactions.html). **nota** A transação inteira deve ser composta por instruções de leitura ou instruções de gravação. Não é permitido misturar os dois em uma transação. A função EXISTS é uma exceção. Você pode usá-la para verificar a condição de atributos específicos do item de uma maneira semelhante a `ConditionCheck` na operação [TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/transaction-apis.html#transaction-apis-txwriteitems) da API. **Topics** + [Sintaxe](#ql-reference.multiplestatements.transactions.syntax) + [Parâmetros](#ql-reference.multiplestatements.transactions.parameters) + [Retornar valores](#ql-reference.multiplestatements.transactions.return) + [Exemplos](#ql-reference.multiplestatements.transactions.examples) ## Sintaxe ``` [ { "Statement":" statement ", "Parameters":[ { " parametertype " : " parametervalue " }, ...] } , ... ] ``` ## Parâmetros ***instrução*** (Obrigatório) Uma instrução valida na linguagem PartiQL para DynamoDB. A transação inteira deve ser composta por instruções de leitura ou instruções de gravação. Não é permitido misturar os dois em uma transação. ***parametertype*** (Opcional) Um tipo do DynamoDB, se parâmetros foram usados ao especificar a instrução PartiQL. ***parametervalue*** (Opcional) Um valor de parâmetro, se parâmetros foram usados ao especificar a instrução PartiQL. ## Retornar valores Esta instrução não retorna nenhum valor para operações de gravação (INSERT, UPDATE ou DELETE). No entanto, ela retorna valores diferentes para operações de leitura (SELECT) com base nas condições especificadas na cláusula WHERE. **nota** Se qualquer uma das operações singleton INSERT, UPDATE ou DELETE retornar um erro, as transações serão canceladas com a exceção `TransactionCanceledException` e o código de motivo de cancelamento incluirá os erros das operações singleton individuais. ## Exemplos O exemplo a seguir executa várias instruções como uma transação. ------ #### [ AWS CLI ] 1. Salve o seguinte código JSON em um arquivo chamado partiql.json. ``` [ { "Statement": "EXISTS(SELECT * FROM \"Music\" where Artist='No One You Know' and SongTitle='Call Me Today' and Awards is MISSING)" }, { "Statement": "INSERT INTO Music value {'Artist':?,'SongTitle':'?'}", "Parameters": [{\"S\": \"Acme Band\"}, {\"S\": \"Best Song\"}] }, { "Statement": "UPDATE \"Music\" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL Rocks'" } ] ``` 1. Execute o comando a seguir em um prompt de comando. ``` aws dynamodb execute-transaction --transact-statements file://partiql.json ``` ------ #### [ Java ] ``` public class DynamoDBPartiqlTransaction { public static void main(String[] args) { // Create the DynamoDB Client with the region you want AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-2"); try { // Create ExecuteTransactionRequest ExecuteTransactionRequest executeTransactionRequest = createExecuteTransactionRequest(); ExecuteTransactionResult executeTransactionResult = dynamoDB.executeTransaction(executeTransactionRequest); System.out.println("ExecuteTransaction successful."); // Handle executeTransactionResult } catch (Exception e) { handleExecuteTransactionErrors(e); } } private static AmazonDynamoDB createDynamoDbClient(String region) { return AmazonDynamoDBClientBuilder.standard().withRegion(region).build(); } private static ExecuteTransactionRequest createExecuteTransactionRequest() { ExecuteTransactionRequest request = new ExecuteTransactionRequest(); // Create statements List statements = getPartiQLTransactionStatements(); request.setTransactStatements(statements); return request; } private static List getPartiQLTransactionStatements() { List statements = new ArrayList(); statements.add(new ParameterizedStatement() .withStatement("EXISTS(SELECT * FROM "Music" where Artist='No One You Know' and SongTitle='Call Me Today' and Awards is MISSING)")); statements.add(new ParameterizedStatement() .withStatement("INSERT INTO "Music" value {'Artist':'?','SongTitle':'?'}") .withParameters(new AttributeValue("Acme Band"),new AttributeValue("Best Song"))); statements.add(new ParameterizedStatement() .withStatement("UPDATE "Music" SET AwardsWon=1 SET AwardDetail={'Grammys':[2020, 2018]} where Artist='Acme Band' and SongTitle='PartiQL Rocks'")); return statements; } // Handles errors during ExecuteTransaction execution. Use recommendations in error messages below to add error handling specific to // your application use-case. private static void handleExecuteTransactionErrors(Exception exception) { try { throw exception; } catch (TransactionCanceledException tce) { System.out.println("Transaction Cancelled, implies a client issue, fix before retrying. Error: " + tce.getErrorMessage()); } catch (TransactionInProgressException tipe) { System.out.println("The transaction with the given request token is already in progress, consider changing " + "retry strategy for this type of error. Error: " + tipe.getErrorMessage()); } catch (IdempotentParameterMismatchException ipme) { System.out.println("Request rejected because it was retried with a different payload but with a request token that was already used, " + "change request token for this payload to be accepted. Error: " + ipme.getErrorMessage()); } catch (Exception e) { handleCommonErrors(e); } } private static void handleCommonErrors(Exception exception) { try { throw exception; } catch (InternalServerErrorException isee) { System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage()); } catch (RequestLimitExceededException rlee) { System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " + "retrying. Error: " + rlee.getErrorMessage()); } catch (ProvisionedThroughputExceededException ptee) { System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " + "Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " + ptee.getErrorMessage()); } catch (ResourceNotFoundException rnfe) { System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage()); } catch (AmazonServiceException ase) { System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " + "service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " + "configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage()); } catch (AmazonClientException ace) { System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " + "service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+ "Error: " + ace.getMessage()); } catch (Exception e) { System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage()); } } } ``` ------ O exemplo a seguir mostra os diferentes valores de retorno quando o DynamoDB lê itens com diferentes condições especificadas na cláusula WHERE. ------ #### [ AWS CLI ] 1. Salve o seguinte código JSON em um arquivo chamado partiql.json. ``` [ // Item exists and projected attribute exists { "Statement": "SELECT * FROM "Music" WHERE Artist='No One You Know' and SongTitle='Call Me Today'" }, // Item exists but projected attributes do not exist { "Statement": "SELECT non_existent_projected_attribute FROM "Music" WHERE Artist='No One You Know' and SongTitle='Call Me Today'" }, // Item does not exist { "Statement": "SELECT * FROM "Music" WHERE Artist='No One I Know' and SongTitle='Call You Today'" } ] ``` 1. comando a seguir em um prompt de comando. ``` aws dynamodb execute-transaction --transact-statements file://partiql.json ``` 1. A resposta a seguir será retornada: ``` { "Responses": [ // Item exists and projected attribute exists { "Item": { "Artist":{ "S": "No One You Know" }, "SongTitle":{ "S": "Call Me Today" } } }, // Item exists but projected attributes do not exist { "Item": {} }, // Item does not exist {} ] } ``` ------ # Executar operações em lote com PartiQL para DynamoDB Esta seção descreve como usar instruções em lote com a linguagem PartiQL para DynamoDB. **nota** O lote inteiro deve consistir em instruções de leitura ou instruções de gravação; não é possível misturar ambas em um lote. `BatchExecuteStatement` e `BatchWriteItem` podem executar mais de 25 instruções por lote. O `BatchExecuteStatement` faz uso do `BatchGetItem` que utiliza uma lista de chaves primárias em declarações separadas. **Topics** + [Sintaxe](#ql-reference.multiplestatements.batching.syntax) + [Parâmetros](#ql-reference.multiplestatements.batching.parameters) + [Exemplos](#ql-reference.multiplestatements.batching.examples) ## Sintaxe ``` [ { "Statement": "SELECT pk FROM ProblemSet WHERE pk = 'p#9StkWHYTxm7x2AqSXcrfu7' AND sk = 'info'" }, { "Statement": "SELECT pk FROM ProblemSet WHERE pk = 'p#isC2ChceGbxHgESc4szoTE' AND sk = 'info'" } ] ``` ``` [ { "Statement":" statement ", "Parameters":[ { " parametertype " : " parametervalue " }, ...] } , ... ] ``` ## Parâmetros ***instrução*** (Obrigatório) Uma instrução valida na linguagem PartiQL para DynamoDB. + O lote inteiro deve consistir em instruções de leitura ou instruções de gravação; não é possível misturar ambas em um lote. + `BatchExecuteStatement` e `BatchWriteItem` podem executar mais de 25 instruções por lote. ***parametertype*** (Opcional) Um tipo do DynamoDB, se parâmetros foram usados ao especificar a instrução PartiQL. ***parametervalue*** (Opcional) Um valor de parâmetro, se parâmetros foram usados ao especificar a instrução PartiQL. ## Exemplos ------ #### [ AWS CLI ] 1. Salve o seguinte json em um arquivo chamado partiql.json ``` [ { "Statement": "INSERT INTO Music VALUE {'Artist':?,'SongTitle':?}", "Parameters": [{"S": "Acme Band"}, {"S": "Best Song"}] }, { "Statement": "UPDATE Music SET AwardsWon=1, AwardDetail={'Grammys':[2020, 2018]} WHERE Artist='Acme Band' AND SongTitle='PartiQL Rocks'" } ] ``` 1. Execute o comando a seguir em um prompt de comando. ``` aws dynamodb batch-execute-statement --statements file://partiql.json ``` ------ #### [ Java ] ``` public class DynamoDBPartiqlBatch { public static void main(String[] args) { // Create the DynamoDB Client with the region you want AmazonDynamoDB dynamoDB = createDynamoDbClient("us-west-2"); try { // Create BatchExecuteStatementRequest BatchExecuteStatementRequest batchExecuteStatementRequest = createBatchExecuteStatementRequest(); BatchExecuteStatementResult batchExecuteStatementResult = dynamoDB.batchExecuteStatement(batchExecuteStatementRequest); System.out.println("BatchExecuteStatement successful."); // Handle batchExecuteStatementResult } catch (Exception e) { handleBatchExecuteStatementErrors(e); } } private static AmazonDynamoDB createDynamoDbClient(String region) { return AmazonDynamoDBClientBuilder.standard().withRegion(region).build(); } private static BatchExecuteStatementRequest createBatchExecuteStatementRequest() { BatchExecuteStatementRequest request = new BatchExecuteStatementRequest(); // Create statements List statements = getPartiQLBatchStatements(); request.setStatements(statements); return request; } private static List getPartiQLBatchStatements() { List statements = new ArrayList(); statements.add(new BatchStatementRequest() .withStatement("INSERT INTO Music value {'Artist':'Acme Band','SongTitle':'PartiQL Rocks'}")); statements.add(new BatchStatementRequest() .withStatement("UPDATE Music set AwardDetail.BillBoard=[2020] where Artist='Acme Band' and SongTitle='PartiQL Rocks'")); return statements; } // Handles errors during BatchExecuteStatement execution. Use recommendations in error messages below to add error handling specific to // your application use-case. private static void handleBatchExecuteStatementErrors(Exception exception) { try { throw exception; } catch (Exception e) { // There are no API specific errors to handle for BatchExecuteStatement, common DynamoDB API errors are handled below handleCommonErrors(e); } } private static void handleCommonErrors(Exception exception) { try { throw exception; } catch (InternalServerErrorException isee) { System.out.println("Internal Server Error, generally safe to retry with exponential back-off. Error: " + isee.getErrorMessage()); } catch (RequestLimitExceededException rlee) { System.out.println("Throughput exceeds the current throughput limit for your account, increase account level throughput before " + "retrying. Error: " + rlee.getErrorMessage()); } catch (ProvisionedThroughputExceededException ptee) { System.out.println("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off. " + "Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: " + ptee.getErrorMessage()); } catch (ResourceNotFoundException rnfe) { System.out.println("One of the tables was not found, verify table exists before retrying. Error: " + rnfe.getErrorMessage()); } catch (AmazonServiceException ase) { System.out.println("An AmazonServiceException occurred, indicates that the request was correctly transmitted to the DynamoDB " + "service, but for some reason, the service was not able to process it, and returned an error response instead. Investigate and " + "configure retry strategy. Error type: " + ase.getErrorType() + ". Error message: " + ase.getErrorMessage()); } catch (AmazonClientException ace) { System.out.println("An AmazonClientException occurred, indicates that the client was unable to get a response from DynamoDB " + "service, or the client was unable to parse the response from the service. Investigate and configure retry strategy. "+ "Error: " + ace.getMessage()); } catch (Exception e) { System.out.println("An exception occurred, investigate and configure retry strategy. Error: " + e.getMessage()); } } } ``` ------ # Políticas de segurança do IAM com PartiQL para DynamoDB As seguintes permissões são necessárias: + Para ler itens usando PartiQL para DynamoDB, é necessário ter a permissão `dynamodb:PartiQLSelect` na tabela ou no índice. + Para inserir itens usando PartiQL para DynamoDB, é necessário ter a permissão `dynamodb:PartiQLInsert` na tabela ou no índice. + Para atualizar itens usando PartiQL para DynamoDB, é necessário ter a permissão `dynamodb:PartiQLUpdate` na tabela ou no índice. + Para excluir itens usando PartiQL para DynamoDB, é necessário ter a permissão `dynamodb:PartiQLDelete` na tabela ou no índice. ## Exemplo: permitir todas as instruções PartiQL para DynamoDB (Select/Insert/Update/Delete) em uma tabela A política do IAM a seguir concede permissões para executar todas as instruções PartiQL para DynamoDB em uma tabela. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ] } ] } ``` ------ ## Exemplo: permitir instruções Select PartiQL para DynamoDB em uma tabela A política do IAM a seguir concede permissões para executar a instrução `select` em uma tabela específica. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ] } ] } ``` ------ ## Exemplo: permitir instruções Insert PartiQL para DynamoDB em um índice A política do IAM a seguir concede permissões para executar a instrução `insert` em um índice específico. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music/index/index1" ] } ] } ``` ------ ## Exemplo: permitir instruções transacionais PartiQL para DynamoDB somente em uma tabela A política do IAM a seguir concede permissões para executar somente instruções transacionais em uma tabela específica. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ], "Condition":{ "StringEquals":{ "dynamodb:EnclosingOperation":[ "ExecuteTransaction" ] } } } ] } ``` ------ ## Exemplo: permitir leituras e gravações não transacionais PartiQL para DynamoDB e bloquear leituras e gravações transacionais PartiQL em uma tabela. A política do IAM a seguir concede permissões para executar leituras e gravações não transacionais PartiQL para DynamoDB ao mesmo tempo que bloqueia leituras e gravações transacionais PartiQL para DynamoDB. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Deny", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ], "Condition":{ "StringEquals":{ "dynamodb:EnclosingOperation":[ "ExecuteTransaction" ] } } }, { "Effect":"Allow", "Action":[ "dynamodb:PartiQLInsert", "dynamodb:PartiQLUpdate", "dynamodb:PartiQLDelete", "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/Music" ] } ] } ``` ------ ## Exemplo: permitir instruções Select e negar instruções de verificação de tabela completa em PartiQL para DynamoDB A política do IAM a seguir concede permissões para executar a instrução `select` em uma tabela específica ao mesmo tempo que bloqueia instruções `select` que resultam em uma verificação de tabela completa. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect":"Deny", "Action":[ "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/WatchList" ], "Condition":{ "Bool":{ "dynamodb:FullTableScan":[ "true" ] } } }, { "Effect":"Allow", "Action":[ "dynamodb:PartiQLSelect" ], "Resource":[ "arn:aws:dynamodb:us-west-2:123456789012:table/WatchList" ] } ] } ``` ------