

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Declarações DML (linguagem de manipulação de dados) no Amazon Keyspaces
<a name="cql.dml"></a>

*Linguagem de manipulação de dados* (DML) é o conjunto de instruções Cassandra Query Language (CQL) que você usa para gerenciar dados em tabelas do Amazon Keyspaces (para Apache Cassandra). Você usa instruções DML para adicionar, modificar ou excluir dados em uma tabela.

Você também usa instruções DML para consultar dados em uma tabela. (Observe que o CQL não oferece suporte a junções ou subconsultas.)

**Topics**
+ [SELECT](cql.dml.select.md)
+ [INSERT](cql.dml.insert.md)
+ [UPDATE](cql.dml.update.md)
+ [DELETE](cql.dml.delete.md)

# SELECT
<a name="cql.dml.select"></a>

Use uma instrução SELECT para consultar dados. 

**Sintaxe**

```
select_statement ::=  SELECT  [ JSON ] ( select_clause | '*' )
                      FROM table_name
                      [ WHERE 'where_clause' ]
                      [ ORDER BY 'ordering_clause' ]
                      [ LIMIT (integer | bind_marker) ]
                      [ ALLOW FILTERING ]
select_clause    ::=  selector [ AS identifier ] ( ',' selector [ AS identifier ] )
selector         ::=  column_name
                      | term
                      | CAST '(' selector AS cql_type ')'
                      | function_name '(' [ selector ( ',' selector )* ] ')'
where_clause     ::=  relation ( AND relation )*
relation         ::=  column_name operator term
                      TOKEN
operator         ::=  '=' | '<' | '>' | '<=' | '>=' | IN | CONTAINS | CONTAINS KEY
ordering_clause  ::=  column_name [ ASC | DESC ] ( ',' column_name [ ASC | DESC ] )*
```

**Exemplos**

```
SELECT name, id, manager_id FROM "myGSGKeyspace".employees_tbl ;

SELECT JSON name, id, manager_id FROM "myGSGKeyspace".employees_tbl ;
```

