Vous êtes sur la page 1sur 79

Système de Gestion de

Bases de Données
Relationnelles
(SGBDR : MS Access)
Objectifs S
Dans cette partie vous Q
L
apprendrez à :
  Créer et gérer une BD(Base de
données) sous MS-Access tout en
exploitant les résultats des parties 1 &
2.
 Connaître quelques commandes SQL
concernant la création, la mise à
jour et la gestion d’une BD.
MLD:

N.B: Les seuls redondances acceptées concernent les clés étrangères.

Structure de la base de données: Voitures


MPD:
Propriétaire( id_prop, nom, prenom, adresse, cp, ville )
Marque( id_marque, marq, carburant )
Voiture( id_voit, #id_marque, #id_prop, immat,
couleur, dateFabric, dateAchat, prixAchat )

On suppose que dans chaque table on trouve des données


préalablement saisies ( voir le fichier: Etude de cas).
M
o
n
d
e

é
e
r

l
M
O
D
É
L
I
S
A
T
I
O
N
n
o
i
t
s
e
G

Comment
? ?
La gestion d'une base de données pose des
problèmes complexes. Cette gestion est assurée par
des logiciels spécialisés : les Systèmes de Gestion
de Bases de Données ou SGBD.
Quelques caractéristiques:
Organisation des données : le SGBD organise les données en
tables permanentes stockées sur disque; il crée les
mécanismes garantissant un accès rapide aux données.
Gestion des données : le SGBD garantit l'évolution cohérente
des données; il vérifie que les contraintes (unicité, référence
entre tables, etc.) sont respectées.
Accès aux données : le SGBD permet l'accès aux données à la
fois par l'utilisateur occasionnel(Administrateur, utilisateurs
avec pouvoir ou simple, …) et par les programmes de
traitement de données(intranet, web, …).
Protection contre les accidents : le SGBD garantit
l'intégrité et l'accessibilité des données en cas
d'incident ou d'attaque.
Gestion des accès concurrents : le SGBD permet l'accès
simultané aux données par un certain nombre
d'utilisateurs. Il contrôle rigoureusement les opérations
simultanées sur les mêmes données.
Contrôle des accès : le SGBD garantit que seuls les
utilisateurs autorisés peuvent accéder aux données et
les modifier.
Principaux SGBD existants:
 Relationnel
:
Access, Oracle, DB2, SQL server,
Sybase, MySQL, PostgreSQL.
Quelques SGBD Relationnels utilisant SQL:
• ORACLE (Oracle Corporation - 1977)
• MySQL (1995)
• DB2 (IBM - 1984)
• INFORMIX (Informix Inc - 1981)
• SYBASE (Sybase Inc - 1984)
•…
Principales fonctionnalités:
 Stockage sur disque des données, de leur
structure et du code associé
 Manipulations des données (enregistrement,
mises à jour, recherches)
 Gestion des accès (confidentialité,…)
 Administration (attribution des droits,
sauvegarde/restauration, optimisation,
répartition)
Quelles sont les composantes d'Access?
Tables : On trouve: la structure de la table, type de
champs et les informations qui y sont
entreposées.
Requêtes : Recherche d'informations qui répond à
certains critères déterminés par l'utilisateur.
Formulaire : Présentation de l'information à l'écran d'une manière
pratique pour l'utilisateur.

État : Présentation de l'information sur papier d'une manière


pratique pour l'utilisateur.

Macro : Développement de routines pour automatiser certaines


tâches.

Modules : Programmation (VB)


Les composantes d’une base de données Access :
1- Tables
Les données sont stocké dans des tables sous forme des lignes et des colonnes.
2- Formulaire
Les formulaires sont des élément essentielles pour une base données Access car il vous
permettent d’avoir une interface afin de pouvoir modifier vos informations. Ils sont
composé de boutons de commandes et des contrôles vous permettant d’effectuer toutes
ces taches
3- Les états
Les états permettent de faire une mise en forme des informations afin de les rendre plus
visible.
4- Les requêtes
Les requêtes font partie des composants clé d’une base de données Access de fait de
leur utilité indispensable. Leurs rôle essentiel est la récupération des informations
spécifiques de votre table.
5- Les macros
Les macros constituent un langage de programmation permettant d’ajouter des
fonctionnalités à votre base de données. Les macros contiennent des actions effectuant
des tâches.
6- Les modules
S’inspirant des macros, les modules sont des objets permettant de rajouter des
fonctionnalités à notre base. Si les macros sont créées en effectuant une sélection dans
une liste d’actions de macro, les modules eux sont écrit dans le langage de
Le langage SQL
sous MS Access
 Mode graphique :
