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

Précédent | Niveau supérieur | Suivant
CREATE MATERIALIZED VIEW | Sommaire | CREATE OPERATOR CLASS

## CREATE OPERATOR

CREATE OPERATOR — Définir un nouvel opérateur

## Synopsis

    CREATE OPERATOR nom (
        {FUNCTION|PROCEDURE} = nom_fonction
        [, LEFTARG = type_gauche ]
        [, RIGHTARG = type_droit ]
        [, COMMUTATOR = op_com ]
        [, NEGATOR = op_neg ]
        [, RESTRICT = proc_res ]
        [, JOIN = proc_join ]
        [, HASHES ] [, MERGES ]
    )

## Description

`CREATE OPERATOR` définit un nouvel opérateur, `nom`. L'utilisateur qui définit un opérateur en devient propriétaire. Si un nom de schéma est donné, l'opérateur est créé dans le schéma spécifié. Sinon, il est créé dans le schéma courant.

Le nom de l'opérateur est une séquence d'au plus `NAMEDATALEN`-1 (63 par défaut) caractères parmi la liste suivante :

+ - * / < > = ~ ! @ # % ^ & | ` ?

Il existe quelques restrictions dans le choix du nom :

- `--` et `/*` ne peuvent pas apparaître dans le nom d'un opérateur car ils sont pris pour le début d'un commentaire.

- Un nom d'opérateur multicaractères ne peut pas finir avec `+` ou `-` sauf si le nom contient l'un, au moins, de ces caractères :

  ~ ! @ # % ^ & | ` ?

  Par exemple, `@-` est un nom d'opérateur autorisé mais `*-` n'en est pas un. Cette restriction permet à PostgreSQL d'analyser les commandes compatibles SQL sans nécessiter d'espaces entre les lexèmes.

- Le symbole `=>` est réservé par la grammaire SQL, donc il ne peut pas être utilisé comme nom d'opérateur.

L'opérateur `!=` est remplacé par `<>` à la saisie, ces deux noms sont donc toujours équivalents.

### Note

Les opérateurs unaires droits, aussi appelés postfix, sont obsolètes et seront supprimés dans PostgreSQL version 14.

Pour les opérateurs binaires, `LEFTARG` et `RIGHTARG` doivent être définis. Pour les opérateurs préfixes, seul `RIGHTARG` devrait être défini. La fonction `nom_fonction` doit avoir été précédemment définie par `CREATE FUNCTION` et doit accepter le bon nombre d'arguments (un ou deux) des types indiqués.

Dans la syntaxe de `CREATE OPERATOR`, les mot-clés `FUNCTION` et `PROCEDURE` sont équivalents mais la fonction référencée doit dans tous les cas être une fonction et non pas une procédure. L'utilisation du mot clé `PROCEDURE` est ici historique et dépréciée.

Les autres clauses spécifient des clauses optionnelles d'optimisation d'opérateur. Leur signification est détaillée dans Section 38.15.

Pour pouvoir créer un opérateur, vous devez avoir le droit `USAGE` sur le type des arguments et sur le type en retour. Vous devez aussi avoir le droit `EXECUTE` sur la fonction sous-jacente. Si un opérateur de commutation ou de négation est spécifié, vous devez être le propriétaire de ces opérateurs.

## Paramètres

`nom`

  Le nom de l'opérateur à définir. Voir ci-dessus pour les caractères autorisés. Le nom peut être qualifié du nom du schéma, par exemple `CREATE OPERATOR monschema.+ (...)`. Dans le cas contraire, il est créé dans le schéma courant. Deux opérateurs dans le même schéma peuvent avoir le même nom s'ils opérent sur des types de données différents. On parle alors de surchargement.

`nom_fonction`

  La fonction utilisée pour implanter cet opérateur.

`type_gauche`

  Le type de données de l'opérande gauche de l'opérateur, s'il existe. Cette option est omise pour un opérateur préfixe.

`type_droit`

  Le type de données de l'opérande droit de l'opérateur.

`op_com`

  Le commutateur de cet opérateur.

`op_neg`

  La négation de cet opérateur.

`proc_res`

  La fonction d'estimation de la sélectivité de restriction pour cet opérateur.

`proc_join`

  La fonction d'estimation de la sélectivité de jointure pour cet opérateur.

`HASHES`

  L'opérateur peut supporter une jointure de hachage.

`MERGES`

  L'opérateur peut supporter une jointure de fusion.

La syntaxe `OPERATOR()` est utilisée pour préciser un nom d'opérateur qualifié d'un schéma dans `op_com` ou dans les autres arguments optionnels. Par exemple :

    COMMUTATOR = OPERATOR(mon_schema.===) ,

## Notes

Section 38.14 fournit de plus amples informations.

Il n'est pas possible de spécifier la précédence lexicale d'un opérateur dans `CREATE OPERATOR` car le comportement de précédence de l'analyseur n'est pas modifiable. Voir Section 4.1.6 pour des détails sur la gestion de la précédence.

Les options obsolètes, `SORT1`, `SORT2`, `LTCMP` et `GTCMP` étaient utilisées auparavant pour spécifier les noms des opérateurs de tris associés avec un opérateur joignable par fusion (`mergejoinable`). Ceci n'est plus nécessaire car l'information sur les opérateurs associés est disponible en cherchant les familles d'opérateur B-tree. Si une des ces options est fournie, elle est ignorée mais configure implicitement `MERGES` à true.

`DROP OPERATOR` est utilisé pour supprimer les opérateurs utilisateur, `ALTER OPERATOR` pour les modifier.

## Exemples

La commande suivante définit un nouvel opérateur, « area-equality », pour le type de données `box` :

    CREATE OPERATOR === (
        LEFTARG = box,
        RIGHTARG = box,
        FUNCTION = area_equal_function,
        COMMUTATOR = ===,
        NEGATOR = !==,
        RESTRICT = area_restriction_function,
        JOIN = area_join_function,
        HASHES, MERGES
    );

## Compatibilité

`CREATE OPERATOR` est une extension PostgreSQL. Il n'existe pas d'opérateurs utilisateur dans le standard SQL.

## Voir aussi

ALTER OPERATOR, CREATE OPERATOR CLASS, DROP OPERATOR