Comment travailler avec SQLite en Python – Un manuel pour les débutants

SQLite est l’un des systèmes de gestion de base de données relationnelles (RDBMS) les plus populaires. Il est léger, ce qui signifie qu’il ne prend pas beaucoup d’espace sur votre système. One of its best features is that it’s serverless, so you don’t need to install or manage a separate server to use it.

Instead, it stores everything in a simple file on your computer. It also requires zero configuration, so there’s no complicated setup process, making it perfect for beginners and small projects.

SQLite est un excellent choix pour les petites à moyennes applications car il est facile à utiliser, rapide et peut gérer la plupart des tâches que les plus grandes bases de données peuvent faire, mais sans les détails de la gestion de logiciels supplémentaires. Whether you’re building a personal project or prototyping a new app, SQLite is a solid option to get things up and running quickly.

In this tutorial, you’ll learn how to work with SQLite using Python. Here’s what we’re going to cover in this tutorial:

How to Set Up Your Python Environment
How to Create an SQLite Database
How to Create Database Tables
Comment insérer des données dans une table
Comment récupérer des données
Comment mettre à jour et supprimer des données
Comment utiliser des transactions
Comment optimiser les performances des requêtes SQLite en utilisant des indexations
Comment gérer les erreurs et les exceptions
Comment exporter et importer des données [Section supplémentaire]
Récapitulatif

Ce tutoriel est parfait pour toute personne qui souhaite démarrer avec les bases de données sans se plonger dans des configurations complexes.

Comment configurer votre environnement Python

Avant de travailler avec SQLite, veuillez vous assurer que votre environnement Python est prêt. Voici comment installer tout ce qu’il faut.

Installation de Python

Si vous n’avez pas encore installé Python sur votre système, vous pouvez le télécharger à partir de la site officiel de Python. Suivez les instructions d’installation pour votre système d’exploitation (Windows, macOS ou Linux).

Pour vérifier si Python est installé, ouvrez votre terminal (ou boîte de dialogue de commandes) et tapez :

python --version

Cela devrait afficher la version actuelle de Python installée. Si elle n’est pas installée, suivez les instructions sur le site de Python.

Installation du module SQLite3

La bonne nouvelle est que SQLite3 est intégré à Python ! Vous n’avez pas besoin de l’installer séparément car il est inclus dans la bibliothèque standard de Python. Cela signifie que vous pouvez commencer à l’utiliser sans aucun autre paramétrage.

Comment Créer Un Environnement Virtuel (Facultatif mais recommandé)

Il est recommandé de créer un environnement virtuel pour chaque projet pour garder vos dépendances organisées. Un environnement virtuel est comme un carnet blanc où vous pouvez installer des paquets sans affecter votre installation globale de Python.

Pour créer un environnement virtuel, suivez ces étapes :

Tout d’abord, ouvrez votre terminal ou boîte de dialogue de commandes et naviguez vers le répertoire où vous voulez créer votre projet.
Exécutez la commande suivante pour créer un environnement virtuel :

python -m venv env

Dans cet exemple, env est le nom de l’environnement virtuel. Vous pouvez le nommer comme bon vous semble.

Activez l’environnement virtuel :

# Utilisez la commande pour Windows
env\Scripts\activate

# Utilisez la commande pour macOS/Linux :
env/bin/activate

Après l’activation de l’environnement virtuel, vous remarquerez que votre invite de commandes change, affichant le nom de l’environnement virtuel. Cela signifie que vous travaillez maintenant à l’intérieur de celui-ci.

Installation des bibliothèques nécessaires

Nous aurons besoin de quelques bibliothèques supplémentaires pour ce projet. Spécifiquement, nous utiliserons :

pandas : Cette bibliothèque optionnelle permet de gérer et d’afficher les données sous forme de tableau, utile pour les cas d’utilisation avancés.
faker : Cette bibliothèque nous aidera à générer des données factices, comme des noms et des adresses aléatoires, que nous pouvons insérer dans notre base de données pour les tests.

Pour installer pandas et faker, exécutez simplement les commandes suivantes :

pip install pandas faker

Ceci installe à la fois pandas et faker dans votre environnement virtuel. Avec cela, votre environnement est configuré, et vous êtes prêt à commencer à créer et gérer votre base de données SQLite en Python !

Comment créer une base de données SQLite

Une base de données est une manière structurée de stocker et de gérer des données de façon à ce qu’elles puissent être facilement accessibles, mises à jour et organisées. C’est comme un système de fichiers numérique qui vous permet de stocker efficacement de grandes quantités de données, que ce soit pour une application simple ou un système plus complexe. Les bases de données utilisent des tables pour organiser les données, avec des lignes et des colonnes représentant les enregistrements individuels et leurs attributs.

Comment fonctionnent les bases de données SQLite

Contrairement à la plupart des autres systèmes de base de données, SQLite est une base de données sans serveur. Cela signifie qu’il n’est pas nécessaire de configurer ou de gérer un serveur, ce qui la rend légère et facile à utiliser. Toutes les données sont stockées dans un seul fichier sur votre ordinateur, que vous pouvez facilement déplacer, partager ou faire une copie de sauvegarde. Malgré sa simplicité, SQLite est assez puissante pour gérer de nombreuses tâches de base de données courantes et est largement utilisée dans les applications mobiles, les systèmes intégrés et les petits à moyens projets.

Comment Créer une Nouvelle Base de Données SQLite

Allons créer une nouvelle base de données SQLite et apprendre à interagir avec elle en utilisant la bibliothèque sqlite3 de Python.

Connexion à la Base de Données

Comme sqlite3 est préinstallé, vous devez simplement l’importer dans votre script Python. Pour créer une nouvelle base de données ou se connecter à une base de données existante, nous utilisons la méthode sqlite3.connect(). Cette méthode prend le nom du fichier de base de données en argument. Si le fichier n’existe pas, SQLite le créera automatiquement.

import sqlite3

# Se connecter à la base de données SQLite (ou la créer si elle n'existe pas)
connection = sqlite3.connect('my_database.db')

Dans cet exemple, un fichier nommé my_database.db est créé dans le même dossier que votre script. Si le fichier existe déjà, SQLite ouvrira simplement la connexion à celle-ci.

Création d’un curseur

Une fois que vous avez une connexion, le prochain pas est de créer un objet curseur. Le curseur est responsable de l’exécution de commandes et de requêtes SQL sur la base de données.

# Créer un objet curseur
cursor = connection.cursor()

Fermeture de la Connexion

Une fois que vous aurez terminé de travailler avec la base de données, il est important de fermer la connexion pour libérer toutes les ressources utilisées. Vous pouvez fermer la connexion en utilisant la commande suivante :

# Fermer la connexion à la base de données
connection.close()

Cependant, vous devriez fermer la connexion uniquement une fois que vous aurez terminé toutes vos opérations.

Lorsque vous exécuteriez votre script Python, un fichier nommé my_database.db serait créé dans le répertoire de travail actuel. Vous avez maintenant réussi à créer votre première base de données SQLite !

