Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Bekerja dengan Ekstensi Bahasa Tepercaya untuk PostgreSQL
Ekstensi Bahasa Tepercaya untuk PostgreSQL adalah kit pengembangan sumber terbuka untuk mendesain ekstensi PostgreSQL. Ini memungkinkan Anda untuk membangun ekstensi PostgreSQL performa tinggi dan menjalankannya dengan aman di instans DB RDS for PostgreSQL. Dengan menggunakan Ekstensi Bahasa Tepercaya (TLE) untuk PostgreSQL, Anda dapat membuat ekstensi PostgreSQL yang mengikuti pendekatan terdokumentasi untuk memperluas fungsionalitas PostgreSQL. Lihat informasi selengkapnya, lihat [Packaging Related Objects into an Extension](https://www.postgresql.org/docs/current/extend-extensions.html) dalam dokumentasi PostgreSQL.
Salah satu manfaat utama TLE adalah Anda dapat menggunakannya di lingkungan yang tidak menyediakan akses ke sistem file yang mendasari instans PostgreSQL. Sebelumnya, penginstalan ekstensi baru memerlukan akses ke sistem file. TLE menghilangkan batasan ini. Ini menyediakan lingkungan pengembangan untuk membuat ekstensi baru untuk basis data PostgreSQL apa pun, termasuk yang berjalan di instans DB RDS for PostgreSQL.
TLE dirancang untuk mencegah akses ke sumber daya yang tidak aman untuk ekstensi yang Anda buat menggunakan TLE. Lingkungan runtime-nya membatasi dampak kerusakan ekstensi apa pun ke koneksi basis data tunggal. TLE juga memberi administrator basis data kontrol terperinci atas siapa saja yang dapat menginstal ekstensi, dan memberikan model izin untuk menjalankannya.
TLE didukung pada versi RDS for PostgreSQL berikut:
+ Versi 18.1 dan versi 18 yang lebih tinggi
+ Versi 17.1 dan versi 17 yang lebih tinggi
+ Versi 16.1 dan versi 16 yang lebih tinggi
+ Versi 15.2 dan versi 15 yang lebih tinggi
+ Versi 14.5 dan versi 14 yang lebih tinggi
+ Versi 13.12 dan versi 13 yang lebih tinggi
Lingkungan pengembangan dan runtime Ekstensi Bahasa Tepercaya dikemas sebagai ekstensi PostgreSQL `pg_tle`, versi 1.0.1. Ini mendukung pembuatan ekstensi di JavaScript, Perl, Tcl, PL/PGSQL, dan SQL. Anda menginstal ekstensi `pg_tle` di instans RDS for PostgreSQL dengan cara yang sama seperti Anda menginstal ekstensi PostgreSQL lainnya. Setelah `pg_tle` disiapkan, developer dapat menggunakannya untuk membuat ekstensi PostgreSQL baru, yang dikenal sebagai *ekstensi TLE*.
Dalam topik berikut, Anda dapat menemukan informasi tentang cara mengatur Ekstensi Bahasa Tepercaya dan cara memulai membuat ekstensi TLE Anda sendiri.
**Topics**
+ [Terminologi](PostgreSQL_trusted_language_extension-terminology.md)
+ [Persyaratan untuk menggunakan Ekstensi Bahasa Tepercaya untuk PostgreSQL](PostgreSQL_trusted_language_extension-requirements.md)
+ [Menyiapkan Ekstensi Bahasa Tepercaya di SQL](PostgreSQL_trusted_language_extension-setting-up.md)
+ [Ikhtisar Ekstensi Bahasa Tepercaya untuk Postgre SQL](PostgreSQL_trusted_language_extension.overview.md)
+ [Membuat ekstensi TLE untuk RDS for PostgreSQL](PostgreSQL_trusted_language_extension-creating-TLE-extensions.md)
+ [Menjatuhkan TLE ekstensi Anda dari database](PostgreSQL_trusted_language_extension-creating-TLE-extensions.dropping-TLEs.md)
+ [Menghapus Instalasi Ekstensi Bahasa Tepercaya untuk Postgre SQL](PostgreSQL_trusted_language_extension-uninstalling-pg_tle-devkit.md)
+ [Menggunakan hook PostgreSQL dengan ekstensi TLE](PostgreSQL_trusted_language_extension.overview.tles-and-hooks.md)
+ [Menggunakan Tipe Data Kustom di TLE](PostgreSQL_trusted_language_extension-custom-data-type.md)
+ [Referensi fungsi untuk Ekstensi Bahasa Tepercaya untuk Postgre SQL](PostgreSQL_trusted_language_extension-functions-reference.md)
+ [Referensi hook untuk Trusted Language Extensions for PostgreSQL](PostgreSQL_trusted_language_extension-hooks-reference.md)
# Terminologi
Untuk membantu Anda lebih memahami Ekstensi Bahasa Tepercaya, lihat glosarium berikut untuk istilah yang digunakan dalam topik ini.
**Ekstensi Bahasa Tepercaya untuk Postgre SQL**
*Ekstensi Bahasa Tepercaya untuk Postgre SQL* adalah nama resmi kit pengembangan open source yang dikemas sebagai ekstensi. `pg_tle` Ini tersedia untuk digunakan pada sistem Postgre SQL apa pun. Untuk informasi selengkapnya, lihat [aws/pg\$1tle](https://github.com/aws/pg_tle) di. GitHub
**Ekstensi Bahasa Terpercaya**
*Trusted Language Extensions* adalah singkatan dari Trusted Language Extensions for PostgreSQL. Nama singkat ini dan singkatannya (TLE) juga digunakan dalam dokumentasi ini.
**bahasa tepercaya**
*Bahasa tepercaya* adalah bahasa pemrograman atau skrip yang memiliki atribut keamanan tertentu. Misalnya, bahasa tepercaya biasanya membatasi akses ke sistem file, dan membatasi penggunaan properti jaringan tertentu. Kit TLE pengembangan dirancang untuk mendukung bahasa tepercaya. Postgre SQL mendukung beberapa bahasa berbeda yang digunakan untuk membuat ekstensi tepercaya atau tidak tepercaya. Sebagai contoh, lihat [PL/Perl Tepercaya dan Tidak Tepercaya](https://www.postgresql.org/docs/current/plperl-trusted.html) di dokumentasi Postgre. SQL Saat Anda membuat ekstensi menggunakan Ekstensi Bahasa Tepercaya, ekstensi tersebut akan menggunakan mekanisme bahasa tepercaya secara inheren.
**TLEekstensi**
*TLEEkstensi adalah ekstensi* Postgre SQL yang dibuat dengan menggunakan kit pengembangan Trusted Language Extensions (TLE).
# Persyaratan untuk menggunakan Ekstensi Bahasa Tepercaya untuk PostgreSQL
Berikut ini adalah persyaratan untuk menyiapkan dan menggunakan kit pengembangan TLE.
+ ** Versi RDS for PostgreSQL** – Ekstensi Bahasa Tepercaya didukung pada RDS for PostgreSQL versi 13.12 dan versi 13 yang lebih tinggi, 14.5 dan versi 14 yang lebih tinggi, dan 15.2 dan versi yang lebih tinggi saja.
+ Jika Anda perlu meningkatkan instans RDS for PostgreSQL, lihat [Upgrade RDS untuk mesin PostgreSQL DB](USER_UpgradeDBInstance.PostgreSQL.md).
+ Jika belum memiliki instans DB Amazon RDS yang menjalankan PostgreSQL, Anda dapat membuatnya. Untuk informasi selengkapnya, lihat Instans DB RDS for PostgreSQL, lihat [Membuat dan menghubungkan ke instans DB PostgreSQL](CHAP_GettingStarted.CreatingConnecting.PostgreSQL.md).
+ **Memerlukan hak istimewa `rds_superuser`** – Untuk menyiapkan dan mengonfigurasi ekstensi `pg_tle`, peran pengguna basis data Anda harus memiliki izin peran `rds_superuser`. Secara default, peran ini diberikan kepada `postgres` pengguna yang membuat Instans DB RDS for PostgreSQL.
+ **Memerlukan grup parameter DB kustom** - instans DB RDS for PostgreSQL Anda harus dikonfigurasi dengan grup parameter DB kustom.
+ Jika instans DB RDS for PostgreSQL Anda tidak dikonfigurasi dengan grup parameter DB kustom, Anda harus membuatnya dan mengaitkannya dengan instans DB RDS for PostgreSQL Anda. Untuk ringkasan langkah-langkahnya, lihat [Membuat dan menerapkan grup parameter DB kustom](#PostgreSQL_trusted_language_extension-requirements-create-custom-params).
+ Jika instans DB RDS for PostgreSQL Anda sudah dikonfigurasi menggunakan grup parameter DB kustom, Anda dapat menyiapkan Ekstensi Bahasa Tepercaya. Untuk detailnya, lihat [Menyiapkan Ekstensi Bahasa Tepercaya di SQL](PostgreSQL_trusted_language_extension-setting-up.md).
## Membuat dan menerapkan grup parameter DB kustom
Gunakan langkah-langkah berikut untuk membuat grup parameter DB kustom dan mengonfigurasi instans DB RDS for PostgreSQL untuk menggunakannya.
### Konsol
**Untuk membuat grup parameter DB kustom dan menggunakannya dengan**
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. Pilih grup Parameter dari menu Amazon RDS.
1. Pilih **Buat grup parameter**.
1. Di halaman **Detail grup parameter**, masukkan informasi berikut.
+ Untuk **Keluarga grup Parameter**, pilih postgres14.
+ Untuk **Jenis**, pilih Grup Parameter DB.
+ Untuk **Nama grup**, berikan grup parameter Anda nama yang bermakna dalam konteks operasi Anda.
+ Untuk **Deskripsi**, masukkan deskripsi yang berguna sehingga orang lain di tim Anda dapat dengan mudah menemukannya.
1. Pilih **Buat**. Grup parameter DB kustom Anda dibuat di Wilayah AWS. Anda sekarang dapat mengubah instans DB RDS for PostgreSQL untuk menggunakannya dengan mengikuti langkah selanjutnya.
1. Pilih **Basis data** dari menu Amazon RDS.
1. Pilih instans DB RDS for PostgreSQL yang ingin digunakan dengan TLE dari yang tercantum tersebut, lalu pilih **Ubah.**
1. Di halaman Halaman Ubah pengaturan instans DB, cari **Opsi Basis Data** di bagian Konfigurasi tambahan dan pilih grup parameter DB kustom Anda dari pemilih.
1. Pilih **Lanjutkan** untuk menyimpan perubahan.
1. Pilih **Terapkan langsung** sehingga Anda dapat melanjutkan penyiapan instans DB RDS for PostgreSQL untuk menggunakan TLE.
Untuk melanjutkan penyiapan sistem untuk Ekstensi Bahasa Tepercaya, lihat [Menyiapkan Ekstensi Bahasa Tepercaya di SQL](PostgreSQL_trusted_language_extension-setting-up.md).
Untuk informasi selengkapnya tentang cara menggunakan Grup parameter DB, lihat [Grup parameter DB untuk instans Amazon RDS Aurora DB](USER_WorkingWithDBInstanceParamGroups.md).
### AWS CLI
Anda dapat menghindari penentuan argumen `--region` saat menggunakan perintah CLI dengan mengonfigurasi AWS CLI dengan Wilayah AWS default. Untuk informasi selengkapnya, lihat [Dasar-dasar konfigurasi](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) di *Panduan Pengguna AWS Command Line Interface *.
**Untuk membuat grup parameter DB kustom dan menggunakannya dengan**
1. Gunakan [create-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-parameter-group.html) AWS CLI perintah untuk membuat grup parameter DB kustom berdasarkan untuk Anda. Wilayah AWS
Untuk Linux, macOS, atau Unix:
```
aws rds create-db-parameter-group \
--region aws-region \
--db-parameter-group-name custom-params-for-pg-tle \
--db-parameter-group-family postgres14 \
--description "My custom DB parameter group for Trusted Language Extensions"
```
Untuk Windows:
```
aws rds create-db-parameter-group ^
--region aws-region ^
--db-parameter-group-name custom-params-for-pg-tle ^
--db-parameter-group-family postgres14 ^
--description "My custom DB parameter group for Trusted Language Extensions"
```
Grup parameter DB kustom Anda tersedia di Wilayah AWS Anda, sehingga Anda dapat mengubah instans DB RDS for PostgreSQL untuk menggunakannya.
1. Gunakan [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) AWS CLI perintah untuk menerapkan grup parameter DB kustom Anda ke . RDS Anda untuk instance PostgreSQL DB. Perintah ini langsung mem-boot ulang instans yang aktif.
Untuk Linux, macOS, atau Unix:
```
aws rds modify-db-instance \
--region aws-region \
--db-instance-identifier your-instance-name \
--db-parameter-group-name custom-params-for-pg-tle \
--apply-immediately
```
Untuk Windows:
```
aws rds modify-db-instance ^
--region aws-region ^
--db-instance-identifier your-instance-name ^
--db-parameter-group-name custom-params-for-pg-tle ^
--apply-immediately
```
Untuk melanjutkan penyiapan sistem untuk Ekstensi Bahasa Tepercaya, lihat [Menyiapkan Ekstensi Bahasa Tepercaya di SQL](PostgreSQL_trusted_language_extension-setting-up.md).
Untuk informasi selengkapnya, lihat [Grup parameter untuk RDS](USER_WorkingWithParamGroups.md).
# Menyiapkan Ekstensi Bahasa Tepercaya di SQL
Anda dapat menggunakan Konsol Manajemen AWS atau AWS CLI untuk langkah-langkah ini.
Saat menyiapkan Ekstensi Bahasa Tepercaya di untuk instans Postgre SQL DB, Anda menginstalnya di database tertentu untuk digunakan oleh pengguna database yang memiliki izin pada database tersebut.
## Konsol
**Untuk menyiapkan Ekstensi Bahasa Tepercaya**
Lakukan langkah-langkah berikut menggunakan akun yang merupakan anggota grup `rds_superuser` (peran).
1. Masuk ke Konsol Manajemen AWS dan buka RDS konsol Amazon di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Di panel navigasi, pilih instance . SQL
1. Buka tab **Konfigurasi** untuk instance penulis cluster Anda. RDSuntuk contoh Postgre SQL DB. Di antara detail Instans, temukan tautan **Grup parameter**.
1. Pilih tautan untuk membuka parameter khusus yang terkait dengan cluster DB Anda. RDSuntuk contoh Postgre SQL DB.
1. Di kolom pencarian **Parameter**, ketik `shared_pre` untuk menemukan parameter `shared_preload_libraries`.
1. Pilih **Edit parameter** untuk mengakses nilai properti.
1. Tambahkan `pg_tle` ke daftar di kolom **Nilai**. Gunakan koma untuk memisahkan item dalam daftar nilai.
![\[Gambar parameter shared_preload_libraries dengan pg_tle ditambahkan.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/images/apg_rpg_shared_preload_pg_tle.png)
1. Reboot untuk instance Postgre SQL DB sehingga perubahan Anda pada parameter berlaku. `shared_preload_libraries`
1. Ketika instans tersedia, verifikasi bahwa `pg_tle` telah diinisialisasi. Gunakan `psql` untuk terhubung ke dan kemudian jalankan perintah berikut.
```
SHOW shared_preload_libraries;
shared_preload_libraries
--------------------------
rdsutils,pg_tle
(1 row)
```
1. Dengan ekstensi `pg_tle` yang diinisialisasi, Anda kini dapat membuat ekstensi.
```
CREATE EXTENSION pg_tle;
```
Anda dapat memverifikasi bahwa ekstensi diinstal dengan menggunakan metacommand `psql` berikut.
```
labdb=> \dx
List of installed extensions
Name | Version | Schema | Description
---------+---------+------------+--------------------------------------------
pg_tle | 1.0.1 | pgtle | Trusted-Language Extensions for PostgreSQL
plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language
```
1. Berikan `pgtle_admin` peran ke nama pengguna utama yang Anda buat untuk saat Anda SQL mengaturnya. Jika Anda menerima opsi default-nya, berarti nilainya `postgres`.
```
labdb=> GRANT pgtle_admin TO postgres;
GRANT ROLE
```
Anda dapat memverifikasi bahwa pemberian telah terjadi dengan menggunakan metacommand `psql` seperti yang ditunjukkan pada contoh berikut. Hanya peran `pgtle_admin` dan `postgres` yang ditampilkan dalam output. Untuk informasi selengkapnya, lihat [Memahami peran rds\$1superuser](Appendix.PostgreSQL.CommonDBATasks.Roles.rds_superuser.md).
```
labdb=> \du
List of roles
Role name | Attributes | Member of
-----------------+---------------------------------+-----------------------------------
pgtle_admin | Cannot login | {}
postgres | Create role, Create DB +| {rds_superuser,pgtle_admin}
| Password valid until infinity |...
```
1. Tutup sesi `psql` menggunakan metacommand `\q`.
```
\q
```
Untuk mulai membuat TLE ekstensi, lihat[Contoh: Membuat ekstensi bahasa tepercaya menggunakan SQL](PostgreSQL_trusted_language_extension-creating-TLE-extensions.md#PostgreSQL_trusted_language_extension-simple-example).
## AWS CLI
Anda dapat menghindari menentukan `--region` argumen ketika Anda menggunakan CLI perintah dengan mengkonfigurasi AWS CLI dengan default Anda Wilayah AWS. Untuk informasi selengkapnya, lihat [Dasar-dasar konfigurasi](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) di *AWS Command Line Interface Panduan Pengguna*.
**Untuk menyiapkan Ekstensi Bahasa Tepercaya**
1. Gunakan [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html) AWS CLI perintah untuk `pg_tle` 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=pg_tle,ApplyMethod=pending-reboot" \
--region aws-region
```
1. Gunakan [reboot-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/reboot-db-instance) AWS CLI perintah untuk me-reboot dan menginisialisasi SQL perpustakaan. `pg_tle`
```
aws rds reboot-db-instance \
--db-instance-identifier your-instance \
--region aws-region
```
1. Saat instans tersedia, verifikasikan bahwa `pg_tle` telah diinisialisasi. Gunakan `psql` untuk terhubung ke dan kemudian jalankan perintah berikut.
```
SHOW shared_preload_libraries;
shared_preload_libraries
--------------------------
rdsutils,pg_tle
(1 row)
```
Dengan `pg_tle` diinisialisasi, Anda sekarang dapat membuat ekstensi.
```
CREATE EXTENSION pg_tle;
```
1. Berikan `pgtle_admin` peran ke nama pengguna utama yang Anda buat untuk saat Anda SQL mengaturnya. Jika Anda menerima opsi default-nya, berarti nilainya `postgres`.
```
GRANT pgtle_admin TO postgres;
GRANT ROLE
```
1. Tutup sesi `psql` seperti berikut.
```
labdb=> \q
```
Untuk mulai membuat TLE ekstensi, lihat[Contoh: Membuat ekstensi bahasa tepercaya menggunakan SQL](PostgreSQL_trusted_language_extension-creating-TLE-extensions.md#PostgreSQL_trusted_language_extension-simple-example).
# Ikhtisar Ekstensi Bahasa Tepercaya untuk Postgre SQL
Ekstensi Bahasa Tepercaya untuk Postgre SQL adalah ekstensi Postgre yang Anda instal di dengan cara yang sama seperti Anda mengatur SQL ekstensi Postgre SQL lainnya. SQL Pada gambar berikut dari database contoh di alat pgAdmin klien, Anda dapat melihat beberapa komponen yang terdiri dari `pg_tle` ekstensi.
![\[Gambar menunjukkan beberapa komponen yang membentuk kit TLE pengembangan.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/images/apg-pg_tle-installed-view-in-pgAdmin.png)
Anda dapat melihat detail berikut.
1. Kit SQL pengembangan Trusted Language Extensions (TLE) untuk Postgre dikemas sebagai ekstensi. `pg_tle` Dengan demikian, `pg_tle` ditambahkan ke ekstensi yang tersedia untuk basis data tempat kit ini diinstal.
1. TLEmemiliki skema sendiri,`pgtle`. Skema ini berisi fungsi pembantu (3) untuk menginstal dan mengelola ekstensi yang Anda buat.
1. TLEmenyediakan lebih dari selusin fungsi pembantu untuk menginstal, mendaftar, dan mengelola ekstensi Anda. Untuk mempelajari selengkapnya tentang fungsi ini, lihat [Referensi fungsi untuk Ekstensi Bahasa Tepercaya untuk Postgre SQL](PostgreSQL_trusted_language_extension-functions-reference.md).
Komponen lain dari ekstensi `pg_tle` meliputi:
+ **Peran `pgtle_admin`** – Peran `pgtle_admin` dibuat jika ekstensi `pg_tle` diinstal. Peran ini diistimewakan dan harus diperlakukan semestinya. Sebaiknya Anda mengikuti prinsip *hak akses paling rendah* saat memberikan peran `pgtle_admin` kepada pengguna basis data. Dengan kata lain, berikan `pgtle_admin` peran hanya kepada pengguna database yang diizinkan untuk membuat, menginstal, dan mengelola TLE ekstensi baru, seperti`postgres`.
+ **`pgtle.feature_info`Tabel** — `pgtle.feature_info` Tabel adalah tabel yang dilindungi yang berisi informasi tentang AndaTLEs, kait, dan prosedur dan fungsi tersimpan khusus yang mereka gunakan. Jika Anda memiliki hak istimewa `pgtle_admin`, gunakan fungsi Ekstensi Bahasa Tepercaya berikut untuk menambahkan dan memperbarui informasi tersebut dalam tabel.
+ [pgtle.register\$1feature](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.register_feature)
+ [pgtle.register\$1feature\$1if\$1not\$1exists](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.register_feature_if_not_exists)
+ [pgtle.unregister\$1feature](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.unregister_feature)
+ [pgtle.unregister\$1feature\$1if\$1exists](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.unregister_feature_if_exists)
# Membuat ekstensi TLE untuk RDS for PostgreSQL
Anda dapat menginstal ekstensi apa pun yang Anda buat dengan TLE di setiap instans DB RDS for PostgreSQL yang ekstensi `pg_tle`-nya telah diinstal. Ekstensi `pg_tle` dicakup ke basis data PostgreSQL tempat ekstensi diinstal. Ekstensi yang Anda buat menggunakan TLE dicakup ke basis data yang sama.
Gunakan berbagai fungsi `pgtle` untuk menginstal kode yang membentuk ekstensi TLE Anda. Semua fungsi Ekstensi Bahasa Tepercaya berikut memerlukan peran `pgtle_admin`.
+ [pgtle.install\$1extension](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.install_extension)
+ [pgtle.install\$1update\$1path](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.install_update_path)
+ [pgtle.register\$1feature](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.register_feature)
+ [pgtle.register\$1feature\$1if\$1not\$1exists](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.register_feature_if_not_exists)
+ [pgtle.set\$1default\$1version](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.set_default_version)
+ [pgtle.uninstall\$1extension(nama)](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.uninstall_extension-name)
+ [pgtle.uninstall\$1extension (nama, versi)](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.uninstall_extension-name-version)
+ [pgtle.uninstall\$1extension\$1if\$1exists](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.uninstall_extension_if_exists)
+ [pgtle.uninstall\$1update\$1path](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.uninstall_update_path)
+ [pgtle.uninstall\$1update\$1path\$1if\$1exists](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.uninstall_update_path_if_exists)
+ [pgtle.unregister\$1feature](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.unregister_feature)
+ [pgtle.unregister\$1feature\$1if\$1exists](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.unregister_feature_if_exists)
## Contoh: Membuat ekstensi bahasa tepercaya menggunakan SQL
Contoh berikut menunjukkan cara membuat ekstensi TLE bernama `pg_distance` yang berisi beberapa fungsi SQL untuk menghitung jarak menggunakan berbagai formula. Dalam daftar, Anda dapat menemukan fungsi untuk menghitung jarak Manhattan dan fungsi untuk menghitung jarak Euclidean. Untuk informasi selengkapnya tentang perbedaan antara formula ini, lihat [Geometri taksi](https://en.wikipedia.org/wiki/Taxicab_geometry) dan [Geometri Euclidean](https://en.wikipedia.org/wiki/Euclidean_geometry) di Wikipedia.
Anda dapat menggunakan contoh ini di instans DB RDS for PostgreSQL Anda sendiri jika Anda memiliki ekstensi `pg_tle` yang diatur seperti yang dijelaskan [Menyiapkan Ekstensi Bahasa Tepercaya di SQL](PostgreSQL_trusted_language_extension-setting-up.md).
**catatan**
Untuk mengikuti prosedur ini, Anda harus memiliki hak istimewa peran `pgtle_admin`.
**Untuk membuat contoh ekstensi TLE**
Langkah-langkah berikut menggunakan contoh basis data bernama `labdb`. Basis data ini milik pengguna utama `postgres`. Peran `postgres` juga memiliki izin peran `pgtle_admin`.
1. Gunakan `psql` untuk terhubung ke . Instans DB RDS for PostgreSQL.
```
psql --host=db-instance-123456789012.aws-region.rds.amazonaws.com
--port=5432 --username=postgres --password --dbname=labdb
```
1. Buat ekstensi TLE bernama `pg_distance` dengan menyalin kode berikut dan menempelkannya ke konsol sesi `psql` Anda.
```
SELECT pgtle.install_extension
(
'pg_distance',
'0.1',
'Distance functions for two points',
$_pg_tle_$
CREATE FUNCTION dist(x1 float8, y1 float8, x2 float8, y2 float8, norm int)
RETURNS float8
AS $$
SELECT (abs(x2 - x1) ^ norm + abs(y2 - y1) ^ norm) ^ (1::float8 / norm);
$$ LANGUAGE SQL;
CREATE FUNCTION manhattan_dist(x1 float8, y1 float8, x2 float8, y2 float8)
RETURNS float8
AS $$
SELECT dist(x1, y1, x2, y2, 1);
$$ LANGUAGE SQL;
CREATE FUNCTION euclidean_dist(x1 float8, y1 float8, x2 float8, y2 float8)
RETURNS float8
AS $$
SELECT dist(x1, y1, x2, y2, 2);
$$ LANGUAGE SQL;
$_pg_tle_$
);
```
Anda akan melihat output seperti berikut.
```
install_extension
---------------
t
(1 row)
```
Artefak yang membentuk ekstensi `pg_distance` sekarang diinstal di basis data Anda. Artefak ini mencakup file kontrol dan kode untuk ekstensi, yang merupakan item yang harus ada sehingga ekstensi dapat dibuat menggunakan perintah `CREATE EXTENSION`. Dengan kata lain, Anda masih perlu membuat ekstensi agar fungsinya tersedia bagi pengguna basis data.
1. Untuk membuat ekstensi, gunakan perintah `CREATE EXTENSION` seperti yang Anda lakukan untuk ekstensi lainnya. Seperti ekstensi lainnya, pengguna basis data harus memiliki izin `CREATE` dalam basis data.
```
CREATE EXTENSION pg_distance;
```
1. Untuk menguji ekstensi TLE `pg_distance`, Anda dapat menggunakannya untuk menghitung [Jarak Manhattan](https://en.wikipedia.org/wiki/Taxicab_geometry) antara empat titik.
```
labdb=> SELECT manhattan_dist(1, 1, 5, 5);
8
```
Untuk menghitung [Jarak Euclidean](https://en.wikipedia.org/wiki/Euclidean_geometry) antara kumpulan titik yang sama, Anda dapat menggunakan berikut.
```
labdb=> SELECT euclidean_dist(1, 1, 5, 5);
5.656854249492381
```
Ekstensi `pg_distance` memuat fungsi dalam basis data dan membuatnya tersedia bagi setiap pengguna dengan izin pada basis data.
## Mengubah ekstensi TLE
Untuk meningkatkan performa kueri untuk fungsi yang dikemas dalam ekstensi TLE ini, tambahkan dua atribut PostgreSQL berikut ke spesifikasinya.
+ `IMMUTABLE` – Atribut `IMMUTABLE` memastikan bahwa pengoptimal kueri dapat menggunakan pengoptimalan untuk meningkatkan waktu respons kueri. Untuk informasi selengkapnya, lihat [Function Volatility Categories](https://www.postgresql.org/docs/current/xfunc-volatility.html) dalam dokumentasi PostgreSQL.
+ `PARALLEL SAFE` – Atribut `PARALLEL SAFE` adalah atribut lain yang memungkinkan PostgreSQL menjalankan fungsi dalam mode paralel. Untuk informasi selengkapnya, lihat [CREATE FUNCTION](https://www.postgresql.org/docs/current/sql-createfunction.html) dalam dokumentasi PostgreSQL.
Dalam contoh berikut, Anda dapat melihat bagaimana fungsi `pgtle.install_update_path` digunakan untuk menambahkan atribut ini ke setiap fungsi guna membuat ekstensi TLE `pg_distance` versi `0.2`. Untuk informasi selengkapnya tentang fungsi ini, lihat [pgtle.install\$1update\$1path](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.install_update_path). Anda harus memiliki peran `pgtle_admin` untuk melakukan tugas ini.
**Untuk memperbarui ekstensi TLE yang ada dan menentukan versi default**
1. Hubungkan ke instans DB RDS for PostgreSQL Anda menggunakan `psql` atau alat klien lainnya, seperti pgAdmin.
```
psql --host=db-instance-123456789012.aws-region.rds.amazonaws.com
--port=5432 --username=postgres --password --dbname=labdb
```
1. Buat ekstensi TLE yang ada dengan menyalin kode berikut dan menempelkannya ke konsol sesi `psql` Anda.
```
SELECT pgtle.install_update_path
(
'pg_distance',
'0.1',
'0.2',
$_pg_tle_$
CREATE OR REPLACE FUNCTION dist(x1 float8, y1 float8, x2 float8, y2 float8, norm int)
RETURNS float8
AS $$
SELECT (abs(x2 - x1) ^ norm + abs(y2 - y1) ^ norm) ^ (1::float8 / norm);
$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION manhattan_dist(x1 float8, y1 float8, x2 float8, y2 float8)
RETURNS float8
AS $$
SELECT dist(x1, y1, x2, y2, 1);
$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION euclidean_dist(x1 float8, y1 float8, x2 float8, y2 float8)
RETURNS float8
AS $$
SELECT dist(x1, y1, x2, y2, 2);
$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
$_pg_tle_$
);
```
Anda akan melihat hasil yang mirip dengan berikut ini.
```
install_update_path
---------------------
t
(1 row)
```
Anda dapat menjadikan versi ekstensi ini sebagai versi default, sehingga pengguna basis data tidak perlu menentukan versi saat mereka membuat atau memperbarui ekstensi di basis data mereka.
1. Untuk menentukan bahwa versi modifikasi (versi 0.2) ekstensi TLE Anda adalah versi default, gunakan fungsi `pgtle.set_default_version` seperti yang ditunjukkan pada contoh berikut.
```
SELECT pgtle.set_default_version('pg_distance', '0.2');
```
Untuk informasi selengkapnya tentang fungsi ini, lihat [pgtle.set\$1default\$1version](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.set_default_version).
1. Dengan kode yang diterapkan, Anda dapat memperbarui ekstensi TLE yang diinstal seperti biasa, dengan menggunakan perintah `ALTER EXTENSION ... UPDATE`, seperti yang ditunjukkan di sini:
```
ALTER EXTENSION pg_distance UPDATE;
```
# Menjatuhkan TLE ekstensi Anda dari database
Anda dapat menjatuhkan TLE ekstensi Anda dengan menggunakan `DROP EXTENSION` perintah dengan cara yang sama seperti yang Anda lakukan untuk ekstensi Postgre SQL lainnya. Menghapus ekstensi tidak menghapus file penginstalan yang membentuk ekstensi, yang memungkinkan pengguna membuat ulang ekstensi. Untuk menghapus ekstensi dan file penginstalannya, lakukan proses dua langkah berikut.
**Untuk menjatuhkan TLE ekstensi dan menghapus file instalasinya**
1. Gunakan `psql` atau alat klien lain untuk terhubung ke . RDSuntuk contoh Postgre SQL DB.
```
psql --host=.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=dbname
```
1. Jatuhkan ekstensi seperti yang Anda lakukan pada ekstensi Postgre SQL apa pun.
```
DROP EXTENSION your-TLE-extension
```
Misalnya, jika Anda membuat ekstensi `pg_distance` seperti yang dijelaskan dalam[Contoh: Membuat ekstensi bahasa tepercaya menggunakan SQL](PostgreSQL_trusted_language_extension-creating-TLE-extensions.md#PostgreSQL_trusted_language_extension-simple-example), Anda dapat menghilangkan ekstensi sebagai berikut.
```
DROP EXTENSION pg_distance;
```
Anda melihat output yang mengonfirmasi bahwa ekstensi telah dihilangkan, sebagai berikut.
```
DROP EXTENSION
```
Pada titik ini, ekstensi tidak lagi aktif dalam basis data. Namun, file penginstalan dan file kontrolnya masih tersedia di basis data, sehingga pengguna basis data dapat membuat ekstensi lagi jika ingin.
+ Jika Anda ingin membiarkan file ekstensi utuh sehingga pengguna database dapat membuat TLE ekstensi Anda, Anda dapat berhenti di sini.
+ Jika Anda ingin menghapus semua file yang membentuk ekstensi, lanjutkan ke langkah berikutnya.
1. Untuk menghapus semua file penginstalan untuk ekstensi Anda, gunakan fungsi `pgtle.uninstall_extension`. Fungsi ini menghapus semua kode dan file kontrol untuk ekstensi Anda.
```
SELECT pgtle.uninstall_extension('your-tle-extension-name');
```
Misalnya, untuk menghapus semua file penginstalan `pg_distance`, gunakan perintah berikut.
```
SELECT pgtle.uninstall_extension('pg_distance');
uninstall_extension
---------------------
t
(1 row)
```
# Menghapus Instalasi Ekstensi Bahasa Tepercaya untuk Postgre SQL
Jika Anda tidak lagi ingin membuat TLE ekstensi Anda sendiri menggunakanTLE, Anda dapat menjatuhkan `pg_tle` ekstensi dan menghapus semua artefak. Tindakan ini termasuk menjatuhkan TLE ekstensi apa pun dalam database dan menjatuhkan skema. `pgtle`
**Untuk menghilangkan ekstensi `pg_tle` dan skema dari basis data**
1. Gunakan `psql` atau alat klien lain untuk terhubung ke . RDSuntuk contoh Postgre SQL DB.
```
psql --host=.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=dbname
```
1. Hilangkan ekstensi `pg_tle` dari basis data. Jika database memiliki TLE ekstensi Anda sendiri yang masih berjalan di database, Anda juga harus menghapus ekstensi tersebut. Untuk melakukannya, Anda dapat menggunakan kata kunci `CASCADE`, seperti yang ditunjukkan berikut ini.
```
DROP EXTENSION pg_tle CASCADE;
```
Jika ekstensi `pg_tle` masih tidak aktif dalam basis data, Anda tidak perlu menggunakan kata kunci `CASCADE`.
1. Hilangkan skema `pgtle`. Tindakan ini akan menghapus semua fungsi manajemen dari basis data.
```
DROP SCHEMA pgtle CASCADE;
```
Perintah ini menampilkan hasil berikut setelah proses selesai.
```
DROP SCHEMA
```
Ekstensi `pg_tle`, skema dan fungsinya, serta semua artefak dihapus. Untuk membuat ekstensi baru menggunakanTLE, melalui proses pengaturan lagi. Untuk informasi selengkapnya, lihat [Menyiapkan Ekstensi Bahasa Tepercaya di SQL](PostgreSQL_trusted_language_extension-setting-up.md).
# Menggunakan hook PostgreSQL dengan ekstensi TLE
*Hook* adalah mekanisme callback yang tersedia di PostgreSQL yang memungkinkan developer memanggil fungsi kustom atau rutinitas lainnya selama operasi basis data reguler. Kit pengembangan TLE mendukung hook PostgreSQL sehingga Anda dapat mengintegrasikan fungsi kustom dengan perilaku PostgreSQL saat runtime. Misalnya, Anda dapat menggunakan hook untuk mengaitkan proses autentikasi dengan kode kustom Anda sendiri, atau mengubah proses perencanaan dan eksekusi kueri untuk kebutuhan spesifik Anda.
Ekstensi TLE Anda dapat menggunakan hook. Jika hook cakupannya global, ini berlaku di semua basis data. Oleh karena itu, jika ekstensi TLE Anda menggunakan hook global, Anda perlu membuat ekstensi TLE di semua basis data yang dapat diakses pengguna.
Saat menggunakan ekstensi `pg_tle` untuk membuat Ekstensi Bahasa Tepercaya Anda sendiri, Anda dapat menggunakan hook yang tersedia dari SQL API untuk membangun fungsi ekstensi. Anda harus mendaftarkan hook apa pun di `pg_tle`. Untuk beberapa hook, Anda mungkin juga perlu mengatur berbagai parameter konfigurasi. Misalnya, hook pemeriksaan `passcode` dapat diatur ke aktif, nonaktif, wajib. Untuk informasi selengkapnya tentang persyaratan khusus untuk hook `pg_tle` yang tersedia, lihat [Referensi hook untuk Trusted Language Extensions for PostgreSQL](PostgreSQL_trusted_language_extension-hooks-reference.md).
## Contoh: Membuat ekstensi yang menggunakan hook PostgreSQL
Contoh yang dibahas di bagian ini menggunakan hook PostgreSQL untuk memeriksa kata sandi yang diberikan selama operasi SQL tertentu dan mencegah pengguna basis data mengatur kata sandi mereka ke salah satu basis data yang tercantum dalam tabel `password_check.bad_passwords`. Tabel berisi sepuluh besar pilihan kata sandi yang paling umum digunakan, tetapi mudah dipecahkan.
Untuk menyiapkan contoh ini di instans DB RDS for PostgreSQL, Anda harus sudah menginstal Ekstensi Bahasa Tepercaya. Untuk detailnya, lihat [Menyiapkan Ekstensi Bahasa Tepercaya di SQL](PostgreSQL_trusted_language_extension-setting-up.md).
**Untuk menyiapkan contoh hook pemeriksaan kata sandi**
1. Gunakan `psql` untuk terhubung ke . Instans DB RDS for PostgreSQL.
```
psql --host=db-instance-123456789012.aws-region.rds.amazonaws.com
--port=5432 --username=postgres --password --dbname=labdb
```
1. Salin kode dari [Daftar kode hook pemeriksaan kata sandi](#PostgreSQL_trusted_language_extension-example-hook_code_listing) dan tempel ke basis data Anda.
```
SELECT pgtle.install_extension (
'my_password_check_rules',
'1.0',
'Do not let users use the 10 most commonly used passwords',
$_pgtle_$
CREATE SCHEMA password_check;
REVOKE ALL ON SCHEMA password_check FROM PUBLIC;
GRANT USAGE ON SCHEMA password_check TO PUBLIC;
CREATE TABLE password_check.bad_passwords (plaintext) AS
VALUES
('123456'),
('password'),
('12345678'),
('qwerty'),
('123456789'),
('12345'),
('1234'),
('111111'),
('1234567'),
('dragon');
CREATE UNIQUE INDEX ON password_check.bad_passwords (plaintext);
CREATE FUNCTION password_check.passcheck_hook(username text, password text, password_type pgtle.password_types, valid_until timestamptz, valid_null boolean)
RETURNS void AS $$
DECLARE
invalid bool := false;
BEGIN
IF password_type = 'PASSWORD_TYPE_MD5' THEN
SELECT EXISTS(
SELECT 1
FROM password_check.bad_passwords bp
WHERE ('md5' || md5(bp.plaintext || username)) = password
) INTO invalid;
IF invalid THEN
RAISE EXCEPTION 'Cannot use passwords from the common password dictionary';
END IF;
ELSIF password_type = 'PASSWORD_TYPE_PLAINTEXT' THEN
SELECT EXISTS(
SELECT 1
FROM password_check.bad_passwords bp
WHERE bp.plaintext = password
) INTO invalid;
IF invalid THEN
RAISE EXCEPTION 'Cannot use passwords from the common password dictionary';
END IF;
END IF;
END
$$ LANGUAGE plpgsql SECURITY DEFINER;
GRANT EXECUTE ON FUNCTION password_check.passcheck_hook TO PUBLIC;
SELECT pgtle.register_feature('password_check.passcheck_hook', 'passcheck');
$_pgtle_$
);
```
Setelah ekstensi dimuat ke basis data, Anda akan melihat output seperti berikut.
```
install_extension
-------------------
t
(1 row)
```
1. Jika masih terhubung ke basis data, Anda kini dapat membuat ekstensi.
```
CREATE EXTENSION my_password_check_rules;
```
1. Anda dapat mengonfirmasi bahwa ekstensi telah dibuat dalam basis data dengan menggunakan metacommand `psql` berikut.
```
\dx
List of installed extensions
Name | Version | Schema | Description
-------------------------+---------+------------+-------------------------------------------------------------
my_password_check_rules | 1.0 | public | Prevent use of any of the top-ten most common bad passwords
pg_tle | 1.0.1 | pgtle | Trusted-Language Extensions for PostgreSQL
plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language
(3 rows)
```
1. Buka sesi terminal lain untuk bekerja dengan AWS CLI. Anda perlu mengubah grup parameter DB kustom untuk mengaktifkan hook pemeriksaan kata sandi. Untuk melakukannya, gunakan perintah [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html)CLI seperti yang ditunjukkan pada contoh berikut.
```
aws rds modify-db-parameter-group \
--region aws-region \
--db-parameter-group-name your-custom-parameter-group \
--parameters "ParameterName=pgtle.enable_password_check,ParameterValue=on,ApplyMethod=immediate"
```
Jika parameter berhasil dihidupkan, Anda akan melihat output seperti berikut.
```
(
"DBParameterGroupName": "docs-lab-parameters-for-tle"
}
```
Mungkin diperlukan waktu beberapa menit agar perubahan pada pengaturan grup parameter diterapkan. Akan tetapi, parameter ini bersifat dinamis, jadi Anda tidak perlu memulai ulang instans DB RDS for PostgreSQL DB untuk menerapkan pengaturan.
1. Buka sesi `psql` dan kirim kueri ke basis data untuk memverifikasi bahwa hook password\$1check telah diaktifkan.
```
labdb=> SHOW pgtle.enable_password_check;
pgtle.enable_password_check
-----------------------------
on
(1 row)
```
Hook password\$1check kini aktif. Anda dapat mengujinya dengan membuat peran baru dan menggunakan salah satu kata sandi yang buruk, seperti pada contoh berikut.
```
CREATE ROLE test_role PASSWORD 'password';
ERROR: Cannot use passwords from the common password dictionary
CONTEXT: PL/pgSQL function password_check.passcheck_hook(text,text,pgtle.password_types,timestamp with time zone,boolean) line 21 at RAISE
SQL statement "SELECT password_check.passcheck_hook(
$1::pg_catalog.text,
$2::pg_catalog.text,
$3::pgtle.password_types,
$4::pg_catalog.timestamptz,
$5::pg_catalog.bool)"
```
Output ini telah diformat agar mudah dibaca.
Contoh berikut menunjukkan bahwa perilaku `\password` metacommand interaktif `pgsql` juga dipengaruhi oleh hook password\$1check.
```
postgres=> SET password_encryption TO 'md5';
SET
postgres=> \password
Enter new password for user "postgres":*****
Enter it again:*****
ERROR: Cannot use passwords from the common password dictionary
CONTEXT: PL/pgSQL function password_check.passcheck_hook(text,text,pgtle.password_types,timestamp with time zone,boolean) line 12 at RAISE
SQL statement "SELECT password_check.passcheck_hook($1::pg_catalog.text, $2::pg_catalog.text, $3::pgtle.password_types, $4::pg_catalog.timestamptz, $5::pg_catalog.bool)"
```
Anda dapat menghilangkan ekstensi TLE ini dan menghapus instalan file sumbernya jika ingin. Untuk informasi selengkapnya, lihat [Menjatuhkan TLE ekstensi Anda dari databaseMenjatuhkan TLE ekstensi Anda dari database](PostgreSQL_trusted_language_extension-creating-TLE-extensions.dropping-TLEs.md).
### Daftar kode hook pemeriksaan kata sandi
Kode contoh yang ditampilkan di sini menentukan spesifikasi untuk ekstensi TLE `my_password_check_rules`. Jika kode ini disalin dan ditempelkan ke basis data, kode untuk ekstensi `my_password_check_rules` akan dimuat ke dalam basis data, dan hook `password_check` akan didaftarkan untuk digunakan oleh ekstensi.
```
SELECT pgtle.install_extension (
'my_password_check_rules',
'1.0',
'Do not let users use the 10 most commonly used passwords',
$_pgtle_$
CREATE SCHEMA password_check;
REVOKE ALL ON SCHEMA password_check FROM PUBLIC;
GRANT USAGE ON SCHEMA password_check TO PUBLIC;
CREATE TABLE password_check.bad_passwords (plaintext) AS
VALUES
('123456'),
('password'),
('12345678'),
('qwerty'),
('123456789'),
('12345'),
('1234'),
('111111'),
('1234567'),
('dragon');
CREATE UNIQUE INDEX ON password_check.bad_passwords (plaintext);
CREATE FUNCTION password_check.passcheck_hook(username text, password text, password_type pgtle.password_types, valid_until timestamptz, valid_null boolean)
RETURNS void AS $$
DECLARE
invalid bool := false;
BEGIN
IF password_type = 'PASSWORD_TYPE_MD5' THEN
SELECT EXISTS(
SELECT 1
FROM password_check.bad_passwords bp
WHERE ('md5' || md5(bp.plaintext || username)) = password
) INTO invalid;
IF invalid THEN
RAISE EXCEPTION 'Cannot use passwords from the common password dictionary';
END IF;
ELSIF password_type = 'PASSWORD_TYPE_PLAINTEXT' THEN
SELECT EXISTS(
SELECT 1
FROM password_check.bad_passwords bp
WHERE bp.plaintext = password
) INTO invalid;
IF invalid THEN
RAISE EXCEPTION 'Cannot use passwords from the common password dictionary';
END IF;
END IF;
END
$$ LANGUAGE plpgsql SECURITY DEFINER;
GRANT EXECUTE ON FUNCTION password_check.passcheck_hook TO PUBLIC;
SELECT pgtle.register_feature('password_check.passcheck_hook', 'passcheck');
$_pgtle_$
);
```
# Menggunakan Tipe Data Kustom di TLE
Postgre SQL mendukung perintah untuk mendaftarkan tipe dasar baru (juga dikenal sebagai tipe skalar) untuk menangani struktur data yang kompleks secara efisien dalam database Anda. Jenis dasar memungkinkan Anda menyesuaikan bagaimana data disimpan secara internal, dan cara mengonversinya ke dan dari representasi tekstual eksternal. Tipe data khusus ini sangat membantu saat memperluas Postgre SQL untuk mendukung domain fungsional di mana tipe bawaan seperti angka atau teks tidak dapat memberikan semantik pencarian yang memadai.
RDSuntuk Postgre SQL memungkinkan Anda membuat tipe data khusus dalam ekstensi bahasa tepercaya Anda dan menentukan fungsi yang mendukung SQL dan mengindeks operasi untuk tipe data baru ini. Jenis data kustom tersedia untuk versi berikut:
+ RDSuntuk Postgre SQL 15.4 dan versi 15 yang lebih tinggi
+ RDSuntuk Postgre SQL 14.9 dan versi 14 yang lebih tinggi
+ RDSuntuk Postgre SQL 13.12 dan versi 13 yang lebih tinggi
Untuk informasi selengkapnya, lihat [Jenis Dasar Bahasa Tepercaya](https://github.com/aws/pg_tle/blob/main/docs/09_datatypes.md).
# Referensi fungsi untuk Ekstensi Bahasa Tepercaya untuk Postgre SQL
Lihat dokumentasi referensi berikut tentang fungsi yang tersedia di Ekstensi Bahasa Tepercaya untuk PostgreSQL. Gunakan fungsi-fungsi ini untuk menginstal, mendaftar, memperbarui, dan mengelola *TLEekstensi* Anda, yaitu SQL ekstensi Postgre yang Anda kembangkan menggunakan kit pengembangan Ekstensi Bahasa Tepercaya.
**Topics**
+ [pgtle.available\$1extensions](#pgtle.available_extensions)
+ [pgtle.available\$1extension\$1versions](#pgtle.available_extension_versions)
+ [pgtle.extension\$1update\$1paths](#pgtle.extension_update_paths)
+ [pgtle.install\$1extension](#pgtle.install_extension)
+ [pgtle.install\$1update\$1path](#pgtle.install_update_path)
+ [pgtle.register\$1feature](#pgtle.register_feature)
+ [pgtle.register\$1feature\$1if\$1not\$1exists](#pgtle.register_feature_if_not_exists)
+ [pgtle.set\$1default\$1version](#pgtle.set_default_version)
+ [pgtle.uninstall\$1extension(nama)](#pgtle.uninstall_extension-name)
+ [pgtle.uninstall\$1extension (nama, versi)](#pgtle.uninstall_extension-name-version)
+ [pgtle.uninstall\$1extension\$1if\$1exists](#pgtle.uninstall_extension_if_exists)
+ [pgtle.uninstall\$1update\$1path](#pgtle.uninstall_update_path)
+ [pgtle.uninstall\$1update\$1path\$1if\$1exists](#pgtle.uninstall_update_path_if_exists)
+ [pgtle.unregister\$1feature](#pgtle.unregister_feature)
+ [pgtle.unregister\$1feature\$1if\$1exists](#pgtle.unregister_feature_if_exists)
## pgtle.available\$1extensions
Fungsi `pgtle.available_extensions` adalah fungsi pengembalian set. Ia mengembalikan semua TLE ekstensi yang tersedia dalam database. Setiap baris yang dikembalikan berisi informasi tentang TLE ekstensi tunggal.
### Prototipe fungsi
```
pgtle.available_extensions()
```
### Peran
Tidak ada.
### Argumen
Tidak ada.
### Output
+ `name`— Nama TLE ekstensi.
+ `default_version`— Versi TLE ekstensi yang akan digunakan saat `CREATE EXTENSION` dipanggil tanpa versi yang ditentukan.
+ `description`— Penjelasan yang lebih rinci tentang TLE ekstensi.
### Contoh penggunaan
```
SELECT * FROM pgtle.available_extensions();
```
## pgtle.available\$1extension\$1versions
Fungsi `available_extension_versions` adalah fungsi pengembalian set. Ini mengembalikan daftar semua TLE ekstensi yang tersedia dan versinya. Setiap baris berisi informasi tentang versi tertentu dari TLE ekstensi yang diberikan, termasuk apakah itu memerlukan peran tertentu.
### Prototipe fungsi
```
pgtle.available_extension_versions()
```
### Peran
Tidak ada.
### Argumen
Tidak ada.
### Output
+ `name`— Nama TLE ekstensi.
+ `version`— Versi TLE ekstensi.
+ `superuser`— Nilai ini selalu `false` untuk TLE ekstensi Anda. Izin yang diperlukan untuk membuat TLE ekstensi atau memperbaruinya sama dengan membuat objek lain dalam database yang diberikan.
+ `trusted`— Nilai ini selalu `false` untuk TLE ekstensi.
+ `relocatable`— Nilai ini selalu `false` untuk TLE ekstensi.
+ `schema`— Menentukan nama skema di mana TLE ekstensi diinstal.
+ `requires`— Array yang berisi nama-nama ekstensi lain yang dibutuhkan oleh TLE ekstensi ini.
+ `description`— Penjelasan rinci tentang TLE ekstensi.
Untuk informasi selengkapnya tentang nilai keluaran, lihat [Mengemas Objek Terkait ke dalam Ekstensi > File Ekstensi](https://www.postgresql.org/docs/current/extend-extensions.html#id-1.8.3.20.11) dalam dokumentasi PostgreSQL.
### Contoh penggunaan
```
SELECT * FROM pgtle.available_extension_versions();
```
## pgtle.extension\$1update\$1paths
Fungsi `extension_update_paths` adalah fungsi pengembalian set. Ini mengembalikan daftar semua jalur pembaruan yang mungkin untuk TLE ekstensi. Setiap baris menyertakan peningkatan atau penurunan versi yang tersedia untuk ekstensi itu. TLE
### Prototipe fungsi
```
pgtle.extension_update_paths(name)
```
### Peran
Tidak ada.
### Argumen
`name`— Nama TLE ekstensi dari mana untuk mendapatkan jalur upgrade.
### Output
+ `source` – Versi sumber untuk pembaruan.
+ `target` – Versi target untuk pembaruan.
+ `path`— Jalur pemutakhiran yang digunakan untuk memperbarui TLE ekstensi dari `source` `target` versi ke versi, misalnya,`0.1--0.2`.
### Contoh penggunaan
```
SELECT * FROM pgtle.extension_update_paths('your-TLE');
```
## pgtle.install\$1extension
`install_extension`Fungsi ini memungkinkan Anda menginstal artefak yang membentuk TLE ekstensi Anda di database, setelah itu dapat dibuat menggunakan `CREATE EXTENSION` perintah.
### Prototipe fungsi
```
pgtle.install_extension(name text, version text, description text, ext text, requires text[] DEFAULT NULL::text[])
```
### Peran
Tidak ada.
### Argumen
+ `name`— Nama TLE ekstensi. Nilai ini digunakan saat memanggil `CREATE EXTENSION`.
+ `version`— Versi TLE ekstensi.
+ `description`— Penjelasan rinci tentang TLE ekstensi. Deskripsi ini ditampilkan di kolom `comment` pada `pgtle.available_extensions()`.
+ `ext`— Isi TLE ekstensi. Nilai ini berisi objek seperti fungsi.
+ `requires`— Parameter opsional yang menentukan dependensi untuk ekstensi ini. TLE Ekstensi `pg_tle` secara otomatis ditambahkan sebagai dependensi.
Banyak dari argumen ini sama dengan yang disertakan dalam file kontrol ekstensi untuk menginstal ekstensi Postgre SQL pada sistem file instance SQL Postgre. Untuk informasi selengkapnya, lihat [File Ekstensi](http://www.postgresql.org/docs/current/extend-extensions.html#id-1.8.3.20.11) dalam [Kemasan Objek Terkait ke Ekstensi](https://www.postgresql.org/docs/current/extend-extensions.html) dalam dokumentasi PostgreSQL.
### Output
Fungsi ini akan mengembalikan `OK` jika berhasil, dan `NULL` jika terjadi kesalahan.
+ `OK`— TLE Ekstensi telah berhasil dipasang di database.
+ `NULL`— TLE Ekstensi belum berhasil dipasang di database.
### Contoh penggunaan
```
SELECT pgtle.install_extension(
'pg_tle_test',
'0.1',
'My first pg_tle extension',
$_pgtle_$
CREATE FUNCTION my_test()
RETURNS INT
AS $$
SELECT 42;
$$ LANGUAGE SQL IMMUTABLE;
$_pgtle_$
);
```
## pgtle.install\$1update\$1path
`install_update_path`Fungsi ini menyediakan jalur pembaruan antara dua versi TLE ekstensi yang berbeda. Fungsi ini memungkinkan pengguna TLE ekstensi Anda untuk memperbarui versinya dengan menggunakan `ALTER EXTENSION ... UPDATE` sintaks.
### Prototipe fungsi
```
pgtle.install_update_path(name text, fromvers text, tovers text, ext text)
```
### Peran
`pgtle_admin`
### Argumen
+ `name`— Nama TLE ekstensi. Nilai ini digunakan saat memanggil `CREATE EXTENSION`.
+ `fromvers`— Versi sumber TLE ekstensi untuk peningkatan.
+ `tovers`— Versi tujuan TLE ekstensi untuk peningkatan.
+ `ext` – Konten pembaruan. Nilai ini berisi objek seperti fungsi.
### Output
Tidak ada.
### Contoh penggunaan
```
SELECT pgtle.install_update_path('pg_tle_test', '0.1', '0.2',
$_pgtle_$
CREATE OR REPLACE FUNCTION my_test()
RETURNS INT
AS $$
SELECT 21;
$$ LANGUAGE SQL IMMUTABLE;
$_pgtle_$
);
```
## pgtle.register\$1feature
`register_feature`Fungsi menambahkan SQL fitur Postgre internal yang ditentukan ke tabel. `pgtle.feature_info` Postgre SQL hook adalah contoh fitur Postgre internal. SQL Kit pengembangan Ekstensi Bahasa Tepercaya mendukung penggunaan kait PostgreSQL. Saat ini, fungsi ini mendukung fitur berikut.
+ `passcheck`— Mendaftarkan hook pemeriksaan kata sandi dengan prosedur atau fungsi Anda yang menyesuaikan perilaku pemeriksaan kata sandi Postgre. SQL
### Prototipe fungsi
```
pgtle.register_feature(proc regproc, feature pg_tle_feature)
```
### Peran
`pgtle_admin`
### Argumen
+ `proc` – Nama prosedur atau fungsi yang disimpan untuk digunakan dengan fitur tersebut.
+ `feature` – Nama fitur `pg_tle` (seperti `passcheck`) untuk mendaftar dengan fungsi.
### Output
Tidak ada.
### Contoh penggunaan
```
SELECT pgtle.register_feature('pw_hook', 'passcheck');
```
## pgtle.register\$1feature\$1if\$1not\$1exists
`pgtle.register_feature_if_not_exists`Fungsi menambahkan SQL fitur Postgre yang ditentukan ke `pgtle.feature_info` tabel dan mengidentifikasi TLE ekstensi atau prosedur atau fungsi lain yang menggunakan fitur tersebut. Untuk informasi selengkapnya tentang hook dan Trusted Language Extensions, lihat [Menggunakan hook PostgreSQL dengan ekstensi TLE](PostgreSQL_trusted_language_extension.overview.tles-and-hooks.md).
### Prototipe fungsi
```
pgtle.register_feature_if_not_exists(proc regproc, feature pg_tle_feature)
```
### Peran
`pgtle_admin`
### Argumen
+ `proc`— Nama prosedur atau fungsi tersimpan yang berisi logika (kode) untuk digunakan sebagai fitur untuk TLE ekstensi Anda. Misalnya, kode `pw_hook`.
+ `feature`— Nama SQL fitur Postgre untuk mendaftar untuk fungsi tersebut. TLE Saat ini, satu-satunya fitur yang tersedia adalah hook `passcheck`. Untuk informasi selengkapnya, lihat [Hook pemeriksaan kata sandi (passcheck)](PostgreSQL_trusted_language_extension-hooks-reference.md#passcheck_hook).
### Output
Mengembalikan `true` setelah mendaftarkan fitur untuk ekstensi yang ditentukan. Mengembalikan `false` jika fitur sudah terdaftar.
### Contoh penggunaan
```
SELECT pgtle.register_feature_if_not_exists('pw_hook', 'passcheck');
```
## pgtle.set\$1default\$1version
`set_default_version`Fungsi ini memungkinkan Anda menentukan `default_version` untuk TLE ekstensi Anda. Anda dapat menggunakan fungsi ini untuk menentukan jalur pemutakhiran dan menetapkan versi sebagai default untuk TLE ekstensi Anda. Ketika pengguna database menentukan TLE ekstensi Anda dalam `ALTER EXTENSION ... UPDATE` perintah `CREATE EXTENSION` dan, versi TLE ekstensi Anda dibuat dalam database untuk pengguna tersebut.
Fungsi ini mengembalikan `true` jika berhasil. Jika TLE ekstensi yang ditentukan dalam `name` argumen tidak ada, fungsi mengembalikan kesalahan. Demikian pula, jika TLE ekstensi tidak ada, ia mengembalikan kesalahan. `version`
### Prototipe fungsi
```
pgtle.set_default_version(name text, version text)
```
### Peran
`pgtle_admin`
### Argumen
+ `name`— Nama TLE ekstensi. Nilai ini digunakan saat memanggil `CREATE EXTENSION`.
+ `version`— Versi TLE ekstensi untuk mengatur default.
### Output
+ `true` – Saat pengaturan versi default berhasil, fungsi mengembalikan `true`.
+ `ERROR`— Mengembalikan pesan kesalahan jika TLE ekstensi dengan nama atau versi tertentu tidak ada.
### Contoh penggunaan
```
SELECT * FROM pgtle.set_default_version('my-extension', '1.1');
```
## pgtle.uninstall\$1extension(nama)
`uninstall_extension`Fungsi ini menghapus semua versi TLE ekstensi dari database. Fungsi ini mencegah panggilan future `CREATE EXTENSION` dari menginstal TLE ekstensi. Jika TLE ekstensi tidak ada dalam database, kesalahan muncul.
`uninstall_extension`Fungsi tidak akan menjatuhkan TLE ekstensi yang saat ini aktif dalam database. Untuk menghapus TLE ekstensi yang saat ini aktif, Anda perlu memanggil secara eksplisit `DROP EXTENSION` untuk menghapusnya.
### Prototipe fungsi
```
pgtle.uninstall_extension(extname text)
```
### Peran
`pgtle_admin`
### Argumen
+ `extname`— Nama TLE ekstensi yang akan dihapus. Nama ini sama dengan yang digunakan `CREATE EXTENSION` untuk memuat TLE ekstensi untuk digunakan dalam database tertentu.
### Output
Tidak ada.
### Contoh penggunaan
```
SELECT * FROM pgtle.uninstall_extension('pg_tle_test');
```
## pgtle.uninstall\$1extension (nama, versi)
`uninstall_extension(name, version)`Fungsi ini menghapus versi TLE ekstensi yang ditentukan dari database. Fungsi ini mencegah `CREATE EXTENSION` dan `ALTER EXTENSION` dari menginstal atau memperbarui TLE ekstensi ke versi yang ditentukan. Fungsi ini juga menghapus semua jalur pembaruan untuk versi TLE ekstensi yang ditentukan. Fungsi ini tidak akan menghapus instalasi TLE ekstensi jika saat ini aktif dalam database. Anda harus secara eksplisit memanggil `DROP EXTENSION` untuk menghapus ekstensi. TLE Untuk menghapus semua versi TLE ekstensi, lihat[pgtle.uninstall\$1extension(nama)](#pgtle.uninstall_extension-name).
### Prototipe fungsi
```
pgtle.uninstall_extension(extname text, version text)
```
### Peran
`pgtle_admin`
### Argumen
+ `extname`— Nama TLE ekstensi. Nilai ini digunakan saat memanggil `CREATE EXTENSION`.
+ `version`— Versi TLE ekstensi untuk menghapus instalasi dari database.
### Output
Tidak ada.
### Contoh penggunaan
```
SELECT * FROM pgtle.uninstall_extension('pg_tle_test', '0.2');
```
## pgtle.uninstall\$1extension\$1if\$1exists
`uninstall_extension_if_exists`Fungsi ini menghapus semua versi TLE ekstensi dari database yang diberikan. Jika TLE ekstensi tidak ada, fungsi kembali diam-diam (tidak ada pesan kesalahan yang muncul). Jika ekstensi yang ditentukan sedang aktif dalam basis data, fungsi ini tidak akan menghapusnya. Anda harus secara eksplisit memanggil `DROP EXTENSION` untuk menghapus TLE ekstensi sebelum menggunakan fungsi ini untuk menghapus artefaknya.
### Prototipe fungsi
```
pgtle.uninstall_extension_if_exists(extname text)
```
### Peran
`pgtle_admin`
### Argumen
+ `extname`— Nama TLE ekstensi. Nilai ini digunakan saat memanggil `CREATE EXTENSION`.
### Output
Fungsi `uninstall_extension_if_exists` mengembalikan `true` setelah menghapus instalasi ekstensi yang ditentukan. Jika ekstensi yang ditentukan tidak ada, fungsi akan mengembalikan `false`.
+ `true`— Kembali `true` setelah mencopot pemasangan TLE ekstensi.
+ `false`— Kembali `false` ketika TLE ekstensi tidak ada dalam database.
### Contoh penggunaan
```
SELECT * FROM pgtle.uninstall_extension_if_exists('pg_tle_test');
```
## pgtle.uninstall\$1update\$1path
`uninstall_update_path`Fungsi menghapus jalur pembaruan tertentu dari TLE ekstensi. Fungsi ini membuat `ALTER EXTENSION ... UPDATE TO` tidak dapat menggunakan ekstensi ini sebagai jalur pembaruan.
Jika TLE ekstensi saat ini digunakan oleh salah satu versi di jalur pembaruan ini, ekstensi tetap ada di database.
Jika jalur pembaruan yang ditentukan tidak ada, fungsi akan memunculkan kesalahan.
### Prototipe fungsi
```
pgtle.uninstall_update_path(extname text, fromvers text, tovers text)
```
### Peran
`pgtle_admin`
### Argumen
+ `extname`— Nama TLE ekstensi. Nilai ini digunakan saat memanggil `CREATE EXTENSION`.
+ `fromvers`— Versi sumber TLE ekstensi yang digunakan pada jalur pembaruan.
+ `tovers`— Versi tujuan TLE ekstensi yang digunakan pada jalur pembaruan.
### Output
Tidak ada.
### Contoh penggunaan
```
SELECT * FROM pgtle.uninstall_update_path('pg_tle_test', '0.1', '0.2');
```
## pgtle.uninstall\$1update\$1path\$1if\$1exists
`uninstall_update_path_if_exists`Fungsinya mirip `uninstall_update_path` dengan menghapus jalur pembaruan yang ditentukan dari TLE ekstensi. Namun, jika jalur pembaruan tidak ada, fungsi ini tidak memunculkan pesan kesalahan. Sebaliknya, fungsi mengembalikan `false`.
### Prototipe fungsi
```
pgtle.uninstall_update_path_if_exists(extname text, fromvers text, tovers text)
```
### Peran
`pgtle_admin`
### Argumen
+ `extname`— Nama TLE ekstensi. Nilai ini digunakan saat memanggil `CREATE EXTENSION`.
+ `fromvers`— Versi sumber TLE ekstensi yang digunakan pada jalur pembaruan.
+ `tovers`— Versi tujuan TLE ekstensi yang digunakan pada jalur pembaruan.
### Output
+ `true`— Fungsi telah berhasil memperbarui jalur untuk TLE ekstensi.
+ `false`— Fungsi tidak dapat memperbarui jalur untuk TLE ekstensi.
### Contoh penggunaan
```
SELECT * FROM pgtle.uninstall_update_path_if_exists('pg_tle_test', '0.1', '0.2');
```
## pgtle.unregister\$1feature
Fungsi `unregister_feature` menyediakan cara untuk menghapus fungsi yang terdaftar untuk menggunakan fitur `pg_tle`, seperti hook. Untuk informasi tentang pendaftaran fitur, lihat [pgtle.register\$1feature](#pgtle.register_feature).
### Prototipe fungsi
```
pgtle.unregister_feature(proc regproc, feature pg_tle_features)
```
### Peran
`pgtle_admin`
### Argumen
+ `proc` – Nama fungsi tersimpan untuk mendaftar dengan fitur `pg_tle`.
+ `feature` – Nama fitur `pg_tle` untuk mendaftar dengan fungsi. Misalnya, `passcheck` adalah fitur yang dapat didaftarkan untuk digunakan oleh ekstensi bahasa tepercaya yang Anda kembangkan. Untuk informasi selengkapnya, lihat [Hook pemeriksaan kata sandi (passcheck)](PostgreSQL_trusted_language_extension-hooks-reference.md#passcheck_hook).
### Output
Tidak ada.
### Contoh penggunaan
```
SELECT * FROM pgtle.unregister_feature('pw_hook', 'passcheck');
```
## pgtle.unregister\$1feature\$1if\$1exists
Fungsi `unregister_feature` menyediakan cara untuk menghapus fungsi yang terdaftar untuk menggunakan fitur `pg_tle`, seperti hook. Untuk informasi selengkapnya, lihat [Menggunakan hook PostgreSQL dengan ekstensi TLE](PostgreSQL_trusted_language_extension.overview.tles-and-hooks.md). Mengembalikan `true` setelah berhasil membatalkan pendaftaran fitur. Mengembalikan `false` jika fitur tidak terdaftar.
Untuk informasi tentang mendaftarkan `pg_tle` fitur untuk TLE ekstensi Anda, lihat[pgtle.register\$1feature](#pgtle.register_feature).
### Prototipe fungsi
```
pgtle.unregister_feature_if_exists('proc regproc', 'feature pg_tle_features')
```
### Peran
`pgtle_admin`
### Argumen
+ `proc` – Nama fungsi tersimpan yang terdaftar untuk menyertakan fitur `pg_tle`.
+ `feature` – Nama fitur `pg_tle` yang terdaftar dengan ekstensi bahasa tepercaya.
### Output
Mengembalikan `true` atau `false`, sebagai berikut.
+ `true` – Fungsi telah berhasil membatalkan pendaftaran fitur dari ekstensi.
+ `false`— Fungsi tidak dapat membatalkan pendaftaran fitur dari TLE ekstensi.
### Contoh penggunaan
```
SELECT * FROM pgtle.unregister_feature_if_exists('pw_hook', 'passcheck');
```
# Referensi hook untuk Trusted Language Extensions for PostgreSQL
Trusted Language Extensions for PostgreSQL mendukung hook PostgreSQL. *Hook* adalah mekanisme panggilan balik internal yang tersedia bagi developer untuk memperluas fungsionalitas inti PostgreSQL. Dengan hook, developer dapat mengimplementasikan fungsi atau prosedurnya sendiri untuk digunakan dalam berbagai operasi basis data, sehingga mengubah perilaku PostgreSQL dalam beberapa cara. Misalnya, Anda dapat menggunakan hook `passcheck` untuk menyesuaikan cara PostgreSQL menangani kata sandi yang diberikan saat membuat atau mengubah kata sandi untuk pengguna (peran).
Lihat dokumentasi berikut untuk mempelajari kait passcheck yang tersedia untuk ekstensi TLE Anda. Untuk mempelajari lebih lanjut tentang kait yang tersedia termasuk hook autentikasi klien, lihat kait [Ekstensi Bahasa Tepercaya](https://github.com/aws/pg_tle/blob/main/docs/04_hooks.md).
## Hook pemeriksaan kata sandi (passcheck)
Hook `passcheck` digunakan untuk menyesuaikan perilaku PostgreSQL selama proses pemeriksaan kata sandi untuk perintah SQL dan metacommand `psql` berikut.
+ `CREATE ROLE username ...PASSWORD` – Untuk informasi selengkapnya, lihat [CREATE ROLE](https://www.postgresql.org/docs/current/sql-createrole.html) dalam dokumentasi PostgreSQL.
+ `ALTER ROLE username...PASSWORD` – Untuk informasi selengkapnya, lihat [ALTER ROLE](https://www.postgresql.org/docs/current/sql-alterrole.html) dalam dokumentasi PostgreSQL.
+ `\password username` – Metacommand `psql` interaktif ini secara aman mengubah kata sandi untuk pengguna yang ditentukan dengan hashing kata sandi sebelum menggunakan sintaks `ALTER ROLE ... PASSWORD` secara transparan. Metacommand adalah pembungkus aman untuk perintah `ALTER ROLE ... PASSWORD`, sehingga hook diterapkan untuk perilaku metacommand `psql`.
Untuk contohnya, lihat [Daftar kode hook pemeriksaan kata sandi](PostgreSQL_trusted_language_extension.overview.tles-and-hooks.md#PostgreSQL_trusted_language_extension-example-hook_code_listing).
**Contents**
+ [Prototipe fungsi](#passcheck_hook-prototype)
+ [Pendapat](#passcheck_hook-arguments)
+ [Konfigurasi](#passcheck_hook-configuration)
+ [Catatan penggunaan](#passcheck_hook-usage)
### Prototipe fungsi
```
passcheck_hook(username text, password text, password_type pgtle.password_types, valid_until timestamptz, valid_null boolean)
```
### Pendapat
Fungsi hook `passcheck` memiliki argumen berikut.
+ `username` – Nama (sebagai teks) dari peran (nama pengguna) yang mengatur kata sandi.
+ `password` – Kata sandi yang di-hash atau teks biasa. Kata sandi yang dimasukkan harus sesuai dengan jenis yang ditentukan dalam `password_type`.
+ `password_type` – Menentukan format `pgtle.password_type` kata sandi. Format ini dapat berupa salah satu opsi berikut.
+ `PASSWORD_TYPE_PLAINTEXT` – Kata sandi teks biasa.
+ `PASSWORD_TYPE_MD5`— Kata sandi yang telah di-hash menggunakan algoritma MD5 (message digest 5).
+ `PASSWORD_TYPE_SCRAM_SHA_256` – Kata sandi yang telah di-hash menggunakan algoritma SCRAM-SHA-256.
+ `valid_until` – Menentukan waktu ketika kata sandi menjadi tidak valid. Argumen ini opsional. Jika Anda menggunakan argumen ini, tentukan waktu sebagai nilai `timestamptz`.
+ `valid_null` – Jika Boolean ini diatur ke `true`, opsi `valid_until` diatur ke `NULL`.
### Konfigurasi
Fungsi `pgtle.enable_password_check` mengontrol apakah hook passcheck aktif. Hook passcheck memiliki tiga pengaturan yang memungkinkan.
+ `off` – Menonaktifkan hook pemeriksaan kata sandi `passcheck`. Ini adalah nilai default.
+ `on` – Mengaktifkan hook pemeriksaan kata sandi `passcode` sehingga kata sandi diperiksa di tabel.
+ `require` – Memerlukan hook pemeriksaan kata sandi untuk didefinisikan.
### Catatan penggunaan
Untuk mengaktifkan atau menonaktifkan hook `passcheck`, Anda perlu memodifikasi grup parameter DB kustom untuk instans DB RDS for PostgreSQL Anda.
Untuk Linux, macOS, atau Unix:
```
aws rds modify-db-parameter-group \
--region aws-region \
--db-parameter-group-name your-custom-parameter-group \
--parameters "ParameterName=pgtle.enable_password_check,ParameterValue=on,ApplyMethod=immediate"
```
Untuk Windows:
```
aws rds modify-db-parameter-group ^
--region aws-region ^
--db-parameter-group-name your-custom-parameter-group ^
--parameters "ParameterName=pgtle.enable_password_check,ParameterValue=on,ApplyMethod=immediate"
```