CREATE OPERATOR — Définir un nouvel opérateur
CREATE OPERATORnom
( {FUNCTION|PROCEDURE} =nom_fonction
[, LEFTARG =type_gauche
] [, RIGHTARG =type_droit
] [, COMMUTATOR =op_com
] [, NEGATOR =op_neg
] [, RESTRICT =proc_res
] [, JOIN =proc_join
] [, HASHES ] [, MERGES ] )
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.
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 attributs optionnels d'optimisation d'opérateur. Leur signification est détaillée dans Section 36.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.
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.===) ,
Section 36.14 et Section 36.15 fournissent de plus amples informations.
Quand vous définissez un opérateur auto-commutatif, vous le faites directement. Quand vous définissez une paire d'opérateurs commutatifs, cela devient un peu plus compliqué : comment pouvez-vous définir le premier qui fait référence au second que vous n'avez pas encore défini ? Il existe trois solutions à ce problème :
Un premier moyen est d'omettre la clause COMMUTATOR
dans le premier opérateur que vous définissez, puis de fournir le
premier dans la définition du second. Comme
PostgreSQL sait que les opérateurs commutatifs
viennent en paire, alors quand il voit la deuxième définition, il
retourne sur la première définition et remplit automatiquement la
clause COMMUTATOR
manquante.
Une autre moyen, plus direct, revient juste à inclure les clauses
COMMUTATOR
dans les deux définitions. Quand
PostgreSQL traite la première définition et
réalise que COMMUTATOR
fait référence à un opérateur
inexistant, le système fait une entrée inopérante pour cet opérateur
dans le catalogue système. Cette entrée aura des données valides
uniquement pour le nom de l'opérateur, les types d'opérande gauche et
droit, et le propriétaire car ce sont les seuls que
PostgreSQL peut déduire à ce moment.
L'entrée du catalogue pour le premier opérateur se liera à cette
entrée inopérante. Plus tard, quand vous définirez le deuxième opérateur,
le système mettra à jour l'entre inopérante avec l'information
supplémentaire provenant de la deuxième définition. Si vous essayez
d'utiliser l'entrée inopérante avant qu'elle ne soit complètement
remplie, vous obtiendrez un message d'erreur.
Enfin, les deux opérateurs peuvent être définis sans les clauses
COMMUTATOR
, puis ALTER OPERATOR
peut être utilisé pour configurer les liens des commutateurs. Il
est suffisant d'utiliser ALTER
sur chaque paire.
Dans les trois cas, vous devez être propriétaire des deux opérateurs pour les marquer comme commutateurs.
Les paires d'opérateurs de nagétion peuvent être définies en utilisant les mêmes méthodes que celles des paires de commutateurs.
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.
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 );
CREATE OPERATOR
est une extension
PostgreSQL. Il n'existe pas d'opérateurs utilisateur dans le standard SQL.