Comment utiliser le gestionnaire de contexte pour ouvrir et fermer les connexions

Python offre une méthode plus efficace et plus propre pour gérer les connexions aux bases de données en utilisant l’instruction with, également connue sous le nom de gestionnaire de contexte. L’instruction with ouvre et ferme automatiquement la connexion, garantissant que la connexion est correctement fermée même si une erreur se produit pendant les opérations de base de données. Cela élimine la nécessité d’appeler manuellement connection.close().

Voici comment vous pouvez utiliser l’instruction with pour gérer les connexions à la base de données :

import sqlite3

# Étape 1 : Utilisez 'with' pour vous connecter à la base de données (ou la créer) et la fermer automatiquement lorsque vous l'avez terminée
with sqlite3.connect('my_database.db') as connection:

    # Étape 2 : Créer un objet curseur pour interagir avec la base de données
    cursor = connection.cursor()

    print("Database created and connected successfully!")

# Aucun besoin de call connection.close(); cela est fait automatiquement !

Désormais, nous utiliserons l’instruction with dans les exemples de code à venir pour gérer les connexions à la base de données de manière efficiente. Cela rendra le code plus court et plus facile à maintenir.

Comment Créer des tables de Base de Données

Maintenant que nous avons créé une base de données SQLite et qu’ nous avons établi une connexion avec elle, le prochain pas est de créer des tables dans la base de données. Une table est l’endroit où nous stockerons notre donnée, organisée en lignes (enregistrements) et en colonnes (attributs). Dans cet exemple, nous créerons une table appelée Étudiants pour stocker les informations sur les élèves, que nous réutiliserons dans les sections à venir.

Pour créer une table, nous utilisons l’instruction SQL CREATE TABLE. Cet ordre définit la structure de la table, y compris les noms des colonnes et les types de données pour chaque colonne.

Voici un simple ordre SQL pour créer une table Étudiants avec les champs suivants :

id : Un identifiant unique pour chaque élève (un entier).
name : Le nom de l’élève (texte).
age : L’âge de l’élève (un entier).
email : L’adresse électronique de l’élève (texte).

L’ordre SQL pour créer cette table serait comme suit :

CREATE TABLE Students (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    age INTEGER,
    email TEXT
);

Nous pouvons exécuter ce commande SQL CREATE TABLE en Python en utilisant la bibliothèque sqlite3. Voyons comment faire.

import sqlite3

# Utilisez 'with' pour se connecter à la base de données SQLite et fermer automatiquement la connexion lorsque terminé
with sqlite3.connect('my_database.db') as connection:

    # Créer un objet curseur
    cursor = connection.cursor()

    # Ecrivez le commande SQL pour créer la table Étudiants
    create_table_query = '''
    CREATE TABLE IF NOT EXISTS Students (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        age INTEGER,
        email TEXT
    );
    '''

    # Exécuter le commande SQL
    cursor.execute(create_table_query)

    # Valider les modifications
    connection.commit()

    # Afficher un message de confirmation
    print("Table 'Students' created successfully!")

IF NOT EXISTS : Cela garantit que la table n’est créée que si elle n’existe pas déjà, évitant ainsi les erreurs en cas de création de la table avant.
connection.commit() : Cela sauvegarde (valide) les modifications dans la base de données.

Lorsque vous exécutez le code Python ci-dessus, il créera la table Étudiants dans le fichier de base de données my_database.db. Vous verrez également un message dans le terminal confirmant que la table a été créée avec succès.

Voici la traduction en français :

Si vous utilisez Visual Studio Code, vous pouvez installer l’extension SQLite Viewer pour afficher les bases de données SQLite.

Types de données dans SQLite et leur mapping vers Python

SQLite supporte plusieurs types de données, que nous devons comprendre lorsque nous définissons nos tables. Voici un aperçu rapide des types de données SQLite courants et de leur équivalent en Python :

Type de donnée SQLite	Description	Équivalent Python
INTEGER	Nombres entiers	`int`
TEXT	Chaînes de texte	`str`
REAL	Nombres à virgule flottante	`float`
BLOB	Données binaires (par ex., images, fichiers)	`bytes`
NULL	Représente aucune valeur ou données manquantes	`None`

Dans notre table Étudiants :

id est de type INTEGER, qui correspond à int en Python.
name et email sont de type TEXT, qui correspondent à str en Python.
age est également de type INTEGER, correspondant au type int en Python.

Comment Insérer des Données dans une Table

Puisque nous avons créé notre table Étudiants, il est temps de commencer à insérer des données dans la base de données. Dans cette section, nous verrons comment insérer à la fois des enregistrements individuels et plusieurs enregistrements à la fois en utilisant Python et SQLite, et comment éviter les problèmes de sécurité courants tels que l’injection SQL en utilisant des requêtes paramétrées.

Comment Insérer un Seul Enregistrement

Pour insérer des données dans la base de données, nous utilisons l’instruction SQL INSERT INTO. Commençons par insérer un seul enregistrement dans notre table Étudiants.

Voici la syntaxe SQL de base pour insérer un seul enregistrement :

INSERT INTO Students (name, age, email) 
VALUES ('John Doe', 20, '[email protected]');

Cependant, au lieu d’écrire directement du SQL dans notre script Python avec des valeurs codées à main levée, nous utiliserons des requêtes paramétrées pour rendre notre code plus sécurisé et plus flexible. Les requêtes paramétrées aident à prévenir les injections SQL, un type courant d’attaque où les utilisateurs malveillants peuvent manipuler la requête SQL en passant des entrées dangereuses.

Voici comment nous pouvons insérer un seul enregistrement dans la table Étudiants en utilisant une requête paramétrée :

import sqlite3

# Utilisez 'with' pour ouvrir et fermer la connexion automatiquement
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # Insérez un enregistrement dans la table Students
    insert_query = '''
    INSERT INTO Students (name, age, email) 
    VALUES (?, ?, ?);
    '''
    student_data = ('Jane Doe', 23, '[email protected]')

    cursor.execute(insert_query, student_data)

    # Validez les modifications automatiquement
    connection.commit()

    # Inutile d'appeler connection.close() ; cela se fait automatiquement !
    print("Record inserted successfully!")

Les substituants ? représentent les valeurs à insérer dans la table. Les valeurs réelles sont passées sous forme de tuple (student_data) dans la méthode cursor.execute().

Comment insérer plusieurs enregistrements

Si vous souhaitez insérer plusieurs enregistrements à la fois, vous pouvez utiliser la méthode executemany() en Python. Cette méthode prend une liste de tuples, où chaque tuple représente un enregistrement.

Pour rendre notre exemple plus dynamique, nous pouvons utiliser la bibliothèque Faker pour générer des données d’étudiants aléatoires. Cela est utile pour les tests et la simulation de scénarios du monde réel.

from faker import Faker
import sqlite3

# Initialisez Faker
fake = Faker(['en_IN'])