MS Access

QBE (Query By Examples)


 Mode commandes (SQL) :
Ecriture manuel des
QBE : INTERFACE GRAPHIQUE DE
FORMULATION DES REQUETES

TABLES UTILISEES

Conditions de restriction Colonnes de la table Cases à cocher pour


résultat afficher ces champs
SQL : Langage complet, qui permet de créer, de manipuler, ou
d'interroger une base de données relationnelle. On peut ainsi
distinguer plusieurs types de traitements de données:
 Langage de Définition de Données (LDD). Permet la LDD
création et la définition de nouvelles tables ainsi que l'ajout et
la suppression de champs.
 Langage de Manipulation de Données (LMD), qui peut se
décomposer en deux types de requête :
 Interrogation du contenu des tables (LID). Ces requêtes donnent

à l'exécution d’une création de tables virtuelles composées d'un


nouvel ensemble d'enregistrements. Ce type de requêtes ne modifie
pas les tables de la base de données ni leur contenu. LID
 Modifications de données qui permettent l'ajout ou la suppression
d'enregistrements, et la modification (mise à jour) ou la suppression
d'une donnée sur certains enregistrements. LMD

 Langage de Contrôle de Données (LCD) qui permet de


définir les droits d'accès des utilisateurs.
Interrogation d’une BD: Les requêtes (angl.
Queries)
 

Les requêtes sont des "questions" qu'on pose au


SGBDR.
 

Il existe 4 types de requêtes les plus utilisées:

  Mode graphique Mode commande


1. Requête de sélection  Select
2. Requête d'insertion  Insert
3. Requête de modification  Update
4. Requête de suppression  Delete
Interrogation d’une BD: Les requêtes (suite)
  

Pour chaque requête, nous retrouvons le cycle ci-dessous :


Formuler la requête

Analyser et
Exécuter la requête

Résultat de la requête

Le résultat est toujours un sous-ensemble d'une ou de


plusieurs tables (le résultat=table virtuelle).
N.B: seul la syntaxe de la requête est sauvegardée et non son
résultat.
Constitution d'une requête SQL

Le raisonnement est le suivant :

Quoi ? Quelle(s) information(s) obtenir ?


Où ? Dans quelle(s) table(s) ?
[ Comment ?] ( restriction(s), jointure(s), … )

ordre SELECT
Une phrase ou un ordre SQL est construit(e) avec :
 des verbes définissant l'action à exécuter (CREATE,
SELECT, INSERT INTO, UPDATE, …)
 le nom d'un ou plusieurs champ(s)
 le nom des tables où se trouvent le(s) champ(s)
 et d'autre(s) expression(s) (WHERE, ORDER BY,
AND, etc…)

Remarques :
Le signe " ; " marque la fin d'une phrase SQL (selon les versions).
Les lettres en majuscule ou minuscule peuvent être utilisées,
mais on préfère conserver les majuscules pour les termes SQL
Comment créer une requête ?

..\..\..\..\..\ProgrameFiles(x86)
\MicrosofteOffice\Office12\
MSACCESS.EXE

Créer
une BD
?
3
Comment créer une table ?
Exécuter la requête
Mode graphique :

Mode SQL:
SELECT *
FROM proprietaire ;
Exécution d’une requête
REQUETE SOUS ACCESS : Projection

Cliquer ici pour


exécuter la requête
Les instructions SQL :
LDD
Les instructions SQL : LDD
La création d'une table (sous SQL Access)
 CREATE TABLE nom_table
( champ1 type_données PRIMARY KEY ,
    champ2 type_données(taille2) ,
    champ3 type_données ,
   … )

La suppression d'une table (SQL)


 DROP TABLE nom_table ;
Les instructions SQL : LDD
La création d'une table (SQL) appelée:
propriétaire
 CREATE TABLE propriétaire
