1.

Création de relation
En SQL, une relation est aussi appelée tableau ou, plus couramment, table.
Syntaxe :
create table nomRelation (attribut1 typeAttribut1, …, attributN typeAttributN)

Exemple :
create table Etudiant (numeroEtudiant integer, nom varchar(30), adresse
varchar(30))

Il est possible et généralement pertinent de spécifier des contraintes d'intégrité pour les attributs.
Exemple :
create table Etudiant (numeroEtudiant integer unique, nom varchar(30) not null,
adresse varchar(30), unique (nom, adresse))

Il est aussi possible de nommer une contrainte pour l'identifier plus aisément (sinon, elle obtient un nom
automatiquement donné par le SGBD).
Exemple :
create table Etudiant (numeroEtudiant integer constraint numero-unique unique,
nom varchar(30) not null, adresse varchar(30), constraint nom-et-adresse-non-
vides not null (nom, adresse))

2. Modification de relation
Dans certains cas et pour certaines implémentations, la modification de relation ne peut être réalisée que
par une suppression suivie d'une création.

3. Renommage d'une relation :

Syntaxe :
alter table nomRelation rename to nouveaunomRelation

Exemple :
alter table Etudiant rename to Elève.

4. Renommage d'un attribut :

Syntaxe :
alter table Relation rename column nomAttribut to nouveaunomAttribut

Exemple :
alter table Etudiant rename column nom to nom_Etudiant.

5. Ajout d'un ou plusieurs attributs :

Syntaxe :
alter table Relation add (attribut1 typeAttribut1 [[constraint nomContrainte1]
contrainte1], …, attributN typeAttributN [[constraint nomContrainteN]
contrainteN])
Exemple :
alter table Etudiant add (prenom varchar(30))

6. Modification d'un ou plusieurs attributs :

Syntaxe :
alter table Relation modify (attribut1 typeAttribut1
[[constraint nomContrainte1] contrainte1], …, attributN typeAttributN
[[constraint nomContrainteN] contrainteN])

Exemple :
alter table Etudiant modify (nom varchar(40))

Si une contrainte est ajoutée, la modification n'est acceptée que si toutes les valeurs actuelles concernées
dans la table respectent cette contrainte.

7. Suppression de relation
Syntaxe :
drop table nomRelation

Exemple :
drop table Etudiant

I. Manipulation de donnée (Insertion, modification suppression de n-

uplets)
1. Ajout de n-uplets dans une relation
Syntaxe :
insert into nomRelation values (valeurAttribut1, …, valeurAttributN)

Exemple :
insert into Etudiant values (42, 'Amine', 'Oujda')

2. Modification de n-uplets dans une relation

Syntaxe :
update nomRelation set modification where condition

Exemple :
update Etudiant set adresse='Fès' where numéroÉtudiant≤15.

3. Suppression de n-uplets dans une relation

Syntaxe :
delete from nomRelation where condition

Exemple :
delete from Etudiant where adresse!='Fès'.

4. Suppression de toutes les n-uplets d'une relation

Syntaxe :
truncate table nomRelation

Exemple :
truncate table Etudiant

II. Interrogation d’une base de données (commande SELECT)

L’utilisation la plus courante de SQL consiste à lire des données issues de la base de données. Cela
s’effectue grâce à la commande SELECT, qui retourne des enregistrements dans un tableau de résultat.
Cette commande peut sélectionner une ou plusieurs colonnes d’une table.
Dans les exemples ci-dessous de la commande Select, on crée la table Etudiant suivante :

Etudiant
Nom Prénom Age
Idrissi Ahmed 19
Kourchi Adil 20
Madani Mohammed 19
Alami Amal 18
Zaki Ahmed 20

1. SQL SELECT
Commande Basique :
SELECT nom_champ FROM nom_table

Cette requête SQL va sélectionner le champ "nom_champ" provenant de la table appelé "nom_table".
Exemple1 : Obtenir la colonne Nom
SELECT Nom FROM Etudiant

Exemple2 : Obtenir plusieurs colonnes (Nom, Prénom)

SELECT Nom, Prénom FROM Etudiant
Exemple3 : Obtenir toutes les colonnes
SELECT * FROM Etudiant

