10.2. Opérateurs

Exemple 10-1. Résolution de types pour l'opérateur exponentiel

Il n'y a qu'un seul opérateur exponentiel défini dans le catalogue et il prend deux arguments de type double precision (double précision). L'analyseur assigne initialement le type integer (entier) aux deux arguments de cette expression :

SELECT 2 ^ 3 AS "exp";

 exp
-----
   8
(1 row)

L'analyseur fait donc une conversion de types sur les deux opérandes et la requête est équivalente à

SELECT CAST(2 AS double precision) ^ CAST(3 AS double precision) AS "exp";

Exemple 10-2. Résolution de types pour les opérateurs de concaténation de chaînes

La syntaxe d'une chaîne de caractères est utilisée pour travailler avec les types chaînes mais aussi avec les types d'extensions complexes. Les chaînes de caractères avec un type non spécifié sont comparées avec les opérateurs candidats probables.

Un exemple avec un argument non spécifié :

SELECT text 'abc' || 'def' AS "text and unknown";

 text and unknown
------------------
 abcdef
(1 row)

Dans ce cas, l'analyseur cherche à voir s'il existe un opérateur prenant text pour ses deux arguments. Comme il y en a un, il suppose que le second argument devrait être interprété comme un type text.

Voici une concaténation sur des types non spécifiés :

SELECT 'abc' || 'def' AS "unspecified";

 unspecified
-------------
 abcdef
(1 row)

Dans ce cas, il n'y a aucune allusion initiale sur quel type utiliser puisqu'aucun type n'est spécifié dans la requête. Donc l'analyseur regarde pour tous les opérateurs candidats et trouve qu'il existe des candidats acceptant en entrée la catégorie chaîne de caractères (string) et la catégorie morceaux de chaînes (bit-string). Puisque la catégorie chaînes de caractères est préférée quand elle est disponible, cette catégorie est sélectionnée. Le type préféré pour la catégorie chaînes étant texte (text), ce type est utilisé comme le type spécifique pour résoudre les types inconnus.

Exemple 10-3. Résolution de types pour les opérateurs de valeur absolue et factoriel

Le catalogue d'opérateurs de PostgreSQL a plusieurs entrées pour l'opérateur de préfixe @. Ces entrées implémentent toutes des opérations de valeur absolue pour des types de données numériques variées. Une de ces entrées est pour le type float8 (réel) qui est le type préféré dans la catégorie des numériques. Par conséquent, PostgreSQL utilisera cette entrée quand il sera en face d'un argument non numérique :

SELECT @ '-4.5' AS "abs";
 abs
-----
 4.5
(1 row)

Ici le système a effectué une conversion implicite du type text (texte) au type float8 (réel) avant d'appliquer l'opérateur choisi. Nous pouvons vérifier que float8 et pas un autre type a été utilisé :

SELECT @ '-4.5e500' AS "abs";

ERROR:  "-4.5e500" is out of range for type double precision

D'un autre côté, l'opérateur suffixe ! (factoriel) est défini seulement pour les types entiers et non pas pour float8 (réel). Ainsi, si nous essayons un cas similaire avec !, nous obtenons :

SELECT '20' ! AS "factorial";

ERROR:  operator is not unique: "unknown" !
HINT:  Could not choose a best candidate operator. You may need to add explicit
type casts.

Ceci se produit parce que le système ne peut pas décider quel opérateur doit être préféré parmi les différents opérateurs ! possibles. Nous pouvons l'aider avec une conversion explicite :

SELECT CAST('20' AS int8) ! AS "factorial";

      factorial
---------------------
 2432902008176640000
(1 row)