( id_prop integer PRIMARY KEY ,
nom CHAR(20) ,
prenom VARCHAR(20) ,
cp int ,
ville char(10) );
La suppression d'une table (SQL)
DROP TABLE propriétaire ;
 On crée les autres tables (chacune avec
ses propres champs) par la même syntaxe
tout en déclarant les clés étrangères.

(voir page 28)


Comment déclarer un champ auto incrément ?

CREATE TABLE Client (


id_client AUTOINCREMENT,
nom VARCHAR(20),

CONSTRAINT Cli_PK PRIMARY KEY(id_client)


)
La modification d'une table
Il est possible de modifier la structure d’une table. Les
exemples les plus classiques concernent l'addition d'un
nouveaux champ et la suppression d'un champ existant:
 Ajouter un champ (une colonne)

ALTER TABLE nom_table


ADD nom_champ TYPE_CHAMP(taille) ;
Exemple: Ajouter un champ appelé naissance à la table Personne
ALTER TABLE Personne
ADD naissance Date NOT NULL;
 Pour supprimer la colonne (champ) que nous
venons de créer, nous utilisons la requête suivante :
ALTER TABLE Personne
DROP naissance ;
Comment déclarer une clé étrangère
sous MS Access ?

CREATE TABLE Voiture


(
    id_voit int NOT NULL PRIMARY KEY,
    immat char(10) NOT NULL,
    id_marque int FOREIGN KEY
REFERENCES Marque(id_marque)
id_prop integer FOREIGN KEY
REFERENCES Propriétaire(id_prop)
);
Comment déclarer une clé étrangère
sous MS Access ?

Si la table existe sans déclaration de la clé étrangère?

CREATE TABLE Voiture (


    id_voit int NOT NULL PRIMARY KEY,
    immat char(10) NOT NULL,
    id_marque int
id_prop int

);
Comment déclarer une clé étrangère
sous MS Access ?

Si la table existe sans déclaration de la clé étrangère ?

ALTER TABLE voiture

ADD FOREIGN KEY (id_marque) REFERENCES


Marque(id_marque);
 Avant de commencer l’interrogation de votre BD, il
fallait créer les différents liens entre les tables en
acceptant l’intégrité référentielle entre clé primaire et
clé étrangère.

N.B: on doit avoir le


même schéma que
celui du MLD.
Les instructions SQL :
LID
On peut interroger notre BD en
utilisant des requêtes mono-tables
ou multi-tables avec l’ordre:
SELECT
FROM
( c’est pour chercher et
sélectionner l’(es)information(s)
désirée(s) à partir d’une ou
plusieurs table(s) )
Langage d’Interrogation de
Données: LID

MSAccess: SELECT
 La projection PROJECTION

 La sélection/restriction RESTRICTION

 Le tri TRI

 La jointure(cas de plusieurs tables) <=>


MS Access Select
 Pour formuler la requête Select de SQL
en mode interactif on passe par QBE :
 On clique sur l’onglet « Créer » du ruban
Accueil
 Puis, sur le bouton « Création de
requête »
 Puis sur le bouton « Fermer » de la
fenêtre Afficher la table
 Enfin sur le bouton SQL.
La principale commande du langage d’interrogation de
données est la commande SELECT.
La commande SELECT effectue des opérations de
sélection de données sur une ou plusieurs table(s)
relationnelle(s) par projection. Sa syntaxe générale est
la suivante :
SELECT [DISTINCT] < liste des champs > | *
FROM <liste de(s) table(s)>
[ WHERE <condition> ]
[ GROUP BY <liste des champs> ]
[ HAVING <condition de groupement> ]
[ ORDER BY <liste des champs de tri> ] ;
Clause SQL Fonction Obligatoire
SELECT Génère la liste des champs qui contiennent les données
Oui
pertinentes.
FROM Génère la liste des tables qui contiennent les champs
Oui
répertoriés dans la clause SELECT.
WHERE Spécifie les critères de champs auxquels doit répondre
chaque enregistrement pour être inclus dans les Non
résultats.
ORDER BY Spécifie comment trier les résultats. Non
GROUP BY Dans une instruction SQL qui contient des fonctions Uniquement en
d’agrégation, génère la liste des champs qui ne sont pas présence de
répertoriés dans la clause SELECT. tels champs
HAVING Dans une instruction SQL qui contient des fonctions
d’agrégation, spécifie les conditions qui s’appliquent aux
champs qui sont répertoriés dans l’instruction SELECT. Non

