Les types de données de PostgreSQL sont répartis en types de base, types composites, domaines et pseudo-types.
Les types de base sont ceux qui, comme int4
, sont implantés
sous le niveau du langage SQL (typiquement dans un
langage de bas niveau comme le C). Ils correspondent généralement à ce que
l'on appelle les types de données abstraits.
PostgreSQL ne peut opérer sur de tels types
qu'au moyen de fonctions utilisateur et n'en comprend le fonctionnement que
dans la limite de la description qu'en a fait l'utilisateur. Les types
de base sont divisés en types scalaires et types tableaux. Pour chaque type
scalaire, un type tableau est automatiquement créé destiné à
contenir des tableaux de taille variable de ce type scalaire.
Les types composites, ou types lignes, sont créés chaque fois qu'un utilisateur crée une table. Il est égalment possible de définir un type composite autonome sans table associée. Un type composite n'est qu'une simple liste de types de base avec des noms de champs associés. Une valeur de type composite est une ligne ou un enregistrement de valeurs de champ. L'utilisateur peut accéder à ces champs à partir de requêtes SQL. La Section 8.16 fournit de plus amples informations sur ces types.
Un domaine est fondé sur un type de base particulier. Il est, dans de nombreux cas, interchangeable avec ce type. Mais un domaine peut également posséder des contraintes qui restreignent ses valeurs à un sous-ensemble des valeurs autorisées pour le type de base.
Les domaines peuvent être créés à l'aide de la commande SQL CREATE DOMAIN. Leurs création et utilisation n'est pas l'objet de ce chapitre.
Il existe quelques « pseudo-types » pour des besoins particuliers. Les pseudo-types ne peuvent pas apparaître comme champs de table ou comme attributs de types composites, mais ils peuvent être utilisés pour déclarer les types des arguments et des résultats de fonctions. Dans le système de typage, ils fournissent un mécanisme d'identification des classes spéciales de fonctions. La Tableau 8.25 donne la liste des pseudo-types qui existent.
Cinq pseudo-types sont particulièrement intéressants :
anyelement
, anyarray
, anynonarray
,
anyenum
et anyrange
, collectivement appelés types
polymorphes.
Toute fonction déclarée utiliser ces types est dite fonction
polymorphe. Une fonction polymorphe peut opérer sur de nombreux
types de données différents, les types de données spécifiques étant
déterminés par les types des données réellement passés lors d'un appel
particulier de la fonction.
Les arguments et résultats polymorphes sont liés entre eux et
sont résolus dans un type de données spécifique quand une requête faisant
appel à une fonction polymorphe est analysée. Chaque occurrence (argument
ou valeur de retour) déclarée comme anyelement
peut prendre n'importe quel type réel de données mais, lors d'un
appel de fonction donné, elles doivent toutes avoir le
même type réel. Chaque occurrence déclarée comme
anyarray
peut prendre n'importe quel type de données tableau.
De façon similaire, les occurences déclarées en tant que
anyrange
doivent toutes être du même type.
De la même façon, elles doivent toutes être du
même type. Si des occurrences sont déclarées comme
anyarray
et d'autres comme anyelement
ou anyarray
, le type
réel de tableau des occurrences anyarray
doit être un tableau
dont les éléments sont du même type que ceux apparaissant dans les
occurrences de type anyelement
ou du même type que ceux apparaissant dans les
occurrences de type anyarray
.
De la même façon, si des occurences sont déclarées de type
anyrange
et d'autres de type anyelement
, le type
range réel dans les occurences de anyrange
doit être un type
dont le sous-type est du même type que celui apparaissant dans les occurences
de anyelement
.
anynonarray
est traité de la même façon que
anyelement
mais ajoute une contrainte supplémentaire. Le type
réel ne doit pas être un tableau. anyenum
est traité de la même
façon que anyelement
mais ajoute une contrainte supplémentaire.
Le type doit être un type enuméré.
Ainsi, quand plusieurs occurrences d'argument sont déclarées avec un type
polymorphe, seules certaines combinaisons de
types réels d'argument sont autorisées. Par exemple, une fonction déclarée
comme foo(anyelement, anyelement)
peut prendre comme
arguments n'importe quelles valeurs à condition qu'elles soient du même
type de données.
Quand la valeur renvoyée par une fonction est déclarée de type polymorphe,
il doit exister au moins une occurrence d'argument également polymorphe, et
le type réel de donnée passé comme argument détermine le type réel de
résultat renvoyé lors de cet appel à la fonction. Par exemple, s'il
n'existe pas déjà un mécanisme d'indexation d'éléments de
tableau, on peut définir une fonction qui code ce mécanisme :
indice(anyarray, integer) returns anyelement
. La
déclaration de fonction contraint le premier argument réel à être de type
tableau et permet à l'analyseur d'inférer le type correct de résultat à
partir du type réel du premier argument. Une fonction déclarée de cette
façon f(anyarray) returns anyenum
n'accepte que des
tableaux contenant des valeurs de type enum.
Dans la plupart des cas, l'analyseur peut inférer que le type de données
réel pour un type résultat polymorphique pour des arguments qui sont d'un
type polymorphique différent par exemple anyarray
peut
être déduit à partir de anyelement
et vice versa. L'exception
est qu'un résultat polymorphique de type anyrange
nécessite
un argument de type anyrange
; il ne peut pas être
déduit d'arguments anyarray
ou anyelement
. Ceci
est dû au fait qu'il pourrait y avoir plusieurs types d'intervalles avec
le même sous-type.
anynonarray
et anyenum
ne représentent
pas des variables de type séparé ; elles sont du même type que
anyelement
, mais avec une contrainte supplémentaire. Par
exemple, déclarer une fonction f(anyelement, anyenum)
est équivalent à la déclarer f(anyenum, anyenum)
:
les deux arguments réels doivent être du même type enum.
Une fonction variadic (c'est-à-dire une fonction acceptant un nombre
variable d'arguments, comme dans Section 37.4.5) peut être polymorphique :
cela se fait en déclarant son dernier paramètre VARIADIC
anyarray
. Pour s'assurer de la correspondance des arguments
et déterminer le type de la valeur en retour, ce type de fonction se
comporte de la même façon que si vous aviez écrit le nombre approprié de
paramètres anynonarray
.