ISSAT GABES MP2-PC2-T2

Chap. 5
Les Bases De Données
Partie II : Module SQLITE3 De Python

Introduction :
Les bases de données, par leur complexité et leur grande optimisation, nécessitent des
logiciels dédiés, les SGBD. Il en existe un grand nombre :
 des professionnels (puissants et payants) : Oracle, …
 des systèmes développés par des organisations à buts non lucratifs (universités), mais
aussi largement utilisés par le monde professionnel : MySQL, SQLite, …
SQLite est actuellement le moteur de base de données le plus distribué au monde, grâce à son
utilisation dans de nombreux logiciels grand public (Firefox, Skype) et dans les bibliothèques
standards de nombreux langages comme PHP ou Python.
I. Créer une base de données avec SQLite :
Pour créer une base de données avec SQLite, rien de plus simple, Nous devons tout d'abord
importer le module sqlite3 (le 3 indiquant la version de sqlite) :

import sqlite3 # nous importons le paquet Python capable d'interagir avec sqlite

Il faut ensuite décider le nom de fichier que vous voulez attribuer à la base de données.
SQLite mémorise toutes les tables d'une base de données dans un seul fichier que vous
pouvez le sauvegarder où vous voulez:

Bd = sqlite3.connect ('Clinique.db') # créer ou ouvre un fichier nommé 'Clinique.db'

qui doit donc se trouver dans le même répertoire que l'endroit où Python est lancé.

L'objet connexion est désormais en place, et pour pouvoir dialoguer avec la base de données à
l'aide du langage SQL. Il faut mettre en place un autre objet que l'on appelle un curseur. Il
s'agit d'une mémoire intermédiaire, destiné à mémoriser temporairement les données en cours
de traitement, ainsi que les opérations que vous effectuez sur elles, avant leur transfert
définitif vers la base de données.
cur =Bd.cursor ()

 Création d’une table :

La commande CREATE TABLE permet de créer une table en SQL.
La création d’une table sert à définir les colonnes et le type de données qui seront contenus
dans chacune des colonnes.
Syntaxe :
La syntaxe générale pour créer une table est la suivante :

AU 2021/2022 1
ISSAT GABES MP2-PC2-T2

cur.execute (" CREATE TABLE nom_table (colonne1 type1, colonne2 type2...)")

Pour chaque colonne, il est également possible de définir des options telles que :
 NOT NULL : Garantit qu'une colonne ne peut pas avoir la valeur NULL.
 DEFAULT : Fournit une valeur par défaut pour une colonne lorsque rien n'est
spécifié.
 UNIQUE: Veiller à ce que toutes les valeurs d'une colonne sont différents.
 PRIMARY KEY : portant une ou plieurs colonnes servant à identifier une ligne de la
table de manière unique
 FOREIGN KEY : champ qui, dans une table, fait référence à la clé primaire d'une
autre table est appelé clé étrangère. Ainsi sont définies les relations entre les tables.
 CHECK: La contrainte CHECK garantit que toutes les valeurs d'une colonne satisfont
certaines conditions
Types de données :
A noter que les types de données ne portent pas les mêmes noms en Python et en SQL ;
Les principaux types de données en SQL sont :
 TEXT ou CHAR : enregistre la donnée comme une chaîne de caractères, sans
limite de taille.
 INTEGER ou INT : enregistre la donnée comme un entier ;
 REAL ou FLOAT : enregistre la donnée comme un réel ;
 DATE, TIME : enregistre la donnée comme une date ;
 BOOLEAN ou LOGICAL : vrai/faux
Exemple :
Créer la table « Clinique » de notre BD « Gestion_Clinique.db ».

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

 Insertion de données dans une table :

L’insertion de données dans une table s’effectue à l’aide de la commande INSERT INTO.
Cette commande permet au choix d’inclure une seule ligne à la base existante ou plusieurs
lignes d’un coup.
 Insertion d’une ligne :