Para obter uma tabela que mapeia os tipos de dados codificados em JSON para os tipos de dados do Amazon Keyspaces, consulte [Codificação JSON dos tipos de dados do Amazon Keyspaces](cql.elements.md#cql.data-types.JSON).

**Usando a palavra-chave `IN`**

A palavra-chave `IN` especifica igualdade para um ou mais valores. Ela pode ser aplicada à chave de partição e à coluna de cluster. Os resultados são retornados na ordem em que as chaves são apresentadas na declaração `SELECT`.

**Exemplos**

```
SELECT * from mykeyspace.mytable WHERE primary.key1 IN (1,2) and clustering.key1 = 2;
SELECT * from mykeyspace.mytable WHERE primary.key1 IN (1,2) and clustering.key1 <= 2;
SELECT * from mykeyspace.mytable WHERE primary.key1 = 1 and clustering.key1 IN (1, 2);
SELECT * from mykeyspace.mytable WHERE primary.key1 <= 2 and clustering.key1 IN (1, 2) ALLOW FILTERING;
```

Para obter mais informações sobre a palavra-chave `IN` e como o Amazon Keyspaces processa a declaração, consulte [Como usar o operador `IN` com a Instrução `SELECT` em uma consulta no Amazon Keyspaces](in.select.md).

**Como ordenar resultados**

A cláusula `ORDER BY` especifica a ordem de classificação dos resultados retornados. Ela usa como argumentos uma lista de nomes de colunas junto com a ordem de classificação de cada coluna. Você só pode especificar colunas de cluster nas cláusulas de ordenação. Colunas sem cluster não são permitidas. As opções de ordem de classificação são `ASC` para ordem de classificação crescente e `DESC` para decrescente. Se a ordem de classificação for omitida, a ordem padrão da coluna de cluster será usada. Para possíveis ordens de classificação, consulte [Ordenar resultados com `ORDER BY` no Amazon Keyspaces](ordering-results.md).

**Exemplo**

```
SELECT name, id, division, manager_id FROM "myGSGKeyspace".employees_tbl WHERE id = '012-34-5678' ORDER BY division;
```

Ao usar `ORDER BY` com a palavra-chave `IN`, os resultados são ordenados em uma página. A reordenação completa com paginação desativada não é compatível.

**TOKEN**

Você pode aplicar a função `TOKEN` à coluna `PARTITION KEY` nas cláusulas `SELECT` e `WHERE`. Com a função `TOKEN`, o Amazon Keyspaces retorna linhas com base no valor do token mapeado do `PARTITION_KEY` e não no valor do `PARTITION KEY`.

As relações `TOKEN` não são compatíveis com a palavra-chave `IN`.

**Exemplos**

```
SELECT TOKEN(id) from my_table; 

SELECT TOKEN(id) from my_table WHERE TOKEN(id) > 100 and TOKEN(id) < 10000;
```

**Função TTL**

Você pode usar a função `TTL` com a instrução `SELECT` para recuperar o tempo de expiração em segundos armazenado em uma coluna. Se nenhum valor de um conjunto for `TTL`, a função retorna `null`.

**Exemplo**

```
SELECT TTL(my_column) from my_table;
```

A função `TTL` não pode ser usada em colunas com várias células, como coleções.

**Função do WRITETIME**

Você pode usar a função `WRITETIME` com a instrução `SELECT` para recuperar o carimbo de data/hora armazenado como metadados para o valor de uma coluna somente se a tabela usar carimbos de data e hora do lado do cliente. Para obter mais informações, consulte [Carimbos de data/hora do lado do cliente no Amazon Keyspaces](client-side-timestamps.md). 

```
SELECT WRITETIME(my_column) from my_table;
```

A função `WRITETIME` não pode ser usada em colunas com várias células, como coleções.

**nota**  
Para compatibilidade com o comportamento estabelecido do driver Cassandra, as políticas de autorização baseadas em tags não são aplicadas quando você executa operações em tabelas do sistema usando chamadas de API do Cassandra Query Language (CQL) por meio de drivers e ferramentas de desenvolvedor do Cassandra. Para obter mais informações, consulte [Acesso a recursos do Amazon Keyspaces com base em tags](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-tags).

# INSERT
<a name="cql.dml.insert"></a>

Use a instrução `INSERT` para adicionar uma linha a uma tabela.

**Sintaxe**

```
insert_statement ::=  INSERT INTO table_name ( names_values | json_clause )
                      [ IF NOT EXISTS ]
                      [ USING update_parameter ( AND update_parameter )* ]
names_values     ::=  names VALUES tuple_literal
json_clause      ::=  JSON string [ DEFAULT ( NULL | UNSET ) ]                
names            ::=  '(' column_name ( ',' column_name )* ')'
```

**Exemplo**

```
INSERT INTO "myGSGKeyspace".employees_tbl (id, name, project, region, division, role, pay_scale, vacation_hrs, manager_id)
VALUES ('012-34-5678','Russ','NightFlight','US','Engineering','IC',3,12.5, '234-56-7890') ;
```

**Atualizar parâmetros**

`INSERT` compatível com os seguintes valores como `update_parameter`:
+ `TTL`: um valor de tempo em segundos. O valor máximo configurável é 630.720.000 segundos, o que equivale a 20 anos.
+ `TIMESTAMP`: um valor `bigint` que representa o número de microssegundos desde a hora base padrão conhecida como epoch: 1º de janeiro de 1970 às 00:00:00 GMT. Um carimbo de data/hora no Amazon Keyspaces deve estar entre o intervalo de 2 dias no passado e 5 minutos no futuro.

**Exemplo**

```
INSERT INTO my_table (userid, time, subject, body, user)
        VALUES (B79CB3BA-745E-5D9A-8903-4A02327A7E09, 96a29100-5e25-11ec-90d7-b5d91eceda0a, 'Message', 'Hello','205.212.123.123')
        USING TTL 259200;
```

**Suporte para JSON**

Para obter uma tabela que mapeia os tipos de dados codificados em JSON para os tipos de dados do Amazon Keyspaces, consulte [Codificação JSON dos tipos de dados do Amazon Keyspaces](cql.elements.md#cql.data-types.JSON).

Você pode usar a palavra-chave `JSON` para inserir um mapa codificado em `JSON` como uma única linha. Para colunas que existem na tabela, mas são omitidas na instrução de inserção do JSON, use `DEFAULT UNSET` para preservar os valores existentes. Use `DEFAULT NULL` para gravar um valor NULL em cada linha de colunas omitidas e sobrescrever os valores existentes (taxas de gravação padrão se aplicam). `DEFAULT NULL`é a opção padrão.

**Exemplo**

```
INSERT INTO "myGSGKeyspace".employees_tbl JSON '{"id":"012-34-5678",
                                                 "name": "Russ",
                                                 "project": "NightFlight",
                                                 "region": "US",
                                                 "division": "Engineering",
                                                 "role": "IC",
                                                 "pay_scale": 3,
                                                 "vacation_hrs": 12.5,
                                                 "manager_id": "234-56-7890"}';
```

Se os dados JSON contiverem chaves duplicadas, o Amazon Keyspaces armazenará o último valor da chave (semelhante ao Apache Cassandra). No exemplo a seguir, onde está a chave duplicada `id`, o valor `234-56-7890` é usado.

**Exemplo**

```
INSERT INTO "myGSGKeyspace".employees_tbl JSON '{"id":"012-34-5678",
                                                 "name": "Russ",
                                                 "project": "NightFlight",
                                                 "region": "US",
                                                 "division": "Engineering",
                                                 "role": "IC",
                                                 "pay_scale": 3,
                                                 "vacation_hrs": 12.5,
                                                 "id": "234-56-7890"}';
```

# UPDATE
<a name="cql.dml.update"></a>

Use a instrução `UPDATE` para modificar uma linha em uma tabela.

**Sintaxe**

```
update_statement ::=  UPDATE table_name
                      [ USING update_parameter ( AND update_parameter )* ]
                      SET assignment ( ',' assignment )*
                      WHERE where_clause
                      [ IF ( EXISTS | condition ( AND condition )*) ]
update_parameter ::=  ( integer | bind_marker )
assignment       ::=  simple_selection '=' term
                     | column_name '=' column_name ( '+' | '-' ) term
                     | column_name '=' list_literal '+' column_name
simple_selection ::=  column_name
                     | column_name '[' term ']'
                     | column_name '.' `field_name
condition        ::=  simple_selection operator term
```

**Exemplo**

```
UPDATE "myGSGKeyspace".employees_tbl SET pay_scale = 5 WHERE id = '567-89-0123' AND division = 'Marketing' ;
```

Para incrementar um `counter`, use a sintaxe a seguir. Para obter mais informações, consulte [Contadores](cql.elements.md#cql.data-types.numeric.counters).

```
UPDATE ActiveUsers SET counter = counter + 1  WHERE user = A70FE1C0-5408-4AE3-BE34-8733E5K09F14 AND action = 'click';
```

**Atualizar parâmetros**

`UPDATE` compatível com os seguintes valores como `update_parameter`:
+ `TTL`: um valor de tempo em segundos. O valor máximo configurável é 630.720.000 segundos, o que equivale a 20 anos.
+ `TIMESTAMP`: um valor `bigint` que representa o número de microssegundos desde a hora base padrão conhecida como epoch: 1º de janeiro de 1970 às 00:00:00 GMT. Um carimbo de data/hora no Amazon Keyspaces deve estar entre o intervalo de 2 dias no passado e 5 minutos no futuro.

**Exemplo**

```
UPDATE my_table (userid, time, subject, body, user)
        VALUES (B79CB3BA-745E-5D9A-8903-4A02327A7E09, 96a29100-5e25-11ec-90d7-b5d91eceda0a, 'Message', 'Hello again','205.212.123.123')
        USING TIMESTAMP '2022-11-03 13:30:54+0400';
```

# DELETE
<a name="cql.dml.delete"></a>

Use a instrução `DELETE` para remover uma linha de uma tabela.

**Sintaxe**

```
delete_statement ::=  DELETE [ simple_selection ( ',' simple_selection ) ]
                      FROM table_name
                      [ USING update_parameter ( AND update_parameter )* ]
                      WHERE where_clause
                      [ IF ( EXISTS | condition ( AND condition )*) ]

simple_selection ::=  column_name
                     | column_name '[' term ']'
                     | column_name '.' `field_name

condition        ::=  simple_selection operator term
```

Em que:
+ `table_name` é a tabela que contém a linha a ser excluída.

**Exemplo**

```
DELETE manager_id FROM "myGSGKeyspace".employees_tbl WHERE id='789-01-2345' AND division='Executive' ;
```

`DELETE` suporta o seguinte valor como `update_parameter`:
+ `TIMESTAMP`: um valor `bigint` que representa o número de microssegundos desde a hora base padrão conhecida como epoch: 1º de janeiro de 1970 às 00:00:00 GMT.