Les clauses sont exécutées dans cet ordre :


FROM  WHERE  GROUP BY / HAVING  SELECT  ORDER BY
Les instructions SQL : LID
I. La projection: requête mono_table
Une projection est une instruction permettant de sélectionner un
ensemble de colonnes (ou champs) dans une table.

Quoi ? SELECT liste_des_champs | *


Où ? FROM table ; * : signifie que tous
les champs de la
table sont concernés.
Ou bien :
SELECT DISTINCT liste_des_champs
FROM table ;
La clause DISTINCT permet d'éliminer les doublons.
La projection (suite)
Requête n°1:
Afficher la liste des
propriétaires (Nom et Ville)

Quoi ? SELECT nom, ville

Où ? FROM propriétaire ;

SELECT * * : signifie que tous les champs


de la table propriétaire sont
FROM propriétaire ; concernés.
Mode graphique :

Mode commande: requête SQL


SELECT nom, ville
FROM propriétaire;
II. La Sélection (ou Restriction)
Une restriction consiste à sélectionner les lignes satisfaisant à
une condition logique effectuée sur leurs attributs (ou
champs).
Quoi ? SELECT *
Où ? FROM table
Comment ? WHERE condition ;
La condition de sélection exprimée derrière la clause
WHERE peut être spécifiée à l'aide des :
• opérateurs de comparaison : =, >, <, <>, >=, <=
• opérateurs logiques : AND, OR, NOT
• opérateurs : IN, BETWEEN, LIKE
La Sélection (ou Restriction)
Requête n° 2 :
Afficher la liste des propriétaires
(id_prop , nom, ville) dont le
numéro du propriétaire est
supérieur à 5

Quoi ? SELECT id_prop, nom, ville


Où ? FROM propriétaire Utilisation
des
Comment ? WHERE id_prop > 5 ; opérateurs
Requête n° 3 : Afficher la liste des propriétaires (nom, ville)
qui habitent la ville de fès.

Quoi ? SELECT nom, ville


Où ? FROM propriétaire
Comment ? WHERE ville = ‘‘fès’’ ;
Exemples d’utilisation de dates en tant que
critères dans des requêtes Access
Critères de requête : Utilisation de dates

Les dates sont automatiquement entourées par


des dièses: # date #

WHERE DateNaissance < #01/01/2018#


Quoi ? SELECT
III. Le tri
Où ? FROM

Comment ? ORDER BY

SELECT champ1, champ2, champ3, ...


FROM table
ORDER BY champ1 [ASC] , champ2 DESC, ... ;

Le tri peut être:


croissant (ASC) (par défaut) ou décroissant (DESC)
III. Le tri (suite)
Requête n° 4 :
Afficher la liste des propriétaires
(nom, code postal, ville) dans
l’ordre alphabétique de la ville.

SELECT nom, cp, ville

FROM propriétaire

ORDER BY ville ;
Tri sur la ville
Sélection – Exemples
CONSIDÉRONS LA TABLE / RELATION :
ETUDIANT ( NUM , NOM , PRÉNOM , AGE , VILLE , CP )

Quels sont les étudiants âgés de 20 ans ou plus ?


SELECT * FROM Etudiant WHERE Age >= 20;

Quels sont les étudiants âgés de 19 à 23 ans ?


SELECT * FROM Etudiant WHERE Age IN (19, 20, 21, 22, 23);
SELECT * FROM Etudiant WHERE Age BETWEEN 19 AND 23;
Quels sont les étudiants habitant à Rabat ?
SELECT * FROM Etudiant WHERE Cp LIKE '11*' ;

Quels sont les étudiants dont la ville est inconnue/connue ?


