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á.

# Módulos integrados
<a name="built-in-modules-js"></a>

Os módulos fazem parte do `APPSYNC_JS` tempo de execução e fornecem utilitários para ajudar a escrever JavaScript resolvedores e funções. Para amostras e exemplos, consulte o [aws-appsync-resolver-samples](https://github.com/aws-samples/aws-appsync-resolver-samples) GitHub repositório.

## Funções do módulo DynamoDB
<a name="built-in-ddb-modules"></a>

As funções do módulo DynamoDB oferecem uma experiência aprimorada ao interagir com fontes de dados do DynamoDB. Você pode fazer solicitações para suas fontes de dados do DynamoDB usando as funções e sem adicionar mapeamento de tipos. 

Os módulos são importados usando `@aws-appsync/utils/dynamodb`:

```
// Modules are imported using @aws-appsync/utils/dynamodb
import * as ddb from '@aws-appsync/utils/dynamodb';
```

### Funções
<a name="built-in-ddb-modules-functions"></a>

#### Lista de funções
<a name="built-in-ddb-modules-functions-list"></a>

 **` get<T>(payload: GetInput): DynamoDBGetItemRequest`**  
Consulte [Entradas](#built-in-ddb-modules-inputs) para obter informações sobre GetInput.
Gera um `DynamoDBGetItemRequest` objeto para fazer uma [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem)solicitação ao DynamoDB.  

```
import { get } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	return get({ key: { id: ctx.args.id } });
}
```

 **`put<T>(payload): DynamoDBPutItemRequest`**  
Gera um `DynamoDBPutItemRequest` objeto para fazer uma [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)solicitação ao DynamoDB.  

```
import * as ddb from '@aws-appsync/utils/dynamodb'

export function request(ctx) {
	return ddb.put({ key: { id: util.autoId() }, item: ctx.args });
}
```

**`remove<T>(payload): DynamoDBDeleteItemRequest`**  
Gera um `DynamoDBDeleteItemRequest` objeto para fazer uma [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem)solicitação ao DynamoDB.  

```
import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	return ddb.remove({ key: { id: ctx.args.id } });
}
```

**`scan<T>(payload): DynamoDBScanRequest`**  
Gera um objeto `DynamoDBScanRequest` para fazer uma solicitação [Scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) ao DynamoDB.  

```
import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const { limit = 10, nextToken } = ctx.args;
	return ddb.scan({ limit, nextToken });
}
```

**`sync<T>(payload): DynamoDBSyncRequest`**  
Gera um objeto `DynamoDBSyncRequest` para fazer uma solicitação [Sync](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync). A solicitação só recebe os dados alterados desde a última consulta (atualizações delta). As solicitações só podem ser feitas para fontes de dados versionadas do DynamoDB.  

```
import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const { limit = 10, nextToken, lastSync } = ctx.args;
	return ddb.sync({ limit, nextToken, lastSync });
}
```

**`update<T>(payload): DynamoDBUpdateItemRequest`**  
Gera um `DynamoDBUpdateItemRequest` objeto para fazer uma [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem)solicitação ao DynamoDB.

### Operações
<a name="built-in-ddb-modules-operations"></a>

Os auxiliares de operação permitem que você execute ações específicas em partes dos seus dados durante as atualizações. Para começar, importe `operations` de `@aws-appsync/utils/dynamodb`:

```
// Modules are imported using operations
import {operations} from '@aws-appsync/utils/dynamodb';
```

#### Operações de lista
<a name="built-in-ddb-modules-operations-list"></a>

 **`add<T>(payload)`**  
Uma função auxiliar que adiciona um novo item de atributo ao atualizar o DynamoDB.  
**Exemplo**  
Para adicionar um endereço (rua, cidade e código postal) a um item existente do DynamoDB usando o valor do ID:  

```
import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const updateObj = {
		address: operations.add({
			street1: '123 Main St',
			city: 'New York',
			zip: '10001',
		}),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
```

**`append <T>(payload)`**  
Uma função auxiliar que anexa um payload no final da lista existente no DynamoDB.  
**Exemplo**  
Para acrescentar amigo IDs (`newFriendIds`) recém-adicionado a uma lista de amigos existente (`friendsIds`) durante uma atualização:  

```
import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const newFriendIds = [101, 104, 111];
	const updateObj = {
		friendsIds: operations.append(newFriendIds),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
```

**`decrement (by?)`**  
Uma função auxiliar que diminui o valor do atributo existente no item ao atualizar o DynamoDB.  
**Exemplo**  
Para diminuir o contador de amigos (`friendsCount`) em 10:  

```
import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const updateObj = {
		friendsCount: operations.decrement(10),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
```

**`increment (by?)`**  
Uma função auxiliar que aumenta o valor do atributo existente no item ao atualizar o DynamoDB.  
**Exemplo**  
Para aumentar o contador de amigos (`friendsCount`) em 10:  

```
import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const updateObj = {
		friendsCount: operations.increment(10),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
```

**`prepend <T>(payload)`**  
Uma função auxiliar que anexa no início da lista existente no DynamoDB.  
**Exemplo**  
Para acrescentar amigo IDs (`newFriendIds`) recém-adicionado a uma lista de amigos existente (`friendsIds`) durante uma atualização:  

```
import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const newFriendIds = [101, 104, 111];
	const updateObj = {
		friendsIds: operations.prepend(newFriendIds),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
```

**`replace <T>(payload)`**  
Uma função auxiliar que substitui o atributo existente no item ao atualizar um item no DynamoDB. Isso é útil quando você deseja atualizar todo o objeto ou subobjeto no atributo e não apenas as chaves no payload.  
**Exemplo**  
Para substituir um endereço (rua, cidade e CEP) em um objeto `info`:  

```
import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const updateObj = {
		info: {
			address: operations.replace({
				street1: '123 Main St',
				city: 'New York',
				zip: '10001',
			}),
		},
	};
	return update({ key: { id: 1 }, update: updateObj });
}
```

**`updateListItem <T>(payload, index)`**  
Uma função auxiliar que substitui um item em uma lista.  
**Exemplo**  
No escopo do update (`newFriendIds`), este exemplo é usado `updateListItem` para atualizar os valores de ID do segundo item (índice: `1`, novo ID: `102`) e do terceiro item (índice: `2`, novo ID: `112`) em uma lista (`friendsIds`).  

```
import { update, operations as ops } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const newFriendIds = [
		ops.updateListItem('102', 1), ops.updateListItem('112', 2)
	];
	const updateObj = { friendsIds: newFriendIds };
	return update({ key: { id: 1 }, update: updateObj });
}
```

### Entradas
<a name="built-in-ddb-modules-inputs"></a>

#### Lista de entradas
<a name="built-in-ddb-modules-inputs-list"></a>

 **`Type GetInput<T>`**  

```
GetInput<T>: { 
    consistentRead?: boolean; 
    key: DynamoDBKey<T>; 
}
```
**Declaração de tipo**  
+ `consistentRead?: boolean` (opcional)

  Um booleano opcional para especificar se você deseja realizar uma leitura altamente consistente com o DynamoDB.
+ `key: DynamoDBKey<T>`(obrigatório)

  Um parâmetro obrigatório que especifica a chave do item no DynamoDB. Os itens do DynamoDB podem ter uma única chave de hash ou chaves de hash e de classificação.

**`Type PutInput<T>`**  

```
PutInput<T>: { 
    _version?: number; 
    condition?: DynamoDBFilterObject<T> | null; 
    customPartitionKey?: string; 
    item: Partial<T>; 
    key: DynamoDBKey<T>; 
    populateIndexFields?: boolean; 
}
```
**Declaração de tipo**  
+ `_version?: number` (opcional)
+ `condition?: DynamoDBFilterObject<T> | null` (opcional)

  Quando você insere um objeto em uma tabela do DynamoDB, pode especificar uma expressão condicional que controla se a solicitação deve ser bem-sucedida ou não, com base no estado do objeto que já está no DynamoDB antes que a operação seja realizada.
+ `customPartitionKey?: string` (opcional)

  Quando ativado, esse valor de string modifica o formato dos registros `ds_sk` e `ds_pk` usados pela tabela de sincronização delta quando o versionamento é ativado. Quando ativado, o processamento da entrada `populateIndexFields` também é ativado. 
+ `item: Partial<T>`(obrigatório)

  O restante dos atributos do item a ser colocado no DynamoDB.
+ `key: DynamoDBKey<T>`(obrigatório)

  Um parâmetro obrigatório que especifica a chave do item no DynamoDB em que a inserção será feita. Os itens do DynamoDB podem ter uma única chave de hash ou chaves de hash e de classificação.
+ `populateIndexFields?: boolean` (opcional)

  Um valor booleano que, quando ativado com `customPartitionKey`, cria novas entradas para cada registro na tabela de sincronização delta, especificamente nas colunas `gsi_ds_pk` e `gsi_ds_sk`. Para obter mais informações, consulte [Detecção e sincronização de conflitos](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) no *Guia do desenvolvedor do AWS AppSync *.

**`Type QueryInput<T>`**  

```
QueryInput<T>: ScanInput<T> & { 
    query: DynamoDBKeyCondition<Required<T>>; 
}
```
**Declaração de tipo**  
+ `query: DynamoDBKeyCondition<Required<T>>`(obrigatório)

  Especifica uma condição de chave que descreve os itens a serem consultados. Para um determinado índice, a condição para uma chave de partição deve ser uma igualdade e para a chave de classificação, uma comparação ou `beginsWith` (quando for uma string). Somente tipos de números e strings de caracteres são suportados para chaves de partição e de classificação.

  **Exemplo**

  Veja o tipo `User` abaixo:

  ```
  type User = {
    id: string;
    name: string;
    age: number;
    isVerified: boolean;
    friendsIds: string[] 
  }
  ```

  A consulta só pode incluir os seguintes campos: `id`, `name` e `age`:

  ```
  const query: QueryInput<User> = {
      name: { eq: 'John' },
      age: { gt: 20 },
  }
  ```

**`Type RemoveInput<T>`**  

```
RemoveInput<T>: { 
    _version?: number; 
    condition?: DynamoDBFilterObject<T>; 
    customPartitionKey?: string; 
    key: DynamoDBKey<T>; 
    populateIndexFields?: boolean; 
}
```
**Declaração de tipo**  
+ `_version?: number` (opcional)
+ `condition?: DynamoDBFilterObject<T>` (opcional)

  Quando você remove um objeto no DynamoDB, pode especificar uma expressão condicional que controla se a solicitação deve ser bem-sucedida ou não, com base no estado do objeto que já está no DynamoDB antes que a operação seja realizada.

  **Exemplo**

  O exemplo a seguir é uma expressão `DeleteItem` contendo uma condição que permitirá que a operação seja bem-sucedida somente se o proprietário do documento corresponder ao usuário que fez a solicitação.

  ```
  type Task = {
    id: string;
    title: string;
    description: string;
    owner: string;
    isComplete: boolean;
  }
  const condition: DynamoDBFilterObject<Task> = {
    owner: { eq: 'XXXXXXXXXXXXXXXX' },
  }
  
  remove<Task>({
     key: {
       id: 'XXXXXXXXXXXXXXXX',
    },
    condition,
  });
  ```
+ `customPartitionKey?: string` (opcional)

  Quando ativado, esse valor `customPartitionKey` modifica o formato dos registros `ds_sk` e `ds_pk` usados pela tabela de sincronização delta quando o versionamento é ativado. Quando ativado, o processamento da entrada `populateIndexFields` também é ativado. 
+ `key: DynamoDBKey<T>`(obrigatório)

  Um parâmetro obrigatório que especifica a chave do item no DynamoDB que está sendo removido. Os itens do DynamoDB podem ter uma única chave de hash ou chaves de hash e de classificação.

  **Exemplo**

  Se `User` tiver apenas a chave de hash com um usuário `id`, a chave ficará assim:

  ```
  type User = {
  	id: number
  	name: string
  	age: number
  	isVerified: boolean
  }
  const key: DynamoDBKey<User> = {
  	id: 1,
  }
  ```

  Se o usuário da tabela tiver a chave de hash (`id`) e a chave de classificação (`name`), a chave ficará assim:

  ```
  type User = {
  	id: number
  	name: string
  	age: number
  	isVerified: boolean
  	friendsIds: string[]
  }
  
  const key: DynamoDBKey<User> = {
  	id: 1,
  	name: 'XXXXXXXXXX',
  }
  ```
+ `populateIndexFields?: boolean` (opcional)

  Um valor booleano que, quando ativado com `customPartitionKey`, cria novas entradas para cada registro na tabela de sincronização delta, especificamente nas colunas `gsi_ds_pk` e `gsi_ds_sk`.

**`Type ScanInput<T>`**  

```
ScanInput<T>: { 
    consistentRead?: boolean | null; 
    filter?: DynamoDBFilterObject<T> | null; 
    index?: string | null; 
    limit?: number | null; 
    nextToken?: string | null; 
    scanIndexForward?: boolean | null; 
    segment?: number; 
    select?: DynamoDBSelectAttributes; 
    totalSegments?: number; 
}
```
**Declaração de tipo**  
+ `consistentRead?: boolean | null` (opcional)

  Um booleano opcional que indica leituras consistentes ao consultar o DynamoDB. O valor padrão é `false`.
+ `filter?: DynamoDBFilterObject<T> | null` (opcional)

  Um filtro opcional para aplicar aos resultados depois de recuperá-los da tabela.
+ `index?: string | null` (opcional)

  Um nome opcional do índice para digitalizar.
+ `limit?: number | null` (opcional)

  O número máximo opcional de resultados a serem retornados.
+ `nextToken?: string | null` (opcional)

  O token de paginação opcional para continuar uma consulta anterior. Isso seria obtido de uma consulta anterior.
+ `scanIndexForward?: boolean | null` (opcional)

  Um booleano opcional para indicar se a consulta é executada em ordem crescente ou decrescente. Por padrão, esse valor é definido como `true`.
+ `segment?: number` (opcional)
+ `select?: DynamoDBSelectAttributes` (opcional)

  Atributos a serem retornados do DynamoDB. Por padrão, o AWS AppSync resolvedor do DynamoDB retorna somente atributos que são projetados no índice. Os valores compatíveis são:
  + `ALL_ATTRIBUTES`

    Retorna todos os atributos de item da tabela ou índice especificado. Se você consultar um índice secundário local, o DynamoDB buscará todo o item da tabela pai para cada item correspondente no índice. Se o índice estiver configurado para projetar todos os atributos de item, todos os dados podem ser obtidos no índice secundário local, e nenhuma busca será necessária.
  + `ALL_PROJECTED_ATTRIBUTES`

    Recupera todos os atributos que foram projetados no índice. Se o índice estiver configurado para projetar todos os atributos, esse valor de retorno é equivalente a especificar `ALL_ATTRIBUTES`.
  + `SPECIFIC_ATTRIBUTES`

    Retorna somente os atributos listados em `ProjectionExpression`. Esse valor de retorno é equivalente a especificar `ProjectionExpression` sem especificar nenhum valor para `AttributesToGet`.
+ `totalSegments?: number` (opcional)

**`Type DynamoDBSyncInput<T>`**  

```
DynamoDBSyncInput<T>: { 
    basePartitionKey?: string; 
    deltaIndexName?: string; 
    filter?: DynamoDBFilterObject<T> | null; 
    lastSync?: number; 
    limit?: number | null; 
    nextToken?: string | null; 
}
```
**Declaração de tipo**  
+ `basePartitionKey?: string` (opcional)

  A chave de partição da tabela Base usada ao realizar uma operação Sync. Esse campo permite que uma operação Sync seja executada quando a tabela utiliza uma chave de partição personalizada.
+ `deltaIndexName?: string` (opcional)

  O índice usado para a operação Sync. Esse índice é necessário para habilitar uma operação de sincronização em toda a tabela de armazenamento delta quando a tabela usa uma chave de partição personalizada. A operação de sincronização será executada no GSI (criado em `gsi_ds_pk` e `gsi_ds_sk`).
+ `filter?: DynamoDBFilterObject<T> | null` (opcional)

  Um filtro opcional para aplicar aos resultados depois de recuperá-los da tabela.
+ `lastSync?: number` (opcional)

  O momento, em milésimos de segundos de epoch, no qual a última operação de sincronização bem-sucedida foi iniciada. Se especificado, somente os itens que foram alterados após `lastSync` serão retornados. Este campo deve ser preenchido somente depois de recuperar todas as páginas de uma operação inicial de sincronização. Se omitidos, os resultados da tabela base serão retornados. Caso contrário, os resultados da tabela delta serão retornados.
+ `limit?: number | null` (opcional)

  O número máximo opcional de itens a serem avaliados ao mesmo tempo. Se omitido, o limite padrão será definido como `100` itens. O valor máximo para esse campo é de `1000` itens.
+ `nextToken?: string | null` (opcional)

**`Type DynamoDBUpdateInput<T>`**  

```
DynamoDBUpdateInput<T>: { 
    _version?: number; 
    condition?: DynamoDBFilterObject<T>; 
    customPartitionKey?: string; 
    key: DynamoDBKey<T>; 
    populateIndexFields?: boolean; 
    update: DynamoDBUpdateObject<T>; 
}
```
**Declaração de tipo**  
+ `_version?: number` (opcional)
+ `condition?: DynamoDBFilterObject<T>` (opcional)

  Quando você atualiza um objeto no DynamoDB, pode especificar uma expressão condicional que controla se a solicitação deve ser bem-sucedida ou não, com base no estado do objeto que já está no DynamoDB antes que a operação seja realizada.
+ `customPartitionKey?: string` (opcional)

  Quando ativado, esse valor `customPartitionKey` modifica o formato dos registros `ds_sk` e `ds_pk` usados pela tabela de sincronização delta quando o versionamento é ativado. Quando ativado, o processamento da entrada `populateIndexFields` também é ativado. 
+ `key: DynamoDBKey<T>`(obrigatório)

  Um parâmetro obrigatório que especifica a chave do item no DynamoDB que está sendo atualizado. Os itens do DynamoDB podem ter uma única chave de hash ou chaves de hash e de classificação.
+ `populateIndexFields?: boolean` (opcional)

  Um valor booleano que, quando ativado com `customPartitionKey`, cria novas entradas para cada registro na tabela de sincronização delta, especificamente nas colunas `gsi_ds_pk` e `gsi_ds_sk`. 
+ `update: DynamoDBUpdateObject<T>`

  Um objeto que especifica os atributos a serem atualizados junto com os novos valores para eles. O objeto de atualização pode ser usado com `add`, `remove`, `replace`, `increment`, `decrement`, `append`, `prepend`, `updateListItem`.

## Funções do módulo do Amazon RDS
<a name="built-in-rds-modules"></a>

As funções do módulo do Amazon RDS oferecem uma experiência aprimorada ao interagir com bancos de dados configurados com a API de dados do Amazon RDS. O módulo é importado usando `@aws-appsync/utils/rds`: 

```
import * as rds from '@aws-appsync/utils/rds';
```

As funções também podem ser importadas individualmente. Por exemplo, a importação abaixo usa `sql`:

```
import { sql } from '@aws-appsync/utils/rds';
```

### Funções
<a name="built-in-rds-modules-functions"></a>

Você pode usar os auxiliares utilitários do módulo AWS AppSync RDS para interagir com seu banco de dados.

#### Select
<a name="built-in-rds-modules-functions-select"></a>

O utilitário `select` cria uma declaração `SELECT` para consultar o banco de dados relacional. 

**Uso básico**

Na forma básica, é possível especificar a tabela que deseja consultar:

```
import { select, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {

    // Generates statement: 
    // "SELECT * FROM "persons"
    return createPgStatement(select({table: 'persons'}));
}
```

Observe também que é possível especificar o esquema no identificador da tabela:

```
import { select, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {

    // Generates statement:
    // SELECT * FROM "private"."persons"
    return createPgStatement(select({table: 'private.persons'}));
}
```

**Especificar colunas**

É possível especificar colunas com a propriedade `columns`. Se isso não for definido como um valor, o padrão será `*`:

```
export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name']
    }));
}
```

Também é possível especificar a tabela de uma coluna:

```
export function request(ctx) {

    // Generates statement: 
    // SELECT "id", "persons"."name"
    // FROM "persons"
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'persons.name']
    }));
}
```

**Limites e deslocamentos**:

É possível aplicar `limit` e `offset` à consulta:

```
export function request(ctx) {

    // Generates statement: 
    // SELECT "id", "name"
    // FROM "persons"
    // LIMIT :limit
    // OFFSET :offset
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        limit: 10,
        offset: 40
    }));
}
```

**Ordenar por**

É possível classificar os resultados com a propriedade `orderBy`. Forneça uma matriz de objetos especificando a coluna e uma propriedade `dir` opcional:

```
export function request(ctx) {

    // Generates statement: 
    // SELECT "id", "name" FROM "persons"
    // ORDER BY "name", "id" DESC
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        orderBy: [{column: 'name'}, {column: 'id', dir: 'DESC'}]
    }));
}
```

**Filtros**

É possível criar filtros usando o objeto de condição especial:

```
export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    // WHERE "name" = :NAME
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        where: {name: {eq: 'Stephane'}}
    }));
}
```

Também é possível combinar filtros:

```
export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    // WHERE "name" = :NAME and "id" > :ID
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        where: {name: {eq: 'Stephane'}, id: {gt: 10}}
    }));
}
```

Também é possível criar declarações `OR`:

```
export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    // WHERE "name" = :NAME OR "id" > :ID
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        where: { or: [
            { name: { eq: 'Stephane'} },
            { id: { gt: 10 } }
        ]}
    }));
}
```

Também é possível negar uma condição com `not`:

```
export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    // WHERE NOT ("name" = :NAME AND "id" > :ID)
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        where: { not: [
            { name: { eq: 'Stephane'} },
            { id: { gt: 10 } }
        ]}
    }));
}
```

Também é possível usar os seguintes operadores para comparar valores:


| 
| 
| Operador | Description | Tipos de valores possíveis | 
| --- |--- |--- |
| eq | Equal | número, string, booleano | 
| ne | Not equal | número, string, booleano | 
| le | Menor ou igual a | número, seqüência | 
| lt | Menor que | número, seqüência | 
| idade | Maior ou igual a | número, seqüência | 
| gt | Maior que | número, seqüência | 
| contém | Like | string | 
| NÃO contém | Não é como | string | 
| Começa com | Começa com o prefixo | string | 
| entre | Entre dois valores | número, seqüência | 
| O atributo existe | O atributo não é nulo | número, string, booleano | 
| size | verifica o comprimento do elemento | string | 

#### Inserir
<a name="built-in-rds-modules-functions-insert"></a>

O utilitário `insert` oferece uma maneira simples de inserir itens de linha única no banco de dados com a operação `INSERT`.

**Inserções de item único**

Para inserir um item, especifique a tabela e, depois, transmita o objeto de valores. As chaves do objeto são associadas às colunas da tabela. São inseridos automaticamente caracteres de escape nos nomes das colunas e os valores são enviados ao banco de dados usando o mapa de variáveis:

```
import { insert, createMySQLStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: values } = ctx.args;
    const insertStatement = insert({ table: 'persons', values });
    
    // Generates statement:
    // INSERT INTO `persons`(`name`)
    // VALUES(:NAME)
    return createMySQLStatement(insertStatement)
}
```

**Caso de uso do MySQL**

É possível combinar um `insert` seguido por um `select` para recuperar a linha inserida:

```
import { insert, select, createMySQLStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: values } = ctx.args;
    const insertStatement = insert({  table: 'persons', values });
    const selectStatement = select({
        table: 'persons',
        columns: '*',
        where: { id: { eq: values.id } },
        limit: 1,
    });
    
    // Generates statement:
    // INSERT INTO `persons`(`name`)
    // VALUES(:NAME)
    // and
    // SELECT *
    // FROM `persons`
    // WHERE `id` = :ID
    return createMySQLStatement(insertStatement, selectStatement)
}
```

**Caso de uso do Postgres**

Com o Postgres, é possível usar [https://www.postgresql.org/docs/current/dml-returning.html](https://www.postgresql.org/docs/current/dml-returning.html) para obter dados da linha que você inseriu. Ele aceita `*` ou uma matriz de nomes de colunas:

```
import { insert, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: values } = ctx.args;
    const insertStatement = insert({
        table: 'persons',
        values,
        returning: '*'
    });

    // Generates statement:
    // INSERT INTO "persons"("name")
    // VALUES(:NAME)
    // RETURNING *
    return createPgStatement(insertStatement)
}
```

#### Atualizar
<a name="built-in-rds-modules-functions-update"></a>

O utilitário `update` permite atualizar as linhas existentes. É possível usar o objeto de condição para aplicar alterações às colunas especificadas em todas as linhas que atendam à condição. Por exemplo, digamos que temos um esquema que nos permita fazer essa mutação. Queremos atualizar o `name` de `Person` com o valor `id` de `3`, mas somente se os conhecermos (`known_since`) desde o ano `2000`:

```
mutation Update {
    updatePerson(
        input: {id: 3, name: "Jon"},
        condition: {known_since: {ge: "2000"}}
    ) {
    id
    name
  }
}
```

Nosso resolvedor de atualização é semelhante a:

```
import { update, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: { id, ...values }, condition } = ctx.args;
    const where = {
        ...condition,
        id: { eq: id },
    };
    const updateStatement = update({
        table: 'persons',
        values,
        where,
        returning: ['id', 'name'],
    });

    // Generates statement:
    // UPDATE "persons"
    // SET "name" = :NAME, "birthday" = :BDAY, "country" = :COUNTRY
    // WHERE "id" = :ID
    // RETURNING "id", "name"
    return createPgStatement(updateStatement)
}
```

Podemos adicionar uma verificação à nossa condição para garantir que somente a linha que tem a chave primária `id` igual a `3` seja atualizada. Da mesma forma, para Postgres `inserts`, é possível usar `returning` para exibir os dados modificados. 

#### Remover
<a name="built-in-rds-modules-functions-remove"></a>

O utilitário `remove` permite excluir as linhas existentes. É possível usar o objeto de condição em todas as linhas que atendam à condição. Observe que `delete` é uma palavra-chave reservada em JavaScript. `remove`deve ser usado em vez disso:

```
import { remove, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: { id }, condition } = ctx.args;
    const where = { ...condition, id: { eq: id } };
    const deleteStatement = remove({
        table: 'persons',
        where,
        returning: ['id', 'name'],
    });

    // Generates statement:
    // DELETE "persons"
    // WHERE "id" = :ID
    // RETURNING "id", "name"
    return createPgStatement(updateStatement)
}
```

### Conversão
<a name="built-in-rds-modules-casting"></a>

Em alguns casos, convém ter maior especificidade sobre o tipo de objeto correto a ser usado na declaração. Você pode usar as dicas de tipo fornecidas para especificar o tipo dos seus parâmetros. AWS AppSync suporta os [mesmos tipos de dicas](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html#rdsdtataservice-Type-SqlParameter-typeHint) da API de dados. Você pode converter seus parâmetros usando as `typeHint` funções do AWS AppSync `rds` módulo. 

O exemplo a seguir permite enviar uma matriz como um valor que é convertido como um objeto JSON. Usamos o operador `->` para recuperar o elemento `index` `2` na matriz JSON:

```
import { sql, createPgStatement, toJsonObject, typeHint } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const arr = ctx.args.list_of_ids
    const statement = sql`select ${typeHint.JSON(arr)}->2 as value`
    return createPgStatement(statement)
}

export function response(ctx) {
    return toJsonObject(ctx.result)[0][0].value
}
```

A conversão também é útil ao processar e comparar `DATE`, `TIME` e `TIMESTAMP`:

```
import { select, createPgStatement, typeHint } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const when = ctx.args.when
    const statement = select({
        table: 'persons',
        where: { createdAt : { gt: typeHint.DATETIME(when) } }
    })
    return createPgStatement(statement)
}
```

Veja outro exemplo de como enviar a data e a hora atuais:

```
import { sql, createPgStatement, typeHint } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const now = util.time.nowFormatted('YYYY-MM-dd HH:mm:ss')
    return createPgStatement(sql`select ${typeHint.TIMESTAMP(now)}`)
}
```

**Dicas de tipo disponíveis**
+ `typeHint.DATE`: o parâmetro correspondente é enviado como objeto do tipo `DATE` ao banco de dados. O formato aceito é `YYYY-MM-DD`.
+ `typeHint.DECIMAL`: o parâmetro correspondente é enviado como objeto do tipo `DECIMAL` ao banco de dados.
+ `typeHint.JSON`: o parâmetro correspondente é enviado como objeto do tipo `JSON` ao banco de dados.
+ `typeHint.TIME`: o valor de parâmetro de string correspondente é enviado como objeto do tipo `TIME` ao banco de dados. O formato aceito é `HH:MM:SS[.FFF]`. 
+ `typeHint.TIMESTAMP`: o valor de parâmetro de string correspondente é enviado como objeto do tipo `TIMESTAMP` ao banco de dados. O formato aceito é `YYYY-MM-DD HH:MM:SS[.FFF]`.
+ `typeHint.UUID`: o valor de parâmetro de string correspondente é enviado como objeto do tipo `UUID` ao banco de dados.