Le but de ce tutoriel est de vous familiariser avec les commandes
de base du SQL : sélectionner, insérer, mettre à
jour, et supprimer des enregistrements.
Malgré le nombre d'implémentation de ce langage, SQL
est standardisé (ISO et ANSI pour la norme SQL 2, 1992),
ce qui facilite l'interrogation des SGBD, en tout cas pour les opérations
de base... Certains SGBD n'offrent en effet pas toutes les fonctionnalités
offertes par le standard SQL 2 par exemple, d'autres à l'inverse,
étendent cette norme.
En ce qui nous concerne aujourd'hui, pas de souci quant aux différentes
implémentations des commandes que nous allons utiliser. Afin
de permettre au plus grand nombre de tester éventuellement
ces requêtes, nous nous baserons sur l'interface offerte par
phpMyAdmin pour les exécuter.
Pour bénéficier de cette interface il vous suffit
d'installer (très simplement) Php, Apache et phpMyAdmin en
utilisant par exemple EasyPhp.
Création d'une table
SQL ne permet pas seulement d'interroger des données, c'est
aussi par lui que passent les ordres de création de
table. Afin de pouvoir concrètement visualiser le résultat
de nos requêtes, nous créeons une table d'exemple :
CREATE TABLE people (
pp_id tinyint(3) unsigned NOT NULL auto_increment,
pp_prenom varchar(30) default NOT NULL,
pp_mot_clef varchar(30) default NULL,
PRIMARY KEY (pp_id)
)
Si vous utilisez le phpMyAdmin de EasyPhp, plusieurs possibilités
s'offrent à vous. Première solution, passer par les
différents menus pour d'abord créer une base, puis
une table (champ par champ) et enfin renseigner celle-ci toujours
au travers des menus. Seconde solution, vous créez simplement
une base et exécutez le code ci-dessus dans l'interpréteur
de commandes SQL de phpMyAdmin.
Cette version de phpMyAdmin vous propose de visualiser le résultat
de vos actions sous formes de requêtes. Activée par
défaut cette option s'avère intéressante, surtout
lorsque l'on débute. Le "CREATE TABLE" ci-dessus
a ainsi été généré par phpMyAdmin.
Encore faut-il ensuite se donner la peine de comprendre le code...
Notre table "people" comporte trois champs :
- pp_id : la clef primaire de notre table, c'est l'identifiant unique
de chaque tuple
- pp_prenom : le prénom des personnes référencées
dans la base
- pp_mot_clef : le mot-clef qui leur est associé
Notre table "people" est en fait un tableau à
deux dimensions :
pp_id |
pp_prenom |
pp_mot_clef |
1 |
Rasmus |
Php |
2 |
Linus |
Linux |
3 |
Zeev |
Php |
4 |
Bill |
Windows |
On désigne par tuple une ligne du tableau.
Nous avons défini le champ "pp_id" comme auto-incrémental.
Cela signifie qu'à chaque fois que nous insérons un
nouveau tuple dans la table "people", ce champ est automatiquement
incrémenté par MySQL. Ce comportement n'est pas valable
pour tous les SGBD. Sous Oracle par exemple il faut spécifier
(sequence.nextval) lors d'une insertion la valeur à insérer.
Le champ "pp_id" est la clef primaire de la table "people",
grâce à lui chaque tuple est désigné
de manière unique.
Passons aux types que nous avons choisi pour nos colonnes.
Ceux-ci ont une importance. Inutile de gâcher notre espace
de stockage en choisissant un type de colonne capable de stocker
un entier de l'ordre du million si nous savons que notre table ne
contiendra que 10 personnes maximum.
La documentation du SGBD
utilisé est alors d'un grand secours.
Nous avons utilisé ici pour notre champ "pp_id"
le type "TINY_INT"
(extension de la norme SQL). Ce type désigne un entier compris
entre -127 et 128 par défaut. Les valeurs négatives
ne nous intéressent pas, nous pouvons alors appliquer à
ce champ l'attribut "unsigned" qui modifie l'étendue
de ce type : désormais de 0 à 255 caractères.
Par un raisonnement identique le type "VARCHAR"
a été utilisé pour les champs où sont
stockées des chaînes de caractères.
Enfin, et nous aurons fait le tour de toute la syntaxe utilisée
lors de ce "CREATE TABLE", les clauses "NOT NULL"
et "NULL" nous permettent d'indiquer si le champ concerné
est obligatoire ou pas : le SGBD provoquera une erreur si un champ
déclaré comme "NOT NULL" n'est pas renseigné
et soumis à une insertion.
Renseigner, modifier, effacer un enregistrement
(tuple) de la table
Nous avons maintenant à notre disposition un réceptacle
capable de contenir les personnalités de notre choix (voir
le tableau ci-dessus).
Voyons comment insérer ces personnalités dans notre
table "people" :
(une faute de frappe est volontairement introduite
sur le prénom)
INSERT INTO people (pp_prenom, pp_mot_clef) values ('Rasmuss', 'Php')
Les "quotes" ne sont à placer
que lorsque les champs à insérer sont des chaînes
de caractères, elles sont inutiles pour un entier (le champ
chiffre est factice) :
INSERT INTO people (pp_prenom, pp_mot_clef,
chiffre) values ('Rasmuss', 'Php', 12)
La syntaxe de certains SGBD n'oblige pas à spécifier
le nom des champs dans lesquels nous souhaitons insérer les
valeurs. Omettre cette étape n'est pas cependant pas souhaitable
: si un champ, même "NOT NULL" était ajouté
à la table, dans l'état de notre requête et
sans précision supplémentaire, ceci poserait un problème
au SGBD. Celui-ci ne pourrait plus deviner à quels champs
correspondent quelles valeurs. Il est donc plus fiable d'indiquer
systématiquement quels champs l'on souhaite mettre à
jour.
Nous procédons de même pour insérer les autres
personnalités dans notre table.
Passons à la modification. Admettons que l'on souhaite maintenant
corriger la faute de frappe effectuée plus haut sur le prénom
de Rasmus :
UPDATE people
SET pp_prenom = 'Rasmus'
WHERE pp_id = 1
Une nouveauté ici, il nous faut spécifier
"l'identifiant" du champ concerné. Pourquoi ?
Sans cette précision ce sont tous les prénoms de
toute la table "people" qui seraient mis à
jour (écrasés donc) avec la valeur "Rasmus".
Nous utilisons donc l'identifiant unique de ce tuple.
Nous aurions pu pourquoi pas nous passer de cet identifiant :
UPDATE people
SET pp_prenom = 'Rasmus'
WHERE pp_mot_clef = 'Php'
... Mais cela n'est pas possible compte tenu du fait que le prénom
"Zeev" est lui aussi associé à ce même
mot-clef ("Php"). Ce prénom serait alors lui aussi
écrasé et remplacé par "Rasmus".
Comment effacer un champ précis de la base ? C'est l'objet
de la commande "Delete". Si nous devions éliminer
les mots-clefs non liés au mouvement Open-Source alors :
DELETE FROM people
WHERE pp_prenom = 'Bill'
Cette commande provoque l'effacement du tuple "4, Bill, Windows"
(voir le tableau).
Les possibilités d'isoler un champ, pour l'effacer
ou autre, sont nombreuses. Avec le contenu actuel de notre table,
l'instruction suivante aurait provoqué le même effet
:
DELETE FROM people
WHERE pp_prenom LIKE 'B%'
Seule la condition du "WHERE" a été modifiée.
Nous demandons ici de supprimer tous les tuples dont le champ "pp_prenom"
débute par la lettre B. Le caractère "%"
agissant ici comme un "joker" du type " * ".
L'identification du tuple par le champ "pp_id" était
aussi envisageable :
DELETE FROM people
WHERE pp_id = 4
Sélectionner un enregistrement
dans une table
Sans doute la commande SQL la plus utilisée, le "SELECT"
permet de ramener les tuples dont on a besoin :
SELECT pp_prenom
FROM people
WHERE pp_mot_clef = 'Php'
... A pour effet de ramener les valeurs "Rasmus" et "Zeev".
Nous avons en effet sélectionné tous les champs "pp_prenom"
des tuples de la table "people" où les champs "pp_mot_clef"
sont égaux à "Php".
La commande SELECT supporte aussi les opérateurs classiques
de comparaison comme "<>" (différent de),
<, >, <=, >= et "LIKE".
Nos résultats peuvent également être classés.
Si l'on suppose que tous les champs initiaux de notre base sont
présents et rentrés dans la base comme le montre le
tableau à deux-dimensions utilisé plus haut, on peut
obtenir tout le contenu de la table, classé selon
le champ "pp_mot_clef " grâce à :
SELECT pp_prenom, pp_mot_clef
FROM people
ORDER BY pp_mot_clef
On obtient alors :
pp_prenom |
pp_mot_clef |
Linus |
Linux |
Rasmus |
Php |
Zeev |
Php |
Bill |
Windows |
Si la tentation est souvent grande d'utiliser un "SELECT *
" afin de ramener tous les champs possibles d'une table, cette
commande ne doit être utilisée qu'avec précaution
: il est en effet inutile de ramener 10 champs quand seuls deux
vous suffisent !
Répétée plusieurs fois sur un même site,
sur de lourdes tables, cette mauvaise habitude se répercute
sur les performances.
Cette introduction du langage SQL, basée sur la pratique,
est terminée. D'autres articles se pencheront sur des procédés
plus complexes comme les jointures entre tables par exemple. D'ici
là, pour celles et ceux qui veulent aller plus loin, vous
pouvez parcourir ce tutoriel
interactif, en anglais. Il vous permet de tester vos requêtes.
|