Documentation PostgreSQL 14.22 » Référence » Commandes SQL » CREATE TRANSFORM

Précédent | Niveau supérieur | Suivant
CREATE TEXT SEARCH TEMPLATE | Sommaire | CREATE TRIGGER

## CREATE TRANSFORM

CREATE TRANSFORM — définir une nouvelle transformation

## Synopsis

    CREATE [ OR REPLACE ] TRANSFORM FOR nom_type LANGUAGE nom_lang (
        FROM SQL WITH FUNCTION nom_fonction_from_sql_ [ (type_argument [, ...]) ],
        TO SQL WITH FUNCTION nom_fonction_to_sql_ [ (type_argument [, ...]) ]
    );

## Description

`CREATE TRANSFORM` définit une nouvelle transformation. `CREATE OR REPLACE TRANSFORM` va soit créer une nouvelle transformation, soit en remplacer une déjà existante.

Une transformation définit comment adapter un type de données à un langage procédural. Par exemple, pour une fonction en PL/Python écrite avec le type `hstore`, PL/Python n'a pas les informations permettant de déterminer comment il doit présenter ces valeurs dans un environnement Python. Par défaut, les implémentations d'un langage vont utiliser la représentation typée text, mais c'est loin d'être optimal lorsque la représentation devrait être typée en tableau associatif ou liste.

Une transformation spécifie 2 fonctions :

- Une fonction « from SQL » qui convertit le type depuis l'environnement SQL vers le langage. Cette fonction sera appelée pour un argument d'une fonction écrite dans ce langage.

- Une fonction « to SQL » qui convertit le type depuis le langage vers l'environnement SQL. Cette fonction sera appelée sur la valeur retournée par une fonction écrite dans ce langage.

Il n'est pas nécessaire de définir l'ensemble de ces fonctions. Si l'une d'entre elle n'est pas spécifiée et au besoin le comportement par défaut du langage sera appliqué. (Pour éviter qu'une transformation soit effectuée dans un sens, vous pouvez aussi écrire une fonction de transformation qui renvoie systématiquement une erreur.)

Pour pouvoir créer une transformation, vous devez être le propriétaire du type et avoir le droit `USAGE` sur le type et le droit `USAGE` sur le langage, ainsi qu'être le propriétaire et avoir le droit `EXECUTE` sur les fonctions from-SQL et to-SQL si spécifié.

## Paramètres

`nom_type`

  Le nom du type de données de la transformation.

`nom_lang`

  Le nom du langage de la transformation.

``nom_fonction_from_sql`[(`type_argument` [, ...])]`

  Nom de la fonction qui va convertir le type depuis l'environnement SQL vers le langage. Il doit prendre un argument type `internal` et renvoyer un type `internal` . L'argument présent sera du type de la transformation, et la fonction devrait être codée en tant que tel. (Mais il n'est pas autorisé de déclarer une fonction de niveau SQL qui retournerait un type `internal` sans avoir au moins un argument de type `internal`.) La valeur retournée sera spécifique à ce qui est implémenté dans le langage. Si aucune liste n'est spécifiée en argument, le nom de la fonction doit être unique dans son schéma.

``nom_fonction_to_sql`[(`type_argument` [, ...])]`

  Nom de la fonction qui va convertir le type depuis le langage vers l'environnement SQL. Il doit prendre un argument de type `internal` et renvoyer un type qui est le type de la transformation. Cet argument sera spécifique à ce qui est implémenté dans le langage. Si aucune liste n'est spécifiée en argument, le nom de la fonction doit être unique dans son schéma.

## Notes

Utiliser `DROP TRANSFORM` pour supprimer des transformations.

## Exemples

Pour créer une transformation pour le type `hstore` et le langage `plpythonu`, il faut d'abord définir le type et le langage :

    CREATE TYPE hstore ...;

    CREATE EXTENSION plpythonu;

Puis créer les fonctions idoines :

    CREATE FUNCTION hstore_to_plpython(val internal) RETURNS internal
    LANGUAGE C STRICT IMMUTABLE
    AS ...;

    CREATE FUNCTION plpython_to_hstore(val internal) RETURNS hstore
    LANGUAGE C STRICT IMMUTABLE
    AS ...;

Et enfin, créer la transformation pour les lier ensemble :

    CREATE TRANSFORM FOR hstore LANGUAGE plpythonu (
        FROM SQL WITH FUNCTION hstore_to_plpython(internal),
        TO SQL WITH FUNCTION plpython_to_hstore(internal)
    );

En pratique, cette commande est encapsulée dans les extensions.

La section `contrib` contient un certain nombre d'extensions fournissant des transformations, qui peuvent être utilisés comme des exemples concrets.

## Compatibilité

Cette forme de `CREATE TRANSFORM` est une extension PostgreSQL. Il existe une commande `CREATE TRANSFORM` dans le standard SQL, mais elle est utilisée pour adapter les types de données aux langages clients. Cette utilisation n'est pas supportée par PostgreSQL.

## Voir aussi

CREATE FUNCTION, CREATE LANGUAGE, CREATE TYPE, DROP TRANSFORM