# Utilisez 'with' pour ouvrir et fermer la connexion automatiquement
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # Insérez un enregistrement dans la table Students
    insert_query = '''
    INSERT INTO Students (name, age, email) 
    VALUES (?, ?, ?);
    '''
    students_data = [(fake.name(), fake.random_int(
        min=18, max=25), fake.email()) for _ in range(5)]

    # Exécutez la requête pour plusieurs enregistrements
    cursor.executemany(insert_query, students_data)

    # Validez les modifications
    connection.commit()

    # Affichez un message de confirmation
    print("Fake student records inserted successfully!")

Dans ce code :

Faker() génère des noms aléatoires, des âges et des courriels pour les élèves. Transmettre la locale ([‘fr_FR’]) est facultatif.
cursor.executemany() : Cette méthode permet de insérer plusieurs enregistrements en une fois, ce qui rend le code plus efficace.
students_data : Une liste de couples où chaque couple représente les données d’un élève.

Comment traiter les problèmes courants : Injection SQL

L’injection SQL est une faille de sécurité où les attaquants peuvent insérer ou manipuler des requêtes SQL en fournissant un input nocif. Par exemple, un attaquant pourrait essayer d’injecter du code comme '; DROP TABLE Students; -- pour supprimer la table.

En utilisant les requêtes paramétrées (comme illustré ci-dessus), nous évitons ce problème. Les placeholders ? dans les requêtes paramétrées assurent que les valeurs d’entrée sont traitées comme des données, et non pas comme partie des commandes SQL. Cela rend impossible l’exécution de code malveillant.

Comment récupérer les données

Maintenant que nous avons inséré certaines données dans notre tableau Étudiants, apprenons comment récupérer les données à partir de la table. Nous explorerons différentes méthodes pour récupérer des données en Python, y compris fetchone(), fetchall() et fetchmany().

Pour exécuter une requête sur une table, nous utilisons l’instruction SELECT. Voici un simple commande SQL pour sélectionner toutes les colonnes de la table Étudiants :

SELECT * FROM Students;

Cette commande récupère tous les enregistrements et les colonnes de la table Étudiants. Nous pouvons exécuter cette requête SELECT en Python et récupérer les résultats.

Comment récupérer tous les enregistrements

Voici comment nous pouvons récupérer tous les enregistrements de la table Étudiants :

import sqlite3

# Utilisez 'with' pour se connecter à la base de données SQLite
with sqlite3.connect('my_database.db') as connection:

    # Créez un objet curseur
    cursor = connection.cursor()

    # Ecrivez la commande SQL pour sélectionner tous les enregistrements de la table Étudiants
    select_query = "SELECT * FROM Students;"

    # Exécutez la commande SQL
    cursor.execute(select_query)

    # Récupérez tous les enregistrements
    all_students = cursor.fetchall()

    # Affichez les résultats dans le terminal
    print("All Students:")
    for student in all_students:
        print(student)

Dans cet exemple, la méthode fetchall() récupère tous les lignes retournées par la requête sous forme d’une liste de couples.

All Students:
(1, 'Jane Doe', 23, '[email protected]')
(2, 'Bahadurjit Sabharwal', 18, '[email protected]')
(3, 'Zayyan Arya', 20, '[email protected]')
(4, 'Hemani Shukla', 18, '[email protected]')
(5, 'Warda Kara', 20, '[email protected]')
(6, 'Mitali Nazareth', 19, '[email protected]')

Comment récupérer un seul enregistrement

Si vous souhaitez récupérer uniquement un seul enregistrement, vous pouvez utiliser la méthode fetchone() :

import sqlite3

# Utilisez 'with' pour se connecter à la base de données SQLite
with sqlite3.connect('my_database.db') as connection:

    # Créez un objet curseur
    cursor = connection.cursor()

    # Ecrivez la commande SQL pour sélectionner tous les enregistrements de la table Students
    select_query = "SELECT * FROM Students;"

    # Exécutez la commande SQL
    cursor.execute(select_query)

    # Récupérez un enregistrement
    student = cursor.fetchone()

    # Affichez le résultat
    print("First Student:")
    print(student)

Sortie :

First Student:
(1, 'Jane Doe', 23, '[email protected]')

Comment récupérer plusieurs enregistrements

Pour récupérer un certain nombre d’enregistrements, vous pouvez utiliser fetchmany(size) :

import sqlite3

# Utilisez 'with' pour se connecter à la base de données SQLite
with sqlite3.connect('my_database.db') as connection:

    # Créez un objet curseur
    cursor = connection.cursor()

    # Ecrivez la commande SQL pour sélectionner tous les enregistrements de la table Students
    select_query = "SELECT * FROM Students;"

    # Exécutez la commande SQL
    cursor.execute(select_query)

    # Récupérez trois enregistrements
    three_students = cursor.fetchmany(3)

    # Affichez les résultats
    print("Three Students:")
    for student in three_students:
        print(student)

Sortie :

Three Students:
(1, 'Jane Doe', 23, '[email protected]')
(2, 'Bahadurjit Sabharwal', 18, '[email protected]')
(3, 'Zayyan Arya', 20, '[email protected]')

Comment utiliser `pandas` pour une meilleure présentation des données

Pour une meilleure présentation des données, nous pouvons utiliser la bibliothèque pandas pour créer un DataFrame à partir de nos résultats de requête. Cela facilite la manipulation et la visualisation des données.

Voici comment récupérer tous les enregistrements et les afficher sous forme de DataFrame pandas :

import sqlite3
import pandas as pd

# Utilisez 'with' pour se connecter à la base de données SQLite
with sqlite3.connect('my_database.db') as connection:
    # Ecrivez l'ordre SQL pour sélectionner toutes les enregistrements de la table Students
    select_query = "SELECT * FROM Students;"

    # Utilisez pandas pour lire l'ordre SQL directement dans un DataFrame
    df = pd.read_sql_query(select_query, connection)

# Affichez le DataFrame
print("All Students as DataFrame:")
print(df)

Output:

All Students as DataFrame:
   id                  name  age                        email
0   1              Jane Doe   23             [email protected]
1   2  Bahadurjit Sabharwal   18  [email protected]
2   3           Zayyan Arya   20  [email protected]
3   4         Hemani Shukla   18    [email protected]
4   5            Warda Kara   20           [email protected]
5   6       Mitali Nazareth   19          [email protected]

La fonction pd.read_sql_query() exécute l’ordre SQL et retourne directement les résultats sous forme de DataFrame pandas.

Mise à jour et suppression de données

Dans cette section, nous apprenons comment mettre à jour des enregistrements existants et supprimer des enregistrements de notre tableau Students en utilisant des ordres SQL dans Python. Cela est essentiel pour gérer et maintenir vos données efficacement.

Mise à jour d’enregistrements existants

Pour modifier les enregistrements existants dans une base de données, nous utilisons l’ordre SQL UPDATE. Cet ordre nous permet de modifier les valeurs des colonnes spécifiques dans une ou plusieurs lignes en fonction d’une condition spécifiée.

