Présentation du langage SQL

SQL est un acronyme qui signifie « Structured Query Language », c'est-à-dire Langage d'Interrogation Structuré.

En réalité le SQL ne se limite pas aux recherches de données dans une base mais constitue un langage complet de gestion de bases de données relationnelles.

Il a été conçu par IBM dans les années 70, sur les bases de recherches du Docteur Ted Codd, un chercheur d'IBM à San José. A l'origine il avait été nommé SEQUEL pour Structured English QUEry Language. Il est devenu le langage standard des systèmes de gestion de bases de données (SGBD) relationnelles (SGBDR).

Le SQL permet la définition, la manipulation et l'interrogation des données.

• un langage de manipulation des données (LMD)
      - un langage d'interrogation de données (ordre SELECT)
      - un langage de manipulation des données (ordres INSERT, UPDATE, DELETE)
• un langage de définition des structures de données (LDD)
      - ordres CREATE, ALTER, DROP
• un langage de contrôle de l'accès aux données (LCD)
      - ordres GRANT, REVOKE

Le SQL a été normalisé dès 1986 mais les premières normes n'ont pas été suivies par les éditeurs de SGBD car elles étaient incomplètes. Il faut attendre 1992 pour qu'apparaisse la norme SQL-2. Elle a été accepté partout mais quelques grands SGBD ne la respectent pas entièrement. Cette norme est appelée bien souvent SQL-92.

Le SQL est découpé en trois niveaux :
- Full SQL (ensemble de la norme)
- Intermediate SQL
- Entry Level SQL (ensemble minimum à respecter pour être aux normes SQL-2)

Le SQL utilise des identificateurs pour désigner les objets qu'il manipule. Ces objets peuvent être des tables, des vues, des colonnes, des indexes, des constantes, des variables, etc...

Pour nommer un objet, l'identificateur ne doit pas contenir de caractères accentués et certains mots réservés du langage sont interdits. Certains symboles sont utilisables : #, $ et _. Les chiffres peuvent également être utilisés et SQL n'est pas sensible à la casse.

C'est au concepteur de la base de données de fixer ses propres normes de nommage pour que l'utilisation du système de base de données soit la plus claire pour tout le monde. Par exemple on peut choisir de toujours nommer les tables en commençant par table_ ou par un T. Une vue pourra être identifiée par "vue_nomdelavue" ou par "Vnomdelavue". Un index sera désigné par I_ ou devra commencer par I. L'important est de s'y retrouver et de savoir quel est le type d'objet que l'on manipule. SQL n'impose rien à ce sujet.

Dans tout SGBD relationnel, l'objet de base est la table.

Une table est composée de lignes et de colonnes. Une ligne et l'ensemble de ses colonnes est appelée un « tuple ».

Le SQL permet d'interroger des tables sur différents filtres et d'effectuer les jointures entres plusieurs tables.

Les données contenues dans une colonne doivent être toutes d'un même type de donnée. Ce type est indiqué au moment de la création de la table qui contient la colonne. Le type de donnée peut correspondre à un entier, une chaîne de caractère, un booléen, etc.

Chaque colonne est repérée par un identificateur unique à l'intérieur de chaque table. Il ne peut y avoir deux colonnes qui portent le même nom pour une même table. Mais deux colonnes de deux tables différentes peuvent tout à fait avoir le même identifiant. Il est une pratique courante de donner le même nom aux colonnes qui correspondent à des clés étrangères que celui donné à la clé primaire de la table principale. Une autre pratique est de préfixer les noms de colonnes par un préfixe propre à chaque table. Ainsi on repère facilement les colonnes qui sont des clés étrangères car leur préfixe sera celui de la table principale et non celui de la table contenant la clé étrangère.