2. SQL DISTINCT :
La commande SELECT peut afficher des lignes en doubles. Pour éviter des redondances dans les résultats il
faut ajouter DISTINCT après le mot SELECT.
SELECT DISTINCT nom_champ FROM nom_table

Exemple :
SELECT DISTINCT Nom FROM Etudiant

3. SQL WHERE:
La commande WHERE permet d’obtenir uniquement les informations désirées et d’extraire les lignes d’une
base de données qui respectent une condition.
SELECT nom_champ FROM nom_table WHERE Condition

Exemple :
SELECT Nom, Prénom FROM Etudiant WHERE Age = 19

a. Les opérateurs logiques (AND et OR):

Les opérateurs logiques AND et OR peuvent être utilisées au sein de la commande WHERE pour combiner
des conditions.
L’opérateur AND permet de s’assurer que la condition1 ET la condition2 sont vrai :
SELECT nom_colonnes FROM nom_table WHERE condition1 AND condition2

L’opérateur OR vérifie quant à lui que la condition1 OU la condition2 est vrai :

SELECT nom_colonnes FROM nom_table WHERE condition1 OR condition2

Ces opérateurs peuvent être combinés à l’infini et mélangés mais il faut penser à utiliser des parenthèses
lorsque c’est nécessaire.
Exemple :
SELECT Nom FROM Etudiant WHERE Prénom = 'Ahmed' AND Age = 19

b. Opérateurs de comparaisons
 = : Egale
SELECT Nom, Prénom FROM Etudiant WHERE Age = 19

 (!=) : Différent (Pas égale)

SELECT Nom, Prénom FROM Etudiant WHERE Age <> 19

 < (<=) : Inférieur (Inférieur ou égale à)

 (>=) : Supérieur (Supérieur ou égale à)
SELECT Nom, Prénom FROM Etudiant WHERE Age >= 19

 IN : liste de plusieurs valeurs possibles

SELECT Nom FROM Etudiant WHERE Prénom IN ('Ahmed', 'Mohammed')

 BETWEEN : Valeur comprise dans un intervalle donnée

Syntaxe :
SELECT nom_champ(s) FROM nom_table WHERE nom_colonne BETWEEN 'Val1' AND 'VAL2'

Exemple :
SELECT Nom, Prénom FROM Etudiant WHERE Age BETWEEN 18 AND 20

 LIKE : Recherche en spécifiant le début, milieu ou fin d'un mot (un modèle particulier).
Syntaxe :
SELECT nom_champ(s) FROM nom_table WHERE nom_colonne LIKE modèle

Les modèles de LIKE :

 LIKE '%n' : le caractère " % " est un caractère joker qui remplace tous les autres caractères.
Ainsi, ce modèle permet de rechercher toutes les chaines de caractère qui se termine par un
"n".
 LIKE 'n%' : ce modèle permet de rechercher toutes les lignes de "colonne" qui commence par
un " n ".
 LIKE '%n%' : ce modèle est utilisé pour rechercher tous les enregistrements qui utilisent le
caractère " n".
 LIKE 'ar%se' : ce modèle permet de rechercher les chaines qui commence par "ra" et qui se
terminent par "se".
 LIKE 'a_c' : peu utilisé, le caractère "_" (underscore) peut être remplacé par n’importe quel