Par exemple, si nous voulons mettre à jour l’age d’un étudiant, l’ordre SQL ressemblerait à ceci:

UPDATE Students 
SET age = 21 
WHERE name = 'Jane Doe';

Maintenant, écrivons du code Python pour mettre à jour l’age d’un étudiant spécifique dans notre tableau Students.

import sqlite3

# Utilisez 'with' pour se connecter à la base de données SQLite
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # Commande SQL pour mettre à jour l'âge d'un étudiant
    update_query = '''
    UPDATE Students 
    SET age = ? 
    WHERE name = ?;
    '''

    # Données pour la mise à jour
    new_age = 21
    student_name = 'Jane Doe'

    # Exécuter la commande SQL avec les données
    cursor.execute(update_query, (new_age, student_name))

    # Valider les modifications pour enregistrer la mise à jour
    connection.commit()

    # Afficher un message de confirmation
    print(f"Updated age for {student_name} to {new_age}.")

Dans cet exemple, nous avons utilisé des requêtes paramétrées pour éviter les injections SQL.

Comment supprimer des enregistrements de la table

Pour supprimer des enregistrements d’une base de données, nous utilisons la commande SQL DELETE. Cette commande nous permet de supprimer une ou plusieurs lignes en fonction d’une condition spécifiée.

Par exemple, si nous voulons supprimer un étudiant nommé ‘Jane Doe’, la commande SQL ressemblerait à ceci :

DELETE FROM Students 
WHERE name = 'Jane Doe';

Ecrivons du code Python pour supprimer un étudiant spécifique de notre table Students en utilisant l’instruction with.

import sqlite3

# Utilisez 'with' pour se connecter à la base de données SQLite
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # Commande SQL pour supprimer un étudiant
    delete_query = '''
    DELETE FROM Students 
    WHERE name = ?;
    '''

    # Nom de l'étudiant à supprimer
    student_name = 'Jane Doe'

    # Exécuter la commande SQL avec les données
    cursor.execute(delete_query, (student_name,))

    # Valider les modifications pour enregistrer la suppression
    connection.commit()

    # Afficher un message de confirmation
    print(f"Deleted student record for {student_name}.")

Considérations importantes

Conditions

: Utilisez toujours la clause WHERE lors de la mise à jour ou de la suppression d’enregistrements pour éviter de modifier ou de supprimer toutes les lignes de la table. Sans clause WHERE, la commande affecte toutes les lignes de la table.
Sauvegarde : Il est de bonne pratique de sauvegarder votre base de données avant d’effectuer des mises à jour ou des suppressions, surtout dans des environnements de production.

Comment utiliser les Transactions

Une transaction est une séquence d’une ou plusieurs opérations SQL traitées comme une seule unité de travail. Dans le contexte d’une base de données, une transaction vous permet d’effectuer plusieurs opérations qui réussissent toutes ensemble ou aucune du tout. Cela garantit que votre base de données reste dans un état cohérent, même en cas d’erreurs ou de problèmes inattendus.

Par exemple, si vous transférez de l’argent entre deux comptes bancaires, vous voudriez que le débit d’un compte et le crédit de l’autre réussissent ou échouent ensemble. Si une opération échoue, l’autre ne doit pas être exécutée pour maintenir la cohérence.

Pourquoi utiliser des Transactions ?

Atomicité : Les transactions assurent que une série d’opérations est traitée comme une unité unique. Si une opération échoue, aucune des opérations ne sera appliquée au base de données.
Consistance : Les transactions aident à maintenir l’intégrité de la base de données en veillant à ce que toutes les règles et contraintes soient respectées.
Isolation : Chaque transaction fonctionne indépendamment des autres, évitant ainsi toute interférence non intentionnelle.
Durabilité : Une fois qu’une transaction est validée, les modifications sont permanentes, même en cas d’échec système.

Quand utiliser des transactions ?

Vous devez utiliser des transactions lorsque :

Vous effectuez plusieurs opérations liées qui doivent réussir ou échouer ensemble.
Vous modifiez des données critiques qui exigent une cohérence et une intégrité.
Travailler avec des opérations qui peuvent échouer, telles que les transactions financières ou les migrations de données.

Comment gérer les transactions en Python

En SQLite, les transactions sont gérées à l’aide des commandes BEGIN, COMMIT et ROLLBACK. Cependant, lors de l’utilisation du module sqlite3 en Python, vous gérez généralement les transactions à travers l’objet de connexion.

Début d’une transaction

Une transaction commence implicitement lorsque vous exécutez une instruction SQL. Pour démarrer une transaction explicitement, vous pouvez utiliser la commande BEGIN :

cursor.execute("BEGIN;")

Cependant, il est généralement inutile de démarrer manuellement une transaction, car SQLite démarre une transaction automatiquement lorsque vous exécutez une instruction SQL.

Comment valider une transaction

Pour enregistrer toutes les modifications effectuées pendant une transaction, vous utilisez la méthode commit(). Cela rend toutes les modifications permanentes dans la base de données.

connection.commit()

Nous avons déjà utilisé la méthode commit() dans les exemples fournis ci-dessus.

Annuler une transaction

Si quelque chose va mal et que vous souhaitez réverser les modifications effectuées pendant une transaction, vous pouvez utiliser la méthode rollback(). Cela annulera toutes les modifications faites depuis le début de la transaction.

connection.rollback()

Exemple d’utilisation de transactions en Python.

Pour illustrer l’utilisation des transactions dans un scénario du monde réel, nous créerons une nouvelle table appelée Customers pour gérer les comptes clients. Dans cet exemple, nous supposerons que chaque client a un balance. Nous ajouterons deux clients à cette table et effectuerons une opération de transfert de fonds entre eux.

Tout d’abord, créez-nous la table Customers et insérez deux clients :

import sqlite3

# Créer la table Customers et ajouter deux clients
with sqlite3.connect('my_database.db') as connection:
    cursor = connection.cursor()

    # Créer la table Customers
    create_customers_table = '''
    CREATE TABLE IF NOT EXISTS Customers (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL UNIQUE,
        balance REAL NOT NULL
    );
    '''
    cursor.execute(create_customers_table)

    # Insérer deux clients
    cursor.execute(
        "INSERT INTO Customers (name, balance) VALUES (?, ?);", ('Ashutosh', 100.0))
    cursor.execute(
        "INSERT INTO Customers (name, balance) VALUES (?, ?);", ('Krishna', 50.0))

    connection.commit()

Maintenant, effectuons l’opération de transfert de fonds entre Ashutosh et Krishna :

import sqlite3


def transfer_funds(from_customer, to_customer, amount):
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        try:
            # Démarrer une transaction
            cursor.execute("BEGIN;")

            # Déduire le montant de l'expéditeur
            cursor.execute(
                "UPDATE Customers SET balance = balance - ? WHERE name = ?;", (amount, from_customer))
            # Ajouter le montant au récepteur
            cursor.execute(
                "UPDATE Customers SET balance = balance + ? WHERE name = ?;", (amount, to_customer))

            # Valider les modifications
            connection.commit()
            print(
                f"Transferred {amount} from {from_customer} to {to_customer}.")

        except Exception as e:
            # Si une erreur survient, annuler la transaction
            connection.rollback()
            print(f"Transaction failed: {e}")


