| Documentation PostgreSQL 7.2 | ||
|---|---|---|
| <<< Previous | Next >>> | |
Les entrées SQL consistent en une succession de commandes. Une commande est composée d'une suite d'instructions, terminés par un point-virgule (";"). La fin de la chaîne termine aussi une commande. La validité des instructions dépend de la syntaxe de la commande.
Une instruction peut être un mot-clé, un identifiant, un identifiant entre guillemets, un libellé (ou une constante), ou un caractère symbolique. Les instructions sont normalement séparées par des espaces (espace, tabulation, nouvelle ligne), mais ne sont pas nécessaires s'il n'y a pas ambiguïté (ce qui est généralement le cas si un caractère spécial est adjacent à quelque autre type d'instruction).
De plus, des commentaires peuvent apparaître dans les entrées SQL. Ils ne sont pas des instructions, mais sont équivalents à un espace.
Par exemple, la commande SQL valide (syntaxiquement) suivante :
SELECT * FROM MY_TABLE; UPDATE MY_TABLE SET A = 5; INSERT INTO MY_TABLE VALUES (3, 'hi there'); |
La syntaxe SQL n'est pas très logique en regard de ce que les instructions identifient les commandes qui sont des operandes ou des paramètres. Les premières instructions sont généralement le nom de la commande elle-même, ainsi dans exemple c-dessus nous parlons d'une commande "SELECT", "UPDATE", et "INSERT". Mais dans ce cas la commande UPDATE nécessite toujours une instruction SET pour apparaître dans une certaine position, et cette variation particulière de INSERT nécessite aussi un VALUESafin d'être complète. Les règles précises de syntaxe pour chaque commande sont décrites dans le Manuel de référence.
Les instructions comme SELECT, UPDATE, ou VALUES dans l'exemple ci-dessus, sont des exemples de mots-clé, ce qui veut dire que ce sont des termes qui ont une signification dans le SQL. Les instructions MY_TABLE et A sont des exemples d' identifiants. Ils identifient des noms de tables, colonnes, et autres objets de la base, en fonction de la commande dans laquelle ils sont utilisés. Par conséquent, ils sont quelque fois appelés "noms". Les mots-clé et les identifiants ont la même structure lexicale, ce qui signifie qu'on ne peut pas savoir si un signe est un identifiant ou un mot-clé sans connaître le langage. Une liste complète des mots-clé se trouve dans the appendix called Mots-clé SQL.
Les identifiants et les mots-clé SQL doivent débuter par une lettre (a-z, mais aussi par des signes diacritiques et des lettres non latines) ou un souligné (_). En conséquence, les caractères dans un identifient ou un mot-clé peuvent être des lettres, des chiffres (0-9), ou des soulignés, bien que le standard SQL ne définisse pas de mots-clé contenant des chiffres ou débutant ou finissant avec des soulignés.
Le système n'utilise pas plus d'un NAMEDATALEN-1 caractère d'identifiant; les noms plus longs peuvent être écrits dans les commandes, mais ils seront tronqués. Par défaut, NAMEDATALEN est de 32, le maximum de longueur pour un identifiant est de 31 (mais au moment où le système est développé NAMEDATALEN peut être modifié dans src/include/postgres_ext.h).
Les noms d'identifiants et de mots-clé ne sont pas sensibles à la casse. Donc :
UPDATE MY_TABLE SET A = 5; |
uPDaTE my_TabLE SeT a = 5; |
UPDATE my_table SET a = 5; |
C'est la seconde sorte d'identifiants : l'identifiant délimité ou identifiant entre guillemets. Il est formé en insérant une suite de caractères arbitraires dans des guillemets ("). Un identifiant délimité est toujours un identifiant, jamais un mot-clé. Ainsi "select" sera toujours utilisé en référence à une colonne ou une table nommée "select", puisqu'un select non délimité sera pris comme mot-clé et donc provoquera un erreur d'analyse lorsqu'un nom de table ou de colonne est attendu. L'exemple peut être écrit avec des identifiants délimités comme :
UPDATE "my_table" SET "a" = 5; |
Les identifiants délimités peuvent contenir des caractères autres que les guillemets. Ce qui permet de construire des tables et noms de colonnes qui ne seraient pas possible autrement, comme certains contenant des espaces ou des "&". La limitation en longueur s'applique toujours.
Délimiter un identifiant le rend sensible à la casse, attendu que les noms non délimités sont toujours en minuscules. Par exemple, l'identifiant FOO, foo et "foo" sont considérés comme identiques par PostgreSQL, mais "Foo" et "FOO" sont différents des trois autres. [1]
Il existe quatre sortes de constantes implicitement typées dans PostgreSQL: chaînes, chaînes de bit, entiers, et nombres décimaux. Les constantes peuvent aussi être spécifiées avec des types explicites, qui peuvent permettre une représentation plus précise et plus efficace pour la gestion du système. Les constantes implicites sont décrites ci-dessous; les constantes explicites seront décrites après.
Une constante de chaîne, en SQL, est une suite arbitraire de caractères bornée par de simples ("'"), ex., 'Ceci est une chaîne'. SQL admet les apostrophes dans les chaînes en tapant deux apostrophes adjacents (ex. 'Dianne''s horse'). Dans PostgreSQL les apostrophes peuvent alternativement être séparés par un antislash ("\", ex., 'Dianne\'s horse').
Les séparations antislash de type-C sont aussi disponibles : \b est un retour arrière, \f est un positionnement de page suivante, \n est un saut de ligne, \r est un retour chariot, \t une tabulation, et \xxx, où xxx est un nombre octal,c'est le caractère qui correspond au code ASCII. Les autres caractères suivants le backslash sont pris littéralement. Ainsi, pour inclure un backslash dans une constante de chaîne, tapez deux backslash.
Le caractère avec le code zéro ne peut être dans une constante de chaîne.
Deux constantes de chaîne qui sont seulement séparées par des espaces avec au moins un saut de ligne sont concaténées et effectivement traitées comme si la chaîne avait été écrite dans une constante. Par exemple :
SELECT 'foo' 'bar'; |
SELECT 'foobar'; |
SELECT 'foo' 'bar'; |
Les constantes de chaîne-bit ressemblent aux constantes de chaîne avec un B (majuscule ou minuscule) immédiatement avant l'apostrophe (sans espace), ex., B'1001'. Les seuls caractères admis dans les constantes de chaîne-bit sont 0 et 1. Les constantes de chaîne-bit peuvent être poursuivies le long des lignes de la même façon que les constantes de chaîne normales.
Les constantes entier en SQL sont des suites de chiffres décimaux (0 à 9) sans virgule ni exposant. Le champ des valeurs légales dépend du type d'entier utilisé, mais le type entier plein accepte dez valeurs allant de -2147483648 à +2147483647. (Le signe optionnel plus ou moins est actuellement un opérateur unaire séparé et ne fait pas partie de la constante entier).
Les constantes décimales sont acceptées sous ces formes générales :
digits.[digits][e[+-]digits] [digits].digits[e[+-]digits] digitse[+-]digits |
Les constantes décimales sont de type DOUBLE PRECISION. REAL peut être spécifié en utilisant la notation chaîne SQL ou le type de notation de PostgreSQL :
REAL '1.23' -- string style
'1.23'::REAL -- PostgreSQL (historical) style
|
Une constante d'un type arbitraire peut être utilisée en se servant d'une des notations suivantes :
type 'string' 'string'::type CAST ( 'string' AS type ) |
Il est aussi possible d'utiliser un type forcé en utilisant une syntaxe du genre fonction :
typename ( 'string' ) |
Les ::, CAST(), et les syntaxes d'appel-fonction peuvent aussi être utilisés en spécifiant au lancement les conversions de type des expressions arbitraires, voir the section called Coercition de type. Mais la forme type 'string' ne peut être utilisée que pour spécifier le type d'une constante littérale. Une autre restriction sur type 'string' est que ça ne fonctionne pas pour les types tableau ; utilisez :: ou CAST() pour spécifier le type d'une constante tableau.
Le format général d'une constante tableau est le suivant :
'{ val1 delim val2 delim ... }' |
'{{1,2,3},{4,5,6},{7,8,9}}' |
Les éléments individuels des tableaux peuvent être placés entre guillemets (") pour éviter les problèmes ambiguïté avec le respect des espaces. Sans guillemets, l'analyseur sautera les espaces.
(Les constantes de tableau sont actuellement seulement un cas particulier des constantes de type générique que nous avons vues dans cette section. La constante est initialement traitée comme une chaîne et passée à la routine de conversion. Une spécification de type explicite pourrait être nécessaire).
Un opérateur est une suite de plus d'NAMEDATALEN-1 (31 par défaut) caractères de la liste suivante :
+ - * / < > = ~ ! @ # % ^ & | ` ? $
Il y a, cependant, quelques restrictions concernant les noms d'opérateurs :$ (dollar) ne peut pas être un opérateur à caractère unique, bien qu'il puisse faire partie d'un nom d'opérateur à caractère multiple.
-- et /* ne peuvent apparaître nulle part dans un nom d'opérateur, car ils sont interprétés comme le début d'un commentaire.
AUn nom d'opérateur à caractère multiple ne peux se terminer avec un + ou un -, à moins que le nom contienne aussi un de ces caractères :
~ ! @ # % ^ & | ` ? $
Par exemple, @- est un nom d'opérateur admis, mais *- ne l'est pas. Cette restriction permet à PostgreSQL d'analyser la conformité SQL des requêtes sans avoir besoin des espaces entre les identifiants.En travaillant avec des noms d'opérateurs non standards SQL, vous devrez séparer les opérateurs adjacents avec des espaces pour éviter toute ambiguïté. Par exemple, si vous avez défini un opérateur unaire gauche nommé @, vous ne pourrez écrire X*@Y; vous devrez écrire X* @Y pour être sûr que PostgreSQL le lit comme deux noms d'opérateurs et pas un seul nom.
Certains caractères, qui ne sont pas alphanumériques, ont un comportement spécial qui est différent d'un opérateur. Des détails sur leur utilisation peuvent être trouvés à l'endroit où l'élément syntaxique est décrit. Cette section uniquement pour but de vous en faire connaître l'existence et de faire un résumé des ces caractères.
Un signe dollar ($) suivi de chiffres est utilisé pour représenter le paramètre de position dans le corps d'une définition de fonction. Dans d'autres domaines le signe dollar peut une partie d'un nom d'opérateur.
Les parenthèses (()) ont leur comportement habituel pour grouper des expressions et renforcer la priorité. Dans certains cas les parenthèses sont nécessaires dans la syntaxe d'une commande SQL.
Les crochets ([]) sont utilisés pour sélectionner les éléments d'un tableau. Voir the chapter called Tableaux pour plus d'information sur les tableaux.
Les virgules (,) sont utilisées dans certaines constructions syntaxiques pour séparer les éléments d'une liste.
Le point-virgule (;) termine une commande SQL. Il ne peut apparaître n'importe où dans une commande, sauf dans une constante de chaîne ou un identifiant délimité.
Les deux-points (:) sont utilisés pour séléctionner les "slices" des tableaux. (Voir the chapter called Tableaux.) Dans certains dialectes SQL (comme le SQL embarqué), les deux-points sont utilisés pour préfixer les noms de variables.
L'astérisque (*) a un comportement spécial lorsqu'il est utilisé dans la commande SELECT ou avec la fonction agrégation COUNT.
Le point (.) est utilisé dans les constantes décimales et pour séparer les noms de table et de colonne.
Un commentaire est une suite arbitraire de caractères débutant par des doubles tirets et s'étendant jusqu'à la fin de la ligne, ex. :
-- Ceci est un commentaire SQL standard |
De façon alternative, les commentaires de style-C peuvent être utilisés :
/* multiline comment * with nesting: /* nested block comment */ */ |
Un commentaire est supprimé de l'analyse syntaxique et remplacé par des espaces.
| [1] | Le pliage de noms non entre parenthèses et en minuscules PostgreSQL est incompatible avec le standard SQL, qui indique que les noms non délimités doivent être pliés en majuscules. Ainsi, foo pourrait être équivalent à "FOO" pas "foo" selon le standard. Si vous désirez écrire des applications portables vous êtes prévenus de toujours délimiter un nom particulier ou de ne jamais le faire. |
| <<< Previous | Home | Next >>> |
| An 2000 | Up | Colonnes |