SELECT * FROM Etudiant WHERE Ville IS NULL ;
SELECT * FROM Etudiant WHERE Ville IS NOT NULL ;
46
IV. La jointure : requête multi-tables
La jointure va nous permettre de sélectionner des
informations dans plusieurs tables grâce aux
relations existantes entre ces tables(tables
ayant un ou plusieurs champs communs). Il va
néanmoins falloir indiquer comment se fait la
relation entre ces tables (conditions spécifiées
dans la clause WHERE).

Par exemple : récupérer le nom et le prénom du client


ayant passé la commande n°1.
SELECT liste des champs de A et B
FROM Table_A , Table_B
WHERE Table_A . id_A=Table_B . id_A ;
id_A : clé primaire dans la table Table_A
# id_A : clé étrangère dans la table Table_B
id_A et #id_A sont identiques (de même type)
Exemple:

id_client nom_client
1 Driss BENDRISS
id_commande id_client date_commande
2 Marcel Dubois
1 4 26/01/2018
3 Hassane BELBIJOU
2 1 26/01/2018
4 Marc Degraux 3 1 28/01/2019
5 Aicha BENAICHA 4 3 28/01/2018
… … 5 4 28/01/2018
6 3 29/01/2019
7 1 29/01/2018
Effectuons maintenant une requête 8 4 30/01/2018
multi-tables, en l‘occurence la 9 1 01/02/2018
10 4 01/02/2019
sélection des données de nos 2
11 4 01/02/2019
tables en même temps (on va donc 12 3 01/02/2018
joindre nos 2 tables: c’est la … … …
procédure de jointure).
Exemple:

id_client nom_client
1 Driss BENDRISS
id_commande id_client date_commande
2 Marcel Dubois 1 4 26/01/2018
3 Hassane BELBIJOU 2 1 26/01/2018
4 Marc Degraux 3 1 28/01/2019
5 Aicha BENAICHA 4 3 28/01/2018
5 4 28/01/2018
… …
6 3 29/01/2019
7 1 29/01/2018
8 4 30/01/2018
9 1 01/02/2018
10 4 01/02/2019
11 4 01/02/2019

SELECT * 12 3 01/02/2018

FROM client, commande … … …

WHERE client . id_client = commande . id_client


IV. La jointure (suite)
Par exemple : récupérer le nom et le prénom du client
ayant passé la commande n°1 :

SELECT nom, prenom


FROM Client, Commande Clé étrangère
WHERE Client.id_client = Commande.id_client
Clé primaire
AND id_commande = 1 ;
Lorsqu’il y a jointure entre deux tables, les tables sont
mentionnées en ligne FROM et le critère de jointure fait partie
des éléments de la ligne WHERE, lié par AND aux autres
critères de restriction.
Le préfixage est nécessaire pour préciser de quelle table sont
issus les champs concernés par la jointure.
Requête n° 5 :
Afficher la liste des voitures avec leurs marques (id_voit,
immat, marq, couleur, carburant) dans l’ordre croissant du
nom de la marque.
Quoi ? SELECT id_voit, immat, marq, couleur, carburant
Où ? FROM marque, voiture
Comment ? WHERE marque.id_marque = voiture.id_marque

ORDER BY marq ;
Il est possible d’utiliser des alias pour nommer
une table différemment dans la requête.

Requête n° 6 :
Afficher la liste des voitures avec leurs marques (id_voit,
immat, marq, couleur, carburant) dans l’ordre croissant du
nom de la marque.

Quoi ? SELECT id_voit, immat, marq, couleur, carburant


Où ? FROM Marque m, voiture v
Comment ? WHERE m.id_marque = v.id_marque
ORDER BY marq ;
Alias de table
Afficher la liste des propriétaires disposant des voitures
avec leurs marques correspondantes (nom, immat, marq,
couleur, carburant) dans l’ordre croissant du nom du
propriétaire et l’ordre décroissant selon la couleur.

SELECT nom, immat, couleur, marq, carburant


FROM propriétaire p , voiture v, marque m
WHERE (p.id_prop = v.id_prop)
AND (v.id_marque = m.id_marque)
ORDER BY nom, couleur DESC;
L'élimination des doublons
 SELECT DISTINCT marq
FROM Marque;

Requête avec création de champ


(virtuel) :
 SELECT [Nom] & " " & [Prenom] AS Nom_complet
