- A propos des bases de données SQLite
- Avantages et inconvénients des bases de données SQLite
- Les domaines d'utilisation des bases de données SQLite
- Création et gestion de bases de données avec SQLite
- Création et gestion des bases de données SQLite
- Les commandes SQL (SELECT, INSERT, UPDATE, DELETE)
- Editeur WYSIWYG (DB Bowser for SQLite)
- Ressources et références pour apprendre SQLite
1. A propos des bases de données SQLite
SQLite est une bibliothèque qui implémente un système de gestion de base de données relationnelle léger et embarqué. Il permet de stocker des données dans une base de données relationnelle en utilisant le langage SQL. SQLite est souvent utilisé dans les applications mobiles et les applications embarquées en raison de sa taille réduite et de sa faible consommation de mémoire.
SQLite utilise un fichier unique pour stocker toutes les données de la base de données. Cela signifie qu'il n'y a pas besoin d'un serveur de base de données séparé pour gérer la base de données, ce qui facilite son utilisation dans des environnements limités en ressources.
SQLite prend en charge les types de données suivants: NULL, INTEGER, REAL, TEXT, BLOB. Il prend également en charge les contraintes d'intégrité référentielle telles que les clés étrangères et les contraintes UNIQUE. Il offre également un support pour les transactions, les vues, les déclencheurs et les requêtes préparées.
En résumé, SQLite est un système de gestion de base de données relationnelle léger et embarqué qui est facile à utiliser et à intégrer dans des applications mobiles et embarquées. Il prend en charge les principales fonctionnalités de SQL, telles que les types de données, les contraintes d'intégrité référentielle, les transactions et les vues.
2. Avantages et inconvénients de SQLite
2.1 les avantages de SQLite
Voici quelques avantages de l'utilisation de SQLite :
- Taille réduite : SQLite est une bibliothèque très légère qui ne nécessite pas d'installation ou de configuration supplémentaires. Il est facile à intégrer dans des applications mobiles ou embarquées en raison de sa taille réduite.
- Facilité d'utilisation : SQLite utilise le langage SQL standard, ce qui facilite l'apprentissage pour les développeurs expérimentés en SQL. Il offre également une API simple et intuitive pour les développeurs qui n'ont pas d'expérience en SQL.
- Support de la plupart des plateformes : SQLite est disponible pour de nombreux systèmes d'exploitation et plateformes de développement, y compris Windows, MacOS, iOS, Android, et Linux. Cela signifie que vous pouvez utiliser SQLite dans une variété de projets.
- Faible consommation de mémoire : SQLite utilise très peu de mémoire, ce qui le rend idéal pour les applications embarquées ou les applications mobiles qui doivent fonctionner sur des appareils à faible capacité.
- Fichier unique : SQLite stocke toutes les données dans un seul fichier, ce qui facilite la sauvegarde, la synchronisation et la migration des données.
- Support de la transparence de la compression : SQLite supporte la compression transparente de données, ce qui permet de réduire la taille des données stockées sur le disque et d'améliorer les performances d'accès aux données.
- Sécurité: SQLite prend en charge des mécanismes de cryptage pour protéger les données sensibles.
2.2 les inconvénients de SQLite
Voici quelques inconvénients potentiels de l'utilisation de SQLite:
- Limitations de performance : SQLite peut ne pas être adapté pour les applications qui nécessitent des performances élevées en termes de nombre de requêtes par seconde ou de taille de base de données. Il peut ne pas être capable de gérer efficacement de grandes bases de données ou de gros volumes de transactions.
- Limitations de scalabilité : SQLite est principalement conçu pour des applications à échelle unique, il peut ne pas être adapté pour des applications distribuées ou qui nécessitent un accès simultané à partir de plusieurs utilisateurs ou processus.
- Pas de support natif pour les utilisateurs et les privilèges : SQLite ne prend pas en charge la gestion des utilisateurs et des privilèges, ce qui peut rendre plus difficile la gestion des autorisations pour les applications qui nécessitent un contrôle d'accès étendu.
- Pas de support de la réplication : SQLite ne prend pas en charge la réplication de données, ce qui peut rendre difficile la mise en place de systèmes de sauvegarde et de récupération de données en cas de panne.
- Pas de support pour les requêtes géospatiales: SQLite ne prend pas en charge les requêtes géospatiales, cela peut rendre difficile l'utilisation de SQLite pour les applications qui nécessitent la gestion de données géographiques.
En résumé, SQLite est un système de gestion de base de données relationnelle léger et embarqué qui convient pour de nombreux scénarios, mais il peut avoir des limitations en termes de performance, de scalabilité, de sécurité et de fonctionnalités. Il est donc important de considérer ces facteurs lors de la décision d'utiliser SQLite pour un projet donné.
3. Les domaines d'utilisation de SQLite
SQLite est utilisé dans une grande variété d'applications et de projets, car il est facile à utiliser, fiable et léger. Il est particulièrement utile pour les applications qui nécessitent un stockage de données locales et une utilisation en mode déconnecté.
Groso modo, SQLite est utilisé par un grand nombre d'entités, notamment :
- Les développeurs d'applications mobiles : SQLite est souvent utilisé pour stocker des données locales sur les appareils mobiles, car il est léger et facile à intégrer dans les applications. Les développeurs d'applications mobiles peuvent utiliser SQLite pour stocker des informations telles que les préférences de l'utilisateur, les informations d'identification, les données de jeu, etc.
- Les éditeurs d'applications : de nombreux éditeurs d'applications utilisent SQLite pour stocker les données de leurs applications, car il est facile à utiliser, fiable et offre une performance suffisante pour la plupart des applications.
- Les développeurs d'applications embarquées : les systèmes embarqués tels que les récepteurs GPS, les caméras de surveillance, les thermostats connectés et les objets connectés utilisent souvent SQLite pour stocker les données en raison de sa petite taille et de sa facilité d'utilisation.
- Les développeurs de jeux : SQLite est utilisé pour stocker des données de jeux tels que les scores des joueurs, les paramètres de jeu, etc. Il est également utilisé pour stocker des données de jeux en ligne pour lesquelles une connexion Internet n'est pas toujours disponible.
- Les développeurs de logiciels : de nombreux logiciels utilisent SQLite pour stocker des données de configuration, des informations d'enregistrement, des informations de débogage et des informations de performance.
- Les développeurs de sites web : SQLite est utilisé pour stocker les données de sites web tels que les informations de connexion des utilisateurs, les informations de commande, les informations de produit, etc. Il est souvent utilisé comme alternative à des systèmes de gestion de base de données relationnelles plus lourds pour des sites web de petite à moyenne taille.
4. Création de bases de données avec Python & SQLite
4.1 Création d'une base de données SQLite avec Python
Il est possible de créer et gérer des bases de données SQLite en utilisant le module Python sqlite3. Ce module fournit une interface Python pour travailler avec SQLite, permettant de créer et de manipuler des bases de données, des tables, des entrées et des requêtes... Le module sqlite3 n'exige aucune installation, il est livré avec la version standard de Python. pour créer une base de données SQLite vous devez:
- Importer le module sqlite3: en utilisant la commande import sqlite3
- Créer une connexion à la base de donnée: à l'aide de la méthode connect("database_name") (la base de donnée sera créer automatiquement.
|
1 2 3 4 5 6 7 |
import sqlite3 # connexion à la base de données conn = sqlite3.connect('mabase.db') # Fermeture de la connexion conn.close() |
dans ce cas une base de données SQLite nommée mabase.db est crée automatiquement.
4.2 Suppression d'une base de données SQLite
Pour supprimer une base de données SQLite, rien de plus simple, il suffit de:
- importer le module os
- utiliser la méthode os.remove()
|
1 2 3 4 5 6 7 |
import os # base de données à supprimer database = 'mabase.db' # supprimer la base de données os.remove(database) |
5. Création et gestion des tables SQLite
5.1 Création d'une table SQLite
Pour créer une table SQLite avec Python, vous devez suivre les étapes suivantes
- Importer le module sqlite3: en utilisant la commande import sqlite3
- Créer une connexion à la base de donnée: à l'aide de la méthode connect("database_name") (si la base de donnée n'existe pas, elle sera crée automatiquement.
- Créer un objet cursor: à l'aide de la méthode cursor()
- Créer une requête sql: ( exemple création d'une table, insertion de données...)
- Exécuter la requête: à l'aide de la méthode execute() du curseur
- Valider l'exécution de la requête: à l'aide de la méthode commit() de l'objet connexion
- fermer la connexion: à l'aide de la méthode close()
Voici un exemple de code pour créer une base de données "mabase.db" et une table "students" avec les champs: "id", "name", "email" et "section"
Code Python SQLite
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
import sqlite3 # Connexion à la base de données conn = sqlite3.connect('ma_base.db') # Création d'un curseur cursor = conn.cursor() # requête de création d'une table students req = """CREATE TABLE IF NOT EXISTS students( id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT NOT NULL, section TEXT NOT NULL)""" # exécuter la requête cursor.execute(req) # Valider l'exécution de la requête conn.commit() # Fermeture de la connexion conn.close() |
Ce code permet la création d'une base de données nommée "ma_base" au sein de laquelle une table sql nommée "sutdents" qui contient les attributs:
- id: identifiant utilisé comme clé primaire qui s'incrémente tout seul.
- name: pour stocker le nom de l'étudiant
- email: pour stocker l'adresse email de l'étudiant
- section: pour stocker la section de l'étudiant, math, physique, informatique...
Une fois la base de données et les tables créées, vous pouvez utiliser des commandes SQL pour insérer, mettre à jour et sélectionner des données dans les tables.
Remarque
Noter bien que le module sqlite3 n'est pas sécurisé contre les injections SQL, il est donc important de s'assurer que les données utilisées dans les requêtes sont nettoyées et échappées correctement pour éviter les risques de sécurité.
5.2 Lister les tables d'une base de données SQLite
Pour lister les tables d'une base de données SQLite à partir de Python, vous pouvez utiliser la bibliothèque intégrée sqlite3.
Exemple
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import sqlite3 # Ouvrir la connexion à la base de données conn = sqlite3.connect('nom_de_la_base_de_données.db') # Obtenir un curseur pour exécuter des requêtes SQL cur = conn.cursor() # Exécuter une requête pour obtenir la liste des tables cur.execute("SELECT name FROM sqlite_master WHERE type='table';") # Récupérer les résultats de la requête tables = cur.fetchall() # Afficher les noms des tables for table in tables: print(table[0]) # Fermer le curseur et la connexion cur.close() conn.close() |
Notez bien que vous devez remplacer 'nom_de_la_base_de_données.db' par le nom de votre propre base de données SQLite.
5.3 Supprimer une table SQLite
Pour supprimer une table SQLite avec Python, vous pouvez utiliser la méthode execute() du module SQLite3 pour exécuter une instruction SQL DROP TABLE.
Exemple
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import sqlite3 # Connexion à la base de données conn = sqlite3.connect('ma_base_de_donnees.db') # Création d'un objet curseur cur = conn.cursor() # Suppression de la table cur.execute('''DROP TABLE ma_table''') # Validation de la transaction conn.commit() # Fermeture de la connexion conn.close() |
6. Les commandes SQL (SELECT, INSERT, UPDATE, DELETE)
6.1 La commande INSERT
L'insertion de données en environnement SQLite3 est exactement identique au cas MySql. Avant de continuer, il faut qu'on se dispose d'au moins une table au sein d'une base de données SQLite! Créons une nommées 'students':
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import sqlite3 conn = sqlite3.connect('mabase.db') # Créer un cursor cur = conn.cursor() # Création de la requete req = """CREATE TABLE IF NOT EXISTS students( id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT NOT NULL, section TEXT NOT NULL)""" # Exécution de la requete cur.execute(req) # Envoyer la requete conn.commit() # Fermer la connexion conn.close() |
Nous pouvons maintenant commencer à insérer des données au sein de la table 'students'
Syntaxe d'insertion d'une ligne de données:
|
1 2 3 4 5 6 |
cur.execute( """ INSERT INTO students(name, email , section ) VALUES ('Albert', 'albert@gmail.com' , 'math')""" ) |
Remarque
L'identifiant 'ID' ( clé primaire ) est généralement omise! En cas d'omission, il s'incrémente tout seul du fait qu'il possède la propriétés AUTOINCREMENT!
Code complet:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import sqlite3 conn = sqlite3.connect('mabase.db') cur = conn.cursor() # Insérer une ligne de données req = """ INSERT INTO students(name, email , section ) VALUES ('Albert', 'albert@gmail.com' , 'math') """ cur.execute(req) # Engager l'opération conn.commit() # Fermer la connexion conn.close() |
6.2 Insertion des données de variables dans une table SQLite
Quand on a inséré directement les données au sein de la table à l'aide de la requête INSERT comme on a fait dans l'exemple ci-dessus, aucun problème n'a été rencontré!
|
1 |
cur.execute("INSERT INTO students(`nom`,`email`) VALUES ('Albert', 'albert@gmail.com')") |
Imaginez maintenant que les données qu'on souhaite insérer, sont des valeurs de variables récupérées depuis un autre fichier ou provenant d'un formulaire d'enregistrement...Dans ce cas l'insertion des données de cette façon sera totalement erronée !
|
1 2 3 4 5 6 7 8 9 10 |
name = "Najat" email = "najat@gmail.com" section = "SVT" req = """INSERT INTO students (`name` , `email` , `section`) VALUES (name, email , section) """ cur.execute(req) # TOTALEMENT FAUX ! |
ATTENTION ! TOTALEMENT FAUX ! Puisque les variables nom et email ne seront pas interprétées !
Pour corriger l'erreur, on utilise la méthode de formatage des chaines à l'aide du symbole : "?"
|
1 2 3 4 5 6 7 8 9 10 |
name = "Najat" email = "najat@gmail.com" section = "SVT" cur = conn.cursor() req = """ Insert into students (name, email, section) VALUES (?,?,?)""" cur.execute(req ,(name, email, section)) |
Code complet:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
import sqlite3 conn = sqlite3.connect('mabase.db') name = 'Farid' email = 'farid@gmail.com' section = 'Physique' # Créer un cursor cur = conn.cursor() req = """ Insert into students (`name`, `email`, `section`) VALUES (?,?,?) """ # Exécuter la requête cur.execute(req , (name, email, section)) conn.commit() conn.close() |
6.2 La commande SELECT & affichage des données
Maintenant, il nous reste à voir comment sélectionner les données et les afficher, du moment que tout a été bien réglé : création de la table students au sein de la base de données SQLite3 , insertion de données au sein de la table students...
6.2.1 Création d'un cursor pour exécuter une requête de sélection
|
1 2 |
cur = conn.cursor() result = cur.execute("select*from students ") |
6.2.2 Parcourir les résultats de la sélection
Pour afficher les données, on va parcourir l'objet cursor par un compteur row. La variable row qui fait le parcourt est un objet tuple dont les constituants sont les valeurs des champs : id, nom, email, age...
|
1 2 3 4 5 |
for row in result: print("ID : ",row[0]) print("name : ",row[1]) print("Email : ",row[2]) print("Section : ",row[3]) |
Code complet:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
import sqlite3 conn = sqlite3.connect('mabase.db') cur = conn.cursor() result = cur.execute("select*from students ") for row in result: print("ID : ",row[0]) print("name : ",row[1]) print("Email : ",row[2]) print("Section : ",row[3]) print('----------------------------------------') |
6.2.3 Affichage conditionné
Généralement on souhaite afficher une partie d'une table SQLite ou un affichage spécifique...
Voici un exemple qui montre comment sélectionner et afficher les enregistrements dont l'identifiant est compris entre 1 et 3
|
1 2 3 4 5 6 7 8 9 10 11 |
import sqlite3 conn = sqlite3.connect('mabase.db') cur = conn.cursor() req = "SELECT*FROM students where (id) <= (?) and (id) >= (?)" result = cur.execute(req , (3,1, )) for row in result: print(row) |
Ce code affiche les enregistrements dont l'identifiant id vérifie: 1<= id <=3
6.3 Mettre à jour les données à l'aide de la commande UPDATE
Les données d'une table SQLite peuvent être mise à jour facilement grace à la commande UPDATE en utilisant la syntaxe:
|
1 |
"UPDATE table_name set (column1 , column2 ,... )=(?, ?,...) where 'condition' " |
Exemple
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import sqlite3 conn = sqlite3.connect('mabase.db') cur = conn.cursor() name = "Najwa" email = "najwa@gmail.com" section = "Histoire Geo" req = "UPDATE students set (name , email , section )=(?, ?, ?) where (id) = (?)" result = cur.execute(req , (name, email , section, 4, )) conn.commit() conn.close() |
Ce code permet de mettre à jour l'enregistrement dont l'identifiant id = 4.
6.4 Supprimer des données à l'aide de la commande DELETE
Pour effacer un enregistrement spécifique d'une table SQLite, on utilise la commande DELETE avec la syntaxe:
|
1 |
"DELETE FROM table_name where 'condition'" |
Exemple
|
1 2 3 4 5 6 7 8 9 10 11 12 |
import sqlite3 conn = sqlite3.connect('mabase.db') cur = conn.cursor() # requête de suppression de l'enregistrement d'identifiant id = 4 req = "DELETE FROM students where (id) = (?)" result = cur.execute(req , (4, )) conn.commit() conn.close() |
Ce code supprime l'enregistrement d'identifiant id = 4.
7. Éditeur WYSIWYG SQLite3
Tout a été fait en noir ! Jusqu'à présent vous n'avez encore rien vue, ni table ni données...Pour répondre à cette question, je vous informe qu'il y a de nombreux utilitaires permettant d'explorer les bases de données SQLite3. Je vous recommande DB Browser for SQLite qui est gratuit et très simple d'usage :
- Téléchargez DB Browser for SQLite,
- Installez le,
- Lancez DB Browser
- Depuis le menu File –> cliquez sur le sous menu Open Databse
- Sélectionnez ensuite votre base de donnée mabase.db
- Cliquez finalement sur Browse data pour voir votre table students avec les donnée que vous venez d’insérer :
8. Ressources et références pour apprendre SQLite
Il existe de nombreux autres tutoriels, livres et outils disponibles pour apprendre et utiliser SQLite, ces références sont données à titre indicatif. Voici quelques ressources et références pour apprendre et utiliser SQLite:
- Site web officiel de SQLite: https://www.sqlite.org/index.html
- Documentation officielle de SQLite: https://www.sqlite.org/docs.html
- DB Browser for SQLite: un outil gratuit de gestion de base de données SQLite: https://sqlitebrowser.org/
- SQLite Studio: un outil de gestion de base de données SQLite: https://sqlitestudio.pl/
- SQLite Expert : un autre outil de gestion de base de données SQLite: https://www.sqliteexpert.com/
Younes Derfoufi
CRMEF OUJDA
-
Apprendre l'Informatique avec Python - Méthodes et exercices - MPSI-PCSI
$ 22,00 Acheter le livre -
Obtenez Microsoft 365 Famille avec Office 365 apps - 15 Mois + NORTON 360 Deluxe - PC/MAC, tablette et smartphone
$ 57,00 Acheter le produit -
Apprendre à Programmer un Raspberry Pi 3
$ 19,00 Acheter le livre