Cette pratique de nommer les colonnes avec un préfixe rappelant la table permet d'éviter toute ambiguïté. En effet, si vous avez une table "Tbl_DEPARTEMENT" qui contient une colonne "VILLE" et une autre table "Tbl_CLIENT" qui contient elle aussi une colonne "VILLE", il y a ambiguïté. Quand on utilise la colonne "VILLE" on ne sait pas s'il s'agit de la colonne "VILLE" de la table des départements ou bien de la ville d'un client. SQL permet d'éviter la confusion en préfixant les colonnes du nom de la table suivit d'un point.
Exemple :

Tbl_DEPARTEMENT.VILLE
Tbl_CLIENT.VILLE

T01VILLE
T02VILLE

Une vue est une extraction logique d'une table. Toutes les colonnes de la table n'y sont pas forcément représentées. Une vue peux contenir des colonnes provenant de plusieurs tables.

Les vues sont utiles pour restreindre des droits à certains utilisateurs ou pour leur présenter les données de façon plus claire et synthétique pour eux.

Pour accélérer les accès aux données, il est possible de créer des indexes. Un index porte sur une et une seule table et il peut être composé d'une ou plusieurs colonnes.

Un index est dit « UNIQUE » quand il ne peut y avoir plusieurs tuples de la table qui contiennent les mêmes valeurs pour les colonnes appartenant à l'index.

Une bonne pratique est de suffixer le nom des indexes car il ne peut pas y avoir deux indexes qui portent le même nom, même s'ils concernent la même table. Pour la table Tbl_CLIENT on pourra ainsi avoir les indexes suivants :
I_CLIENT01
I_CLIENT02
I_CLIENT03

On suppose que les tables ont déjà été définies et en tant qu'utilisateurs nous souhaitons obtenir des informations contenues dans ces tables. La manière la plus simple est de faire une sélection de toutes les colonnes de la table. Cette sélection s'effectue avec l'ordre SELECT qui doit être suivi d'une liste de colonnes, du mot réservé FROM et enfin du nom de la table. Un ordre SELECT se termine par un point-virgule. L'étoile est un joker qui remplace l'ensemble des colonnes d'une table.

SELECT * FROM Tbl_CLIENT;

SELECT code_postal, ville FROM Tbl_CLIENT;

SELECT code_postal, ville FROM Tbl_CLIENT WHERE numcli = 100;

L'expression qui figure après la clause WHERE peut être très complexe. Il est possible d'utiliser des expressions arithmétiques avec les opérateurs + - * /. La priorité des opérateurs est la même qu'en arithmétique classique. L'utilisation de parenthèses est possible pour forcer des calculs prioritairement aux autres.

Le SQL utilise beaucoup d'autres opérateurs et fonctions pour manipuler les chaînes de caractères ou les dates. L'opérateur || permet de concaténer deux chaînes de caractères. L'opérateur - donne la différence de deux dates.

Les opérateurs peuvent s'utiliser à la fois dans le prédicat de l'ordre SELECT, c'est-à-dire dans la clause WHERE, mais également dans le résultat.

Les résultats d'une requête peuvent eux-même servir de filtre pour une autre requête. Il est possible d'imbriquer plusieurs ordres SELECT ou de les réunir selon la théorie des ensembles.

Nous avons déjà rencontré trois de ces clauses : SELECT, FROM, WHERE.
Mais il en existe au total 6, les quatre dernières étant facultatives :
SELECT...
FROM...
WHERE...
GROUP BY...
HAVING...
ORDER BY...

Il est possible d'utiliser des modificateurs qui vont modifier le comportement d'un ordre SQL.
DISTINCT s'utilise pour éliminer les doublons. Il se place juste après le mot SELECT :
SELECT DISTINCT * FROM ....
SELECT DISTINCT ville FROM Tbl_CLIENT;

Cette dernière requête retournera toutes les villes différents où se trouvent les clients.

Le mot AS permet de nommer une colonne résultante.
SELECT ville AS CLIVILLE FROM Tbl_CLIENT;
SELECT nom, fixe + variable AS Salaire FROM Tbl_Employe;

Dans un SELECT, le mot FROM est obligatoire. Il sert à préciser la table dans laquelle on doit sélectionner les colonnes. Il est possible d'utiliser plusieurs tables après le mot FROM.

