Une constante de type chaîne en SQL est une séquence arbitraire de caractères entourée par des guillemets simples ('), par exemple 'Ceci est une chaîne'. Pour inclure un guillemet simple dans une chaîne constante, saisissez deux guillemets simples adjacents, par exemple 'Le cheval d''Anne'. Notez que ce n'est pas identique à un guillemet double (").

Deux constantes de type chaîne séparées par un espace blanc avec au moins une nouvelle ligne sont concaténées et traitées réellement comme si la chaîne avait été écrite dans une constante. Par exemple :

SELECT 'foo'
'bar';

est équivalent à :

SELECT 'foobar';

mais :

SELECT 'foo'      'bar';

n'a pas une syntaxe valide (ce comportement légèrement bizarre est spécifié par le standard SQL ; PostgreSQL suit le standard).

PostgreSQL accepte aussi les constantes de chaîne utilisant des échappements qui sont une extension au standard SQL. Une constante de type chaîne d'échappement est indiquée en écrivant la lettre E (en majuscule ou minuscule) juste avant le guillemet d'ouverture, par exemple E'foo'. (Pour continuer une constante de ce type sur plusieurs lignes, écrire E seulement avant le premier guillemet d'ouverture.) À l'intérieur d'une chaîne d'échappement, un caractère antislash (\) est géré comme une séquence d'échappement avec antislash du langage C. La combinaison d'antislash et du (ou des) caractère(s) suivant(s) représente une valeur spéciale, comme indiqué dans le Tableau 4.1.

Tout autre caractère suivi d'un antislash est pris littéralement. Du coup, pour inclure un caractère antislash, écrivez deux antislashs (\\). De plus, un guillemet simple peut être inclus dans une chaîne d'échappement en écrivant \', en plus de la façon normale ''.

Il est de votre responsabilité que les séquences d'octets que vous créez, tout spécialement lorsque vous utilisez les échappements octaux et hexadécimaux, soient des caractères valides dans l'encodage du jeu de caractères du serveur. Une alternative utile est d'utiliser les échappements Unicode ou l'autre syntaxe d'échappement Unicode, expliqués dans la Section 4.1.2.3; ensuite le serveur vérifiera que la conversion de caractères est possible.

Le caractère de code zéro ne peut pas être placé dans une constante de type chaîne.

PostgreSQL supporte aussi un autre type de syntaxe d'échappement pour les chaînes qui permettent d'indiquer des caractères Unicode arbitraires par code. Une constante de chaîne d'échappement Unicode commence avec U& (U en majuscule ou minuscule suivi par un « et commercial ») immédiatement suivi par un guillemet double d'ouverture, sans espace entre eux. Par exemple U&"foo". (Notez que c'est source d'ambiguïté avec l'opérateur &. Utilisez les espaces autour de l'opérateur pour éviter ce problème.) À l'intérieur des guillemets, les caractères Unicode peuvent être indiqués dans une forme échappée en écrivant un antislash suivi par le code hexadécimal sur quatre chiffres ou, autre possibilité, un antislash suivi du signe plus suivi d'un code hexadécimal sur six chiffres. Par exemple, l'identificateur 'data' peut être écrit ainsi :

U&'d\0061t\+000061'
    

L'exemple suivant, moins trivial, écrit le mot russe « slon » (éléphant) en lettres cyrilliques :

U&'\0441\043B\043E\043D'
    

Si un caractère d'échappement autre que l'antislash est souhaité, il peut être indiqué en utilisant la clause UESCAPE après la chaîne. Par exemple :

U&'d!0061t!+000061' UESCAPE '!'
    

Le caractère d'échappement peut être tout caractère simple autre qu'un chiffre hexadécimal, le signe plus, un guillemet simple ou double, ou un espace blanc.

Pour inclure le caractère d'échappement dans la chaîne, écrivez-la deux fois.

Les formes d'échappement à 4 chiffres et 6 chiffres sont utilisables pour spécifier les paires surrogates UTF-16 pour composer des caractères avec des codes points plus larges que U+FFFF, bien que la disponibilité de la forme à 6 chiffres la rende non nécessaire. (Les paires surrogates ne sont pas enregistrées directement, mais sont combinées dans un seul point code.)

Si l'encodage du serveur n'est pas en UTF-8, le point code Unicode identifié par une de ces séquences d'échappement est converti dans l'encodage réel du serveur ; une erreur est renvoyée quand la conversion n'est pas possible.

De plus, la syntaxe d'échappement de l'Unicode pour les constantes de chaînes fonctionne seulement quand le paramètre de configuration standard_conforming_strings est activé. Dans le cas contraire, cette syntaxe est confuse pour les clients qui analysent les instructions SQL, au point que cela pourrait amener des injections SQL et des problèmes de sécurité similaires. Si le paramètre est désactivé, cette syntaxe sera rejetée avec un message d'erreur.

Alors que la syntaxe standard pour la spécification des constantes de chaînes est généralement agréable, elle peut être difficile à comprendre quand la chaîne désirée contient un grand nombre de guillemets simples car chacun d'entre eux doit être doublé. Pour permettre la saisie de requêtes plus lisibles dans de telles situations, PostgreSQL fournit une autre façon, appelée « guillemet dollar », pour écrire des constantes de chaînes. Une constante de chaîne avec guillemet dollar consiste en un signe dollar ($), une « balise » optionnelle de zéro ou plus de caractères, un autre signe dollar, une séquence arbitraire de caractères qui constitue le contenu de la chaîne, un signe dollar, la même balise et un signe dollar. Par exemple, voici deux façons de spécifier la chaîne « Le cheval d'Anne » en utilisant les guillemets dollar :

$$Le cheval d'Anne$$
$UneBalise$Le cheval d'Anne$UneBalise$

Notez qu'à l'intérieur de la chaîne avec guillemet dollar, les guillemets simples peuvent être utilisés sans devoir être échappés. En fait, aucun caractère à l'intérieur d'une chaîne avec guillemet dollar n'a besoin d'être échappé : le contenu est toujours écrit littéralement. Les antislashs ne sont pas spéciaux, pas plus que les signes dollar, sauf s'ils font partie d'une séquence correspondant à la balise ouvrante.

Il est possible d'imbriquer les constantes de chaînes avec guillemets dollar en utilisant différentes balises pour chaque niveau d'imbrication. Ceci est habituellement utilisé lors de l'écriture de définition de fonctions. Par exemple :

$fonction$
BEGIN
  RETURN ($1 ~ $q$[\t\r\n\v\\]$q$);
END;
$fonction$

Dans cet exemple, la séquence $q$[\t\r\n\v\\]$q$ représente une chaîne constante avec guillemet dollar [\t\r\n\v\\], qui sera reconnue quand le corps de la fonction est exécuté par PostgreSQL. Mais comme la séquence ne correspond pas au délimiteur $fonction$, il s'agit juste de quelques caractères à l'intérieur de la constante pour ce qu'en sait la chaîne externe.

La balise d'une chaîne avec guillemets dollar, si elle existe, suit les mêmes règles qu'un identificateur sans guillemets, sauf qu'il ne peut pas contenir de signes dollar. Les balises sont sensibles à la casse, du coup $balise$Contenu de la chaîne$balise$ est correct, mais $BALISE$Contenu de la chaîne$balise$ ne l'est pas.

Une chaîne avec guillemets dollar suivant un mot clé ou un identificateur doit en être séparée par un espace blanc ; sinon, le délimiteur du guillemet dollar serait pris comme faisant partie de l'identificateur précédent.

Le guillemet dollar ne fait pas partie du standard SQL, mais c'est un moyen bien plus agréable pour écrire des chaînes constantes que d'utiliser la syntaxe des guillemets simples, bien que compatible avec le standard. Elle est particulièrement utile pour représenter des constantes de type chaîne à l'intérieur d'autres constantes, comme cela est souvent le cas avec les définitions de fonctions. Avec la syntaxe des guillemets simples, chaque antislash dans l'exemple précédent devrait avoir été écrit avec quatre antislashs, ce qui sera réduit à deux antislashs dans l'analyse de la constante originale, puis à un lorsque la constante interne est analysée de nouveau lors de l'exécution de la fonction.

Les constantes de chaînes de bits ressemblent aux constantes de chaînes standard avec un B (majuscule ou minuscule) juste avant le guillemet du début (sans espace blanc), c'est-à-dire B'1001'. Les seuls caractères autorisés dans les constantes de type chaîne de bits sont 0 et 1.

Les constantes de chaînes de bits peuvent aussi être spécifiées en notation hexadécimale en utilisant un X avant (minuscule ou majuscule), c'est-à-dire X'1FF'. Cette notation est équivalente à une constante de chaîne de bits avec quatre chiffres binaires pour chaque chiffre hexadécimal.

Les deux formes de constantes de chaînes de bits peuvent être continuées sur plusieurs lignes de la même façon que les constantes de chaînes habituelles. Le guillemet dollar ne peut pas être utilisé dans une constante de chaîne de bits.

Les constantes numériques sont acceptées dans ces formes générales :

chiffres
chiffres.[chiffres][e[+-]chiffres]
[chiffres].chiffres[e[+-]chiffres]
chiffrese[+-]chiffres
    

où chiffres est un ou plusieurs chiffres décimaux (de 0 à 9). Au moins un chiffre doit être avant ou après le point décimal, s'il est utilisé. Au moins un chiffre doit suivre l'indicateur d'exponentielle (e), s'il est présent. Il ne peut pas y avoir d'espaces ou d'autres caractères imbriqués dans la constante, sauf pour les tirets bas, qui peuvent être utilisé pour un groupement visuel comme indiqué ci-dessous. Notez que tout signe plus ou moins en avant n'est pas considéré comme faisant part de la constante ; il est un opérateur appliqué à la constante.

Voici quelques exemples de constantes numériques valides :

De plus, des constantes d'entiers non décimaux sont acceptées sous cette forme :

0xchiffreshex
0ochiffresoct
0bchiffresbin

où chiffreshex est un ou plusieurs chiffres hexadécimaux (0-9, A-F), chiffresoct est un ou plusieurs chiffres octaux, et chiffresbin est un ou plusieurs chiffres binaires (0 ou 1). Les chiffres hexadécimaux et les Hexadecimal digits and the préfixes de base peuvent être en minuscule ou en majuscule. Notez que seuls les entiers peuvent avoir des formes non décimales. Ce n'est pas le cas pour nombres à virgule.

Voici quelques exemples d'entiers non décimaux valides :

Pour un groupement visuel, des tirets bas peuvent être insérés entre les chiffres. Ils n'ont pas d'effet sur la valeur de la constante. Par exemple :

Les tirets bas ne sont pas autorisés au début ou à la fin d'une constante numérique ou d'un ensemble de chiffres (c'est-à-dire immédiatement avant ou après une constante numérique ou après le point décimal ou le marqueur d'exposant), et plus d'un tiret bas à la suite n'est pas autorisé.

Une constante numérique ne contenant ni un point décimal ni un exposant est tout d'abord présumée du type integer si sa valeur est contenue dans le type integer (32 bits) ; sinon, il est présumé de type bigint si sa valeur entre dans un type bigint (64 bits) ; sinon, il est pris pour un type numeric. Les constantes contenant des points décimaux et/ou des exposants sont toujours présumées de type numeric.

Le type de données affecté initialement à une constante numérique est seulement un point de départ pour les algorithmes de résolution de types. Dans la plupart des cas, la constante sera automatiquement convertie dans le type le plus approprié suivant le contexte. Si nécessaire, vous pouvez forcer l'interprétation d'une valeur numérique sur un type de données spécifique en la convertissant. Par exemple, vous pouvez forcer une valeur numérique à être traitée comme un type real (float4) en écrivant :

REAL '1.23'  -- style chaîne
1.23::REAL   -- style PostgreSQL (historique)

Ce sont en fait des cas spéciaux des notations de conversion générales discutées après.

Une constante de type arbitraire peut être saisie en utilisant une des notations suivantes :

type 'chaîne'
'chaîne'::type
CAST ( 'chaîne' AS type )

Le texte de la chaîne constante est passé dans la routine de conversion pour le type appelé type. Le résultat est une constante du type indiqué. La conversion explicite de type peut être omise s'il n'y a pas d'ambiguïté sur le type de la constante (par exemple, lorsqu'elle est affectée directement à une colonne de la table), auquel cas elle est convertie automatiquement.

La constante chaîne peut être écrite en utilisant soit la notation SQL standard soit les guillemets dollar.

Il est aussi possible de spécifier une conversion de type en utilisant une syntaxe style fonction :

nom_type ( 'chaîne' )

mais tous les noms de type ne peuvent pas être utilisés ainsi ; voir la Section 4.2.9 pour plus de détails.

Les syntaxes ::, CAST() et d'appels de fonctions sont aussi utilisables pour spécifier les conversions de type à l'exécution d'expressions arbitraires, comme discuté dans la Section 4.2.9. Pour éviter une ambiguïté syntaxique, la syntaxe type 'chaîne' peut seulement être utilisée pour spécifier le type d'une constante. Une autre restriction sur la syntaxe type 'chaîne' est qu'elle ne fonctionne pas pour les types de tableau ; utilisez :: ou CAST() pour spécifier le type d'une constante de type tableau.

La syntaxe de CAST() est conforme au standard SQL. La syntaxe type 'chaine' est une généralisation du standard : SQL spécifie cette syntaxe uniquement pour quelques types de données, mais PostgreSQL l'autorise pour tous les types. La syntaxe :: est un usage historique dans PostgreSQL, comme l'est la syntaxe d'appel de fonction.