# Consistência de leitura para encaminhamento de gravação
<a name="aurora-mysql-write-forwarding-consistency"></a>

É possível controlar o grau de consistência de leitura em um cluster de banco de dados. O nível de consistência de leitura determina quanto o cluster de banco de dados espera antes de cada operação de leitura para garantir que algumas ou todas as alterações sejam replicadas do gravador. Você pode ajustar o nível de consistência de leitura para garantir que todas as operações de gravação encaminhadas da sessão estejam visíveis no cluster de banco de dados antes de qualquer consulta subsequente. Você também pode usar essa configuração para garantir que as consultas no cluster de banco de dados sempre vejam as atualizações mais recentes do gravador. Essa configuração também se aplica às consultas enviadas por outras sessões ou outros clusters. Para especificar esse tipo de comportamento para a aplicação, escolha um valor para o parâmetro de banco de dados ou o parâmetro de cluster de banco de dados `aurora_replica_read_consistency`.

**Importante**  
Sempre defina o parâmetro de banco de dados ou o parâmetro de cluster de banco de dados `aurora_replica_read_consistency` quando você desejar encaminhar gravações. Se você não fizer isso, o Aurora não encaminhará as gravações. Esse parâmetro tem um valor vazio por padrão, então escolha um valor específico quando você usar esse parâmetro. O parâmetro `aurora_replica_read_consistency` afeta somente clusters de banco de dados ou instâncias com o encaminhamento de gravação habilitado.

À medida que você aumenta o nível de consistência, mais tempo a aplicação aguarda a propagação das alterações entre as instâncias de banco de dados. Você pode escolher um contrapeso entre o tempo de resposta rápido e a garantia de que as alterações feitas em outras instâncias de banco de dados estejam totalmente disponíveis antes da execução das consultas.

Você pode especificar os seguintes valores para o parâmetro `aurora_replica_read_consistency`:
+ `EVENTUAL`: os resultados das operações de gravação na mesma sessão ficam visíveis apenas quando a operação de gravação é executada na instância de banco de dados do gravador. A consulta não espera que os resultados atualizados estejam disponíveis. Assim, ela pode recuperar os dados mais antigos ou os dados atualizados, dependendo do tempo das declarações e da quantidade de atraso da replicação. Essa é a mesma consistência dos clusters de banco de dados do Aurora MySQL que não usam encaminhamento de gravação.
+ `SESSION`: todas as consultas que usam o encaminhamento de gravação veem os resultados de todas as alterações feitas nessa sessão. As alterações são visíveis independentemente de a transação ser confirmada. Se necessário, a consulta aguardará a replicação dos resultados das operações de gravação encaminhadas.
+ `GLOBAL`: uma sessão vê todas as alterações confirmadas em todas as sessões e instâncias no cluster de banco de dados. Cada consulta pode aguardar por um período que varia de acordo com a quantidade de atraso da sessão. A consulta prossegue quando o cluster de banco de dados está atualizado com todos os dados confirmados do gravador, a partir do momento em que a consulta foi iniciada.

Para receber informações sobre os parâmetros de configuração envolvidos no encaminhamento de gravação, consulte [Parâmetros de configuração para o encaminhamento de gravação](aurora-mysql-write-forwarding.md#aurora-mysql-write-forwarding-params).

**nota**  
Você também pode usar `aurora_replica_read_consistency` como uma variável de sessão; por exemplo:  

```
mysql> set aurora_replica_read_consistency = 'session';
```

## Exemplos de uso do encaminhamento de gravação
<a name="aurora-mysql-write-forwarding-examples"></a>

O exemplo a seguir mostra os efeitos do parâmetro `aurora_replica_read_consistency` na execução de instruções `INSERT` seguidas por declarações `SELECT`. Os resultados podem diferir dependendo do valor de `aurora_replica_read_consistency` e do horário das declarações.

Para obter maior consistência, você pode esperar brevemente antes de emitir a instrução `SELECT`. Ou Aurora pode esperar automaticamente até que os resultados terminem a replicação antes de prosseguir `SELECT`.

Para receber informações sobre como definir parâmetros de banco de dados, consulte [Grupos de parâmetros para Amazon Aurora](USER_WorkingWithParamGroups.md).

**Example com `aurora_replica_read_consistency` definido como `EVENTUAL`**  
A execução de uma declaração `INSERT`, seguida imediatamente de uma declaração `SELECT`, retorna um valor para `COUNT(*)` com o número de linhas antes de a nova linha ser inserida. Executar `SELECT` novamente, pouco tempo depois, retornará a contagem de linhas atualizada. As declarações `SELECT` não aguardam.  

```
mysql> select count(*) from t1;
+----------+
| count(*) |
+----------+
|        5 |
+----------+
1 row in set (0.00 sec)

mysql> insert into t1 values (6); select count(*) from t1;
+----------+
| count(*) |
+----------+
|        5 |
+----------+
1 row in set (0.00 sec)

mysql> select count(*) from t1;
+----------+
| count(*) |
+----------+
|        6 |
+----------+
1 row in set (0.00 sec)
```

**Example com `aurora_replica_read_consistency` definido como `SESSION`**  
Uma declaração `SELECT` imediatamente após `INSERT` aguarda até que as alterações da declaração `INSERT` fiquem visíveis. Declarações `SELECT` subsequentes não aguardam.  

```
mysql> select count(*) from t1;
+----------+
| count(*) |
+----------+
|        6 |
+----------+
1 row in set (0.01 sec)

mysql> insert into t1 values (6); select count(*) from t1; select count(*) from t1;
Query OK, 1 row affected (0.08 sec)
+----------+
| count(*) |
+----------+
|        7 |
+----------+
1 row in set (0.37 sec)
+----------+
| count(*) |
+----------+
|        7 |
+----------+
1 row in set (0.00 sec)
```
Com a configuração de consistência de leitura ainda definida como `SESSION`, a introdução de uma breve espera após a execução de uma instrução `INSERT` torna a contagem de linhas atualizada disponível no momento em que a próxima instrução `SELECT` é executada.  

```
mysql> insert into t1 values (6); select sleep(2); select count(*) from t1;
Query OK, 1 row affected (0.07 sec)
+----------+
| sleep(2) |
+----------+
|        0 |
+----------+
1 row in set (2.01 sec)
+----------+
| count(*) |
+----------+
|        8 |
+----------+
1 row in set (0.00 sec)
```

**Example com `aurora_replica_read_consistency` definido como `GLOBAL`**  
Antes de executar a consulta, cada declaração `SELECT` aguarda que todas as alterações de dados desde a hora de início da declaração fiquem visíveis. O tempo de espera para cada declaração `SELECT` varia, dependendo da quantidade de atraso na replicação.  

```
mysql> select count(*) from t1;
+----------+
| count(*) |
+----------+
|        8 |
+----------+
1 row in set (0.75 sec)

mysql> select count(*) from t1;
+----------+
| count(*) |
+----------+
|        8 |
+----------+
1 row in set (0.37 sec)

mysql> select count(*) from t1;
+----------+
| count(*) |
+----------+
|        8 |
+----------+
1 row in set (0.66 sec)
```