SELECT nom, adresse, Tbl_CLIENT.ville FROM Tbl_CLIENT, Tbl_DEPARTEMENT
WHERE Tbl_CLIENT.ville = Tbl_DEPARTEMENT.ville;

SELECT nom, adresse, a.ville FROM Tbl_CLIENT a, Tbl_DEPARTEMENT b
WHERE a.ville = b.ville;

Le prédicat qui suit une clause WHERE s'applique comme un filtre. Il est possible de combiner plusieurs expressions entre-elles en utilisant des opérateurs.

L'égalité : WHERE exp1 = exp2
La différence : WHERE exp1 <> exp2
L'infériorité : WHERE exp1 < exp2
La supériorité : WHERE exp1 > exp2
Inférieur ou égal : WHERE exp1 <= exp2
Supérieur ou égal : WHERE exp1 >= exp2
Entre deux limites (bornes incluses) : WHERE exp1 BETWEEN exp2 AND exp3
Commençant par : WHERE exp1 LIKE exp2
Ne commençant pas par : WHERE exp1 NOT LIKE exp2
Compris dans : WHERE exp1 IN (exp2, exp3, ...)
Non compris dans : WHERE exp1 NOT IN (exp2, exp3, ...)
Valeur nulle : WHERE exp IS NULL
Valeur non nulle : WHERE exp IS NOT NULL

Pour le prédicat LIKE il est possible d'utiliser le caractère joker % qui représente une chaine quelconque de n'importe quelle longueur, même de longueur nulle. Le caractère joker _ est utilisé pour représenté un seul caractère quelconque.

Les opérateurs logiques AND et OR peuvent être utilisés pour combiner plusieurs prédicats. L'opérateur AND est prioritaire par rapport à l'opérateur OR. Des parenthèses peuvent être utilisées pour imposer une priorité dans l'évaluation du prédicat, ou simplement pour rendre plus claire une expression logique complexe.

L'opérateur NOT placé devant un prédicat en inverse le sens.

Une caractéristique puissante du SQL est la possibilité d'imbriquer plusieurs requêtes. C'est-à-dire qu'un critère de recherche est lui-même le résultat d'une requête SQL.
Exemple :
Vous disposez d'une base tbl_CLIENT et vous voulez savoir quels sont tous vos clients qui habitent la même ville que le client DURAND.
Vous pouvez écrire la requête de cette façon :

SELECT Nom
      ,rue  
  FROM tbl_CLIENT a
      ,tbl_CLIENT b 
WHERE  a.ville = b.ville
  AND  b.nom   = 'DURAND';

SELECT Nom
      ,rue 
  FROM tbl_CLIENT
WHERE  ville = ( SELECT ville FROM tbl_CLIENT
                  WHERE nom = 'DURAND');

La norme SQL-2 a introduit un nouveau formalisme pour coder les jointures, en séparant les critères de filtrage des conditions de jointure. Cette syntaxe se code ainsi :

SELECT colonne1, colonne2, ... 
  FROM table1 a 
  JOIN table2 b 
    ON a.colonne = b.colonne;

SELECT colonne1, colonne2, ... 
  FROM table1 a 
  JOIN table2 b 
    ON a.colonne = b.colonne
 WHERE a.colonne3 > 25;

INNER JOIN

SELECT colonne1, colonne2, ... 
  FROM table1 a 
  INNER JOIN table2 b 
    ON a.colonne = b.colonne
 WHERE ....;

LEFT OUTER JOIN

SELECT a.dept, b.nom, b.ville 
  FROM tbl_DEPARTEMENT a 
  LEFT OUTER JOIN tbl_CLIENT b 
    ON a.dept = b.dept;

RIGHT OUTER JOIN

SELECT b.dept, a.nom, a.ville 
  FROM tbl_CLIENT a 
 RIGHT OUTER JOIN tbl_DEPARTEMENT b 
    ON a.dept = b.dept;

FULL OUTER JOIN

département   nom du client    ville du client
   NULL       nom du client    ville du client
