Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Menggunakan pglogical untuk menyinkronkan data di seluruh instans Semua versi RDS for PostgreSQL yang tersedia saat ini mendukung ekstensi `pglogical`. Ekstensi pglogical mendahului fitur replikasi logis yang mirip secara fungsional yang diperkenalkan oleh PostgreSQL di versi 10. Untuk informasi selengkapnya, lihat [Melakukan replikasi logis untuk Amazon RDS for PostgreSQL](PostgreSQL.Concepts.General.FeatureSupport.LogicalReplication.md). Ekstensi `pglogical` ini mendukung replikasi logis antara dua atau lebih. Instans DB RDS for PostgreSQL. Ini juga mendukung replikasi antara versi PostgreSQL yang berbeda, dan antara basis data yang berjalan pada instans DB RDS for PostgreSQL dan klaster DB Aurora PostgreSQL. Ekstensi `pglogical` menggunakan model terbitkan-dan-langganan untuk mereplikasi perubahan pada tabel dan objek lain, seperti urutan, dari penerbit ke pelanggan. Itu bergantung pada slot replikasi untuk memastikan bahwa perubahan disinkronkan dari simpul penerbit ke simpul pelanggan, didefinisikan sebagai berikut. + *Simpul penerbit* adalah instans DB RDS for PostgreSQL yang merupakan sumber data yang akan direplikasi ke simpul lain. Simpul penerbit mendefinisikan tabel yang akan direplikasi dalam set publikasi. + *Simpul pelanggan* adalah instans DB RDS for PostgreSQL yang menerima pembaruan WAL dari penerbit. Pelanggan membuat langganan untuk menghubungkan ke penerbit dan mendapatkan data WAL yang dikodekan. Saat pelanggan membuat langganan, slot replikasi dibuat pada simpul penerbit. Berikut ini, Anda dapat menemukan informasi tentang cara mengatur ekstensi `pglogical`. **Topics** + [Persyaratan dan batasan untuk ekstensi pglogical](#Appendix.PostgreSQL.CommonDBATasks.pglogical.requirements-limitations) + [Menyiapkan ekstensi pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md) + [Menyiapkan replikasi logis untuk instans DB RDS for PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.pglogical.setup-replication.md) + [Membangun kembali replikasi logis setelah peningkatan besar](Appendix.PostgreSQL.CommonDBATasks.pglogical.recover-replication-after-upgrade.md) + [Mengelola slot replikasi logis untuk untuk PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.pglogical.handle-slots.md) + [Referensi parameter untuk ekstensi pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.reference.md) ## Persyaratan dan batasan untuk ekstensi pglogical Semua rilis RDS for PostgreSQL yang tersedia saat ini mendukung ekstensi `pglogical`. Baik simpul penerbit maupun simpul pelanggan harus disiapkan untuk replikasi logis. Tabel yang ingin Anda replikasi dari penerbit ke pelanggan harus memiliki nama dan skema yang sama. Tabel ini juga harus berisi kolom yang sama, dan kolom harus menggunakan jenis data yang sama. Tabel penerbit dan pelanggan harus memiliki kunci primer yang sama. Sebaiknya Anda hanya menggunakan PRIMARY KEY sebagai batasan unik. Tabel pada simpul pelanggan dapat memiliki batasan yang lebih permisif dibandingkan yang ada di simpul penerbit untuk batasan CHECK dan NOT NULL. Ekstensi `pglogical` ini menyediakan fitur seperti replikasi dua arah yang tidak didukung oleh fitur replikasi logis default PostgreSQL (versi 10 dan lebih tinggi). Untuk informasi selengkapnya, lihat [replikasi bi-direksional PostgreSQL menggunakan pglogical](https://aws.amazon.com/blogs/database/postgresql-bi-directional-replication-using-pglogical/). # Menyiapkan ekstensi pglogical Untuk menyiapkan ekstensi `pglogical` pada instans DB RDS for PostgreSQL , tambahkan `pglogical` ke pustaka bersama pada grup parameter DB kustom untuk instans DB RDS for PostgreSQL. Anda juga perlu mengatur nilai parameter `rds.logical_replication` ke `1`, untuk mengaktifkan penguraian kode logis. Terakhir, Anda membuat ekstensi di basis data. Anda dapat menggunakan Konsol Manajemen AWS atau AWS CLI untuk tugas-tugas ini. Anda harus memiliki izin sebagai peran `rds_superuser` untuk melakukan semua tugas ini. Langkah-langkah berikut mengasumsikan bahwa instans DB RDS for PostgreSQL Anda terhubung dengan grup parameter klaster DB kustom. Untuk informasi cara membuat grup parameter DB kustom, lihat [Grup parameter untuk RDS](USER_WorkingWithParamGroups.md). ## Konsol **Menyiapkan ekstensi pglogical** 1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/). 1. Di panel navigasi, pilih instans DB RDS for PostgreSQL. 1. Buka tab **Konfigurasi** untuk Instans DB RDS for PostgreSQL. Di antara detail Instans, temukan tautan **Grup parameter**. 1. Pilih tautan untuk membuka parameter kustom yang terkait dengan Anda. Instans DB RDS for PostgreSQL. 1. Di kolom pencarian **Parameter**, ketik `shared_pre` untuk menemukan parameter `shared_preload_libraries`. 1. Pilih **Edit parameter** untuk mengakses nilai properti. 1. Tambahkan `pglogical` ke daftar di kolom **Nilai**. Gunakan koma untuk memisahkan item dalam daftar nilai. ![\[Gambar parameter shared_preload_libraries dengan pglogical yang ditambahkan.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/images/apg_rpg_shared_preload_pglogical.png) 1. Temukan parameter `rds.logical_replication` dan atur ke `1`, untuk mengaktifkan replikasi logis. 1. Boot ulang instans DB RDS for PostgreSQL DB Anda agar perubahan Anda diterapkan. 1. Saat instans tersedia, Anda dapat menggunakan `psql` (atau pgAdmin) untuk terhubung ke instans DB RDS for PostgreSQL. ``` psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` 1. Untuk memverifikasi bahwa pglogical telah diinisialisasi, jalankan perintah berikut. ``` SHOW shared_preload_libraries; shared_preload_libraries -------------------------- rdsutils,pglogical (1 row) ``` 1. Verifikasikan pengaturan yang memungkinkan penguraian kode logis, sebagai berikut. ``` SHOW wal_level; wal_level ----------- logical (1 row) ``` 1. Buat ekstensi, sebagai berikut. ``` CREATE EXTENSION pglogical; EXTENSION CREATED ``` 1. Pilih **Simpan perubahan**. 1. Buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/). 1. Pilih instans DB RDS for PostgreSQL dari daftar Basis Data untuk memilihnya, lalu pilih **Boot ulang** dari menu Tindakan. ## AWS CLI **Menyiapkan ekstensi pglogical** Untuk mengatur pglogical menggunakan AWS CLI, Anda memanggil [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html)operasi untuk memodifikasi parameter tertentu dalam grup parameter kustom Anda seperti yang ditunjukkan dalam prosedur berikut. 1. Gunakan AWS CLI perintah berikut `pglogical` untuk menambah `shared_preload_libraries` parameter. ``` aws rds modify-db-parameter-group \ --db-parameter-group-name custom-param-group-name \ --parameters "ParameterName=shared_preload_libraries,ParameterValue=pglogical,ApplyMethod=pending-reboot" \ --region aws-region ``` 1. Gunakan AWS CLI perintah berikut untuk mengatur `rds.logical_replication` `1` untuk mengaktifkan kemampuan decoding logis untuk . Instans DB RDS for PostgreSQL. ``` aws rds modify-db-parameter-group \ --db-parameter-group-name custom-param-group-name \ --parameters "ParameterName=rds.logical_replication,ParameterValue=1,ApplyMethod=pending-reboot" \ --region aws-region ``` 1. Gunakan AWS CLI perintah berikut untuk me-reboot sehingga pustaka pglogical diinisialisasi. ``` aws rds reboot-db-instance \ --db-instance-identifier your-instance \ --region aws-region ``` 1. Saat instans tersedia, gunakan `psql` untuk terhubung ke instans DB RDS for PostgreSQL. ``` psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` 1. Buat ekstensi, sebagai berikut. ``` CREATE EXTENSION pglogical; EXTENSION CREATED ``` 1. Reboot menggunakan perintah berikut. AWS CLI ``` aws rds reboot-db-instance \ --db-instance-identifier your-instance \ --region aws-region ``` # Menyiapkan replikasi logis untuk instans DB RDS for PostgreSQL Prosedur berikut menunjukkan cara memulai replikasi logis di antara dua instans DB RDS for PostgreSQL. Langkah-langkah mengasumsikan bahwa sumber (penerbit) dan target (pelanggan) memiliki ekstensi `pglogical` yang disiapkan seperti yang dijelaskan dalam [Menyiapkan ekstensi pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md). **catatan** `node_name`Node pelanggan tidak dapat memulai dengan`rds`. **Untuk membuat simpul penerbit dan menentukan tabel untuk direplikasi** Langkah-langkah ini mengasumsikan bahwa instans DB RDS for PostgreSQL memiliki basis data yang memiliki satu atau beberapa tabel yang ingin direplikasi ke simpul lain. Anda perlu membuat ulang struktur tabel dari penerbit pada pelanggan, jadi pertama-tama, dapatkan struktur tabel jika perlu. Anda dapat melakukannya dengan menggunakan `psql` metacommand `\d tablename`, lalu membuat tabel yang sama pada instans pelanggan. Prosedur berikut membuat tabel contoh pada penerbit (sumber) untuk tujuan demonstrasi. 1. Gunakan `psql` untuk terhubung ke instans yang memiliki tabel yang ingin Anda gunakan sebagai sumber untuk pelanggan. ``` psql --host=source-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` Jika tidak memiliki tabel yang ingin ditiru, Anda dapat membuat tabel contoh sebagai berikut. 1. Buat contoh tabel menggunakan pernyataan SQL berikut. ``` CREATE TABLE docs_lab_table (a int PRIMARY KEY); ``` 1. Mengisi tabel dengan data yang dihasilkan menggunakan pernyataan SQL berikut. ``` INSERT INTO docs_lab_table VALUES (generate_series(1,5000)); INSERT 0 5000 ``` 1. Verifikasikan bahwa data ada dalam tabel menggunakan pernyataan SQL berikut. ``` SELECT count(*) FROM docs_lab_table; ``` 1. Identifikasi instans DB RDS for PostgreSQL ini sebagai simpul penerbit, sebagai berikut. ``` SELECT pglogical.create_node( node_name := 'docs_lab_provider', dsn := 'host=source-instance.aws-region.rds.amazonaws.com port=5432 dbname=labdb'); create_node ------------- 3410995529 (1 row) ``` 1. Tambahkan tabel yang ingin Anda replikasi ke set replikasi default. Untuk informasi set replikasi selengkapnya, lihat [Replication sets](https://github.com/2ndQuadrant/pglogical/tree/REL2_x_STABLE/docs#replication-sets) dalam dokumentasi pglogical. ``` SELECT pglogical.replication_set_add_table('default', 'docs_lab_table', 'true', NULL, NULL); replication_set_add_table --------------------------- t (1 row) ``` Penyiapan simpul penerbit selesai. Anda sekarang dapat menyiapkan simpul pelanggan untuk menerima informasi terkini dari penerbit. **Untuk menyiapkan simpul pelanggan dan membuat langganan untuk menerima informasi terkini** Langkah-langkah ini mengasumsikan bahwa instans DB RDS for PostgreSQL telah disiapkan dengan ekstensi `pglogical`. Untuk informasi selengkapnya, lihat [Menyiapkan ekstensi pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md). 1. Gunakan `psql` untuk terhubung ke instans yang ingin Anda terima informasi terkini dari penerbit. ``` psql --host=target-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` 1. Pada pelanggan instans DB RDS for PostgreSQL, buat tabel yang sama yang ada pada penerbit. Untuk contoh ini, tabelnya adalah `docs_lab_table`. Anda dapat membuat tabel sebagai berikut. ``` CREATE TABLE docs_lab_table (a int PRIMARY KEY); ``` 1. Verifikasi bahwa tabel ini kosong. ``` SELECT count(*) FROM docs_lab_table; count ------- 0 (1 row) ``` 1. Identifikasi instans DB RDS for PostgreSQL ini sebagai simpul pelanggan, sebagai berikut. ``` SELECT pglogical.create_node( node_name := 'docs_lab_target', dsn := 'host=target-instance.aws-region.rds.amazonaws.com port=5432 sslmode=require dbname=labdb user=postgres password=********'); create_node ------------- 2182738256 (1 row) ``` 1. Buat langganan. ``` SELECT pglogical.create_subscription( subscription_name := 'docs_lab_subscription', provider_dsn := 'host=source-instance.aws-region.rds.amazonaws.com port=5432 sslmode=require dbname=labdb user=postgres password=*******', replication_sets := ARRAY['default'], synchronize_data := true, forward_origins := '{}' ); create_subscription --------------------- 1038357190 (1 row) ``` Saat Anda menyelesaikan langkah ini, data dari tabel pada penerbit akan dibuat dalam tabel pada pelanggan. Anda dapat memverifikasi bahwa tabel telah dibuat menggunakan query SQL berikut. ``` SELECT count(*) FROM docs_lab_table; count ------- 5000 (1 row) ``` Mulai dari titik ini, perubahan yang dilakukan pada tabel pada penerbit direplikasi ke tabel pada pelanggan. # Membangun kembali replikasi logis setelah peningkatan besar Sebelum Anda dapat melakukan upgrade versi utama dari untuk instance Postgre SQL DB yang diatur sebagai node penerbit untuk replikasi logis, Anda harus menghapus semua slot replikasi, bahkan yang tidak aktif. Kami menyarankan Anda mengalihkan sementara transaksi database dari node penerbit, menjatuhkan slot replikasi, meningkatkan dan kemudian membangun kembali dan memulai ulang replikasi. Slot replikasi hanya di-hosting di simpul penerbit. Node SQL pelanggan RDS untuk Postgre dalam skenario replikasi logis tidak memiliki slot untuk turun, tetapi tidak dapat ditingkatkan ke versi utama sementara itu ditetapkan sebagai simpul pelanggan dengan berlangganan ke penerbit. Sebelum memutakhirkan node SQL pelanggan RDS untuk Postgre, lepaskan langganan dan node. Untuk informasi selengkapnya, lihat [Mengelola slot replikasi logis untuk untuk PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.pglogical.handle-slots.md). ## Menentukan bahwa replikasi logis telah terganggu Anda dapat menentukan bahwa proses replikasi telah terganggu dengan menanyakan simpul penerbit atau simpul pelanggan, sebagai berikut. **Untuk memeriksa simpul penerbit** + Gunakan `psql` untuk terhubung ke simpul penerbit, lalu buat kueri fungsi `pg_replication_slots`. Perhatikan nilai di kolom aktif. Biasanya, ini akan kembali `t` (benar), menunjukkan bahwa replikasi aktif. Jika kueri kembali `f` (salah), ini merupakan indikasi bahwa replikasi ke pelanggan telah berhenti. ``` SELECT slot_name,plugin,slot_type,active FROM pg_replication_slots; slot_name | plugin | slot_type | active -------------------------------------------+------------------+-----------+-------- pgl_labdb_docs_labcb4fa94_docs_lab3de412c | pglogical_output | logical | f (1 row) ``` **Untuk memeriksa simpul pelanggan** Pada simpul pelanggan, Anda dapat memeriksa status replikasi dengan tiga cara berbeda. + Lihat melalui SQL log Postgre pada node pelanggan untuk menemukan pesan kegagalan. Log dapat mengidentifikasi kegagalan dengan pesan yang menyertakan kode keluar 1, sebagaimana ditunjukkan berikut. ``` 2022-07-06 16:17:03 UTC::@:[7361]:LOG: background worker "pglogical apply 16404:2880255011" (PID 14610) exited with exit code 1 2022-07-06 16:19:44 UTC::@:[7361]:LOG: background worker "pglogical apply 16404:2880255011" (PID 21783) exited with exit code 1 ``` + Buat kueri fungsi `pg_replication_origin`. Hubungkan ke basis data pada simpul pelanggan menggunakan `psql` dan buat kueri fungsi `pg_replication_origin`, sebagai berikut. ``` SELECT * FROM pg_replication_origin; roident | roname ---------+-------- (0 rows) ``` Set hasil kosong berarti replikasi telah terganggu. Biasanya, Anda akan melihat output seperti berikut. ``` roident | roname ---------+---------------------------------------------------- 1 | pgl_labdb_docs_labcb4fa94_docs_lab3de412c (1 row) ``` + Buat kueri fungsi `pglogical.show_subscription_status` sebagaimana ditunjukkan pada contoh berikut. ``` SELECT subscription_name,status,slot_name FROM pglogical.show_subscription_status(); subscription_name | status | slot_name ---====----------------+--------+------------------------------------- docs_lab_subscription | down | pgl_labdb_docs_labcb4fa94_docs_lab3de412c (1 row) ``` Output ini menunjukkan bahwa replikasi telah terganggu. Statusnya adalah `down`. Biasanya, output menunjukkan status sebagai `replicating`. Jika proses replikasi logis terganggu, Anda dapat membangun kembali replikasi dengan mengikuti langkah-langkah berikut. **Untuk membangun kembali replikasi logis antara simpul penerbit dan pelanggan** Untuk membangun kembali replikasi, pertama-tama Anda memutuskan sambungan pelanggan dari simpul penerbit, lalu membangun kembali langganan, seperti yang diuraikan dalam langkah-langkah ini. 1. Hubungkan ke simpul pelanggan menggunakan `psql`, sebagai berikut. ``` psql --host=222222222222.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` 1. Nonaktifkan langganan menggunakan fungsi `pglogical.alter_subscription_disable`. ``` SELECT pglogical.alter_subscription_disable('docs_lab_subscription',true); alter_subscription_disable ---------------------------- t (1 row) ``` 1. Dapatkan identifier simpul penerbit dengan menanyakan `pg_replication_origin`, sebagai berikut. ``` SELECT * FROM pg_replication_origin; roident | roname ---------+------------------------------------- 1 | pgl_labdb_docs_labcb4fa94_docs_lab3de412c (1 row) ``` 1. Gunakan respons dari langkah sebelumnya dengan perintah `pg_replication_origin_create` untuk menetapkan pengenal yang dapat digunakan oleh langganan saat dibuat kembali. ``` SELECT pg_replication_origin_create('pgl_labdb_docs_labcb4fa94_docs_lab3de412c'); pg_replication_origin_create ------------------------------ 1 (1 row) ``` 1. Aktifkan langganan dengan meneruskan namanya menggunakan status `true`, sebagaimana ditunjukkan dalam contoh berikut. ``` SELECT pglogical.alter_subscription_enable('docs_lab_subscription',true); alter_subscription_enable --------------------------- t (1 row) ``` Periksa status simpul. Statusnya harus `replicating` sebagaimana ditunjukkan dalam contoh ini. ``` SELECT subscription_name,status,slot_name FROM pglogical.show_subscription_status(); subscription_name | status | slot_name -------------------------------+-------------+------------------------------------- docs_lab_subscription | replicating | pgl_labdb_docs_lab98f517b_docs_lab3de412c (1 row) ``` Periksa status slot replikasi pelanggan pada simpul penerbit. Kolom `active` slot harus kembali `t` (benar), menunjukkan bahwa replikasi telah dibuat kembali. ``` SELECT slot_name,plugin,slot_type,active FROM pg_replication_slots; slot_name | plugin | slot_type | active -------------------------------------------+------------------+-----------+-------- pgl_labdb_docs_lab98f517b_docs_lab3de412c | pglogical_output | logical | t (1 row) ``` # Mengelola slot replikasi logis untuk untuk PostgreSQL Sebelum dapat melakukan peningkatan versi utama dari instans DB RDS for PostgreSQL yang disiapkan sebagai simpul penerbit untuk replikasi logis, Anda harus menghapus semua slot replikasi, bahkan yang tidak aktif. Proses pra-pemeriksaan peningkatan versi utama akan memberi tahu Anda bahwa peningkatan tidak dapat dilanjutkan sampai slot dihapuskan sementara. Untuk menghapus sementara slot dari instans DB RDS for PostgreSQL Anda, pertama-tama hapus sementara langganan, lalu hapus sementara slotnya. Untuk mengidentifikasi slot replikasi yang dibuat menggunakan ekstensi `pglogical`, masuk ke setiap basis data dan dapatkan nama simpul. Bila membuat kueri simpul pelanggan, Anda akan mendapatkan simpul penerbit dan pelanggan dalam output, sebagaimana ditunjukkan dalam contoh ini. ``` SELECT * FROM pglogical.node; node_id | node_name ------------+------------------- 2182738256 | docs_lab_target 3410995529 | docs_lab_provider (2 rows) ``` Anda dapat memperoleh detail tentang langganan dengan kueri berikut. ``` SELECT sub_name,sub_slot_name,sub_target FROM pglogical.subscription; sub_name | sub_slot_name | sub_target ----------+--------------------------------+------------ docs_lab_subscription | pgl_labdb_docs_labcb4fa94_docs_lab3de412c | 2182738256 (1 row) ``` Anda sekarang dapat menghapus sementara langganan, sebagai berikut. ``` SELECT pglogical.drop_subscription(subscription_name := 'docs_lab_subscription'); drop_subscription ------------------- 1 (1 row) ``` Setelah menghapus sementara langganan, Anda dapat menghapus simpul. ``` SELECT pglogical.drop_node(node_name := 'docs-lab-subscriber'); drop_node ----------- t (1 row) ``` Anda dapat memverifikasi bahwa simpul tidak ada lagi, sebagai berikut. ``` SELECT * FROM pglogical.node; node_id | node_name ---------+----------- (0 rows) ``` # Referensi parameter untuk ekstensi pglogical Dalam tabel, Anda dapat menemukan parameter yang terkait dengan ekstensi `pglogical`. Parameter seperti `pglogical.conflict_log_level` dan `pglogical.conflict_resolution` digunakan untuk menangani konflik pembaruan. Konflik dapat muncul saat perubahan dilakukan secara lokal ke tabel yang sama yang berlangganan terhadap perubahan dari penerbit. Konflik juga dapat terjadi selama berbagai skenario, seperti replikasi dua arah atau saat beberapa pelanggan mereplikasi dari penerbit yang sama. Untuk informasi selengkapnya, lihat [replikasi bi-direksional PostgreSQL menggunakan pglogical](https://aws.amazon.com/blogs/database/postgresql-bi-directional-replication-using-pglogical/). | Parameter | Deskripsi | | --- | --- | | pglogical.batch\$1inserts | Melakukan penyisipan batch jika memungkinkan. Tidak diatur secara default. Ubah ke '1' untuk mengaktifkan, '0' untuk menonaktifkan. | | pglogical.conflict\$1log\$1level | Menetapkan tingkat log yang digunakan untuk mencatat log konflik yang diselesaikan. Nilai string yang didukung adalah debug5, debug4, debug3, debug2, debug1, info, notice, warning, error, log, fatal, panic. | | pglogical.conflict\$1resolution | Menetapkan metode yang digunakan untuk menyelesaikan konflik saat konflik dapat diselesaikan. Nilai string yang didukung adalah kesalahan, apply\$1remote, keep\$1local, last\$1update\$1wins, first\$1update\$1wins. | | pglogical.extra\$1connection\$1options | Opsi koneksi untuk ditambahkan ke semua koneksi simpul peer. | | pglogical.synchronous\$1commit | nilai komit sinkron spesifik pglogical | | pglogical.use\$1spi | Gunakan SPI (antarmuka pemrograman server) alih-alih API tingkat rendah untuk menerapkan perubahan. Atur ke '1' untuk mengaktifkan, '0' untuk menonaktifkan. Untuk informasi SPI selengkapnya, lihat [Server Programming Interface](https://www.postgresql.org/docs/current/spi.html) dalam dokumentasi PostgreSQL. |