Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # **Le casting de type** dans PostgreSQL est le processus de conversion d'une valeur d'un type de données à un autre. PostgreSQL fournit des conversions intégrées pour de nombreuses conversions courantes, mais vous pouvez également créer des conversions personnalisées pour définir le comportement de conversions de type spécifique. Un cast indique comment effectuer une conversion d'un type de données à un autre. Par exemple, convertir du texte `'123'` en entier `123` ou un nombre numérique `45.67` en texte`'45.67'`. Pour obtenir des informations complètes sur les concepts et la syntaxe de PostgreSQL Cast, consultez la documentation [PostgreSQL](https://www.postgresql.org/docs/current/sql-createcast.html) CREATE CAST. À partir des , vous pouvez utiliser l'extension rds\$1casts pour installer des conversions supplémentaires pour les types intégrés, tout en étant en mesure de créer vos propres conversions pour les types personnalisés. **Topics** + [Installation et utilisation de l'extension rds\$1casts](#PostgreSQL.CustomCasts.Installing) + [Castings pris en charge](#PostgreSQL.CustomCasts.Supported) + [Création ou suppression de moulages](#PostgreSQL.CustomCasts.Creating) + [Création de moulages personnalisés avec une stratégie contextuelle appropriée](#PostgreSQL.CustomCasts.BestPractices) ## Installation et utilisation de l'extension rds\$1casts Pour créer l'`rds_casts`extension, connectez-vous à (votre instance de base de données RDS pour PostgreSQL en tant que telle) et exécutez la commande suivante : `rds_superuser` ``` CREATE EXTENSION IF NOT EXISTS rds_casts; ``` ## Castings pris en charge Créez l'extension dans chaque base de données dans laquelle vous souhaitez utiliser des moulages personnalisés. Après avoir créé l'extension, utilisez la commande suivante pour afficher tous les casts disponibles : ``` SELECT * FROM rds_casts.list_supported_casts(); ``` Cette fonction répertorie les combinaisons de diffusion disponibles (type de source, type de cible, contexte de coercition et fonction de diffusion). Par exemple, si vous souhaitez le `text` créer en `numeric` tant que `implicit` casting. Vous pouvez utiliser la requête suivante pour savoir si le casting est disponible pour être créé : ``` 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 ``` L'extension rds\$1casts fournit deux types de fonctions de conversion pour chaque cast : + *Fonctions \$1inout* - Utilisez le mécanisme de I/O conversion standard de PostgreSQL, en se comportant de la même manière que les conversions créées avec la méthode INOUT + *\$1custom functions* - Fournissez une logique de conversion améliorée qui gère les cas extrêmes, tels que la conversion de chaînes vides en valeurs NULL pour éviter les erreurs de conversion Les `inout` fonctions reproduisent le comportement de casting natif de PostgreSQL, tandis que les `custom` fonctions étendent cette fonctionnalité en gérant des scénarios que les conversions INOUT standard ne peuvent pas prendre en charge, tels que la conversion de chaînes vides en entiers. ## Création ou suppression de moulages Vous pouvez créer et supprimer des diffusions prises en charge à l'aide de deux méthodes : ### Création du casting **Méthode 1 : utilisation de la commande native CREATE CAST** ``` CREATE CAST (text AS numeric) WITH FUNCTION rds_casts.rds_text_to_numeric_custom AS IMPLICIT; ``` **Méthode 2 : utilisation de la fonction rds\$1casts.create\$1cast** ``` SELECT rds_casts.create_cast(10); ``` La `create_cast` fonction prend l'identifiant de la `list_supported_casts()` sortie. Cette méthode est plus simple et garantit que vous utilisez la bonne combinaison de fonction et de contexte. Il est garanti que cet identifiant restera le même dans les différentes versions de Postgres. Pour vérifier que le cast a bien été créé, interrogez le catalogue du système pg\$1cast : ``` 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 ``` La `castcontext` colonne indique : `e` pour EXPLICIT, `a` pour ASSIGNMENT ou `i` pour IMPLICIT. ### Lancer des moulages **Méthode 1 : utilisation de la commande DROP CAST** ``` DROP CAST IF EXISTS (text AS numeric); ``` **Méthode 2 : utilisation de la fonction rds\$1casts.drop\$1cast** ``` SELECT rds_casts.drop_cast(10); ``` La `drop_cast` fonction utilise le même identifiant que celui utilisé lors de la création du casting. Cette méthode garantit que vous supprimez le casting exact créé avec l'ID correspondant. ## Création de moulages personnalisés avec une stratégie contextuelle appropriée Lors de la création de plusieurs conversions pour des types entiers, des erreurs d'ambiguïté d'opérateur peuvent se produire si toutes les conversions sont créées en tant que valeur IMPLICITE. L'exemple suivant illustre ce problème en créant deux conversions implicites à partir du texte en différentes largeurs de nombres entiers : ``` -- 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. ``` L'erreur se produit parce que PostgreSQL ne peut pas déterminer la conversion implicite à utiliser lors de la comparaison d'une colonne entière avec une valeur de texte. Les conversions implicites int4 et int8 sont des candidats valides, ce qui crée une ambiguïté. Pour éviter cette ambiguïté d'opérateur, utilisez le contexte ASSIGNMENT pour les largeurs entières plus petites et le contexte IMPLICITE pour les largeurs entières plus grandes : ``` -- 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) ``` Avec cette stratégie, seul le cast int8 est implicite, de sorte que PostgreSQL peut déterminer sans ambiguïté le cast à utiliser.