département       NULL              NULL

SELECT b.dept, a.nom, a.ville 
  FROM tbl_CLIENT a 
 FULL OUTER JOIN tbl_DEPARTEMENT b 
    ON a.dept = b.dept;

Supposons maintenant que je souhaite obtenir la liste de tous les départements pour lesquels il n'y a pas encore de clients. Il est possible d'utiliser des SELECT imbriqués :

SELECT a.dept 
  FROM tbl_DEPARTEMENT a 
 WHERE a.dept NOT IN (SELECT DISTINCT b.dept FROM tbl_CLIENT b WHERE a.dept = b.dept);

SELECT a.dept 
  FROM tbl_DEPARTEMENT a 
  LEFT OUTER JOIN tbl_CLIENT b 
    ON a.dept = b.dept
 WHERE b.dept IS NULL;

Il peut être intéressant d'obtenir un résultat qui soit trié. Pour ce faire le prédicat ORDER BY est votre ami.  Il s'utilise à la fin d'un ordre SQL et doit être suivit d'une liste de colonnes qui seront les critères de tri. Pour chaque colonne il est possible de préciser le sens du tri :
- ASC pour un tri ascendant
- DESC pour un tri descendant

Par défaut, le tri se fait en ascendant.

Syntaxe :

ORDER BY exp1 [DESC], exp2 [DESC], ...

SELECT DEPT, NOM FROM tbl_DEPARTEMENT ORDER BY NOMD ASC;

SELECT DEPT, NOM FROM tbl_DEPARTEMENT ORDER BY 2;

SELECT DEPT "N°", NOM "Département" FROM tbl_DEPARTEMENT
ORDER BY 2;

Cette clause s'utilise souvent de pair avec la clause HAVING.

Il est possible de subdiviser la table en groupes, chaque groupe étant un ensemble de lignes ayant une valeur commune.

Syntaxe :

GROUP BY exp1, exp2, ...

SELECT a.dept, count(b.*) 
  FROM tbl_DEPARTEMENT a 
  LEFT OUTER JOIN tbl_CLIENT b 
    ON a.dept = b.dept
 GROUP BY a.dept
 ORDER BY a.dept;

SELECT a.dept, count(*) 
  FROM tbl_DEPARTEMENT a 
  JOIN tbl_CLIENT b 
    ON a.dept = b.dept
 GROUP BY a.dept
HAVING count(*) > 50
 ORDER BY a.dept;

Le SQL s'inspire énormément de la théorie des ensembles. Il est possible de réaliser des unions très simplement :

SELECT ....
UNION
SELECT .... ;

Cet article ne prétend pas vous apprendre le SQL dans sa globalité. Il s'agit d'une simple présentation en s'attachant à l'ordre SELECT qui est celui que vous utiliserez sans doute le plus. L'ordre SELECT ne nécessite pas d'être informaticien pour interroger une base de données.

Mais le SQL permet également d'effectuer des insertions en table, des mises à jour, des suppressions. Il s'utilise pour définir les objets tels que les tables, les vues, les indexes, ... Le SQL est un langage très complet et puissant.

Du fait qu'il s'agit d'un langage déclaratif, il est souvent utilisé à l'intérieur de programmes écrits dans un langage procédural ou dans un langage orienté objet. Ces langages utilisent le SQL par le biais d'une interface de connexion au moteur SQL.

Pour traiter chaque ligne de résultat obtenu par un ordre SELECT, il faut ouvrir ce qu'on appelle un « curseur ». Le curseur retourne l'ensemble du résultat. Pour accéder à chaque ligne il faut faire des « FETCH ». Les fetch sont réalisés à l'intérieur d'une boucle. Chaque ligne retournée par le fetch alimente des variables qui sont alors utilisables comme n'importe quelles variable du programme. C'est ainsi qu'un langage tel que le COBOL peut utiliser le SQL pour accéder à des bases de données DB2. Le PHP fonctionne sensiblement de la même façon avec la notion des curseurs et des fetchs légèrement différente qu'en DB2.