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 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_casts verwenden, um zusätzliche Umwandlungen für integrierte Typen zu installieren und gleichzeitig Ihre eigenen Umwandlungen für benutzerdefinierte Typen zu erstellen.

Installation und Verwendung der Erweiterung rds_casts

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_casts bietet zwei Arten von Konvertierungsfunktionen für jede Besetzung:

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_casts.create_cast

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_cast-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_casts.drop_cast

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.