FROM propriétaire ;
Les fonctions agrégatives (ou
statistiques)
Il existe également des fonctions prédéfinies qui donnent une valeur
agrégée calculée pour les lignes sélectionnées :
• count(*) donne le nombre de lignes trouvées,
• count(nom-colonne) donne le nombre de valeurs de la colonne,
• avg(nom-colonne) donne la moyenne des valeurs de la colonne,
• sum(nom-colonne) donne la somme des valeurs de la colonne,
• min(nom-colonne) donne le minimum des valeurs de la colonne,
• max(nom-colonne) donne le maximum des valeurs de la colonne
Le groupement
Il existe une clause bien pratique en SQL qui permet d’opérer des regroupements. Il
s’agit de GROUP BY. On s’en sert pour grouper des éléments identiques.
Par exemple, pour un même client dont on connaît le détail de chaque vente, on peut
réaliser un groupement par client et effectuer un calcul statistique sur les ventes (somme
des ventes, moyenne des ventes, nombre cumulé de ventes, vente maximum ou
minimum)…

Concrètement, la requête va regrouper les éléments identiques et réaliser une


fonction d’aggrégation sur les autres champs choisis.
- En réalisant la requête suivante, on
affiche le total des ventes par client :
SELECT Nom_Client, SUM(Montant _Vente)
FROM Vente
GROUP BY Nom Client;

- En réalisant la requête suivante, on


affiche la moyenne des ventes par jour :

SELECT Date, AVG(Montant _Vente)


FROM Vente
GROUP BY Date;
Le groupement
Il est possible de grouper des lignes de données ayant une
valeur commune à l’aide de la clause GROUP BY et des fonctions
de groupe.

D’une manière générale, une requête avec groupement s’écrit en


SQL comme suit :

Syntaxe :
SELECT Champ1, Champ2,…,Fonction_Groupe
FROM Nom_Table1, Nom_Table2,…
WHERE Liste_Condition
GROUP BY Liste_Groupe
[HAVING Condition ] ;
Le groupement (suite)
Exemple :

SELECT nom_champ1, SUM(nom_champ2)


FROM nom_table
GROUPE BY nom_champ1
HAVING condition_fonction ;

Application (sans la clause HAVING) :


• Donner le nombre de commandes par client.
SELECT NumCl, COUNT(NumCmd) AS Nombre_de_Cmd
FROM Commande
GROUP BY NumCl ;
• Donner la quantité totale commandée
par produit.

SELECT NP, SUM(Qte) AS Som


FROM LigneCmd
GROUP BY NP ;
Le groupement (suite)
Soit la table des résultats suivante :
Résultat(id, date, Agence, CA)

Résultat : id Date Agence CA


1 06/01/2003 Nord 927,02 €
2 07/01/2003 Nord 1 385,55 €
3 06/01/2003 Sud 1 098,46 €
4 07/01/2003 Sud 1 401,56 €
5 06/01/2003 Est 561,29 €
6 07/01/2003 Est 681,09 €

 Nous voulons effectuer le regroupement par date pour


savoir le CA global.
Le regroupement (suite)
Soit la table : Résultat : Date Agence CA
06/01/2003 Nord 927,02 €
07/01/2003 Nord 1 385,55 €
06/01/2003 Sud 1 098,46 €
07/01/2003 Sud 1 401,56 €
06/01/2003 Est 561,29 €
07/01/2003 Est 681,09 €

 Nous effectuons le regroupement par date et nous


sommons sur le CA. Nous obtenons le code SQL
suivant :
SELECT Date, Sum(CA) AS Chiffre_affaires_total
FROM Résultat
GROUP BY Date ;
Compter le nombre de propriétaires habitant rabat.
SELECT COUNT(id_prop) AS total_client_rabat
FROM propriétaire
WHERE ville = "rabat" ;

Calculer le prix d’achat total par numéro de voiture.

SELECT SUM(prixAchat) AS total_prix_achat


FROM voiture
WHERE id_voit = 5 ;
Champs calculés:
Les instructions SQL :
LMD
Les instructions SQL : LMD
Requête: Ajout
 Permet d’insérer des enregistrements dans une table soit à partir d’une liste
