Le Tableau 8.4 présente les types génériques disponibles dans PostgreSQL.

SQL définit deux types de caractères principaux : character varying(n) et character(n) où n est un entier positif. Ces deux types permettent de stocker des chaînes de caractères de taille inférieure ou égale à n (ce ne sont pas des octets). Toute tentative d'insertion d'une chaîne plus longue conduit à une erreur, à moins que les caractères en excès ne soient tous des espaces, auquel cas la chaîne est tronquée à la taille maximale (cette exception étrange est imposée par la norme SQL). Néanmoins, si un utilisater convertit explicitement une valeur en character varying(n) ou character(n), alors toute valeur trop longue sera tronquée à n caractères sans retourner d'erreur. (Ceci est aussi requis par le standard SQL.) Si la chaîne à stocker est plus petite que la taille déclarée, les valeurs de type character sont complétées par des espaces, celles de type character varying sont stockées en l'état.

De plus, PostgreSQL fournit le type text qui enregistre des chaînes de toute longueur. Bien que text ne fasse pas partie du standard SQL, plusieurs autres systèmes de gestion de bases de données SQL en disposent eux-aussi. text est le type de données chaîne natif de PostgreSQL dans le sens où la plupart des fonctions internes opérant sur des chaînes sont déclarées comme prenant ou renvoyant du text, et non pas du character varying. Dans de nombreux cas, character varying agit comme un domaine pour le type text.

Le nom de type varchar est un alias pour character varying, alors que bpchar (avec une indication de taille) et char sont des alias pour character. Les varchar et char sont définis dans le standard SQL ; bpchar est une extension de PostgreSQL.

Si indiqué, la longueur n doit être supérieure à zéro et ne peut pas dépasser 10485760. Si character varying (ou varchar) est utilisé sans indication de longueur, le type accepte les chaînes de toute taille. Si bpchar ne précise pas de longueur, il accepte aussi les chaînes de toute taille, mais les espaces en fin sont sémantiquement insignifiants. Si character (ou char) n'indique pas de longueur, c'est équivalent à character(1).

Les valeurs de type character sont complétées physiquement à l'aide d'espaces pour atteindre la longueur n indiquée. Ces valeurs sont également stockées et affichées de cette façon. Cependant, les espaces de remplissage sont traités comme sémantiquement non significatifs et sont donc ignorés lors de la comparaison de deux valeurs de type character. Dans les collationnements où les espaces de remplissage sont significatifs, ce comportement peut produire des résultats inattendus, par exemple SELECT 'a '::CHAR(2) collate "C" < E'a\n'::CHAR(2) retourne vrai, même si la locale C considérerait qu'un espace est plus grand qu'un retour chariot. Les espaces de remplissage sont supprimés lors de la conversion d'une valeur character vers l'un des autres types chaîne. Ces espaces ont une signification sémantique pour les valeurs de type character varying et text, et lors de l'utilisation de la correspondance de motifs, par exemple avec LIKE ou avec les expressions rationnelles.

Les caractères pouvant être enregistrés dans chacun de ces types de données sont déterminés par le jeu de caractères de la base de données, qui a été sélectionné à la création de la base. Quelque soit le jeu de caractères spécifique, le caractère de code zéro (quelque fois appelé NUL) ne peut être enregistré. Pour plus d'informations, voir Section 23.3.

L'espace nécessaire pour une chaîne de caractères courte (jusqu'à 126 octets) est de un octet, plus la taille de la chaîne qui inclut le remplissage avec des espaces dans le cas du type character. Les chaînes plus longues ont quatre octets d'en-tête au lieu d'un seul. Les chaînes longues sont automatiquement compressées par le système, donc le besoin pourrait être moindre. Les chaînes vraiment très longues sont stockées dans des tables supplémentaires, pour qu'elles n'empêchent pas d'accéder rapidement à des valeurs plus courtes. Dans tous les cas, la taille maximale possible pour une chaîne de caractères est de l'ordre de 1 Go. (La taille maximale pour n dans la déclaration de type est inférieure. Il ne sert à rien de modifier ce comportement, car avec les encodages sur plusieurs octets, les nombres de caractères et d'octets peuvent être très différents. Pour stocker de longues chaînes sans limite supérieure précise, il est préférable d'utiliser les types text et character varying sans taille, plutôt que d'indiquer une limite de taille arbitraire.)

On peut se référer à la Section 4.1.2.1 pour obtenir plus d'informations sur la syntaxe des libellés de chaînes, et le Chapitre 9 pour des informations complémentaires sur les opérateurs et les fonctions.

CREATE TABLE test1 (a character(4));
INSERT INTO test1 VALUES ('ok');
SELECT a, char_length(a) FROM test1; -- (1)

  a   | char_length
------+-------------
 ok   |           2


CREATE TABLE test2 (b varchar(5));
INSERT INTO test2 VALUES ('ok');
INSERT INTO test2 VALUES ('bien      ');
INSERT INTO test2 VALUES ('trop long');
ERROR:  value too long for type character varying(5)
INSERT INTO test2 VALUES ('trop long'::varchar(5)); -- troncature explicite
SELECT b, char_length(b) FROM test2;

   b   | char_length
-------+-------------
 ok    |           2
 bien  |           5
 trop  |           5

Il y a deux autres types caractère de taille fixe dans PostgreSQL. Ils sont décrits dans le Tableau 8.5. Ils ne sont pas destinés à une utilisation générale, mais seulement par les catalogues systèmes internes. Le type name est utilisé pour le stockage des identifiants. Sa taille est actuellement définie à 64 octets (63 utilisables plus le terminateur), mais doit être référencée en utilisant la constante NAMEDATALEN en code source C. La taille est définie à la compilation (et est donc ajustable pour des besoins particuliers). La taille maximale par défaut peut éventuellement être modifiée dans une prochaine version. Le type "char" (attention aux guillemets) est différent de char(1) car il n'utilise qu'un seul octet de stockage et, de ce fait ne peut stocker qu'un seul caractère ASCII. Il est utilisé dans les catalogues système comme un type d'énumération simpliste.