Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Arbeiten mit Trusted Language Extensions für PostgreSQL
Trusted Language Extensions für PostgreSQL ist ein Open-Source-Entwicklungskit für die Erstellung von PostgreSQL-Erweiterungen. Es ermöglicht Ihnen, leistungsstarke PostgreSQL-Erweiterungen zu erstellen und diese sicher auf Ihrer PostgreSQL-DB-Instance auszuführen. Mithilfe von Trusted Language Extensions (TLE) für PostgreSQL können Sie PostgreSQL-Erweiterungen erstellen, die dem dokumentierten Ansatz zur Erweiterung der PostgreSQL-Funktionalität folgen. Weitere Informationen finden Sie unter [Packaging Related Objects in a Extension](https://www.postgresql.org/docs/current/extend-extensions.html) in der PostgreSQL-Dokumentation.
Ein wesentlicher Vorteil von TLE besteht darin, dass Sie es in Umgebungen verwenden können, die keinen Zugriff auf das der PostgreSQL-Instance zugrunde liegende Dateisystem bieten. Bisher war für die Installation einer neuen Erweiterung Zugriff auf das Dateisystem erforderlich. Mit TLE entfällt diese Einschränkung. Es bietet eine Entwicklungsumgebung für die Erstellung neuer Erweiterungen für jede PostgreSQL-Datenbank, einschließlich solcher, die auf Ihren DB-Instances von RDS für PostgreSQL ausgeführt werden.
TLE wurde entwickelt, um den Zugriff auf unsichere Ressourcen für die Erweiterungen zu verhindern, die Sie mit TLE erstellen. Die Laufzeitumgebung begrenzt die Auswirkungen eines Erweiterungsdefekts auf eine einzelne Datenbankverbindung. TLE verleiht Datenbankadministratoren auch eine detaillierte Kontrolle darüber, wer Erweiterungen installieren kann, und bietet ein Berechtigungsmodell für deren Ausführung.
TLE wird von den folgenden RDS-for-PostgreSQL-Versionen unterstützt:
+ Version 18.1 und höhere 18-Versionen
+ Version 17.1 und höhere 17-Versionen
+ Version 16.1 und höhere 16-Versionen
+ Version 15.2 und höhere 15-Versionen
+ Version 14.5 und höhere 14-Versionen
+ Version 13.12 und höhere 13-Versionen
Die Entwicklungsumgebung und Laufzeit von Trusted Language Extensions sind als `pg_tle`-PostgreSQL-Erweiterung, Version 1.0.1, verpackt. Es unterstützt die Erstellung von Erweiterungen in Perl JavaScript, Tcl, PL/pgSQL und SQL. Sie installieren die `pg_tle`-Erweiterung in Ihrer DB-Instance von RDS für PostgreSQL auf die gleiche Weise wie andere PostgreSQL-Erweiterungen. Nach der Einrichtung von `pg_tle` können Entwickler damit neue PostgreSQL-Erweiterungen, sogenannte *TLE-Erweiterungen*, erstellen.
In den folgenden Themen finden Sie Informationen darüber, wie Sie Trusted Language Extensions einrichten und Ihre eigenen TLE-Erweiterungen erstellen.
**Topics**
+ [
# Terminologie
](PostgreSQL_trusted_language_extension-terminology.md)
+ [
# Anforderungen für die Verwendung von Trusted Language Extensions für PostgreSQL
](PostgreSQL_trusted_language_extension-requirements.md)
+ [
# Einrichten von Trusted Language Extensions in Ihrer DB-Instance von RDS für PostgreSQL
](PostgreSQL_trusted_language_extension-setting-up.md)
+ [
# Übersicht über Trusted Language Extensions für PostgreSQL
](PostgreSQL_trusted_language_extension.overview.md)
+ [
# Erstellen von TLE-Erweiterungen für RDS für PostgreSQL
](PostgreSQL_trusted_language_extension-creating-TLE-extensions.md)
+ [
# Löschen Ihrer TLE-Erweiterungen aus einer Datenbank
](PostgreSQL_trusted_language_extension-creating-TLE-extensions.dropping-TLEs.md)
+ [
# Deinstallieren von Trusted Language Extensions für PostgreSQL
](PostgreSQL_trusted_language_extension-uninstalling-pg_tle-devkit.md)
+ [
# Verwenden von PostgreSQL-Haken mit Ihren TLE-Erweiterungen
](PostgreSQL_trusted_language_extension.overview.tles-and-hooks.md)
+ [
# Verwendung benutzerdefinierter Datentypen in TLE
](PostgreSQL_trusted_language_extension-custom-data-type.md)
+ [
# Funktionsreferenz für Trusted Language Extensions für PostgreSQL
](PostgreSQL_trusted_language_extension-functions-reference.md)
+ [
# Hakenreferenz für Trusted Language Extensions für PostgreSQL
](PostgreSQL_trusted_language_extension-hooks-reference.md)
# Terminologie
Sehen Sie sich das folgende Glossar und die in diesem Thema verwendeten Begriffe an, damit Sie Trusted Language Extensions besser verstehen.
**Trusted Language Extensions für PostgreSQL**
*Trusted Language Extensions für PostgreSQL* ist der offizielle Name des Open-Source-Entwicklungskits, das als `pg_tle`-Erweiterung verpackt ist. Es ist für die Verwendung in jedem PostgreSQL-System verfügbar. Weitere Informationen finden Sie unter [aws/pg\$1tle](https://github.com/aws/pg_tle) auf GitHub.
**Trusted Language Extensions**
*Trusted Language Extensions* ist der Kurzname für Trusted Language Extensions für PostgreSQL. Dieser verkürzte Name und seine Abkürzung (TLE) werden ebenfalls in dieser Dokumentation verwendet.
**Vertrauenswürdige Sprache**
Eine *vertrauenswürdige Sprache* ist eine Programmier- oder Skriptsprache mit bestimmten Sicherheitsattributen. Beispielsweise schränken vertrauenswürdige Sprachen in der Regel den Zugriff auf das Dateisystem und die Verwendung bestimmter Netzwerkeigenschaften ein. Das TLE-Entwicklungskit wurde entwickelt, um vertrauenswürdige Sprachen zu unterstützen. PostgreSQL unterstützt verschiedene Sprachen, die verwendet werden, um vertrauenswürdige oder nicht vertrauenswürdige Erweiterungen zu erstellen. Ein Beispiel finden Sie unter [Trusted and Untrusted PL/Perl](https://www.postgresql.org/docs/current/plperl-trusted.html) in der PostgreSQL-Dokumentation. Wenn Sie eine Erweiterung mithilfe von Trusted Language Extensions erstellen, verwendet die Erweiterung von sich aus vertrauenswürdige Sprachmechanismen.
**TLE-Erweiterung**
Eine *TLE-Erweiterung* ist eine PostgreSQL-Erweiterung, die mithilfe des Trusted Language Extensions (TLE)-Entwicklungskits erstellt wurde.
# Anforderungen für die Verwendung von Trusted Language Extensions für PostgreSQL
Beachten Sie die folgenden Anforderungen für die Einrichtung und Verwendung des TLE-Entwicklungskits.
+ ** RDS-für-PostgreSQL Versionen** – Trusted Language Extensions wird nur von , RDS-für-PostgreSQL Versionen 13.12 und höheren 13-Versionen, 14.5 und höheren 14-Versionen und 15.2 und höheren Versionen unterstützt.
+ Wenn Sie Ihren Ihre Instance von RDS für PostgreSQL aktualisieren müssen, finden Sie weitere Informationen unter [Upgrades der DB-Engine von RDS für PostgreSQL](USER_UpgradeDBInstance.PostgreSQL.md).
+ Wenn Sie noch keine DB-Instance von Amazon RDS für die Ausführung von PostgreSQL haben, können Sie eine/n erstellen. Weitere Informationen finden Sie unter DB-Instance von RDS für PostgreSQL siehe [Erstellen einer PostgreSQL-DB-Instance und Herstellen einer Verbindung](CHAP_GettingStarted.CreatingConnecting.PostgreSQL.md).
+ **Erfordert `rds_superuser`-Berechtigungen** – Um die `pg_tle`-Erweiterung einzurichten und zu konfigurieren, muss Ihre Datenbankbenutzerrolle über die Berechtigungen der `rds_superuser`-Rolle verfügen. Diese Rolle wird standardmäßig dem `postgres`-Benutzer zugewiesen, der den erstellt. DB-Instance von RDS für PostgreSQL
+ **Erfordert eine benutzerdefinierte DB-Parametergruppe** – Ihre DB-Instance von RDS für PostgreSQL muss mit einer benutzerdefinierten DB-Parametergruppe konfiguriert sein.
+ Wenn Ihre DB-Instance von RDS für PostgreSQL nicht mit einer benutzerdefinierten DB-Parametergruppe konfiguriert ist, sollten Sie eine erstellen und sie Ihrer DB-Instance von RDS für PostgreSQL zuordnen. Eine kurze Zusammenfassung der Schritte finden Sie unter [Erstellen und Anwenden einer benutzerdefinierten DB-Parametergruppe](#PostgreSQL_trusted_language_extension-requirements-create-custom-params).
+ Wenn Ihre DB-Instance von RDS für PostgreSQL bereits mit einer benutzerdefinierten DB-Parametergruppe konfiguriert ist, können Sie Trusted Language Extensions einrichten. Details hierzu finden Sie unter [Einrichten von Trusted Language Extensions in Ihrer DB-Instance von RDS für PostgreSQL](PostgreSQL_trusted_language_extension-setting-up.md).
## Erstellen und Anwenden einer benutzerdefinierten DB-Parametergruppe
Verwenden Sie die folgenden Schritte, um eine benutzerdefinierte DB-Parametergruppe zu erstellen und Ihre DB-Instance von RDS für PostgreSQLInstance für ihre Verwendung zu konfigurieren.
### Konsole
**So erstellen Sie eine benutzerdefinierte DB-Parametergruppe und verwenden sie mit Ihrem )**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Menü von Amazon RDS „Parameter groups“ (Parametergruppen) aus.
1. Wählen Sie **Parametergruppe erstellen**.
1. Geben Sie auf der Seite **Parameter group details** Parametergruppendetails die folgenden Informationen ein.
+ Wählen Sie unter **Parameter group family** (Parametergruppenfamilie) die Option postgres14 aus.
+ Wählen Sie für **Type** (Typ) die Option DB Parameter Group (DB-Parametergruppe) aus.
+ Geben Sie Ihrer Parametergruppe unter **Group name** (Gruppenname) im Kontext Ihrer Operationen einen aussagekräftigen Namen.
+ Geben Sie unter **Description** (Beschreibung) eine nützliche Beschreibung ein, damit andere Mitglieder Ihres Teams sie leicht finden können.
1. Wählen Sie **Erstellen** aus. Ihre benutzerdefinierte DB-Parametergruppe wird in Ihrer AWS-Region erstellt. Sie können jetzt Ihre DB-Instance von RDS für PostgreSQL ändern, um sie zu verwenden, indem Sie die nächsten Schritte ausführen.
1. Wählen Sie **Databases** (Datenbanken) im Amazon-RDS-Menü aus.
1. Wählen Sie aus der Liste die DB-Instance von RDS für PostgreSQL für die Verwendung mit TLE aus und klicken Sie dann auf **Modify** (Ändern).
1. Suchen Sie auf der Seite zum Suchen Sie auf der Seite zum Ändern der DB-Instance-Einstellungen im Abschnitt „Additional configuration“ (Zusätzliche Konfiguration) nach **Database options** (Datenbankoptionen) und wählen Sie Ihre benutzerdefinierte DB-Parametergruppe in der Auswahl aus.
1. Wählen Sie **Continue** (Weiter) aus, um die Änderung zu speichern.
1. Wählen Sie **Apply immediately** (Sofort anwenden) aus, damit Sie die Einrichtung der DB-Instance von RDS für PostgreSQL zur Verwendung von TLE fortsetzen können.
Informationen zum weiteren Einrichten Ihres Systems für Trusted Language Extensions finden Sie unter [Einrichten von Trusted Language Extensions in Ihrer DB-Instance von RDS für PostgreSQL](PostgreSQL_trusted_language_extension-setting-up.md).
Weitere Informationen zum Arbeiten mit DB-Parametergruppen siehe [DB-Parametergruppen für DB-Instances von Amazon RDS](USER_WorkingWithDBInstanceParamGroups.md).
### AWS CLI
Sie können die Angabe des `--region`-Arguments vermeiden, wenn Sie CLI-Befehle verwenden, indem Sie Ihre AWS CLI mit Ihrer standardmäßigen AWS-Region konfigurieren. Weitere Informationen finden Sie unter [Konfigurationsgrundlagen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) im *AWS Command Line Interface -Benutzerhandbuch*.
**So erstellen Sie eine benutzerdefinierte DB-Parametergruppe und verwenden sie mit Ihrem )**
1. Verwenden Sie den [create-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-parameter-group.html) AWS CLI Befehl, um eine benutzerdefinierte DB-Parametergruppe basierend auf postgres14 für Ihre zu erstellen. AWS-Region
Für Linux, macOS oder 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"
```
Für 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"
```
Ihre benutzerdefinierte DB-Parametergruppe ist in Ihrer AWS-Region verfügbar. Sie können also die DB-Instance von RDS für PostgreSQL ändern, um sie zu verwenden.
1. Verwenden Sie den [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) AWS CLI Befehl, um Ihre benutzerdefinierte DB-Parametergruppe auf anzuwenden. Ihre RDS für PostgreSQL-DB-Instance. Mit diesem Befehl wird die aktive Instance sofort neu gestartet.
Für Linux, macOS oder 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
```
Für 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
```
Informationen zum weiteren Einrichten Ihres Systems für Trusted Language Extensions finden Sie unter [Einrichten von Trusted Language Extensions in Ihrer DB-Instance von RDS für PostgreSQL](PostgreSQL_trusted_language_extension-setting-up.md).
Weitere Informationen finden Sie unter [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md).
# Einrichten von Trusted Language Extensions in Ihrer DB-Instance von RDS für PostgreSQL
Bei den folgenden Schritten wird davon ausgegangen, dass Ihre DB-Instance von RDS für PostgreSQL einer benutzerdefinierten DB-Parametergruppe zugeordnet ist. Für diese Schritte können Sie die AWS-Managementkonsole oder die AWS CLI verwenden.
Wenn Sie Trusted Language Extensions in Ihrer DB-Instance von RDS für PostgreSQL einrichten, installieren Sie sie in einer bestimmten Datenbank, damit sie von den Datenbankbenutzern verwendet werden kann, die über Berechtigungen für diese Datenbank verfügen.
## Konsole
**So richten Sie Trusted Language Extensions ein**
Führen Sie die folgenden Schritte mit einem Konto aus, das Mitglied der `rds_superuser`-Gruppe (Rolle) ist.
1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon-RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich Ihre DB-Instance von RDS für PostgreSQL aus.
1. Öffnen Sie die Registerkarte **Configuration** (Konfiguration) für Ihre DB-Instance von RDS für PostgreSQL Suchen Sie in den Instance-Details den Link **Parameter group** (Parametergruppe).
1. Wählen Sie den Link aus, um die benutzerdefinierten Parameter zu öffnen, die Ihrem DB-Instance von RDS für PostgreSQL
1. Geben Sie in das Suchfeld **Parameters** (Parameter) `shared_pre` ein, um den `shared_preload_libraries`-Parameter zu finden.
1. Wählen Sie **Edit parameters** (Parameter bearbeiten) aus, um auf die Eigenschaftswerte zuzugreifen.
1. Fügen Sie `pg_tle` der Liste im Feld **Values** (Werte) hinzu. Verwenden Sie ein Komma, um Elemente in der Werteliste zu trennen.
![\[Abbildung des shared_preload_libraries-Parameters mit hinzugefügter pg_tle-Erweiterung.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/apg_rpg_shared_preload_pg_tle.png)
1. Starten Sie die DB-Instance von RDS für PostgreSQL neu, damit Ihre Änderung des `shared_preload_libraries`-Parameters wirksam wird.
1. Wenn die Instance verfügbar ist, überprüfen Sie, ob `pg_tle` initialisiert wurde. Stellen Sie über `psql` eine Verbindung mit der DB-Instance von RDS für PostgreSQL her und führen Sie den folgenden Befehl aus.
```
SHOW shared_preload_libraries;
shared_preload_libraries
--------------------------
rdsutils,pg_tle
(1 row)
```
1. Wenn die `pg_tle`-Erweiterung initialisiert ist, können Sie jetzt die Erweiterung erstellen.
```
CREATE EXTENSION pg_tle;
```
Sie können überprüfen, ob die Erweiterung installiert wurde, indem Sie den folgenden `psql`-Metabefehl verwenden.
```
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. Weisen Sie der `pgtle_admin`-Rolle dem primären Benutzernamen zu, den Sie bei der Einrichtung für Ihre DB-Instance von RDS für PostgreSQL erstellt haben. Wenn Sie die Standardeinstellung akzeptiert haben, lautet der Wert `postgres`.
```
labdb=> GRANT pgtle_admin TO postgres;
GRANT ROLE
```
Wie in folgendem Beispiel veranschaulicht, können Sie anhand des `psql`-Metabefehls überprüfen, ob die Gewährung erfolgt ist. In der Ausgabe werden nur die Rollen `pgtle_admin` und `postgres` angezeigt. Weitere Informationen finden Sie unter [Die Rolle „rds\$1superuser“ verstehen](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. Schließen Sie die `psql`-Sitzung mit dem `\q`-Metabefehl.
```
\q
```
Informationen zum Erstellen von TLE-Erweiterungen finden Sie unter [Beispiel: Erstellen einer Trusted Language Extension mit SQL](PostgreSQL_trusted_language_extension-creating-TLE-extensions.md#PostgreSQL_trusted_language_extension-simple-example).
## AWS CLI
Sie können die Angabe des `--region`-Arguments vermeiden, wenn Sie CLI-Befehle verwenden, indem Sie Ihre AWS CLI mit Ihrer standardmäßigen AWS-Region konfigurieren. Weitere Informationen finden Sie unter [ Konfigurationsgrundlagen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) im *AWS Command Line Interface Benutzerhandbuch*.
**So richten Sie Trusted Language Extensions ein**
1. Verwenden Sie den AWS CLI-Befehl [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html), um dem `shared_preload_libraries`-Parameter `pg_tle` hinzuzufügen.
```
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. Verwenden Sie den AWS CLI-Befehl [reboot-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/reboot-db-instance), um die DB-Instance von RDS für PostgreSQL neu zu starten und die `pg_tle`-Bibliothek zu initialisieren.
```
aws rds reboot-db-instance \
--db-instance-identifier your-instance \
--region aws-region
```
1. Wenn die Instance verfügbar ist, können Sie überprüfen, ob `pg_tle` initialisiert wurde. Stellen Sie über `psql` eine Verbindung mit der DB-Instance von RDS für PostgreSQL her und führen Sie den folgenden Befehl aus.
```
SHOW shared_preload_libraries;
shared_preload_libraries
--------------------------
rdsutils,pg_tle
(1 row)
```
Sobald `pg_tle` initialisiert ist, können Sie die Erweiterung erstellen.
```
CREATE EXTENSION pg_tle;
```
1. Weisen Sie der `pgtle_admin`-Rolle dem primären Benutzernamen zu, den Sie bei der Einrichtung für Ihre DB-Instance von RDS für PostgreSQL erstellt haben. Wenn Sie die Standardeinstellung akzeptiert haben, lautet der Wert `postgres`.
```
GRANT pgtle_admin TO postgres;
GRANT ROLE
```
1. Schließen Sie die `psql`-Sitzung wie folgt.
```
labdb=> \q
```
Informationen zum Erstellen von TLE-Erweiterungen finden Sie unter [Beispiel: Erstellen einer Trusted Language Extension mit SQL](PostgreSQL_trusted_language_extension-creating-TLE-extensions.md#PostgreSQL_trusted_language_extension-simple-example).
# Übersicht über Trusted Language Extensions für PostgreSQL
Trusted Language Extensions für PostgreSQL ist eine PostgreSQL-Erweiterung, die Sie in Ihrer DB-Instance von RDS für PostgreSQL auf die gleiche Weise installieren, wie Sie andere PostgreSQL-Erweiterungen einrichten. In der folgenden Abbildung einer Beispieldatenbank im pgAdmin-Client-Tool können Sie einige der Komponenten sehen, aus denen die `pg_tle`-Erweiterung besteht.
![\[Die Abbildung zeigt einige der Komponenten des TLE-Entwicklungskits.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/apg-pg_tle-installed-view-in-pgAdmin.png)
Sie können die folgenden Details sehen.
1. Das Entwicklungskit von Trusted Language Extensions (TLE) für PostgreSQL ist als `pg_tle`-Erweiterung verpackt. Daher wird `pg_tle` den verfügbaren Erweiterungen für die Datenbank hinzugefügt, in der es installiert ist.
1. TLE hat ein eigenes Schema, `pgtle`. Dieses Schema enthält Hilfsfunktionen (3) für die Installation und Verwaltung der von Ihnen erstellten Erweiterungen.
1. TLE bietet über ein Dutzend Hilfsfunktionen für die Installation, Registrierung und Verwaltung Ihrer Erweiterungen. Weitere Informationen zu diesen Funktionen finden Sie unter [Funktionsreferenz für Trusted Language Extensions für PostgreSQL](PostgreSQL_trusted_language_extension-functions-reference.md).
Das `pg_tle`-Erweiterungspaket umfasst außerdem folgende Komponenten:
+ **Die `pgtle_admin`-Rolle** – Die `pgtle_admin`-Rolle wird erstellt, wenn die `pg_tle`-Erweiterung installiert wird. Diese Rolle ist privilegiert und sollte entsprechend behandelt werden. Es wird dringend empfohlen, bei der Gewährung der `pgtle_admin`-Rolle an Datenbankbenutzer dem Prinzip der *geringsten Berechtigung* zu folgen. Mit anderen Worten, weisen Sie die `pgtle_admin`-Rolle nur Datenbankbenutzern zu, die berechtigt sind, neue TLE-Erweiterungen zu erstellen, zu installieren und zu verwalten, wie z. b. `postgres`.
+ **Die `pgtle.feature_info`-Tabelle** – Die `pgtle.feature_info`-Tabelle ist eine geschützte Tabelle, die Informationen über Ihre TLEs, Haken und die von ihnen verwendeten benutzerdefinierten gespeicherten Prozeduren und Funktionen enthält. Wenn Sie über `pgtle_admin`-Berechtigungen verfügen, verwenden Sie die folgenden Funktionen von Trusted Language Extensions, um diese Informationen in der Tabelle hinzuzufügen und zu aktualisieren.
+ [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)
# Erstellen von TLE-Erweiterungen für RDS für PostgreSQL
Sie können alle Erweiterungen, die Sie mit TLE erstellen, in in jeder beliebigen DB-Instance von RDS für PostgreSQL installieren, sofern die die `pg_tle`-Erweiterung darauf installiert ist. Die `pg_tle`-Erweiterung ist auf die PostgreSQL-Datenbank beschränkt, in der sie installiert ist. Die Erweiterungen, die Sie mit TLE erstellen, sind auf dieselbe Datenbank ausgelegt.
Verwenden Sie die verschiedenen `pgtle`-Funktionen, um den Code zu installieren, aus dem Ihre TLE-Erweiterung besteht. Die folgenden Funktionen von Trusted Language Extensions erfordern alle die `pgtle_admin`-Rolle.
+ [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(name)](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.uninstall_extension-name)
+ [pgtle.uninstall\$1extension(name, version)](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)
## Beispiel: Erstellen einer Trusted Language Extension mit SQL
Das folgende Beispiel zeigt Ihnen, wie Sie eine TLE-Erweiterung namens `pg_distance` erstellen, die einige SQL-Funktionen für die Berechnung von Entfernungen mit verschiedenen Formeln enthält. In der Liste finden Sie die Funktion zur Berechnung der Manhattan-Distanz und die Funktion zur Berechnung des euklidischen Abstands. Weitere Informationen zum Unterschied zwischen diesen Formeln finden Sie unter [Taxi-Geometerie](https://en.wikipedia.org/wiki/Taxicab_geometry) und [Euklidische Geometrie](https://en.wikipedia.org/wiki/Euclidean_geometry) in Wikipedia.
Sie können dieses Beispiel in Ihrer eigenen DB-Instance von RDS für PostgreSQL verwenden, wenn Sie die `pg_tle`-Erweiterung wie unter [Einrichten von Trusted Language Extensions in Ihrer DB-Instance von RDS für PostgreSQL](PostgreSQL_trusted_language_extension-setting-up.md) beschrieben eingerichtet haben.
**Anmerkung**
Sie benötigen die Rechte der `pgtle_admin`-Rolle, um dieses Verfahren ausführen zu können.
**So erstellen Sie die TLE-Beispielerweiterung**
In den folgenden Schritten wird eine Beispieldatenbank namens `labdb` verwendet. Diese Datenbank gehört dem `postgres`-Hauptbenutzer. Die `postgres`-Rolle verfügt auch über die Berechtigungen der `pgtle_admin`-Rolle.
1. Verwenden Sie `psql`, um eine Verbindung mit der herzustellen. DB-Instance von RDS für PostgreSQL
```
psql --host=db-instance-123456789012.aws-region.rds.amazonaws.com
--port=5432 --username=postgres --password --dbname=labdb
```
1. Erstellen Sie eine TLE-Erweiterung mit dem Namen `pg_distance`, indem Sie den folgenden Code kopieren und in Ihre `psql`-Sitzungskonsole einfügen.
```
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_$
);
```
Die Ausgabe sollte folgendermaßen aussehen.
```
install_extension
---------------
t
(1 row)
```
Die Artefakte, aus denen die `pg_distance`-Erweiterung besteht, sind jetzt in Ihrer Datenbank installiert. Zu diesen Artefakten gehören die Steuerdatei und der Code für die Erweiterung. Diese Elemente müssen vorhanden sein, damit die Erweiterung mit dem `CREATE EXTENSION`-Befehl erstellt werden kann. Mit anderen Worten, Sie müssen die Erweiterung nach wie vor erstellen, um ihre Funktionen Datenbankbenutzern zur Verfügung zu stellen.
1. Um die Erweiterung zu erstellen, verwenden Sie den `CREATE EXTENSION`-Befehl wie für jede andere Erweiterung. Wie bei anderen Erweiterungen muss der Datenbankbenutzer über die `CREATE`-Berechtigungen in der Datenbank verfügen.
```
CREATE EXTENSION pg_distance;
```
1. Um die `pg_distance`-TLE-Erweiterung zu testen, können Sie sie verwenden, um die [Manhattan-Distanz](https://en.wikipedia.org/wiki/Taxicab_geometry) zwischen vier Punkten zu berechnen.
```
labdb=> SELECT manhattan_dist(1, 1, 5, 5);
8
```
Um den [euklidischen Abstand](https://en.wikipedia.org/wiki/Euclidean_geometry) zwischen derselben Menge von Punkten zu berechnen, können Sie Folgendes verwenden.
```
labdb=> SELECT euclidean_dist(1, 1, 5, 5);
5.656854249492381
```
Die `pg_distance`-Erweiterung lädt die Funktionen in die Datenbank und stellt sie allen Benutzern mit Berechtigungen für die Datenbank zur Verfügung.
## Ändern Ihrer TLE-Erweiterung
Um die Abfrageleistung für die in dieser TLE-Erweiterung enthaltenen Funktionen zu verbessern, fügen Sie ihren Spezifikationen die beiden folgenden PostgreSQL-Attribute hinzu.
+ `IMMUTABLE` – Das `IMMUTABLE`-Attribut stellt sicher, dass der Abfrageoptimierer Optimierungen verwenden kann, um die Antwortzeiten von Abfragen zu verbessern. Weitere Informationen finden Sie im Abschnitt [Volatilitätskategorien von Funktionen](https://www.postgresql.org/docs/current/xfunc-volatility.html) der PostgreSQL-Dokumentation.
+ `PARALLEL SAFE` – Das `PARALLEL SAFE`-Attribut ist ein weiteres Attribut, das es PostgreSQL ermöglicht, die Funktion im Parallelmodus auszuführen. Weitere Informationen finden Sie im Abschnitt [CREATE FUNCTION](https://www.postgresql.org/docs/current/sql-createfunction.html) der PostgreSQL-Dokumentation.
Im folgenden Beispiel können Sie sehen, wie die `pgtle.install_update_path`-Funktion verwendet wird, um diese Attribute jeder Funktion hinzuzufügen, um eine Version `0.2` der `pg_distance`-TLE-Erweiterung zu erstellen. Weitere Informationen zu dieser Funktion finden Sie unter [pgtle.install\$1update\$1path](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.install_update_path). Sie benötigen die `pgtle_admin` Rolle, um diese Aufgabe auszuführen.
**So aktualisieren Sie eine vorhandene TLE-Erweiterung und geben die Standardversion an**
1. Stellen Sie über `psql` oder ein anderes Client-Tool wie pgAdmin eine Verbindung mit der der DB-Instance von RDS für PostgreSQL her.
```
psql --host=db-instance-123456789012.aws-region.rds.amazonaws.com
--port=5432 --username=postgres --password --dbname=labdb
```
1. Ändern Sie die vorhandene TLE-Erweiterung, indem Sie den folgenden Code kopieren und in Ihre `psql`-Sitzungskonsole einfügen.
```
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_$
);
```
Es wird eine Antwort ähnlich dem folgenden Beispiel angezeigt.
```
install_update_path
---------------------
t
(1 row)
```
Sie können diese Version der Erweiterung zur Standardversion machen, sodass Datenbankbenutzer keine Version angeben müssen, wenn sie die Erweiterung in ihrer Datenbank erstellen oder aktualisieren.
1. Um anzugeben, dass die modifizierte Version (Version 0.2) Ihrer TLE-Erweiterung die Standardversion ist, verwenden Sie die `pgtle.set_default_version`-Funktion wie im folgenden Beispiel gezeigt.
```
SELECT pgtle.set_default_version('pg_distance', '0.2');
```
Weitere Informationen zu dieser Funktion finden Sie unter [pgtle.set\$1default\$1version](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.set_default_version).
1. Wenn der Code vorhanden ist, können Sie die installierte TLE-Erweiterung wie gewohnt aktualisieren, indem Sie den `ALTER EXTENSION ... UPDATE`-Befehl verwenden, wie hier gezeigt:
```
ALTER EXTENSION pg_distance UPDATE;
```
# Löschen Ihrer TLE-Erweiterungen aus einer Datenbank
Sie können Ihre TLE-Erweiterungen löschen, indem Sie den `DROP EXTENSION`-Befehl auf die gleiche Weise wie für andere PostgreSQL-Erweiterungen verwenden. Durch das Löschen der Erweiterung werden die Installationsdateien, aus denen die Erweiterung besteht, nicht entfernt, sodass Benutzer die Erweiterung neu erstellen können. Gehen Sie wie folgt in zwei Schritten vor, um die Erweiterung und ihre Installationsdateien zu entfernen.
**So löschen Sie die TLE-Erweiterung und entfernen ihre Installationsdateien**
1. Stellen Sie über `psql` oder ein anderes Client-Tool eine Verbindung mit der DB-Instance von RDS für PostgreSQL her.
```
psql --host=.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=dbname
```
1. Löschen Sie die Erweiterung so wie jede andere PostgreSQL-Erweiterung.
```
DROP EXTENSION your-TLE-extension
```
Wenn Sie die `pg_distance`-Erweiterung beispielsweise wie in beschrieben [Beispiel: Erstellen einer Trusted Language Extension mit SQL](PostgreSQL_trusted_language_extension-creating-TLE-extensions.md#PostgreSQL_trusted_language_extension-simple-example) erstellen, können Sie die Erweiterung wie folgt löschen.
```
DROP EXTENSION pg_distance;
```
Es wird eine Ausgabe angezeigt, die bestätigt, dass die Erweiterung gelöscht wurde, wie im Folgenden gezeigt.
```
DROP EXTENSION
```
Zu diesem Zeitpunkt ist die Erweiterung in der Datenbank nicht mehr aktiv. Die Installationsdateien und die Steuerdatei sind jedoch nach wie vor in der Datenbank verfügbar, sodass Datenbankbenutzer die Erweiterung erneut erstellen können, wenn sie möchten.
+ Wenn Sie die Erweiterungsdateien intakt lassen möchten, damit Datenbankbenutzer Ihre TLE-Erweiterung erstellen können, können Sie an dieser Stelle aufhören.
+ Wenn Sie alle Dateien, aus denen die Erweiterung besteht, entfernen möchten, fahren Sie mit dem nächsten Schritt fort.
1. Verwenden Sie die `pgtle.uninstall_extension`-Funktion, um alle Installationsdateien für Ihre Erweiterung zu entfernen. Diese Funktion entfernt dne gesamten Code und die Steuerdateien für Ihre Erweiterung.
```
SELECT pgtle.uninstall_extension('your-tle-extension-name');
```
Verwenden Sie beispielsweise den folgenden Befehl, um alle `pg_distance`-Installationsdateien zu entfernen.
```
SELECT pgtle.uninstall_extension('pg_distance');
uninstall_extension
---------------------
t
(1 row)
```
# Deinstallieren von Trusted Language Extensions für PostgreSQL
Wenn Sie keine eigenen TLE-Erweiterungen mehr mit TLE erstellen möchten, können Sie die `pg_tle`-Erweiterung löschen und alle Artefakte entfernen. Diese Aktion beinhaltet das Löschen aller TLE-Erweiterungen in der Datenbank und das Entfernen des`pgtle`-Schemas.
**So löschen Sie die `pg_tle`-Erweiterung und ihr Schema aus einer Datenbank**
1. Stellen Sie über `psql` oder ein anderes Client-Tool eine Verbindung mit der DB-Instance von RDS für PostgreSQL her.
```
psql --host=.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=dbname
```
1. Löschen Sie die `pg_tle`-Erweiterung aus der Datenbank. Wenn Ihre eigenen TLE-Erweiterungen noch in der Datenbank laufen, müssen Sie diese Erweiterungen ebenfalls löschen. Dazu können Sie das `CASCADE`-Schlüsselwort verwenden, wie im Folgenden gezeigt.
```
DROP EXTENSION pg_tle CASCADE;
```
Wenn die `pg_tle`-Erweiterung in der Datenbank nicht mehr aktiv ist, müssen Sie das `CASCADE`-Schlüsselwort nicht verwenden.
1. Löschen Sie das `pgtle`-Schema. Mit dieser Aktion werden alle Verwaltungsfunktionen aus der Datenbank entfernt.
```
DROP SCHEMA pgtle CASCADE;
```
Der Befehl gibt nach Abschluss des Vorgangs Folgendes zurück.
```
DROP SCHEMA
```
Die `pg_tle`-Erweiterung, ihr Schema und ihre Funktionen sowie alle Artefakte werden entfernt. Um neue Erweiterungen mit TLE zu erstellen, führen Sie den Einrichtungsvorgang erneut durch. Weitere Informationen finden Sie unter [Einrichten von Trusted Language Extensions in Ihrer DB-Instance von RDS für PostgreSQL](PostgreSQL_trusted_language_extension-setting-up.md).
# Verwenden von PostgreSQL-Haken mit Ihren TLE-Erweiterungen
Ein *Haken* ist ein in PostgreSQL verfügbarer Callback-Mechanismus, der es Entwicklern ermöglicht, benutzerdefinierte Funktionen oder andere Routinen während regulärer Datenbankoperationen aufzurufen. Das TLE-Entwicklungskit unterstützt PostgreSQL-Haken, sodass Sie benutzerdefinierte Funktionen zur Laufzeit in das PostgreSQL-Verhalten integrieren können. Sie können beispielsweise einen Haken verwenden, um den Authentifizierungsprozess mit Ihrem eigenen benutzerdefinierten Code zu verknüpfen oder um den Planungs- und Ausführungsprozess für Abfragen Ihren spezifischen Bedürfnissen entsprechend anzupassen.
Ihre TLE-Erweiterungen können Haken verwenden. Wenn ein Haken einen globalen Gültigkeitsbereich hat, gilt er für alle Datenbanken. Wenn Ihre TLE-Erweiterung einen globalen Haken verwendet, müssen Sie Ihre TLE-Erweiterung daher in allen Datenbanken erstellen, auf die Ihre Benutzer zugreifen können.
Wenn Sie die `pg_tle`-Erweiterung verwenden, um Ihre eigenen Trusted Language Extensions zu erstellen, können Sie die verfügbaren Haken einer SQL-API verwenden, um die Funktionen Ihrer Erweiterung zu erstellen. Sie sollten alle Haken bei `pg_tle` registrieren. Für einige Haken müssen Sie möglicherweise auch verschiedene Konfigurationsparameter festlegen. Der `passcode`-Prüfungshaken kann beispielsweise auf ein, aus oder erforderlich festgelegt werden. Weitere Hinweise zu den spezifischen Anforderungen für verfügbare `pg_tle`-Haken finden Sie unter [Hakenreferenz für Trusted Language Extensions für PostgreSQL](PostgreSQL_trusted_language_extension-hooks-reference.md).
## Beispiel: Erstellen einer Erweiterung, die einen PostgreSQL-Haken verwendet
Das in diesem Abschnitt besprochene Beispiel verwendet einen PostgreSQL-Haken, um das bei bestimmten SQL-Vorgängen angegebene Passwort zu überprüfen, und verhindert, dass Datenbankbenutzer ihre Passwörter auf eines der in der `password_check.bad_passwords`-Tabelle enthaltenen Passwörter festlegen. Die Tabelle enthält die zehn am häufigsten verwendeten, aber leicht zu knackenden Optionen für Passwörter.
Um dieses Beispiel in Ihrer DB-Instance von RDS für PostgreSQL einzurichten, müssen Sie Trusted Language Extensions bereits installiert haben. Details hierzu finden Sie unter [Einrichten von Trusted Language Extensions in Ihrer DB-Instance von RDS für PostgreSQL](PostgreSQL_trusted_language_extension-setting-up.md).
**So richten Sie das Beispiel für einen Haken für die Passwortüberprüfung ein**
1. Verwenden Sie `psql`, um eine Verbindung mit der herzustellen. DB-Instance von RDS für PostgreSQL
```
psql --host=db-instance-123456789012.aws-region.rds.amazonaws.com
--port=5432 --username=postgres --password --dbname=labdb
```
1. Kopieren Sie den Code von [Liste der Hakencodes für die Passwortüberprüfung](#PostgreSQL_trusted_language_extension-example-hook_code_listing) und fügen Sie ihn in Ihre Datenbank ein.
```
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_$
);
```
Wenn die Erweiterung in Ihre Datenbank geladen wurde, sehen Sie eine Ausgabe ähnlich wie die folgende.
```
install_extension
-------------------
t
(1 row)
```
1. Während Sie noch mit der Datenbank verbunden sind, können Sie jetzt die Erweiterung erstellen.
```
CREATE EXTENSION my_password_check_rules;
```
1. Mit dem folgenden `psql`-Metabefehl können Sie bestätigen, dass die Erweiterung in der Datenbank erstellt wurde.
```
\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. Öffnen Sie eine weitere Terminalsitzung, um mit der AWS CLI zu arbeiten. Sie müssen Ihre benutzerdefinierte DB-Parametergruppe ändern, um den Haken für die Passwortüberprüfung zu aktivieren. Verwenden Sie dazu den CLI-Befehl [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html), wie im folgenden Beispiel gezeigt.
```
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"
```
Wenn der Parameter erfolgreich aktiviert wurde, wird eine Ausgabe wie die folgende angezeigt.
```
(
"DBParameterGroupName": "docs-lab-parameters-for-tle"
}
```
Es kann einige Minuten dauern, bis die Änderung der Parametergruppe wirksam wird. Dieser Parameter ist jedoch dynamisch, sodass Sie die DB-Instance von RDS für PostgreSQL nicht neu starten müssen, damit die Einstellung wirksam wird.
1. Öffnen Sie die `psql`-Sitzung und fragen Sie die Datenbank ab, um zu überprüfen, ob der password\$1check-Haken aktiviert wurde.
```
labdb=> SHOW pgtle.enable_password_check;
pgtle.enable_password_check
-----------------------------
on
(1 row)
```
Der Haken für die Passwortüberprüfung ist jetzt aktiv. Sie können dies testen, indem Sie eine neue Rolle erstellen und eines der schwachen Passwörter verwenden, wie im folgenden Beispiel gezeigt.
```
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)"
```
Die Ausgabe wurde zur besseren Lesbarkeit formatiert.
Das folgende Beispiel zeigt, dass das interaktive `pgsql`-Metabefehlverhalten `\password` auch vom password\$1check-Haken beeinflusst wird.
```
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)"
```
Sie können diese TLE-Erweiterung löschen und ihre Quelldateien deinstallieren, wenn Sie möchten. Weitere Informationen finden Sie unter [Löschen Ihrer TLE-Erweiterungen aus einer DatenbankLöschen Ihrer TLE-Erweiterungen aus einer Datenbank](PostgreSQL_trusted_language_extension-creating-TLE-extensions.dropping-TLEs.md).
### Liste der Hakencodes für die Passwortüberprüfung
Der hier gezeigte Beispielcode definiert die Spezifikation für die `my_password_check_rules`-TLE-Erweiterung. Wenn Sie diesen Code kopieren und in Ihre Datenbank einfügen, wird der Code für die `my_password_check_rules`-Erweiterung in die Datenbank geladen und der `password_check`-Haken für die Verwendung durch die Erweiterung registriert.
```
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_$
);
```
# Verwendung benutzerdefinierter Datentypen in TLE
PostgreSQL unterstützt Befehle zur Registrierung neuer Basistypen (auch bekannt als Skalartypen), um komplexe Datenstrukturen in Ihrer Datenbank effizient zu handhaben. Mit einem Basistyp können Sie anpassen, wie die Daten intern gespeichert werden und wie sie in und aus einer externen Textdarstellung konvertiert werden. Diese benutzerdefinierten Datentypen sind nützlich, wenn PostgreSQL erweitert wird, um funktionale Domains zu unterstützen, in denen ein integrierter Typ wie Zahl oder Text keine ausreichende Suchsemantik bieten kann.
Mit RDS für PostgreSQL können Sie benutzerdefinierte Datentypen in Ihrer Trusted Languages Extension erstellen und Funktionen definieren, die SQL- und Indexoperationen für diese neuen Datentypen unterstützen. Benutzerdefinierte Datentypen sind für die folgenden Versionen verfügbar:
+ RDS für PostgreSQL 15.4 und höhere 15-Versionen
+ RDS für PostgreSQL 14.9 und höhere 14-Versionen
+ RDS für PostgreSQL 13.12 und höhere 13-Versionen
Weitere Informationen finden Sie unter [Trusted Language Base-Typen](https://github.com/aws/pg_tle/blob/main/docs/09_datatypes.md).
# Funktionsreferenz für Trusted Language Extensions für PostgreSQL
Sehen Sie sich die folgende Referenzdokumentation zu den Funktionen an, die in Trusted Language Extensions für PostgreSQL verfügbar sind. Verwenden Sie diese Funktionen, um Ihre *TLE-Erweiterungen*, d. h. die PostgreSQL-Erweiterungen, die Sie mit dem Trusted Language Extensions Development Kit entwickeln, zu installieren, zu registrieren, zu aktualisieren und zu verwalten.
**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(name)
](#pgtle.uninstall_extension-name)
+ [
## pgtle.uninstall\$1extension(name, version)
](#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
Die `pgtle.available_extensions`-Funktion ist eine Mengenrückgabefunktion. Sie gibt alle verfügbaren TLE-Erweiterungen in der Datenbank zurück. Jede zurückgegebene Zeile enthält Informationen zu einer einzelnen TLE-Erweiterung.
### Funktionsprototyp
```
pgtle.available_extensions()
```
### Rolle
Keine.
### Argumente
Keine.
### Output
+ `name` – Der Name der TLE-Erweiterung.
+ `default_version` – Die Version der TLE-Erweiterung, die verwendet werden soll, wenn `CREATE EXTENSION` ohne Angabe einer Version aufgerufen wird.
+ `description` – Eine ausführlichere Beschreibung der TLE-Erweiterung.
### Verwendungsbeispiel
```
SELECT * FROM pgtle.available_extensions();
```
## pgtle.available\$1extension\$1versions
Die `available_extension_versions`-Funktion ist eine Mengenrückgabefunktion. Sie gibt eine Liste aller verfügbaren TLE-Erweiterungen und deren Versionen zurück. Jede Zeile enthält Informationen zu einer bestimmten Version der angegebenen TLE-Erweiterung, einschließlich der Frage, ob für sie eine bestimmte Rolle erforderlich ist.
### Funktionsprototyp
```
pgtle.available_extension_versions()
```
### Rolle
Keine.
### Argumente
Keine.
### Output
+ `name` – Der Name der TLE-Erweiterung.
+ `version` – Die Version der TLE-Erweiterung.
+ `superuser` – Dieser Wert ist für Ihre TLE-Erweiterungen immer `false`. Die Berechtigungen, die zum Erstellen oder Aktualisieren der TLE-Erweiterung erforderlich sind, entsprechen denen, die für die Erstellung anderer Objekte in der angegebenen Datenbank notwendig sind.
+ `trusted` – Dieser Wert ist für eine TLE-Erweiterung immer `false`.
+ `relocatable` – Dieser Wert ist für eine TLE-Erweiterung immer `false`.
+ `schema` – Gibt den Namen des Schemas an, in dem die TLE-Erweiterung installiert ist.
+ `requires` – Ein Array, das die Namen anderer Erweiterungen enthält, die für diese TLE-Erweiterung benötigt werden.
+ `description` – Eine ausführliche Beschreibung der TLE-Erweiterung.
Weitere Informationen zu Ausgabewerten finden Sie unter [Packaging Related Objects into an Extension > Extension Files](https://www.postgresql.org/docs/current/extend-extensions.html#id-1.8.3.20.11) in der PostgreSQL-Dokumentation.
### Verwendungsbeispiel
```
SELECT * FROM pgtle.available_extension_versions();
```
## pgtle.extension\$1update\$1paths
Die `extension_update_paths`-Funktion ist eine Mengenrückgabefunktion. Sie gibt eine Liste aller möglichen Aktualisierungspfade für eine TLE-Erweiterung zurück. Jede Zeile enthält die verfügbaren Upgrades oder Downgrades für diese TLE-Erweiterung.
### Funktionsprototyp
```
pgtle.extension_update_paths(name)
```
### Rolle
Keine.
### Argumente
`name` – Der Name der TLE-Erweiterung, von der die Upgrade-Pfade abgerufen werden sollen.
### Output
+ `source` – Die Quellversion für eine Aktualisierung.
+ `target` – Die Zielversion für eine Aktualisierung.
+ `path` – Der Upgrade-Pfad, der verwendet wird, um eine TLE-Erweiterung von der `source`-Version auf die `target`-Version zu aktualisieren, zum Beispiel `0.1--0.2`.
### Verwendungsbeispiel
```
SELECT * FROM pgtle.extension_update_paths('your-TLE');
```
## pgtle.install\$1extension
Mit dieser `install_extension`-Funktion können Sie die Artefakte, aus denen Ihre TLE-Erweiterung besteht, in der Datenbank installieren. Anschließend können sie mit dem `CREATE EXTENSION`-Befehl erstellt werden.
### Funktionsprototyp
```
pgtle.install_extension(name text, version text, description text, ext text, requires text[] DEFAULT NULL::text[])
```
### Rolle
Keine.
### Argumente
+ `name` – Der Name der TLE-Erweiterung. Dieser Wert wird beim Aufrufen von `CREATE EXTENSION` verwendet.
+ `version` – Die Version der TLE-Erweiterung.
+ `description` – Eine ausführliche Beschreibung der TLE-Erweiterung. Diese Beschreibung wird im Feld `comment` in `pgtle.available_extensions()` angezeigt.
+ `ext` – Der Inhalt der TLE-Erweiterung. Dieser Wert enthält Objekte wie Funktionen.
+ `requires` – Ein optionaler Parameter, der Abhängigkeiten für diese TLE-Erweiterung angibt. Die `pg_tle`-Erweiterung wird automatisch als Abhängigkeit hinzugefügt.
Viele dieser Argumente entsprechen denen, die in einer Erweiterungskontrolldatei für die Installation einer PostgreSQL-Erweiterung im Dateisystem einer PostgreSQL-Instance enthalten sind. Weitere Informationen finden Sie unter [Extension Files](http://www.postgresql.org/docs/current/extend-extensions.html#id-1.8.3.20.11) in [Packaging Related Objects in a Extension](https://www.postgresql.org/docs/current/extend-extensions.html) in der PostgreSQL-Dokumentation.
### Output
Diese Funktion gibt bei Erfolg `OK` und bei Fehler `NULL` zurück.
+ `OK` – Die TLE-Erweiterung wurde erfolgreich in der Datenbank installiert.
+ `NULL` – Die TLE-Erweiterung wurde nicht erfolgreich in der Datenbank installiert.
### Verwendungsbeispiel
```
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
Die `install_update_path`-Funktion stellt einen Aktualisierungspfad zwischen zwei verschiedenen Versionen einer TLE-Erweiterung bereit. Mit dieser Funktion können Benutzer Ihrer TLE-Erweiterung ihre Version mithilfe der `ALTER EXTENSION ... UPDATE`-Syntax aktualisieren.
### Funktionsprototyp
```
pgtle.install_update_path(name text, fromvers text, tovers text, ext text)
```
### Rolle
`pgtle_admin`
### Argumente
+ `name` – Der Name der TLE-Erweiterung. Dieser Wert wird beim Aufrufen von `CREATE EXTENSION` verwendet.
+ `fromvers` – Die Quellversion der TLE-Erweiterung für das Upgrade.
+ `tovers` – Die Zielversion der TLE-Erweiterung für das Upgrade.
+ `ext` – Der Inhalt der Aktualisierung. Dieser Wert enthält Objekte wie Funktionen.
### Output
Keine.
### Verwendungsbeispiel
```
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
Die `register_feature`-Funktion fügt der `pgtle.feature_info`-Tabelle das angegebene interne PostgreSQL-Feature hinzu. PostgreSQL-Haken sind ein Beispiel für ein internes PostgreSQL-Feature. Das Trusted Language Extensions Development Kit unterstützt die Verwendung von PostgreSQL-Haken. Derzeit unterstützt diese Funktion das folgende Feature.
+ `passcheck` – Registriert den Haken für die Passwortüberprüfung bei Ihrer Prozedur oder Funktion, die das Verhalten von PostgreSQL bei der Passwortüberprüfung anpasst.
### Funktionsprototyp
```
pgtle.register_feature(proc regproc, feature pg_tle_feature)
```
### Rolle
`pgtle_admin`
### Argumente
+ `proc` – Der Name einer gespeicherten Prozedur oder Funktion, die für das Feature verwendet werden soll.
+ `feature` – Der Name des `pg_tle`-Features (z. B. `passcheck`), das für die Funktion registriert werden soll.
### Output
Keine.
### Verwendungsbeispiel
```
SELECT pgtle.register_feature('pw_hook', 'passcheck');
```
## pgtle.register\$1feature\$1if\$1not\$1exists
Die `pgtle.register_feature_if_not_exists`-Funktion fügt der `pgtle.feature_info`-Tabelle das angegebene PostgreSQL-Feature hinzu und identifiziert die TLE-Erweiterung oder eine andere Prozedur oder Funktion, die das Feature verwendet. Weitere Informationen zu Haken und Trusted Language Extensions finden Sie unter [Verwenden von PostgreSQL-Haken mit Ihren TLE-Erweiterungen](PostgreSQL_trusted_language_extension.overview.tles-and-hooks.md).
### Funktionsprototyp
```
pgtle.register_feature_if_not_exists(proc regproc, feature pg_tle_feature)
```
### Rolle
`pgtle_admin`
### Argumente
+ `proc` – Der Name einer gespeicherten Prozedur oder Funktion, die die Logik (Code) enthält, die als Feature für Ihre TLE-Erweiterung verwendet werden soll. Beispielsweise der `pw_hook`-Code.
+ `feature` – Der Name des PostgreSQL-Features, das für die TLE-Funktion registriert werden soll. Derzeit ist der `passcheck`-Haken das einzige verfügbare Feature. Weitere Informationen finden Sie unter [Haken zur Passwortüberprüfung (Passcheck)](PostgreSQL_trusted_language_extension-hooks-reference.md#passcheck_hook).
### Output
Gibt `true` zurück, nachdem das Feature für die angegebene Erweiterung registriert wurde. Gibt `false` zurück, wenn das Feature bereits registriert ist.
### Verwendungsbeispiel
```
SELECT pgtle.register_feature_if_not_exists('pw_hook', 'passcheck');
```
## pgtle.set\$1default\$1version
Mit der `set_default_version`-Funktion können Sie eine `default_version` für Ihre TLE-Erweiterung angeben. Mit dieser Funktion können Sie einen Upgrade-Pfad definieren und die Version als Standard für Ihre TLE-Erweiterung festlegen. Wenn Datenbankbenutzer Ihre TLE-Erweiterung in den Befehlen `CREATE EXTENSION` und `ALTER EXTENSION ... UPDATE` angeben, wird diese Version Ihrer TLE-Erweiterung in der Datenbank für diesen Benutzer erstellt.
Diese Funktion gibt bei Erfolg `true` zurück. Wenn die im `name`-Argument angegebene TLE-Erweiterung nicht vorhanden ist, gibt die Funktion einen Fehler zurück. Entsprechend wird ein Fehler zurückgegeben, wenn die `version` der TLE-Erweiterung nicht existiert.
### Funktionsprototyp
```
pgtle.set_default_version(name text, version text)
```
### Rolle
`pgtle_admin`
### Argumente
+ `name` – Der Name der TLE-Erweiterung. Dieser Wert wird beim Aufrufen von `CREATE EXTENSION` verwendet.
+ `version` – Die Version der TLE-Erweiterung, für die die Standardeinstellung festgelegt werden soll.
### Output
+ `true`– Wenn die Standardversion erfolgreich festgelegt wurde, gibt die Funktion `true` zurück.
+ `ERROR` – Gibt eine Fehlermeldung zurück, wenn eine TLE-Erweiterung mit dem angegebenen Namen oder der angegebenen Version nicht existiert.
### Verwendungsbeispiel
```
SELECT * FROM pgtle.set_default_version('my-extension', '1.1');
```
## pgtle.uninstall\$1extension(name)
Die `uninstall_extension`-Funktion entfernt alle Versionen einer TLE-Erweiterung aus einer Datenbank. Diese Funktion verhindert, dass die TLE-Erweiterung durch künftige Aufrufe von `CREATE EXTENSION` installiert wird. Wenn die TLE-Erweiterung in der Datenbank nicht existiert, wird ein Fehler ausgelöst.
Die `uninstall_extension`-Funktion löscht die TLE-Erweiterung jedoch nicht, wenn diese derzeit in der Datenbank aktiv ist. Zum Löschen einer TLE-Erweiterung, die derzeit aktiv ist, müssen Sie explizit `DROP EXTENSION` aufrufen, um sie zu entfernen.
### Funktionsprototyp
```
pgtle.uninstall_extension(extname text)
```
### Rolle
`pgtle_admin`
### Argumente
+ `extname` – Der Name der zu deinstallierenden TLE-Erweiterung. Dieser Name ist derselbe, der mit `CREATE EXTENSION` verwendet wurde, um die TLE-Erweiterung zur Verwendung in einer bestimmten Datenbank zu laden.
### Output
Keine.
### Verwendungsbeispiel
```
SELECT * FROM pgtle.uninstall_extension('pg_tle_test');
```
## pgtle.uninstall\$1extension(name, version)
Die `uninstall_extension(name, version)`-Funktion entfernt die angegebene Version der TLE-Erweiterung aus der Datenbank. Diese Funktion verhindert, dass `CREATE EXTENSION` und `ALTER EXTENSION` eine TLE-Erweiterung installieren oder auf die angegebene Version aktualisieren. Diese Funktion entfernt außerdem alle Aktualisierungspfade für die angegebene Version der TLE-Erweiterung. Diese Funktion deinstalliert die TLE-Erweiterung jedoch nicht, wenn diese derzeit in der Datenbank aktiv ist. Sie müssen explizit `DROP EXTENSION` aufrufen, um die TLE-Erweiterung zu entfernen. Informationen zur Deinstallation aller Versionen einer TLE-Erweiterung finden Sie unter [pgtle.uninstall\$1extension(name)](#pgtle.uninstall_extension-name).
### Funktionsprototyp
```
pgtle.uninstall_extension(extname text, version text)
```
### Rolle
`pgtle_admin`
### Argumente
+ `extname` – Der Name der TLE-Erweiterung. Dieser Wert wird beim Aufrufen von `CREATE EXTENSION` verwendet.
+ `version` – Die Version der TLE-Erweiterung, die in der Datenbank deinstalliert werden soll.
### Output
Keine.
### Verwendungsbeispiel
```
SELECT * FROM pgtle.uninstall_extension('pg_tle_test', '0.2');
```
## pgtle.uninstall\$1extension\$1if\$1exists
Die `uninstall_extension_if_exists`-Funktion entfernt alle Versionen einer TLE-Erweiterung aus einer bestimmten Datenbank. Wenn die TLE-Erweiterung nicht existiert, bleibt die Funktion im Hintergrund (es wird keine Fehlermeldung ausgegeben). Wenn die angegebene Erweiterung derzeit in einer Datenbank aktiv ist, wird sie von dieser Funktion nicht gelöscht. Sie müssen `DROP EXTENSION` explizit aufrufen, um die TLE-Erweiterung zu entfernen, bevor Sie diese Funktion verwenden, um ihre Artefakte zu deinstallieren.
### Funktionsprototyp
```
pgtle.uninstall_extension_if_exists(extname text)
```
### Rolle
`pgtle_admin`
### Argumente
+ `extname` – Der Name der TLE-Erweiterung. Dieser Wert wird beim Aufrufen von `CREATE EXTENSION` verwendet.
### Output
Die `uninstall_extension_if_exists`-Funktion gibt `true` nach der Deinstallation der angegebenen Erweiterung zurück. Wenn die angegebene Erweiterung nicht vorhanden ist, gibt die Funktion `false` zurück.
+ `true` – Gibt `true` nach der Deinstallation der TLE-Erweiterung zurück.
+ `false` – Gibt `false` zurück, wenn die TLE-Erweiterung in der Datenbank nicht existiert.
### Verwendungsbeispiel
```
SELECT * FROM pgtle.uninstall_extension_if_exists('pg_tle_test');
```
## pgtle.uninstall\$1update\$1path
Die `uninstall_update_path`-Funktion entfernt den angegebenen Aktualisierungspfad einer TLE-Erweiterung. Dadurch wird verhindert, dass `ALTER EXTENSION ... UPDATE TO` diesen Pfad als Aktualisierungspfad verwendet.
Wenn die TLE-Erweiterung derzeit von einer der Versionen in diesem Aktualisierungspfad verwendet wird, verbleibt sie in der Datenbank.
Wenn der angegebene Aktualisierungspfad nicht vorhanden ist, gibt diese Funktion einen Fehler aus.
### Funktionsprototyp
```
pgtle.uninstall_update_path(extname text, fromvers text, tovers text)
```
### Rolle
`pgtle_admin`
### Argumente
+ `extname` – Der Name der TLE-Erweiterung. Dieser Wert wird beim Aufrufen von `CREATE EXTENSION` verwendet.
+ `fromvers` – Die Quellversion der TLE-Erweiterung, die im Aktualisierungspfad verwendet wird.
+ `tovers` – Die Zielversion der TLE-Erweiterung, die im Aktualisierungspfad verwendet wird.
### Output
Keine.
### Verwendungsbeispiel
```
SELECT * FROM pgtle.uninstall_update_path('pg_tle_test', '0.1', '0.2');
```
## pgtle.uninstall\$1update\$1path\$1if\$1exists
Die `uninstall_update_path_if_exists`-Funktion ähnelt `uninstall_update_path` insofern, als sie den angegebenen Aktualisierungspfad aus einer TLE-Erweiterung entfernt. Wenn der Aktualisierungspfad jedoch nicht existiert, löst diese Funktion keine Fehlermeldung aus. Stattdessen gibt die Funktion `false` zurück.
### Funktionsprototyp
```
pgtle.uninstall_update_path_if_exists(extname text, fromvers text, tovers text)
```
### Rolle
`pgtle_admin`
### Argumente
+ `extname` – Der Name der TLE-Erweiterung. Dieser Wert wird beim Aufrufen von `CREATE EXTENSION` verwendet.
+ `fromvers` – Die Quellversion der TLE-Erweiterung, die im Aktualisierungspfad verwendet wird.
+ `tovers` – Die Zielversion der TLE-Erweiterung, die im Aktualisierungspfad verwendet wird.
### Output
+ `true` – Die Funktion hat den Pfad für die TLE-Erweiterung erfolgreich aktualisiert.
+ `false` – Die Funktion konnte den Pfad für die TLE-Erweiterung nicht aktualisieren.
### Verwendungsbeispiel
```
SELECT * FROM pgtle.uninstall_update_path_if_exists('pg_tle_test', '0.1', '0.2');
```
## pgtle.unregister\$1feature
Die `unregister_feature`-Funktion bietet eine Möglichkeit, Funktionen zu entfernen, die für die Verwendung von `pg_tle`-Features wurden, wie z. B. Haken. Weitere Informationen zur Registrierung eines Features erhalten Sie unter [pgtle.register\$1feature](#pgtle.register_feature).
### Funktionsprototyp
```
pgtle.unregister_feature(proc regproc, feature pg_tle_features)
```
### Rolle
`pgtle_admin`
### Argumente
+ `proc` – Der Name einer gespeicherten Funktion, für die ein `pg_tle`-Feature registriert werden soll.
+ `feature` – Der Name des `pg_tle`-Features, das für die Funktion registriert werden soll. Beispielsweise ist `passcheck` ein Feature, das für die Verwendung durch die vertrauenswürdigen Spracherweiterungen, die Sie entwickeln, registriert werden kann. Weitere Informationen finden Sie unter [Haken zur Passwortüberprüfung (Passcheck)](PostgreSQL_trusted_language_extension-hooks-reference.md#passcheck_hook).
### Output
Keine.
### Verwendungsbeispiel
```
SELECT * FROM pgtle.unregister_feature('pw_hook', 'passcheck');
```
## pgtle.unregister\$1feature\$1if\$1exists
Die `unregister_feature`-Funktion bietet eine Möglichkeit, Funktionen zu entfernen, die für die Verwendung von `pg_tle`-Features wurden, wie z. B. Haken. Weitere Informationen finden Sie unter [Verwenden von PostgreSQL-Haken mit Ihren TLE-Erweiterungen](PostgreSQL_trusted_language_extension.overview.tles-and-hooks.md). Gibt `true` zurück, nachdem die Registrierung der Funktion erfolgreich aufgehoben wurde. Gibt `false` zurück, wenn das Feature nicht registriert wurde.
Informationen zur Registrierung von `pg_tle`-Features für Ihre TLE-Erweiterungen finden Sie unter [pgtle.register\$1feature](#pgtle.register_feature).
### Funktionsprototyp
```
pgtle.unregister_feature_if_exists('proc regproc', 'feature pg_tle_features')
```
### Rolle
`pgtle_admin`
### Argumente
+ `proc` – Der Name der gespeicherten Funktion, für die ein `pg_tle`-Feature registriert wurde.
+ `feature` – Der Name des `pg_tle`-Features, das mit der vertrauenswürdigen Spracherweiterung registriert wurde.
### Output
Gibt `true` oder `false` wie folgt zurück.
+ `true` – Die Funktion hat die Registrierung des Features in der Erweiterung erfolgreich aufgehoben.
+ `false` – Die Funktion konnte die Registrierung des Features in der TLE-Erweiterung nicht aufheben.
### Verwendungsbeispiel
```
SELECT * FROM pgtle.unregister_feature_if_exists('pw_hook', 'passcheck');
```
# Hakenreferenz für Trusted Language Extensions für PostgreSQL
Trusted Language Extensions für PostgreSQL unterstützt PostgreSQL-Haken. Ein *Haken* ist ein interner Callback-Mechanismus, der Entwicklern zur Erweiterung der Kernfunktionalität von PostgreSQL zur Verfügung steht. Durch die Verwendung von Haken können Entwickler ihre eigenen Funktionen oder Verfahren zur Verwendung bei verschiedenen Datenbankoperationen implementieren und so das Verhalten von PostgreSQL in gewisser Weise ändern. Sie können beispielsweise einen `passcheck`-Haken verwenden, um anzupassen, wie PostgreSQL die Passwörter behandelt, die beim Erstellen oder Ändern von Passwörtern für Benutzer (Rollen) angegeben werden.
In der folgenden Dokumentation erfahren Sie mehr über die Passcheck-Hooks, die für Ihre TLE-Erweiterungen verfügbar sind. Weitere Informationen zu den verfügbaren Hooks, einschließlich des Client-Authentifizierungs-Hooks, finden Sie unter [Trusted Language Extensions-Hooks](https://github.com/aws/pg_tle/blob/main/docs/04_hooks.md).
## Haken zur Passwortüberprüfung (Passcheck)
Der `passcheck`-Haken wird verwendet, um das PostgreSQL-Verhalten während der Passwortüberprüfung für die folgenden SQL-Befehle und `psql`-Metabefehle anzupassen.
+ `CREATE ROLE username ...PASSWORD` – Weitere Informationen finden Sie im Abschnitt [CREATE ROLE](https://www.postgresql.org/docs/current/sql-createrole.html) der PostgreSQL-Dokumentation.
+ `ALTER ROLE username...PASSWORD` – Weitere Informationen finden Sie im Abschnitt [ALTER ROLE](https://www.postgresql.org/docs/current/sql-alterrole.html) der PostgreSQL-Dokumentation.
+ `\password username` – Dieser interaktive `psql`-Metabefehl ändert das Passwort für den angegebenen Benutzer auf sichere Weise, indem er das Passwort hasht, bevor die `ALTER ROLE ... PASSWORD`-Syntax transparent verwendet wird. Der Metabefehl ist ein sicherer Wrapper für den `ALTER ROLE ... PASSWORD`-Befehl, daher gilt der Haken für das Verhalten des`psql`-Metabefehls.
Ein Beispiel finden Sie unter [Liste der Hakencodes für die Passwortüberprüfung](PostgreSQL_trusted_language_extension.overview.tles-and-hooks.md#PostgreSQL_trusted_language_extension-example-hook_code_listing).
**Contents**
+ [
### Funktionsprototyp
](#passcheck_hook-prototype)
+ [
### Argumente
](#passcheck_hook-arguments)
+ [
### Konfiguration
](#passcheck_hook-configuration)
+ [
### Nutzungshinweise
](#passcheck_hook-usage)
### Funktionsprototyp
```
passcheck_hook(username text, password text, password_type pgtle.password_types, valid_until timestamptz, valid_null boolean)
```
### Argumente
Eine `passcheck`-Hakenfunktion verwendet die folgenden Argumente.
+ `username` – Der Name (als Text) der Rolle (Benutzername), die ein Passwort festlegt.
+ `password` – Das Klartext- oder Hash-Passwort. Das eingegebene Passwort sollte dem im `password_type` angegebenen Typ entsprechen.
+ `password_type` – Geben Sie das `pgtle.password_type`-Format des Passworts an. Dieses Format kann einer der folgenden Optionen entsprechen.
+ `PASSWORD_TYPE_PLAINTEXT` – Ein Klartext-Passwort.
+ `PASSWORD_TYPE_MD5`— Ein Passwort, das mit dem Algorithmus MD5 (Message Digest 5) gehasht wurde.
+ `PASSWORD_TYPE_SCRAM_SHA_256` – Ein Passwort, das mit dem SCRAM-SHA-256-Algorithmus gehasht wurde.
+ `valid_until` – Geben Sie den Zeitpunkt an, am dem das Passwort ungültig wird. Dieses Argument ist optional. Wenn Sie dieses Argument verwenden, geben Sie die Uhrzeit als `timestamptz`-Wert an.
+ `valid_null` – Wenn dieser boolesche Wert auf `true` festgelegt ist, wird die `valid_until`-Option auf `NULL` eingestellt.
### Konfiguration
Die Funktion `pgtle.enable_password_check` steuert, ob der Passcheck-Haken aktiv ist. Der Passcheck-Haken hat drei mögliche Einstellungen.
+ `off` – Schaltet den `passcheck`-Haken für die Passwortüberprüfung aus. Dies ist der Standardwert.
+ `on` – Aktiviert den `passcode`-Haken für die Passwortüberprüfung, sodass Passwörter mit der Tabelle verglichen werden.
+ `require` – Erfordert, dass ein Passwortüberprüfungshaken definiert wird.
### Nutzungshinweise
Um den `passcheck`-Haken ein- oder auszuschalten, müssen Sie die benutzerdefinierte DB-Parametergruppe für Ihre DB-Instance von RDS für PostgreSQL ändern.
Für Linux, macOS oder 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"
```
Für 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"
```