# Exemple d'utilisation
transfer_funds('Ashutosh', 'Krishna', 80.0)

Voici la traduction en français :

Nous avons dans un premier temps créé une table Customers et inséré deux clients, Ashutosh avec un solde de ₹100 et Krishna avec un solde de ₹50. Nous avons ensuite effectué un transfert de fonds de ₹80 d’Ashutosh vers Krishna. En utilisant des transactions, nous nous assurons que le débit du compte d’Ashutosh et le crédit sur le compte de Krishna sont exécutés en une seule opération atomique, préservant ainsi l’intégrité des données en cas d’erreurs. Si le transfert échoue (par exemple, en raison de fonds insuffisants), la transaction est annulée, et les deux comptes restent inchangés.

Comment optimiser la performance des requêtes SQLite avec l’indexation

L’indexation est une technique puissante utilisée dans les bases de données pour améliorer la performance des requêtes. Un index est essentiellement une structure de données qui stocke l’emplacement des lignes en fonction des valeurs spécifiques de colonnes, tout comme l’index à la fin d’un livre vous aide à localiser rapidement un sujet.

Sans index, SQLite doit scanner la totalité de la table ligne par ligne pour trouver les données pertinentes, ce qui devient inefficace à mesure que le jeu de données grandit. En utilisant un index, SQLite peut sauter directement aux lignes nécessaires, ce qui permet de considérablement accélérer l’exécution des requêtes.

Comment remplir la base de données avec des données factices

Pour tester efficacement l’impact de l’indexation, nous avons besoin d’un jeu de données substantiel. Au lieu d’ajouter manuellement des enregistrements, nous pouvons utiliser la bibliothèque faker pour générer rapidement des données factices. Dans cette section, nous générerons 10 000 enregistrements factices et les insérerons dans notre table Students. Cela simule un scénario réel où les bases de données grandissent et la performance des requêtes devient importante.

Nous utiliserons la méthode executemany() pour insérer les enregistrements comme suit :

import sqlite3
from faker import Faker

# Initialiser la bibliothèque Faker
fake = Faker(['en_IN'])


def insert_fake_students(num_records):
    """Generate and insert fake student data into the Students table."""
    fake_data = [(fake.name(), fake.random_int(min=18, max=25),
                  fake.email()) for _ in range(num_records)]

    # Utiliser 'with' pour gérer la connexion à la base de données
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Insérer des fausses données dans la table des étudiants
        cursor.executemany('''
        INSERT INTO Students (name, age, email) 
        VALUES (?, ?, ?);
        ''', fake_data)

        connection.commit()

    print(f"{num_records} fake student records inserted successfully.")


# Insérer 10 000 enregistrements factices dans la table des étudiants
insert_fake_students(10000)

En exécutant ce script, 10 000 faux enregistrements d’étudiants seront ajoutés à la table Students. Dans la section suivante, nous interrogerons la base de données et comparerons les performances des requêtes avec et sans index.

Comment effectuer une requête sans index

Dans cette section, nous interrogerons la table Students sans aucun index pour observer comment SQLite se comporte lorsqu’il n’y a pas d’optimisations en place. Cela servira de référence pour comparer les performances lorsque nous ajouterons des index plus tard.

Sans index, SQLite effectue un balayage complet de la table, ce qui signifie qu’il doit vérifier chaque ligne de la table pour trouver des résultats correspondants. Pour de petits ensembles de données, c’est gérable, mais à mesure que le nombre d’enregistrements augmente, le temps nécessaire pour la recherche augmente de manière spectaculaire. Voyons cela en action en exécutant une requête de base SELECT pour rechercher un étudiant spécifique par nom et mesurer le temps nécessaire.

Tout d’abord, nous interrogerons la table Students en recherchant un étudiant avec un nom spécifique. Nous enregistrerons le temps nécessaire pour exécuter la requête en utilisant le module time de Python pour mesurer les performances.

import sqlite3
import time


def query_without_index(search_name):
    """Query the Students table by name without an index and measure the time taken."""

    # Se connecter à la base de données en utilisant 'with'
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Mesurer l'heure de départ
        start_time = time.perf_counter_ns()

        # Exécuter une requête SELECT pour trouver un étudiant par son nom
        cursor.execute('''
        SELECT * FROM Students WHERE name = ?;
        ''', (search_name,))

        # Extraire tous les résultats (il devrait en exister un seul ou quelques-uns dans la pratique)
        results = cursor.fetchall()

        # Mesurer l'heure de fin
        end_time = time.perf_counter_ns()

        # Calculer le temps total mis
        elapsed_time = (end_time - start_time) / 1000

        # Afficher les résultats et le temps mis
        print(f"Query completed in {elapsed_time:.5f} microseconds.")
        print("Results:", results)


# Exemple : Rechercher un étudiant par son nom
query_without_index('Ojasvi Dhawan')

Voici la sortie :

Query completed in 1578.10000 microseconds.
Results: [(104, 'Ojasvi Dhawan', 21, '[email protected]')]

En exécutant le script ci-dessus, vous verrez combien de temps il faut pour rechercher dans la table Students sans aucune indexation. Par exemple, si la table contient 10 000 enregistrements, la requête peut prendre de 1000 à 2000 microsecondes en fonction de la taille de la table et de votre matériel. Cela peut sembler lent pour un petit jeu de données, mais la performance se détériorera au fur et à mesure de l’ajout d’enregistrements.

Nous utilisons time.perf_counter_ns() pour mesurer le temps d’execution de la requête en nanosecondes. Cette méthode est très précise pour le benchmarking de petites intervalles de temps. Nous convertissons le temps en microsecondes (us) pour une lecture plus aisée.

Introduction du plan de requête

Lorsque vous traballez avec des bases de données, comprendre comment les requêtes sont exécutées peut vous aider à identifier les points d’appui et à optimiser votre code. SQLite fournit une belle méthode pour cela nommée EXPLAIN QUERY PLAN, qui vous permet d’analyser les étapes que SQLite prend pour récupérer les données.

Dans cette section, nous allons introduire comment utiliser EXPLAIN QUERY PLAN pour visualiser et comprendre les fonctionnements internes d’une requête – en particulier, comment SQLite effectue une scan de table complète lorsque pas d’index est présent.

Faisons donc l’expérience de EXPLAIN QUERY PLAN pour voir comment SQLite récupère les données de la table Students sans aucun index. Nous rechercherons un élève par son nom, et le plan de requête révélera les étapes que SQLite effectue pour trouver les lignes correspondantes.

import sqlite3