caractère, mais un seul caractère uniquement (alors que le symbole pourcentage "%" peut être
remplacé par un nombre incalculable de caractères . Ainsi, ce modèle permet de retourner les
lignes « aac », « abc » ou même « azc ».
Exemple :
SELECT * FROM Etudiant WHERE Prénom LIKE 'A%'

 IS NULL (IS NOT NULL) : valeur Nulle (valeur non Nulle)

Syntaxe :
SELECT * FROM nom_table WHERE nom_colonne IS NULL (IS NOT NULL)

Exemple :
SELECT * FROM Etudiant WHERE Prénom IS NOT NULL

4. SQL GROUP BY:

La commande GROUP BY est utilisée en SQL pour grouper plusieurs résultats.
SELECT colonne1, fonction (colonne2) FROM table GROUP BY colonne1

Exemple :
SELECT Nom, SUM (Age) FROM Etudiant GROUP BY Nom

Fonctions d’agrégations :
Il existe plusieurs fonctions qui peuvent être utilisées pour manipuler plusieurs enregistrements, il s’agit
des fonctions d’agrégations statistiques, les principales sont les suivantes :
  AVG () : pour calculer la moyenne d’un set de valeur.
 COUNT () : pour compter le nombre de lignes concernées.
 MAX () : pour récupérer la plus haute valeur.
 MIN () : pour récupérer la plus petite valeur.
 SUM () : pour calculer la somme de plusieurs lignes.

5. SQL HAVING
La condition HAVING en SQL est presque similaire à WHERE à la seule différence que HAVING permet de
filtrer en utilisant des fonctions telles que SUM (), COUNT (), AVG (), MIN () ou MAX ().
Syntaxe
SELECT colonne1, fonction1 (colonne2) FROM nom_table GROUP BY colonne1 HAVING
fonction2 (colonne2) operateur valeur

Cela permet donc de SÉLECTIONNER les colonnes de la table "nom_table" en GROUPANT les lignes qui ont
des valeurs identiques sur la colonne "colonne1" et que la condition de HAVING soit respectée.
Important : HAVING est très souvent utilisé en même temps que GROUP BY bien que ce ne soit pas
obligatoire.
SELECT Nom, AVG (Age) FROM Etudiant GROUP BY Nom HAVING Max (Age) >= 19

6. SQL ORDER BY
La commande ORDER BY permet de trier les lignes dans un résultat d’une requête SQL. Il est possible de
trier les données sur une ou plusieurs colonnes, par ordre ascendant ou descendant.
Syntaxe :
SELECT colonne1, colonne2… FROM nom_table ORDER BY colonne1 (2…) [ASC ou DESC]

Par défaut les résultats sont classés par ordre ascendant, toutefois il est possible d’inverser l’ordre en
utilisant le suffixe DESC après le nom de la colonne. Par ailleurs, il est possible de trier sur plusieurs
colonnes en les séparant par une virgule.
Exemple1 :
SELECT * FROM Etudiant ORDER BY nom

Exemple1 :
SELECT * FROM Etudiant ORDER BY nom, Age DESC

7. SQL UNION
C’est donc une commande qui permet de concaténer les résultats de 2 requêtes ou plus.
Syntaxe :
SELECT * FROM table1 UNION SELECT * FROM table2

Exemple :
SELECT * FROM Etudiant1 UNION SELECT * FROM Etudiant2
 8. SQL INTERSECT
Cette commande permet donc de récupérer les enregistrements communs à 2 requêtes.
Syntaxe :
SELECT * FROM table1 INTERSECT SELECT * FROM table2

Dans cet exemple, il faut que les 2 tables soient similaires (mêmes colonnes, mêmes types et même ordre).
Le résultat correspondra aux enregistrements qui existent dans table1 et dans table2.
Exemple :
SELECT * FROM Etudiant1 INTERSECT SELECT * FROM Etudiant2

9. JOINTURE SQL
Les jointures en SQL permettent d’associer plusieurs tables dans une même requête. Cela permet d’exploiter la
puissance des bases de données relationnelles pour obtenir des résultats qui combinent les données de
plusieurs tables de manière efficace.
En général, les jointures consistent à associer des lignes de 2 tables en associant l’égalité des valeurs d’une
colonne d’une première table par rapport à la valeur d’une colonne d’une seconde table.
Syntaxe :
SELECT * FROM table1 JOIN table2 ON table1.key = table2.key

Où "key" et une clé de jointure reliant les 2 tables.

Exemple :
On suppose les tables suivantes de la base Gestion_Bibliothèque

Etudiant (IdEtudiant, Nom, Prénom)

Livre (IdLivre, Titre, Auteur, IdBibliothèque)
Bibliothèque (IdBibliothèque, Adresse)
Emprunt (IdEtudiant, IdLivre, Date_Emprunt)
On veut obtenir le nom de l'étudiant et la date d'emprunt d'un livre par cet étudiant :
SELECT Etudiant.Nom, Emprunt.Date_Emprunt
FROM Etudiant JOIN Emprunt
ON Etudiant.IdEtudiant = Emprunt.IdEtudiant

10. SQL et Python :

a. Le module SQLite de Python :
a. Les opérations
 connect() : Pour se connecter à une base de données
 cursor() : Ces curseurs sont utilisés pour les interactions avec la base
 close() : ferme une connexion.
 b. Emission de requêtes SQL
 execute() : permet l’évaluation d’une requête SQL
 executemany() : permet l'exécution de valeurs retardées
 fetchone() et fetchall() permettent de récupérer respectivement une valeur ou toutes les
valeurs.
 commit() :valide une transaction avec la base.
 rollback() :annule une transaction avec la base.

c. Exemple Complet :
On va élaborer des fonctions qui font la gestion d'une base de données "Scolarité" de type SQLite à travers
le langage Python en se basant sur le module sqlite3.
import sqlite3
 Connexion à la base et création des tables :
def connexion ( ) :
conn = sqlite3.connect ("Scolarité")
curseur = conn.cursor ( )
#création de la table Etudiant
curseur.execute ("CREATE TABLE IF NOT EXISTS Etudiant (Nom char(20),
Prénom char(25), Age int (2))")
conn.commit ( )
conn.close( )

 Suppression d'une table :

def suppression_table():
conn = sqlite3.connect ("Scolarité")
curseur = conn.cursor ( )
curseur.execute ("DROP TABLE Etudiant")
conn.commit ( )

 Insertion des données :

def insertion ( ):
conn = sqlite3.connect ("Scolarité")
curseur = conn.cursor ( )
curseur.execute ("INSERT INTO Etudiant VALUES ('Slimani','Ahmed', 19)")
curseur.execute ('INSERT INTO Etudiant VALUES
(?,?,?)',('Slimani','Ahmed', 19))
curseur.executemany ('INSERT INTO Etudiant VALUES (?,?,?)',
[('Kourchi,'Adil ', 18), ('Alami','Amal', 19), ('Zaki','Walid', 18)])
#Avec une liste
Etudiants = [['Chakir', Fatima', 19],['Maaroufi', 'Kamal', 18],
['Talbi','Zineb',18]
 for élément in Etudiants:
curseur.execute ('INSERT INTO Etudiant VALUES (?,?,?)', élément)
#Avec les dictionnaires
Etudiants = {"nom" : "Hasnaoui", "prénom" : "Ahmed", "age" : 20}
curseur.execute ("INSERT INTO Etudiant (Nom, Prénom, Age) VALUES (:nom,
:prénom, :age)", Etudiants)
conn.commit ( )
conn.close ( )

 Récupération des données :

Récupération de la première ligne :
curseur.execute("SELECT * FROM Etudiant")
Etudiant1 = curseur.fetchone ( )
print (Etudiant1)

 Récupération de plusieurs lignes :

requete="SELECT * FROM Etudiant"
curseur.execute(requete)
for ligne in curseur.fetchall ( ):
print (ligne)

 Recherche des éléments dans la table :

def recherche(nom,age):
conn= sqlite3.connect("Scolarité")
curseur=conn.cursor ()
#recherche par âge
curseur.execute ("SELECT * FROM Etudiant WHERE Age = %i" %age)
for ligne in curseur.fetchall ( ):
print (ligne)
#recherche par le nom
#curseur.execute ("SELECT * FROM Etudiant WHERE Nom = 'Slimani'")
curseur.execute ("SELECT * FROM Etudiant WHERE Nom = ? ", (nom,))
for ligne in curseur.fetchall ( ):
print (ligne)

 Modification des entrées :

def modification (age):
conn= sqlite3.connect("Scolarité")
curseur=conn.cursor ()
#curseur.execute("UPDATE Etudiant SET Age = 20 WHERE Nom = 'Slimani' ")
curseur.execute ("UPDATE Etudiant SET Age = ? WHERE Nom = 'Slimani' ",
(age,))
conn.commit ( )
 conn.close ( )

 Annulation des transactions :

Pour revenir au dernier commit, on utilise rollback ( )
conn.rollback ( )