33.2. Le système des types de PostgreSQL
Les types de données de PostgreSQL™ sont répartis en types de
base, types composites, domaines et pseudo-types.
33.2.1. Les types de base
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 fournies par l'utilisateur et n'en
comprend le fonctionnement que dans la mesure où l'utilisateur les
décrit. 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.
33.2.2. Les types composites
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.11, « Types
composites » fournit de plus amples informations sur ces
types.
33.2.3. Les domaines
Un domaine est fondé sur un type de base particulier. Il est, dans
de nombreux cas, interchangeables avec le type de base, mais ses
valeurs peuvent être contraintes à un sous-ensemble des valeurs
autorisées pour le type de base à l'aide de contraintes. Les
domaines peuvent être créés par de simples commandes
SQL.
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.
33.2.4. Pseudo-types
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.20,
« Pseudo-Types » donne la liste des pseudo-types
existant.
33.2.5. Types et fonctions polymorphes
Deux pseudo-types particulièrement intéressants sont anyelement et anyarray,
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 mais, 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, 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.
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 implémente 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.
Étendre le SQL