Syntaxe :
cur.execute ("INSERT INTO nom_table (nom_colonne1, nom_colonne2, ...) VALUES
(valeur 1, valeur 2, ...)")

AU 2021/2022 2
ISSAT GABES MP2-PC2-T2

 Insertion de plusieurs lignes à la fois :

Il est possible d’ajouter plusieurs lignes à un tableau avec une seule requête. Pour ce faire, il
convient d’utiliser la syntaxe suivante :

Serv = [(14, 'Achat'), (15, 'Informatique'), (17, 'Comptabilité'), (13, 'Vente')]

# liste de tuples contenant toutes les informations nécessaires pour ajouter les services à la
base de données
cur.executemany ("INSERT INTO nom_table VALUES (?,?)", Serv)

Exemple :
Remplir la table « Clinique » de notre BD « Gestion_Clinique.db ».

…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………
…………………………………………………………………………………………………

 Mise à jour d’une table :

La commande UPDATE permet d’effectuer des modifications sur des lignes existantes. Très
souvent cette commande est utilisée avec la clause WHERE pour spécifier sur quelles lignes
doivent porter la ou les modifications.
Syntaxe :
La syntaxe d’une requête utilisant UPDATE est la suivante :

cur.execute ("UPDATE nom_table SET nom_colonne ='nouvelle valeur1', nom_colonne2=

'nouvelle valeur2 ',… WHERE condition")

Exemple :
Donner la requête SQL pour ajouter 20 lits aux cliniques ayant une capacité inférieure à 100.

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

AU 2021/2022 3
ISSAT GABES MP2-PC2-T2

 L’ajout d’une colonne :

La commande ALTER TABLE en SQL permet de modifier une table existante. Il est ainsi
possible d’ajouter une colonne.
Syntaxe :
cur.execute ("ALTER TABLE nom_table ADD nom_colonne type_données")

A noter : On ne peut pas supprimer directement une colonne, il faut définir une nouvelle
table.
Exemple :
Donner la requête SQL pour ajouter une colonne « adresse_cl » à la table Clinique :

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

 Suppression d’une ligne :

La commande DELETE en SQL permet de supprimer les lignes d’une table. En utilisant cette
commande associe à la clause WHERE il est possible de sélectionner les lignes concernées
qui seront supprimées.
Syntaxe :

cur.execute (" DELETE FROM Nom_table WHERE condition")

Exemple :
Donner la requête SQL pour Supprimer les enregistrements de la table « Service » ayant
comme Num_cl la valeur 10 :

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

 Suppression d’une table:

La commande DROP TABLE en SQL permet de supprimer définitivement une table d’une
base de données.
Syntaxe :

cur.execute (" DROP TABLE Nom_table")

Exemple :
Donner la requête SQL pour Supprimer la table « Service » :

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

AU 2021/2022 4
 ISSAT GABES MP2-PC2-T2

Attention : à ce stade des opérations, les enregistrements sont dans le tampon du curseur,
mais ils n'ont pas encore été transférés véritablement dans la base de données. Vous pourriez
donc annuler tout. Le transfert dans la basse de données sera déclenché par la
méthode commit () de l'objet connexion :

Bd.commit()

Le curseur peut alors être refermé, de même que la connexion, si le travail est terminé :

cur.close()
Bd.close()

II. Les requêtes d'interrogation en SQL :

Le langage SQL est conçu pour pouvoir exprimer la plupart des opérateurs de l’algèbre
relationnelle. Nous indiquerons ici la syntaxe de ce langage pour faire des requêtes de
recherche en présentant la traduction des opérations vues précédemment.
On peut toujours désigner l'attribut Ai d'une relation R en utilisant la notation préfixée : R.Ai.
Cela permet, en cas de nécessité, de distinguer des attributs qui portent le même nom dans
différentes tables.
 Requête pour la projection :
La projection a pour but de ne prendre qu’un sous-ensemble des attributs de la relation
opérante. La clause SELECT définit les attributs à conserver :

cur.execute ("SELECT Ai FROM R ")

Il est possible d’obtenir l’intégralité de la relation grâce à l’utilisation du joker * à la place des
attributs :

cur.execute ("SELECT * FROM R") # Renvoie toutes les colonnes de R

Par exemple, donner la requête SQL pour afficher les numéros et les noms des cliniques :

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

La projection peut renvoyer des doublons. On peut éviter cela avec :

cur. execute ("SELECT DISTINCT Ai FROM R”)

 Requête pour la sélection :

La sélection a pour but de ne prendre que les occurrences satisfaisant une condition.
L’intégralité des attributs est conservée ; la condition est définie par la clause WHERE.

cur. execute ("SELECT * FROM R WHERE A = a")

AU 2021/2022 5
ISSAT GABES MP2-PC2-T2

Par exemple, donner les numéros des cliniques de gabes :

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

Exemples d’opérateurs :

Opération Opérateur SQL Exemple

Recherche d’un caractère dans
une chaîne
Recherche d’un ensemble de
caractères dans une chaîne
Entre deux valeurs
Contient (pour une
chaîne de caractères)
_ Select ….. where nom like ‘t_t_‘
Le nom contient un t en 1ère et en 3ème
lettre
% Select ….where nom like ‘d%d’
Le nom commence par un d et finit par
un d.
Between … and Select ….Where prix between 5 and 20
Les bornes sont Incluses
Like Select ……where nom like ‘A%’
Recherche des noms commençant par la
lettre A

Ne contient pas Not LIKe Select ……where nom not like ‘ALI’
Recherche des noms déférents de ‘ALI’
Vérifie l’appartenance ou pas à IN, NOT IN Select ……where nom IN [elt1, elt2,…
une liste de valeurs ]

Comment récupérer le résultat d’un select ?

N.B : L’exécution d’une requête renvoie un itérateur d’un type spécial (Cursor), que l’on peut
utiliser directement à l’aide d’une boucle for...in, qui permet de parcourir les lignes du
résultat de la requête. Ces lignes se présentent sous forme de tuples. On peut aussi convertir le
résultat en “liste de lignes” grâce à la méthode fetchall () ou récupérer une seule ligne du
résultat grâce à la méthode fetchone ().
Exemple :
Afficher le contenu de la table « Clinique » :
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

 Requêtes pour les opérations ensemblistes :

Pour combiner dans un résultat unique des lignes venant d’interrogations différentes, on
réalise des opérations ensemblistes. On utilise les mots-clés UNION, INTERSECT ou
EXCEPT pour réaliser les opérations d’union, d’intersection et de différence.

AU 2021/2022 6
ISSAT GABES MP2-PC2-T2

 UNION :
La commande UNION de SQL permet de mettre bout-a-bout les résultats de plusieurs
requêtes utilisant elles-mêmes la commande SELECT. C’est donc une commande qui permet
de concaténer les résultats de 2 requêtes ou plus. Pour l’utiliser il est nécessaire que chacune
des requêtes à concaténer retournes le même nombre de colonnes, avec les mêmes types de
données et dans le même ordre.
Syntaxe :

cur. execute ("SELECT * FROM nom_table1 UNION SELECT * FROM

nom_table2")

A savoir : par défaut, les enregistrements exactement identiques ne seront pas répètes dans le
résultat. Pour effectuer une union dans laquelle même les lignes dupliquées sont affichées il
faut plutôt utiliser la commande UNION ALL.
 INTERSECTION :
La commande INTERSECT de SQL permet d’obtenir l’intersection des résultats de deux
requêtes. Cette commande permet donc de récupérer les enregistrements communs à deux
requêtes. Cela peut s’avérer utile lorsqu’il faut trouver s’il y a des données similaires sur deux
tables distinctes.
A savoir : pour l’utiliser convenablement il faut que les deux requêtes retournent le même
nombre de colonnes, avec les mêmes types et dans le même ordre.
Syntaxe :
La syntaxe à adopter pour utiliser cette commande est la suivante :

cur. execute ("SELECT * FROM nom_table1 INTERSECT SELECT * FROM nom_

table2")

Par exemple, donner les numéros des cliniques qui disposent à la fois des spécialités 300 et
600 » :

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

 DIFFERENCE :
La commande EXCEPT s’utilise entre 2 instructions pour récupérer les enregistrements de la
première instruction sans inclure les résultats de la seconde requête. Si un même
enregistrement devait être présent dans les résultats des 2 syntaxes, il ne sera pas présent dans
le résultat final.

cur. execute ("Requête 1 EXCEPT Requête 2 ")

AU 2021/2022 7
 ISSAT GABES MP2-PC2-T2

 JOINTURE :
Avec une base de données complexe, on a souvent besoin de rassembler des données réparties
dans plusieurs tables, typiquement concaténer les enregistrements provenant de deux tables,
table1 et table2, et vérifiant table1.champ1 = table2.champ2 (l’un des deux champ1 ou
champ2 est souvent une clé primaire dans sa table).
Il faut préférer à ce type de requête l’utilisation d’une jointure.
La syntaxe est la suivante :

cur. execute("SELECT expr1, expr2,... FROM table1, table2, … where table1.champ1

= table2.champ2 ")
N.B:
 Quand un même attribut figure dans les deux tables, il faut indiquer la table en temps
que préfixe.
Exemple:
Donner les noms des spécialités de la Clinique BON SECOURS à Gabes :

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
…………………………………………………………………………………………………………..

III. Autres possibilités avec SQL :

 Les fonctions d'agrégation :
Derrière ce mot compliqué se cachent quelques fonctions qui peuvent être utilisées à
l'intérieur des requêtes de sélection pour faire des calculs sur le résultat de la requête.
Voici les fonctions d'agrégations les plus répandues:

COUNT (*) Détermine le nombre d'enregistrements du résultat de la

requête. Tient compte de tous les enregistrements, y inclus
ceux contenant des valeurs NULL
COUNT (Nom d'un Détermine le nombre des enregistrements pour lesquels le
champ) champ indiqué ne contient pas la valeur NULL
SUM (Nom d'un champ) Calcule pour tous les enregistrements sélectionnés, la somme
des valeurs du champ indiqué.
AVG (Nom d'un champ) Calcule pour tous les enregistrements sélectionnés, la
moyenne des valeurs du champ indiqué.
MAX (Nom d'un champ) Détermine pour tous les enregistrements sélectionnés, la plus
grande des valeurs du champ indiqué.
MIN (Nom d'un champ) Détermine pour tous les enregistrements sélectionnés, la plus
petite des valeurs du champ indiqué.

AU 2021/2022 8
ISSAT GABES MP2-PC2-T2

N.B : Les paramètres d'une fonction d'agrégation sont toujours entourés de parenthèses.
Imaginons la requête suivante:

cur. execute ("SELECT * FROM Clinique WHERE nblits=100 ")

Cette requête nous retourne toutes les cliniques ayant une capacité égale à 100. Il se peut très
bien que l'utilisateur ne soit pas intéressé dans le détail, mais veuille uniquement connaître le
nombre des cliniques ayant l’attribut nblits égal à 100.
La requête correspondante est:

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

Le résultat de cette requête est une valeur unique indiquant combien de cliniques se trouvent
dans la table avec le champ nblits ayant la valeur 100.
 La clause ORDER BY:
L'ordre obtenu dans la réponse d'une requête de sélection a été laissé jusqu'à maintenant au
pur hasard.
L'expression ORDER BY nous permet de définir convenablement l'ordre d'apparition des
enregistrements qui vérifient les critères de sélection de la requête.
Voici la syntaxe:

cur. execute ("SELECT <Nom d'un champ>, <Nom d'un champ>, ... FROM <Nom de la
table> WHERE <Critères de sélection> ORDER BY <Nom d'un champ>[ASC/DESC],
<Nom d'un champ>[ASC/DESC] ")

Par défaut l'ordre de tri est ascendant (ASC), donc vous n'avez pas nécessairement besoin
d'indiquer le mot ASC. Cependant, lorsque vous voulez trier les enregistrements en ordre
descendant, le mot DESC est indispensable.
Exemple :
Afficher toutes les cliniques triées selon leurs noms en ordre descendant.

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

 La clause GROUP BY :
La clause GROUP BY <Liste des champs de groupe> intervient sur le résultat d'un
SELECT. En fait, les enregistrements résultant d'une requête de sélection sont groupés, de
façon qu'à l'intérieur de chaque groupe, les valeurs pour la liste des champs de groupe soient
identiques.

AU 2021/2022 9
ISSAT GABES MP2-PC2-T2

Syntaxe:

cur. execute(" SELECT <Liste des champs de groupe> FROM <Nom de la table>
WHERE <Critères de sélection> GROUP BY <Liste de champs de groupe>")

Exemple :
Donner pour chaque ville, la somme de nombre des lits :

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

 La clause HAVING :
Sachant que les critères de sélection (WHERE ...) nous permettent d'éliminer un certain
nombre d'enregistrements avant la création des groupes, il serait intéressant de disposer d'une
deuxième possibilité de filtrage, qui s'applique aux groupes eux-mêmes.
La clause HAVING <Critères de sélection des groupes> est uniquement spécifiée en
relation avec un GROUP BY. Une fois les groupes créés, cette clause en élimine certains,
basés sur les critères de sélection des groupes.
Les critères de sélection des groupes portent bien entendu sur la valeur d'une ou de plusieurs
des fonctions d'agrégation calculées pour chaque groupe.
Reprenons l'exemple:

cur.execute ("Select ville, sum(nblits) from Clinique GROUP BY ville")

Lorsqu'on veut par exemple uniquement afficher les groupes pour lesquelles le nombre de lits
est supérieur à 100, on utilise la clause HAVING de la façon suivante:

……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………
……………………………………………………………………………………………………………

AU 2021/2022 10