def explain_query(search_name):
    """Explain the query execution plan for a SELECT query without an index."""

    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Utilisez EXPLAIN QUERY PLAN pour analyser l'exécution de la requête
        cursor.execute('''
        EXPLAIN QUERY PLAN
        SELECT * FROM Students WHERE name = ?;
        ''', (search_name,))

        # Récupérez et affichez le plan de requête
        query_plan = cursor.fetchall()

        print("Query Plan:")
        for step in query_plan:
            print(step)


# Exemple : Analyse du plan de requête pour la recherche par nom
explain_query('Ojasvi Dhawan')

Lorsque vous exécutez ce code, SQLite retournera une décomposition de la manière dont elle prévoit exécuter la requête. Voici un exemple de ce que la sortie pourrait ressembler :

Query Plan:
(2, 0, 0, 'SCAN Students')

Cela indique que SQLite effectue un scan de table complète de la table Students (un scan de table complète) pour trouver les lignes où la colonne name correspond à la valeur fournie (Ojasvi Dhawan). Comme il n’y a pas d’index sur la colonne name, SQLite doit examiner chacune des lignes de la table.

Comment Créer Un Index

Créer un index sur une colonne permet à SQLite de trouver les enregistrements plus rapidement lors des opérations de requête. Au lieu de scanner entièrement la table, SQLite peut utiliser l’index pour sauter directement aux enregistrements pertinents, accélérant显著ement les requêtes, en particulier celles impliquant de grands jeux de données.

Pour créer un index, utilisez l’instruction SQL suivante :

CREATE INDEX IF NOT EXISTS index-name ON table (column(s));

Dans cet exemple, nous créerons un index sur la colonne name de la table Students. Voici comment vous pouvez le faire en utilisant Python :

import sqlite3
import time


def create_index():
    """Create an index on the name column of the Students table."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # SQL command to create an index on the name column
        create_index_query = '''
        CREATE INDEX IF NOT EXISTS idx_name ON Students (name);
        '''

        # Measure the start time
        start_time = time.perf_counter_ns()

        # Execute the SQL command to create the index
        cursor.execute(create_index_query)

        # Measure the start time
        end_time = time.perf_counter_ns()

        # Commit the changes
        connection.commit()

        print("Index on 'name' column created successfully!")

        # Calculate the total time taken
        elapsed_time = (end_time - start_time) / 1000

        # Display the results and the time taken
        print(f"Query completed in {elapsed_time:.5f} microseconds.")


# Call the function to create the index
create_index()

Output :

Index on 'name' column created successfully!
Query completed in 102768.60000 microseconds.

Même si la création de l’index prend autant de temps (102768,6 microsecondes), il s’agit d’une opération unique. Vous obtiendrez toujours une importante augmentation de vitesse lors de l’exécution de multiples requêtes. Dans les sections suivantes, nous interrogerons à nouveau la base de données pour observer les améliorations de performance permises par cet index.

Comment interroger les indexes

Dans cette section, nous exécuterons la même requête SELECT que celle que nous avons effectuée plus tôt, mais cette fois-ci, nous profiterons de l’index que nous avons créé sur la colonne name de la table Students. Nous mesurons et enregistrons le temps d’exécution pour observer les améliorations de performance apportées par l’index.

import sqlite3
import time


def query_with_index(student_name):
    """Query the Students table using an index on the name column."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Commande SQL pour sélectionner un étudiant par son nom
        select_query = 'SELECT * FROM Students WHERE name = ?;'

        # Mesurer le temps d'exécution
        start_time = time.perf_counter_ns()  # Démarrer le chronomètre

        # Exécuter la requête avec le nom d'étudiant fourni
        cursor.execute(select_query, (student_name,))
        result = cursor.fetchall()  # Extraire tous les résultats

        end_time = time.perf_counter_ns()  # Arrêter le chronomètre

        # Calculer le temps écoulé en microsecondes
        execution_time = (end_time - start_time) / 1000

        # Afficher les résultats et le temps d'exécution
        print(f"Query result: {result}")
        print(f"Execution time with index: {execution_time:.5f} microseconds")


# Exemple : Recherche d'un étudiant par son nom
query_with_index('Ojasvi Dhawan')

Voici ce que nous obtenons dans la sortie :

Query result: [(104, 'Ojasvi Dhawan', 21, '[email protected]')]
Execution time with index: 390.70000 microseconds

Nous pouvons observer une réduction significative du temps d’exécution par rapport à l’exécution de la requête sans index.

Maintenant, Analysez le plan d’exécution de la requête pour la requête avec l’index sur la colonne name de la table Students. Si vous exécutez à nouveau le même script pour expliquer la requête, vous obtiendrez l’output ci-dessous :

Query Plan:
(3, 0, 0, 'SEARCH Students USING INDEX idx_name (name=?)')

Le plan indique maintenant que la requête utilise l’index idx_name, réduisant considérablement le nombre de lignes à scanner, ce qui entraîne une exécution de requête plus rapide.

Comparaison des Résultats de Performances

Maintenant, récapitulons les résultats de performance que nous avons obtenus lors des requêtes avec et sans index.

Comparaison de Temps d’Exécution

Type de Requête	Temps d’Exécution (microsecondes)
Sans Index	1578,1
Avec Index	390,7

Récapitulatif de l’Amélioration des Performances

La requête avec l’index est environ 4,04 fois plus rapide que la requête sans index.
Le temps d’exécution a été amélioré d’environ 75,24% après l’ajout de l’index.

Meilleures Pratiques pour L’Utilisation des Indexes

Les indexes peuvent améliorer considérablement les performances de votre base de données SQLite, mais ils devraient être utilisés judicieusement. Voici quelques meilleures pratiques à prendre en considération lorsque vous trabalisez avec les indexes :

Quand et Pourquoi Utiliser des Indexes

Colonnes de Requêtes Fréquentes : Utilisez des indexs sur les colonnes souvent utilisées dans les requêtes SELECT, en particulier celles utilisées dans les clauses WHERE, JOIN et ORDER BY. Cela est dû au fait que l’indexation de ces colonnes peut réduire considérablement le temps d’exécution des requêtes.
Contraintes d’unicité : Lorsque vous avez des colonnes qui doivent contenir des valeurs uniques (comme les noms d’utilisateurs ou les adresses emails), créer un index peut en enfermer cette contrainte de manière efficace.
Jetsons de données : Pour les tables avec un grand nombre d’enregistrements, les indexs deviennent de plus en plus bénéfiques. Ils permettent des recherches rapides, ce qui est essentiel pour maintenir la performance au fil de la croissance de vos données.
Indexs composites : Envisagez de créer des indexs composites pour les requêtes qui filtrent ou classent par plusieurs colonnes. Par exemple, si vous recherchez souvent des élèves par nom et âge, un index sur les deux colonnes peut optimiser de telles requêtes.

Inconvénients potentiels des indexes

Les indexes offrent des avantages importants, mais ils présentent également quelques inconvénients potentiels :