de valeurs, soit à partir d’enregistrements d’une autre table.
Syntaxe 1 : Ajout de nouvelles valeurs à une table.
Forme 1 :
INSERT INTO NomTable(champ1, champ2, champ3,...)
VALUES(valeur1, valeur2, valeur3,...)

Forme 2 :
INSERT INTO NomTable

VALUES(valeur1, valeur2, valeur3,...)


Ajouter un nouveau propriétaire à la table «Propriétaire»

INSERT INTO Propriétaire


VALUES(100,"BELBIJOU","rue de la
paix",13000,"Tanger") ;
Syntaxe 2 : Ajout d’enregistrements provenant
d’une autre table.

INSERT

INTO TableDestination(champ1, champ2, champ3,...)


( SELECT champ_A, Champ_B, Champ_C,…
FROM TableSource 
[ WHERE Condition ] )
On peut insérer simultanément plusieurs enregistrements
ou parties d'enregistrements dans une table.
Par exemple, si nous voulons placer dans une table
nommée "Clients_Rt" les clients habitant Rabat, nous
allons procéder ainsi:
1) Créer une table "Clients_Rt" avec Access, nous allons
supposer que cette table comporte 3 champs: le nom, le
prénom et l'adresse.
2) Taper la commande :
INSERT INTO Clients_Rt(nom, prenom, adresse)
( SELECT nom, prenom, adresse
FROM Clients
WHERE ville=‘Rabat‘ )
Les requêtes mises à jour
 Les requêtes mises à jour permettent de
modifier un ou plusieurs enregistrements
automatiquement.
UPDATE nomTable
SET nomChamp = nouvelleValeur
WHERE Condition
 1)  Formulez la requête SQL permettant de modifier l’erreur
suivante : Dans la base de données BIBLIOTHEQUE, l’auteur
Abdellah ELAROUI s’appelle en réalité Abdellah AROUI
UPDATE Auteur
SET nomAut = ’’AROUI’’
WHERE nomAut=’’ELAROUI’’ AND prenomAut=’’Abdellah’’ ;
Par exemple, si nous voulons, dans la table
« Produit », modifier le prix d'un produit dont le
nom est "prod1", nous taperons :

UPDATE Produit
SET prix_unitaire = 1000
WHERE libelle = ‘'prod1’';

NB: Si la clause WHERE est absente, tous les enregistrements de la table


seront affectés.
UPDATE propriétaire
SET prenom = "Hassane" 

WHERE nom = "BELBIJOU"


AND cin = "AB5544";
Tout comme la commande INSERT, la
commande UPDATE peut contenir une requête.

Dans ce cas la syntaxe est la suivante :

UPDATE table
SET champ1 = nouvelle_valeur1,
champ2 = nouvelle_valeur2,
WHERE condition = (requête);

La requête est une requête faite avec la commande


SELECT.
 Les requêtes suppression
Une requête suppression a pour effet de
supprimer tous les enregistrements d’une table
répondant à une condition déterminée.
DELETE *
FROM NomTable
WHERE Condition
Par exemple, pour supprimer tous les clients dont la ville
est Rabat :
DELETE *
FROM Client
WHERE ville='Rabat‘ ;
Requête calcul du "Total" :
 Le nombre total des voitures enregistrées dans la BD ?

SELECT count(id_voit) AS Total_voitures


FROM Voiture ;

 Le nombre total des voitures de couleur bleu ?

SELECT count(id_voit) AS Total_voitures


FROM Voiture
WHERE couleur = ‘‘bleu’’ ;
Requête paramétrée
Les sous-requêtes
On peut imbriquer autant de requêtes que l'on veut. La condition
après la clause WHERE peut porter sur le résultat d'une autre
requête (ou sous-requête).
Supposons les tables suivantes :
Vente Acheteur
#Num_acheteur Num_acheteur
#Num_produit Nom
Prénom
Prix
Cette table contient, pour chaque acheteur, le produit qu'il a acheté et le prix
d'achat.
Nous voulons la liste des acheteurs ayant acheté des articles chers. Nous
considérerons qu'un article cher est un article dont le prix est supérieur à la moyenne du
prix des produits achetés + 100 Dh.
SELECT Num_acheteur
FROM Vente
L
WHERE prix > ( SELECT AVG(prix) FROM Vente) M