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. # **Typumwandlung** in PostgreSQL ist der Prozess der Konvertierung eines Werts von einem Datentyp in einen anderen. PostgreSQL bietet integrierte Umwandlungen für viele gängige Konvertierungen, aber Sie können auch benutzerdefinierte Umwandlungen erstellen, um zu definieren, wie sich bestimmte Typkonvertierungen verhalten sollen. Eine Umwandlung gibt an, wie eine Konvertierung von einem Datentyp in einen anderen durchgeführt wird. Zum Beispiel die Konvertierung von Text in `'123'` eine Ganzzahl `123` oder einer Zahl `45.67` in Text`'45.67'`. Umfassende Informationen zu PostgreSQL-Casting-Konzepten und -Syntax finden Sie in der [PostgreSQL](https://www.postgresql.org/docs/current/sql-createcast.html) CREATE CAST-Dokumentation. Ab den Versionen 13.23, 14.20, 15.15, 16.11, 17.7 und 18.1, können Sie die Erweiterung rds\$1casts verwenden, um zusätzliche Umwandlungen für integrierte Typen zu installieren und gleichzeitig Ihre eigenen Umwandlungen für benutzerdefinierte Typen zu erstellen. **Topics** + [Installation und Verwendung der Erweiterung rds\$1casts](#PostgreSQL.CustomCasts.Installing) + [Unterstützte Casts](#PostgreSQL.CustomCasts.Supported) + [Umwandlungen erstellen oder löschen](#PostgreSQL.CustomCasts.Creating) + [Erstellen von benutzerdefinierten Besetzungen mit der richtigen Kontextstrategie](#PostgreSQL.CustomCasts.BestPractices) ## Installation und Verwendung der Erweiterung rds\$1casts Um die `rds_casts` Erweiterung zu erstellen, stellen Sie eine Verbindung zur (Ihre RDS for PostgreSQL-DB-Instance) her `rds_superuser` und führen Sie den folgenden Befehl aus: ``` CREATE EXTENSION IF NOT EXISTS rds_casts; ``` ## Unterstützte Casts Erstellen Sie die Erweiterung in jeder Datenbank, in der Sie benutzerdefinierte Casts verwenden möchten. Verwenden Sie nach dem Erstellen der Erweiterung den folgenden Befehl, um alle verfügbaren Casts anzuzeigen: ``` SELECT * FROM rds_casts.list_supported_casts(); ``` Diese Funktion listet die verfügbaren Cast-Kombinationen auf (Quelltyp, Zieltyp, Zwangskontext und Cast-Funktion). Zum Beispiel, wenn Sie to `numeric` als Besetzung erstellen `text` möchten. `implicit` Sie können die folgende Abfrage verwenden, um herauszufinden, ob die Besetzung zum Erstellen verfügbar ist: ``` SELECT * FROM rds_casts.list_supported_casts() WHERE source_type = 'text' AND target_type = 'numeric'; id | source_type | target_type | qualified_function | coercion_context ----+-------------+-------------+--------------------------------------+------------------ 10 | text | numeric | rds_casts.rds_text_to_numeric_custom | implicit 11 | text | numeric | rds_casts.rds_text_to_numeric_custom | assignment 13 | text | numeric | rds_casts.rds_text_to_numeric_custom | explicit 20 | text | numeric | rds_casts.rds_text_to_numeric_inout | implicit 21 | text | numeric | rds_casts.rds_text_to_numeric_inout | assignment 23 | text | numeric | rds_casts.rds_text_to_numeric_inout | explicit ``` Die Erweiterung rds\$1casts bietet zwei Arten von Konvertierungsfunktionen für jede Besetzung: + *\$1inout-Funktionen* — Verwenden Sie den I/O Standard-Konvertierungsmechanismus von PostgreSQL, der sich genauso verhält wie Casts, die mit der INOUT-Methode erstellt wurden + *\$1benutzerdefinierte Funktionen* — Stellen eine erweiterte Konvertierungslogik bereit, die Sonderfälle behandelt, z. B. die Konvertierung leerer Zeichenketten in NULL-Werte, um Konvertierungsfehler zu vermeiden Die `inout` Funktionen replizieren das native Casting-Verhalten von PostgreSQL, während `custom` Funktionen diese Funktionalität erweitern, indem sie Szenarien behandeln, die mit Standard-INOUT-Umwandlungen nicht berücksichtigt werden können, wie z. B. die Konvertierung leerer Zeichenketten in ganze Zahlen. ## Umwandlungen erstellen oder löschen Sie können unterstützte Besetzungen mit zwei Methoden erstellen und löschen: ### Erstellung von Darstellern **Methode 1: Verwenden des nativen CREATE CAST-Befehls** ``` CREATE CAST (text AS numeric) WITH FUNCTION rds_casts.rds_text_to_numeric_custom AS IMPLICIT; ``` **Methode 2: Verwendung der Funktion rds\$1casts.create\$1cast** ``` SELECT rds_casts.create_cast(10); ``` Die `create_cast` Funktion verwendet die ID aus der Ausgabe. `list_supported_casts()` Diese Methode ist einfacher und stellt sicher, dass Sie die richtige Kombination aus Funktion und Kontext verwenden. Es ist garantiert, dass diese ID in verschiedenen Postgres-Versionen gleich bleibt. Um zu überprüfen, ob der Cast erfolgreich erstellt wurde, fragen Sie den pg\$1cast-Systemkatalog ab: ``` SELECT oid, castsource::regtype, casttarget::regtype, castfunc::regproc, castcontext, castmethod FROM pg_cast WHERE castsource = 'text'::regtype AND casttarget = 'numeric'::regtype; oid | castsource | casttarget | castfunc | castcontext | castmethod --------+------------+------------+--------------------------------------+-------------+------------ 356372 | text | numeric | rds_casts.rds_text_to_numeric_custom | i | f ``` Die `castcontext` Spalte zeigt: `e` für EXPLICIT, für ASSIGNMENT oder `a` `i` für IMPLICIT. ### Besetzungen löschen **Methode 1: Verwenden des Befehls DROP CAST** ``` DROP CAST IF EXISTS (text AS numeric); ``` **Methode 2: Verwendung der Funktion rds\$1casts.drop\$1cast** ``` SELECT rds_casts.drop_cast(10); ``` Die `drop_cast` Funktion verwendet dieselbe ID, die bei der Erstellung der Besetzung verwendet wurde. Diese Methode stellt sicher, dass Sie genau die Besetzung löschen, die mit der entsprechenden ID erstellt wurde. ## Erstellen von benutzerdefinierten Besetzungen mit der richtigen Kontextstrategie Beim Erstellen mehrerer Umwandlungen für Integer-Typen können Operator-Mehrdeutigkeitsfehler auftreten, wenn alle Umwandlungen als IMPLIZIT erstellt werden. Das folgende Beispiel veranschaulicht dieses Problem, indem zwei implizite Umwandlungen von Text in unterschiedliche Ganzzahlbreiten erstellt werden: ``` -- Creating multiple IMPLICIT casts causes ambiguity postgres=> CREATE CAST (text AS int4) WITH FUNCTION rds_casts.rds_text_to_int4_custom(text) AS IMPLICIT; CREATE CAST postgres=> CREATE CAST (text AS int8) WITH FUNCTION rds_casts.rds_text_to_int8_custom(text) AS IMPLICIT; CREATE CAST postgres=> CREATE TABLE test_cast(col int); CREATE TABLE postgres=> INSERT INTO test_cast VALUES ('123'::text); INSERT 0 1 postgres=> SELECT * FROM test_cast WHERE col='123'::text; ERROR: operator is not unique: integer = text LINE 1: SELECT * FROM test_cast WHERE col='123'::text; ^ HINT: Could not choose a best candidate operator. You might need to add explicit type casts. ``` Der Fehler tritt auf, weil PostgreSQL nicht bestimmen kann, welche implizite Umwandlung beim Vergleich einer Integer-Spalte mit einem Textwert verwendet werden soll. Sowohl die implizite Umwandlung von int4 als auch die implizite Umwandlung von int8 sind gültige Kandidaten, was zu Mehrdeutigkeiten führt. Um diese Mehrdeutigkeit der Operatoren zu vermeiden, verwenden Sie den ASSIGNMENT-Kontext für kleinere Ganzzahlbreiten und den IMPLIZITEN Kontext für größere Ganzzahlbreiten: ``` -- Use ASSIGNMENT for smaller integer widths CREATE CAST (text AS int2) WITH FUNCTION rds_casts.rds_text_to_int2_custom(text) AS ASSIGNMENT; CREATE CAST (text AS int4) WITH FUNCTION rds_casts.rds_text_to_int4_custom(text) AS ASSIGNMENT; -- Use IMPLICIT for larger integer widths CREATE CAST (text AS int8) WITH FUNCTION rds_casts.rds_text_to_int8_custom(text) AS IMPLICIT; postgres=> INSERT INTO test_cast VALUES ('123'::text); INSERT 0 1 postgres=> SELECT * FROM test_cast WHERE col='123'::text; col ----- 123 (1 row) ``` Bei dieser Strategie ist nur die int8-Umwandlung implizit, sodass PostgreSQL eindeutig bestimmen kann, welche Umwandlung verwendet werden soll.