Opérations d’insertion/mise à jour plus lentes : Lorsque vous insérez ou mettez à jour des enregistrements dans une table dotée d’indexes, SQLite doit également mettre à jour l’index, ce qui peut ralentir ces opérations. Cela est dû au fait que chaque insertion ou mise à jour nécessite un surcharges supplémentaires pour maintenir la structure de l’index.
Requêtes d’espace de stockage accru : Les indexes consomment de l’espace disque supplémentaire. Pour de grandes tables, le coût de l’espace peut être important. Pensez à cela lors de la conception de votre schéma de base de données, en particulier pour les systèmes dotés de ressources d’espace limitées.
Gestion complexe des indexs : Avoir trop d’indexs peut compliquer la gestion de la base de données. Il peut mener à des situations où vous avez des indexs redondants, qui peuvent se dégrader plutôt que d’améliorer le rendement. Revoir régulièrement et optimiser vos indexs est une bonne pratique.

Les indexs sont des outils puissants pour optimiser les requêtes de base de données, mais ils exigent une considération prudente. Équilibrer l’amélioration du performance de lecture et le potentiel du surchargement des opérations d’écriture est clé. Voici quelques stratégies pour atteindre cet équilibre :

Surveiller la performance des requêtes : Utilisez EXPLAIN QUERY PLAN d’SQLite pour analyser la performance de vos requêtes avec et sans indexs. Cela peut aider à identifier lesquels des indexs sont bénéfiques et lesquels peuvent être inutiles.
Entretien régulier : Revoir périodiquement vos indexs et évaluer s’ils sont toujours nécessaires. Enlevez les indexs redondants ou rarement utilisés pour streamliner vos opérations de base de données.
Tester et évaluer : Avant de mettre en œuvre des indexeurs dans un environnement de production, effectuez des tests approfondis pour comprendre leur impact sur les opérations de lecture et d’écriture.

En suivant ces meilleures pratiques, vous pouvez tirer parti des avantages des indexeurs tout en minimisant les désavantages potentiels, améliorant ainsi le rendement et l’efficacité de votre base de données SQLite.

Comment gérer les erreurs et les exceptions

Dans cette section, nous verrons comment gérer les erreurs et les exceptions lorsque vous travaillez avec SQLite en Python. Une gestion adéquate des erreurs est essentielle pour maintenir l’intégrité de votre base de données et pour que votre application se comporte de manière prévisible.

Erreurs communes dans les opérations SQLite

Lorsque vous interagissez avec une base de données SQLite, plusieurs erreurs communes peuvent survenir :

Violations de contraintes : Cela se produit lorsque vous essayez d’insérer ou de mettre à jour des données qui contreviennent à une contrainte de la base de données, telles que l’unicité des clés primaires ou les contraintes de clés étrangères. Par exemple, essayez d’insérer une clé primaire dupliquée et une erreur se produira.
Incompatibilité de types de données : Essayer d’insérer des données du mauvais type (par exemple, insérer une chaîne où un nombre est attendu) peut entraîner une erreur.
Erreurs de verrouillage de base de données : Si une base de données est écrite par une autre processus ou connexion, essayez d’y accéder et vous pourriez obtenir une erreur de « base de données verrouillée ».
Erreurs de syntaxe : Des erreurs se produiront lorsque vous essayez d’exécuter vos commandes en cas d’erreurs dans votre syntaxe SQL.

Comment utiliser le traitement d’exceptions de Python.

Les mécanismes de gestion d’exceptions intégrés en Python (try et except) sont essentiels pour gérer les erreurs lors d’opérations avec SQLite. En utilisant ces constructions, vous pouvez attraper des exceptions et réagir adéquatement sans que votre programme s’arrête brusquement.

Voici un exemple basique de la manière de gérer les erreurs lors de l’insertion de données dans la base de données :

import sqlite3


def add_customer_with_error_handling(name, balance):
    """Add a new customer with error handling."""
    try:
        with sqlite3.connect('my_database.db') as connection:
            cursor = connection.cursor()
            cursor.execute(
                "INSERT INTO Customers (name, balance) VALUES (?, ?);", (name, balance))
            connection.commit()
            print(f"Added customer: {name} with balance: {balance}")

    except sqlite3.IntegrityError as e:
        print(f"Error: Integrity constraint violated - {e}")

    except sqlite3.OperationalError as e:
        print(f"Error: Operational issue - {e}")

    except Exception as e:
        print(f"An unexpected error occurred: {e}")


# Exemple d'utilisation
add_customer_with_error_handling('Vishakha', 100.0)  # Valide
add_customer_with_error_handling('Vishakha', 150.0)  # Entrée en double

Dans cet exemple :

Nous attrapons IntegrityError, qui est levée pour des violations telles que les contraintes uniques.
Nous attrapons OperationalError pour les problèmes généraux liés à la base de données (comme les erreurs de verrouillage de la base de données).
Nous avons également un bloc except générique pour gérer toutes les exceptions imprévues.

Sortie :

Added customer: Vishakha with balance: 100.0
Error: Integrity constraint violated - UNIQUE constraint failed: Customers.name

Meilleures pratiques pour assurer l’intégrité de la base de données.

Utiliser des transactions

: N’utilisez jamais de transactions (comme discuté dans la section précédente) lors de l’exécution de plusieurs opérations connexes. Cela aide à s’assurer que toutes les opérations réussissent ou aucune ne réussit, maintenant ainsi la cohérence.
Valider les données d’entrée : Avant d’exécuter des commandes SQL, validez les données d’entrée pour s’assurer qu’elles répondent aux critères attendus (par exemple, les bonnes types, dans les plages autorisées).
Catch Specific Exceptions : Attrapez toujours des exceptions spécifiques pour gérer les différents types d’erreurs de manière appropriée. Cela permet une gestion des erreurs plus claire et une meilleure débuggage.
Log Errors : Au lieu de simplement imprimer les erreurs sur la console, envisagez de les enregistrer dans un fichier ou un système de surveillance. Cela vous aidera à suivre les problèmes dans la production.
Dégradation Gracieuse : Concevez votre application pour gérer les erreurs avec élégance. Si une opération échoue, fournissez un feedback significatif à l’utilisateur plutôt que de faire planter l’application.
Sauvegarde régulière des données : Effectuez régulièrement des sauvegardes de votre base de données pour prévenir la perte de données en cas de défaillances critiques ou de corruption.
Utilisez les déclarations préparées : Les déclarations préparées aident à prévenir les attaques par injection SQL et peuvent également offrir de meilleurs performances pour les requêtes répétées.

Comment exporter et importer des données [Section Bonus]

Dans cette section, nous apprendrons comment exporter des données d’une base de données SQLite vers des formats communs tels que CSV et JSON, ainsi que comment importer des données dans SQLite à partir de ces formats en utilisant Python. Ceci est utile pour le partage de données, la sauvegarde et l’intégration avec d’autres applications.

Exportation de données de SQLite vers CSV

L’exportation de données vers un fichier CSV (Valeurs Séparées par des Virgules) est aisée avec les bibliothèques intégrées de Python. Les fichiers CSV sont largement utilisés pour le stockage et l’échange de données, ce qui en fait un format pratique pour l’exportation de données.

