Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Konsistensi baca untuk penerusan tulis
<a name="aurora-mysql-write-forwarding-consistency"></a>

Anda dapat mengontrol tingkat konsistensi baca di klaster DB. Tingkat konsistensi baca menentukan berapa lama klaster DB menunggu sebelum operasi baca untuk memastikan beberapa atau semua perubahan direplikasi dari penulis. Anda dapat menyesuaikan tingkat konsistensi baca untuk memastikan bahwa semua operasi tulis yang diteruskan dari sesi Anda terlihat dalam klaster DB sebelum kueri berikutnya. Anda juga dapat menggunakan pengaturan ini untuk memastikan kueri pada klaster DB selalu melihat pembaruan terkini dari penulis. Pengaturan ini juga berlaku untuk kueri yang dikirimkan oleh sesi lain atau klaster lainnya. Untuk menentukan jenis perilaku ini untuk aplikasi Anda, pilih nilai untuk parameter DB `aurora_replica_read_consistency` atau parameter klaster DB.

**penting**  
Selalu atur parameter DB `aurora_replica_read_consistency` atau parameter klaster DB saat Anda ingin meneruskan penulisan. Jika Anda tidak mengaturnya, Aurora tidak akan meneruskan penulisan. Parameter ini mempunyai nilai kosong secara default, jadi pilih nilai tertentu apabila Anda menggunakan parameter ini. Parameter `aurora_replica_read_consistency` hanya memengaruhi klaster atau instans DB yang mengaktifkan penerusan tulis.

Saat Anda meningkatkan tingkat konsistensi, aplikasi Anda menghabiskan lebih banyak waktu untuk menunggu perubahan disebarkan di antara instans-instans DB. Anda dapat memilih keseimbangan antara waktu respons yang cepat dan memastikan bahwa perubahan yang dilakukan dalam instans DB lainnya sepenuhnya tersedia sebelum kueri Anda berjalan.

Anda dapat menentukan nilai berikut untuk parameter `aurora_replica_read_consistency`:
+ `EVENTUAL` – Hasil operasi tulis dalam sesi yang sama tidak terlihat sampai operasi tulis dilakukan pada instans DB penulis. Kueri tidak menunggu hasil yang diperbarui untuk tersedia. Dengan demikian, kueri dapat mengambil data yang lebih lama atau data yang diperbarui, bergantung pada waktu pernyataan dan jumlah lag replikasi. Ini adalah konsistensi yang sama seperti untuk cluster Aurora My SQL DB yang tidak menggunakan penerusan tulis.
+ `SESSION` – Semua kueri yang menggunakan penerusan tulis melihat hasil semua perubahan yang dilakukan dalam sesi tersebut. Perubahan dapat dilihat terlepas dari apakah transaksi dilakukan. Jika perlu, kueri menunggu hasil operasi tulis yang diteruskan untuk direplikasi.
+ `GLOBAL` – Sebuah sesi melihat semua perubahan yang dilakukan di semua sesi dan instans di dalam klaster DB. Setiap kueri mungkin akan menunggu selama periode yang berbeda-beda tergantung jumlah lag sesi. Kueri berlanjut ketika cluster DB up-to-date dengan semua data yang dikomit dari penulis, pada saat kueri dimulai.

Untuk informasi tentang parameter konfigurasi yang terlibat dalam penerusan tulis, lihat [Parameter konfigurasi untuk penerusan tulis](aurora-mysql-write-forwarding.md#aurora-mysql-write-forwarding-params).

**catatan**  
Anda juga dapat menggunakan `aurora_replica_read_consistency` sebagai variabel sesi, misalnya:  

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

## Contoh menggunakan penerusan tulis
<a name="aurora-mysql-write-forwarding-examples"></a>

Contoh berikut ini menunjukkan efek parameter `aurora_replica_read_consistency` pada pernyataan `INSERT` yang berjalan diikuti oleh pernyataan `SELECT`. Hasilnya dapat berbeda, tergantung nilai `aurora_replica_read_consistency` dan waktu pernyataan.

Untuk mencapai konsistensi yang lebih tinggi, Anda mungkin menunggu sebentar sebelum mengeluarkan pernyataan `SELECT`. Atau Aurora dapat secara otomatis menunggu sampai hasil selesai mereplikasi sebelum melanjutkan dengan `SELECT`.

Untuk informasi tentang cara menetapkan parameter DB, lihat [](USER_WorkingWithParamGroups.md).

**Example dengan `aurora_replica_read_consistency` diatur ke `EVENTUAL`**  
Menjalankan pernyataan `INSERT`, yang langsung diikuti dengan pernyataan `SELECT`, memunculkan nilai untuk `COUNT(*)` dengan jumlah baris sebelum baris baru disisipkan. Dengan menjalankan `SELECT` lagi beberapa saat kemudian, muncul hitungan baris yang diperbarui. Pernyataan `SELECT` tidak menunggu.  

```
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 dengan `aurora_replica_read_consistency` diatur ke `SESSION`**  
Pernyataan `SELECT` langsung setelah `INSERT` akan menunggu sampai perubahan dari pernyataan `INSERT` terlihat. Pernyataan `SELECT` selanjutnya tidak menunggu.  

```
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)
```
Dengan pengaturan konsistensi baca tetap disetel ke `SESSION`, memperkenalkan waktu tunggu singkat setelah melaksanakan pernyataan `INSERT` membuat hitungan baris yang diperbarui tersedia pada saat pernyataan `SELECT` berikutnya berjalan.  

```
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 dengan `aurora_replica_read_consistency` diatur ke `GLOBAL`**  
Setiap pernyataan `SELECT` menunggu sampai semua perubahan data, sejak waktu mulai pernyataan, terlihat sebelum melakukan kueri. Waktu tunggu untuk setiap pernyataan `SELECT` bervariasi, tergantung jumlah lag replikasi.  

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