# Coherencia de lectura para el reenvío de escritura
<a name="aurora-mysql-write-forwarding-consistency"></a>

Puede controlar cuál es el grado de coherencia de lectura en un clúster de base de datos. El nivel de coherencia de lectura determina cuánto espera el clúster base de datos antes de cada operación de lectura para garantizar que algunos de los cambios o todos los cambios se repliquen desde el escritor. Puede ajustar el nivel de coherencia de lectura para asegurarse de que todas las operaciones de escritura reenviadas desde la sesión estén visibles en el clúster de base de datos antes de cualquier consulta posterior. También puede utilizar esta configuración para asegurarse de que las consultas del clúster de base de datos siempre vean las actualizaciones más recientes del escritor. Esta configuración también se aplica a las consultas enviadas por otras sesiones u otros clústeres. Para especificar este tipo de comportamiento para la aplicación, elija un valor para el parámetro del clúster de base de datos o el parámetro de base de datos `aurora_replica_read_consistency`.

**importante**  
Configure siempre el parámetro del clúster de base de datos o el parámetro de base de datos `aurora_replica_read_consistency` cuando desee utilizar el reenvío de escritura. Si no lo hace, Aurora no reenvía las escrituras. Este parámetro tiene un valor vacío por defecto, por lo que debe elegir un valor específico cuando utilice este parámetro. El parámetro `aurora_replica_read_consistency` solo afecta a los clústeres o instancias de base de datos que tengan habilitado el reenvío de escritura.

A medida que aumenta el nivel de coherencia, la aplicación pasa más tiempo esperando que los cambios se propaguen entre instancias de base de datos. Puede buscar el equilibrio entre un tiempo de respuesta rápido y la garantía de que los cambios realizados en otras instancias de base de datos estén completamente disponibles antes de que se ejecuten las consultas.

Puede especificar los siguientes valores para el parámetro `aurora_replica_read_consistency`:
+ `EVENTUAL`: los resultados de las operaciones de escritura de la misma sesión no están visibles hasta que la operación de escritura se realice en la instancia de base de datos del escritor. La consulta no espera a que los resultados actualizados estén disponibles. Por lo tanto, podría recuperar los datos antiguos o los datos actualizados, en función del momento de las instrucciones y la cantidad de retraso de replicación. Se trata de la misma coherencia que en los clústeres de bases de datos de Aurora MySQL que no utilizan el reenvío de escritura.
+ `SESSION`: todas las consultas que utilizan el reenvío de escritura ven los resultados de todos los cambios realizados en esa sesión. Los cambios son visibles independientemente de si la transacción está confirmada. Si es necesario, la consulta espera a que se repliquen los resultados de las operaciones de escritura reenviadas.
+ `GLOBAL`: una sesión ve todos los cambios confirmados en todas las sesiones e instancias del clúster de base de datos. Cada consulta puede esperar un tiempo, que variará en función de la cantidad de retardo de la sesión. La consulta continúa cuando el clúster de base de datos está actualizado con todos los datos confirmados del escritor, a partir del momento en que comenzó la consulta.

Para obtener información sobre los parámetros de configuración relacionados con el reenvío de escritura, consulte [Parámetros de configuración para el reenvío de escritura](aurora-mysql-write-forwarding.md#aurora-mysql-write-forwarding-params).

**nota**  
También puede usar `aurora_replica_read_consistency` como una variable de sesión, por ejemplo:  

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

## Ejemplos de uso del reenvío de escritura
<a name="aurora-mysql-write-forwarding-examples"></a>

El siguiente ejemplo muestra los efectos del parámetro `aurora_replica_read_consistency` en la ejecución de instrucciones `INSERT` seguidas de instrucciones `SELECT`. Los resultados pueden diferir según el valor de `aurora_replica_read_consistency` y el momento en que se produzcan las instrucciones.

Para lograr una mayor coherencia, puede esperar brevemente antes de emitir la instrucción `SELECT`. O Aurora puede esperar automáticamente hasta que los resultados terminen de replicarse antes de continuar con `SELECT`.

Para obtener información sobre la configuración de parámetros de base de datos, consulte [Grupos de parámetros para Amazon Aurora](USER_WorkingWithParamGroups.md).

**Example con `aurora_replica_read_consistency` establecido en `EVENTUAL`**  
Ejecutar una instrucción `INSERT`, seguida inmediatamente de una instrucción `SELECT`, devuelve un valor para `COUNT(*)` con el número de filas antes de insertar la nueva fila. Al ejecutar `SELECT` de nuevo poco tiempo después se devuelve el recuento de filas actualizado. Las instrucciones `SELECT` no esperan.  

```
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 con `aurora_replica_read_consistency` establecido en `SESSION`**  
Una instrucción `SELECT` inmediatamente después de una instrucción `INSERT` espera hasta que los cambios de la instrucción `INSERT` sean visibles. Las instrucciones `SELECT` posteriores no esperan.  

```
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)
```
Con la configuración de coherencia de lectura todavía establecida en `SESSION`, al introducir una breve espera después de realizar una instrucción `INSERT`, el recuento de filas actualizado estará disponible para cuando se ejecute la siguiente instrucción `SELECT`.  

```
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 con `aurora_replica_read_consistency` establecido en `GLOBAL`**  
Cada instrucción `SELECT` espera a que todos los cambios de datos que se realicen a partir de la hora de inicio de la instrucción sean visibles antes de realizar la consulta. El tiempo de espera para cada instrucción `SELECT` varía según la cantidad de retraso de replicación.  

```
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)
```