Voici la manière de transférer des données d’une table SQLite vers un fichier CSV :

import sqlite3
import csv

def export_to_csv(file_name):
    """Export data from the Customers table to a CSV file."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Exécuter une requête pour récupérer toutes les données des clients
        cursor.execute("SELECT * FROM Customers;")
        customers = cursor.fetchall()

        # Écrire les données dans un fichier CSV
        with open(file_name, 'w', newline='') as csv_file:
            csv_writer = csv.writer(csv_file)
            csv_writer.writerow(['ID', 'Name', 'Balance'])  # Écrire l'en-tête
            csv_writer.writerows(customers)  # Écrire les lignes de données

        print(f"Data exported successfully to {file_name}.")

# Exemple d'utilisation
export_to_csv('customers.csv')

Comment exporter des données vers un fichier JSON

De même, vous pouvez exporter des données vers un fichier JSON (JavaScript Object Notation), un format populaire pour l’échange de données, en particulier dans les applications web.

Voici un exemple de la manière de transférer des données vers un fichier JSON :

import json
import sqlite3


def export_to_json(file_name):
    """Export data from the Customers table to a JSON file."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Exécuter une requête pour récupérer toutes les données des clients
        cursor.execute("SELECT * FROM Customers;")
        customers = cursor.fetchall()

        # Convertir les données en une liste de dictionnaires
        customers_list = [{'ID': customer[0], 'Name': customer[1],
                           'Balance': customer[2]} for customer in customers]

        # Écrire les données dans un fichier JSON
        with open(file_name, 'w') as json_file:
            json.dump(customers_list, json_file, indent=4)

        print(f"Data exported successfully to {file_name}.")


# Exemple d'utilisation
export_to_json('customers.json')

Comment importer des données dans SQLite à partir de CSV

Vous pouvez également importer des données à partir d’un fichier CSV dans une base de données SQLite. Cela est utile pour remplir votre base de données avec des jeux de données existants.

Voici comment importer des données à partir d’un fichier CSV :

import csv
import sqlite3


def import_from_csv(file_name):
    """Import data from a CSV file into the Customers table."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Ouvrir le fichier CSV en lecture
        with open(file_name, 'r') as csv_file:
            csv_reader = csv.reader(csv_file)
            next(csv_reader)  # Ignorer la ligne d'en-tête

            # Insérer chaque ligne dans la table Customers
            for row in csv_reader:
                cursor.execute(
                    "INSERT INTO Customers (name, balance) VALUES (?, ?);", (row[1], row[2]))

        connection.commit()
        print(f"Data imported successfully from {file_name}.")


# Exemple d'utilisation
import_from_csv('customer_data.csv')

Comment importer des données dans SQLite à partir de JSON

De même, l’importation de données à partir de fichiers JSON est simple. Vous pouvez lire le fichier JSON et insérer les données dans votre table SQLite.

Voici comment le faire :

import json
import sqlite3


def import_from_json(file_name):
    """Import data from a JSON file into the Customers table."""
    with sqlite3.connect('my_database.db') as connection:
        cursor = connection.cursor()

        # Ouvrir le fichier JSON en lecture
        with open(file_name, 'r') as json_file:
            customers_list = json.load(json_file)

            # Insérer chaque client dans la table Customers
            for customer in customers_list:
                cursor.execute("INSERT INTO Customers (name, balance) VALUES (?, ?);", (customer['Name'], customer['Balance']))

        connection.commit()
        print(f"Data imported successfully from {file_name}.")


# Exemple d'utilisation
import_from_json('customer_data.json')

Conclusion

Et voilà, c’est fini ! Ce guide vous a présenté les fondamentaux du travail avec SQLite en Python, couvrant tout, depuis la configuration de votre environnement jusqu’à la recherche et à la manipulation des données, ainsi que l’exportation et l’importation d’informations. J’espère que vous l’avez trouvé utile et que cela vous a inspiré pour utiliser SQLite pour vos projets.

Maintenant, il est temps de mettre à profit vos nouvelles connaissances ! Je vous encourage à créer votre projet en utilisant SQLite et Python. Que ce soit une application simple pour gérer votre bibliothèque, un outil de budget ou quelque chose de unique, les possibilités sont infinies.

Une fois votre projet terminé, partagez-le sur Twitter et mentionnez-moi ! J’aimerais voir ce que vous avez créé et célébrer vos accomplissements.

Vous pouvez trouver tout le code de ce tutoriel sur GitHub. Merci d’avoir suivi avec nous et bon coding !

Générez une table des matières pour vos articles freeCodeCamp gratuitement en utilisant l’outil TOC Generator.

Comment configurer votre environnement Python

Installation de Python

Installation du module SQLite3

Comment Créer Un Environnement Virtuel (Facultatif mais recommandé)

Installation des bibliothèques nécessaires

Comment créer une base de données SQLite

Comment fonctionnent les bases de données SQLite

Comment Créer une Nouvelle Base de Données SQLite

Connexion à la Base de Données

Création d’un curseur

Fermeture de la Connexion

Comment utiliser le gestionnaire de contexte pour ouvrir et fermer les connexions

Comment Créer des tables de Base de Données

Types de données dans SQLite et leur mapping vers Python

Comment Insérer des Données dans une Table

Comment Insérer un Seul Enregistrement

Comment insérer plusieurs enregistrements

Comment traiter les problèmes courants : Injection SQL

Comment récupérer les données

Comment récupérer tous les enregistrements

Comment récupérer un seul enregistrement

Comment récupérer plusieurs enregistrements

Comment utiliser pandas pour une meilleure présentation des données

Mise à jour et suppression de données

Mise à jour d’enregistrements existants

Comment supprimer des enregistrements de la table

Considérations importantes

Comment utiliser les Transactions

Pourquoi utiliser des Transactions ?

Quand utiliser des transactions ?

Comment gérer les transactions en Python

Début d’une transaction

Comment valider une transaction

Annuler une transaction

Exemple d’utilisation de transactions en Python.

Comment optimiser la performance des requêtes SQLite avec l’indexation

Comment remplir la base de données avec des données factices

Comment effectuer une requête sans index

Introduction du plan de requête

Comment Créer Un Index

Comment interroger les indexes

Comparaison des Résultats de Performances

Comparaison de Temps d’Exécution

Récapitulatif de l’Amélioration des Performances

Meilleures Pratiques pour L’Utilisation des Indexes

Quand et Pourquoi Utiliser des Indexes

Inconvénients potentiels des indexes

Comment gérer les erreurs et les exceptions

Erreurs communes dans les opérations SQLite

Comment utiliser le traitement d’exceptions de Python.

Meilleures pratiques pour assurer l’intégrité de la base de données.

Comment exporter et importer des données [Section Bonus]

Exportation de données de SQLite vers CSV

Comment exporter des données vers un fichier JSON

Comment importer des données dans SQLite à partir de CSV

Comment importer des données dans SQLite à partir de JSON

Conclusion

Comment utiliser `pandas` pour une meilleure présentation des données