Tutoriel Python MariaDB : Connexion, CRUD, Transactions et Gestion des erreurs

1. Introduction

Pour ceux qui souhaitent travailler avec MariaDB en Python

De nombreuses personnes souhaitent se connecter à MariaDB en utilisant Python et manipuler des données. Dans cet article, nous expliquerons tout, des bases aux sujets plus avancés, pour travailler avec MariaDB en Python.

Rencontrez-vous l’un de ces problèmes ?

• Vous ne savez pas comment vous connecter à MariaDB depuis Python
• Vous voulez créer, lire, mettre à jour et supprimer facilement des données dans MariaDB avec Python
• Vous souhaitez connaître les erreurs courantes et comment les corriger

Ce que vous apprendrez dans cet article

• Comment se connecter facilement à MariaDB depuis Python
• Comment implémenter le CRUD (Créer, Lire, Mettre à jour, Supprimer)
• Erreurs courantes et leurs solutions
• Comment protéger l’intégrité des données avec les transactions

Après avoir lu cet article, vous serez capable de travailler sans problème avec MariaDB en Python. Maintenant, plongeons dans les détails.

2. Configuration de l’environnement (Installation de MariaDB & Python)

Qu’est-ce que MariaDB ?

MariaDB est un système de gestion de bases de données relationnelles (SGBDR) open source largement utilisé comme successeur de MySQL. Tout en conservant une grande compatibilité avec MySQL, MariaDB a amélioré les performances et ajouté de nouvelles fonctionnalités.

Outils requis

• Python (version 3.x ou ultérieure recommandée)
• MariaDB (serveur)
• Connecteur Python pour MariaDB (la bibliothèque mariadb)

Comment installer MariaDB (par OS)

Pour Windows

1. Téléchargez l’installateur MariaDB depuis le site officiel.
2. Exécutez l’installateur et suivez les instructions pour terminer l’installation.
3. Après l’installation, vérifiez que MariaDB fonctionne en exécutant la commande suivante :

   mysql -u root -p
   

4. Si vous pouvez vous connecter avec succès, l’installation est terminée.

Pour macOS

Sur macOS, vous pouvez installer facilement MariaDB en utilisant Homebrew.

1. Si Homebrew n’est pas installé, installez-le avec la commande suivante :

   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
   

2. Installez MariaDB :

   brew install mariadb
   

3. Démarrez MariaDB :

   brew services start mariadb
   

4. Vérifiez l’installation :

   mysql -u root -p
   

Pour Linux (Ubuntu)

1. Mettez à jour la liste des paquets et installez MariaDB :

   sudo apt update
   sudo apt install mariadb-server mariadb-client
   

2. Démarrez MariaDB :

   sudo systemctl start mariadb
   

3. Activez MariaDB (démarrage automatique au démarrage) :

   sudo systemctl enable mariadb
   

4. Exécutez le script d’installation sécurisée :

   sudo mysql_secure_installation
   

Cela vous permet de définir le mot de passe root et de supprimer les paramètres par défaut inutiles.

Installation de Python et de la bibliothèque requise

Pour intégrer MariaDB avec Python, vous devez installer la bibliothèque mariadb.

1. Installez la bibliothèque mariadb avec pip :

   pip install mariadb
   

2. Vérifiez l’installation :

   import mariadb
   print("The MariaDB library was installed successfully.")
   

S’il n’y a aucune erreur, l’installation a réussi.

Votre configuration d’environnement pour utiliser Python avec MariaDB est maintenant terminée. Ensuite, nous expliquerons comment se connecter à MariaDB depuis Python.

3. Connexion à MariaDB

Comment se connecter à MariaDB avec Python

Importer la bibliothèque requise

Pour se connecter à MariaDB, importez la bibliothèque Python mariadb.

import mariadb

Code de base pour se connecter à la base de données

Le code suivant montre la façon basique de se connecter à MariaDB en utilisant Python.

import mariadb

# Database connection settings
config = {
    "host": "localhost",   # Hostname of the MariaDB server
    "user": "root",        # MariaDB username
    "password": "password", # MariaDB password
    "database": "sample_db" # Database name to connect to
}

try:
    # Connect to MariaDB
    conn = mariadb.connect(**config)
    print("Connected to MariaDB!")

    # Créer un curseur
    cursor = conn.cursor()

    # Si la connexion réussit, fermez‑la
    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Connection error: {e}")

About the arguments of connect()

If the server is remote, specify an IP address or domain name in host.

A secure connection method using environment variables

Hardcoding sensitive information such as passwords directly in your code is a security risk. By using environment variables, you can manage them more safely.

Install python-dotenv

First, install a library to manage environment variables.

pip install python-dotenv

Create a .env file and write your connection settings

Create a .env file in your project folder and add your connection settings like this:

DB_HOST=localhost
DB_USER=root
DB_PASSWORD=password
DB_NAME=sample_db

Load environment variables in your Python script

To load the .env file in a Python script, write the following:

import mariadb
import os
from dotenv import load_dotenv

# Load the .env file
load_dotenv()

config = {
    "host": os.getenv("DB_HOST"),
    "user": os.getenv("DB_USER"),
    "password": os.getenv("DB_PASSWORD"),
    "database": os.getenv("DB_NAME")
}

try:
    conn = mariadb.connect(**config)
    print("Connected securely to MariaDB!")
    conn.close()
except mariadb.Error as e:
    print(f"Connection error: {e}")

Common connection errors and how to fix them

Below are some errors you may encounter when connecting Python to MariaDB, along with their solutions.

Access denied for user 'root'@'localhost'

Error message

mariadb.OperationalError: Access denied for user 'root'@'localhost' (using password: YES)

Causes

• The user’s credentials are incorrect
• MariaDB authentication settings are not configured properly

Solutions

1. Log in to MariaDB and check the user’s privileges.

   mysql -u root -p
   

2. Grant the required privileges to the user.

   GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;
   FLUSH PRIVILEGES;
   

3. Try connecting again.

Can't connect to MySQL server on 'localhost'

Error message

mariadb.OperationalError: Can't connect to MySQL server on 'localhost' (10061)

Causes

• The MariaDB server is not running
• The host setting is incorrect

Solutions

1. Check whether the server is running.

   sudo systemctl status mariadb
   

2. If the server is stopped, start it.

   sudo systemctl start mariadb
   

3. Check that the host setting is correct.

Summary

In this section, we explained how to connect to MariaDB from Python.

• Basic connection method using mariadb.connect()
• A secure connection method using a .env file
• Common connection errors and how to fix them

4. Creating Databases and Tables

Creating a database

In MariaDB, you need to create a database to store data. Let’s look at how to create a database using Python.

Create a database using a MariaDB management tool

You can create a database using the MariaDB command line (or GUI tools such as MySQL Workbench).

CREATE DATABASE sample_db;

To view the list of databases you created, use the following command:

SHOW DATABASES;

Create a database using Python

To create a database using Python, run the following code:

import mariadb

# Database connection (no database specified)
config = {
    "host": "localhost",
    "user": "root",
    "password": "password"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Create the database
    cursor.execute("CREATE DATABASE IF NOT EXISTS sample_db")

    print("Created database 'sample_db'.")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Erreur survenue : {e}")

By adding IF NOT EXISTS, you can prevent errors if a database with the same name already exists.

Creating a table

After creating the database, the next step is to create a table to store data.

Basic table structure

A table typically has a structure like the following:

Create a table with SQL

If you create a table using MariaDB SQL commands, write the following:

USE sample_db;

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

To view the list of tables, run:

SHOW TABLES;

Create a table using Python

Here is how to create the same table using a Python script.

import mariadb

# Connexion à la base de données
config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # SQL de création de table
    table_creation_query = """
    CREATE TABLE IF NOT EXISTS users (
        id INT AUTO_INCREMENT PRIMARY KEY,
        name VARCHAR(100) NOT NULL,
        email VARCHAR(100) UNIQUE NOT NULL,
        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
    )
    """

    cursor.execute(table_creation_query)
    print("Table 'users' créée.")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Erreur survenue : {e}")

By adding IF NOT EXISTS, you can prevent errors if the table already exists.

How to choose data types

When designing tables, it is important to choose appropriate data types. Below is a summary of commonly used data types in MariaDB.

For example, it is common to use VARCHAR(100) for the name field, but if you need a longer string, TEXT can be a good option.

How to check and drop existing tables

Check existing tables

To check the tables in a database, use the following SQL:

SHOW TABLES;

To view a table’s detailed structure, run the DESCRIBE command:

DESCRIBE users;

Drop a table

To drop a table, use DROP TABLE:

DROP TABLE users;

To drop a table from Python, run the following code:

cursor.execute("DROP TABLE IF EXISTS users")

Summary

In this section, we explained how to create databases and tables in MariaDB to store data.

• How to create a database in MariaDB
• How to create a table using Python
• How to choose appropriate data types
• How to check and drop existing tables

Now the basic setup for MariaDB is complete. In the next section, we will explain CRUD operations (Create, Read, Update, Delete) in detail.

5. CRUD Operations (Create, Read, Update, Delete)

After creating the MariaDB database and tables, the next step is to perform CRUD operations. CRUD stands for Create, Read, Update, and Delete, which are the basic operations of a database.

In this section, we will explain how to manipulate MariaDB data using Python.

Inserting data (INSERT)

To add a new record to the database, use the INSERT statement.

Insert data using SQL

To insert data using MariaDB SQL, execute the following command:

INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com');

To verify the inserted data, use the SELECT statement:

SELECT * FROM users;

Insert data using Python

To insert data using Python, run the following code:

import mariadb

# Paramètres de connexion à la base de données
config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Insérer des données
    insert_query = "INSERT INTO users (name, email) VALUES (?, ?)"
    data = ("Alice", "alice@example.com")
    cursor.execute(insert_query, data)

    # Enregistrer les modifications
    conn.commit()
    print("Données insérées avec succès !")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Une erreur s'est produite : {e}")

Key points:

• Using ? placeholders helps prevent SQL injection.
• If you do not execute conn.commit() , the data will not be saved to the database.

Retrieving data (SELECT)

To retrieve registered data, use the SELECT statement.

Retrieve data using SQL

To retrieve data using MariaDB SQL:

SELECT * FROM users;

To retrieve data with conditions, use the WHERE clause:

SELECT * FROM users WHERE email = 'alice@example.com';

Retrieve data using Python

To retrieve data using Python, run the following code:

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Récupérer les données
    select_query = "SELECT id, name, email FROM users"
    cursor.execute(select_query)

    # Afficher les données récupérées
    for (id, name, email) in cursor:
        print(f"ID: {id}, Name: {name}, Email: {email}")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Une erreur s'est produite : {e}")

Key points:

• Execute SQL with cursor.execute(select_query) and retrieve data from the cursor object.
• You can process records one by one using a for loop.

Updating data (UPDATE)

To modify registered data, use the UPDATE statement.

Update data using SQL

To update data using MariaDB SQL, execute:

UPDATE users SET name = 'Alice Smith' WHERE email = 'alice@example.com';

Update data using Python

To update data using Python, run the following code:

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Mettre à jour les données
    update_query = "UPDATE users SET name = ? WHERE email = ?"
    data = ("Alice Smith", "alice@example.com")
    cursor.execute(update_query, data)

    # Enregistrer les modifications
    conn.commit()
    print("Données mises à jour avec succès !")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Une erreur s'est produite : {e}")

Deleting data (DELETE)

To remove unnecessary data, use the DELETE statement.

Delete data using SQL

To delete data using MariaDB SQL, execute:

DELETE FROM users WHERE email = 'alice@example.com';

Delete data using Python

To delete data using Python, run the following code:

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Supprimer les données
    delete_query = "DELETE FROM users WHERE email = ?"
    data = ("alice@example.com",)
    cursor.execute(delete_query, data)

    # Enregistrer les modifications
    conn.commit()
    print("Données supprimées avec succès !")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Une erreur s'est produite : {e}")

Summary

In this section, we explained how to manipulate MariaDB data using Python.

• Insert data (INSERT)
• Retrieve data (SELECT)
• Update data (UPDATE)
• Delete data (DELETE)

You can now perform basic data operations in MariaDB using Python.

6. Transactions and Rollback (Ensuring Data Integrity)

Lorsqu’on travaille avec une base de données, il est important d’utiliser des transactions pour maintenir l’intégrité des données.
En particulier, la capacité de restaurer les données à leur état d’origine (rollback) lorsqu’une erreur survient pendant le traitement est essentielle pour maintenir la cohérence.

Dans cette section, nous expliquerons comment gérer les transactions dans MariaDB en utilisant Python.

Qu’est-ce qu’une transaction ?

Une transaction est un mécanisme qui regroupe une série d’opérations de base de données en une seule unité, valide toutes les modifications si chaque processus réussit, et annule toutes les modifications si une erreur survient.

Caractéristiques des transactions

• Propriétés ACID
• Atomicité : Toutes les opérations aboutissent soit avec succès, soit aucune n’est appliquée.
• Cohérence : L’intégrité des données est maintenue.
• Isolation : Les transactions concurrentes n’interfèrent pas les unes avec les autres.
• Durabilité : Une fois validées, les modifications sont enregistrées de façon permanente.

Opérations de base des transactions (COMMIT et ROLLBACK)

Les transactions MariaDB peuvent être contrôlées avec les commandes suivantes :

Utiliser les transactions en Python

Voici un exemple de base de gestion des transactions MariaDB en Python.

Gérer plusieurs opérations au sein d’une même transaction

Le code suivant traite plusieurs opérations d’insertion comme une seule transaction et ne valide que si toutes les opérations réussissent.

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Start transaction
    conn.start_transaction()

    # Insert data
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Bob", "bob@example.com"))
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Charlie", "charlie@example.com"))

    # Commit if all operations succeed
    conn.commit()
    print("Data added successfully.")

    cursor.close()
    conn.close()
except mariadb.Error as e:
    print(f"Error occurred: {e}")
    conn.rollback()  # Roll back if an error occurs

Points clés

• Utilisez conn.start_transaction() pour démarrer une transaction.
• Utilisez conn.commit() pour finaliser les modifications (impossible à annuler après validation).
• En cas d’erreur, utilisez conn.rollback() pour annuler les modifications et restaurer l’état d’origine.

Gestion des erreurs basée sur les transactions

Des erreurs peuvent survenir lors des opérations de base de données.
Par exemple, une adresse e‑mail dupliquée (violation de contrainte UNIQUE) ou un délai d’attente du serveur peuvent se produire.

Gestion des transactions avec gestion des erreurs

Le code suivant ajoute une logique pour annuler les modifications et restaurer l’état d’origine si une erreur survient pendant le traitement.

import mariadb

config = {
    "host": "localhost",
    "user": "root",
    "password": "password",
    "database": "sample_db"
}

try:
    conn = mariadb.connect(**config)
    cursor = conn.cursor()

    # Start transaction
    conn.start_transaction()

    try:
        # First insert succeeds
        cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Dave", "dave@example.com"))

        # Second insert causes an error (duplicate email)
        cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Eve", "dave@example.com"))

        # Commit if all operations succeed
        conn.commit()
        print("Data inserted successfully.")

    except mariadb.Error as e:
        print(f"Error occurred during data processing: {e}")
        conn.rollback()  # Roll back on error
        print("Transaction rolled back.")

    cursor.close()
    conn.close()

except mariadb.Error as e:
    print(f"Database connection error: {e}")

Résumé

Dans cette section, nous avons expliqué les bases des transactions et comment les implémenter en Python.

• L’importance des transactions et des propriétés ACID
• Comment utiliser commit() et rollback() en Python
• Gestion des transactions combinée à la gestion des erreurs

7. Gestion des erreurs (Erreurs courantes et solutions)

Lorsque vous travaillez avec MariaDB en Python, des erreurs peuvent survenir.
En particulier, les erreurs de connexion à la base de données, les erreurs de syntaxe SQL et les erreurs d’intégrité des données sont courantes, il est donc important de comprendre leurs causes et leurs solutions.

Dans cette section, nous présentons les causes des erreurs courantes et comment les corriger.

Access denied for user (Erreur d’authentification)

Message d’erreur

mariadb.OperationalError: Access denied for user 'root'@'localhost' (using password: YES)

Cause

• Le nom d’utilisateur ou le mot de passe est incorrect
• L’utilisateur MariaDB n’a pas les privilèges appropriés

Solution

1. Se connecter à MariaDB et vérifier les privilèges de l’utilisateur

   mysql -u root -p
   

2. Accorder les privilèges à l’utilisateur

   GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;
   FLUSH PRIVILEGES;
   

3. Redémarrer MariaDB

   sudo systemctl restart mariadb
   

Can't connect to MySQL server on 'localhost' (Erreur de connexion)

Message d’erreur

mariadb.OperationalError: Can't connect to MySQL server on 'localhost' (10061)

Cause

• Le serveur MariaDB n’est pas en cours d’exécution
• Le paramètre host est incorrect

Solution

1. Vérifier si le serveur MariaDB est en cours d’exécution

   sudo systemctl status mariadb
   

2. Si le serveur est arrêté, le démarrer

   sudo systemctl start mariadb
   

3. Activer le démarrage automatique du serveur

   sudo systemctl enable mariadb
   

Unknown database 'sample_db' (Base de données inexistante)

Message d’erreur

mariadb.ProgrammingError: Unknown database 'sample_db'

Cause

• La base de données spécifiée n’existe pas
• Il y a une faute de frappe dans le nom de la base de données

Solution

1. Vérifier la liste des bases de données

   SHOW DATABASES;
   

2. Créer la base de données si elle n’existe pas

   CREATE DATABASE sample_db;
   

Table doesn't exist (Table inexistante)

Message d’erreur

mariadb.ProgrammingError: Table 'sample_db.users' doesn't exist

Cause

• La table spécifiée n’existe pas
• La base de données n’a pas été sélectionnée avec USE sample_db;

Solution

1. Vérifier la liste des tables

   SHOW TABLES;
   

2. Créer la table si elle n’existe pas

   CREATE TABLE users (
       id INT AUTO_INCREMENT PRIMARY KEY,
       name VARCHAR(100) NOT NULL,
       email VARCHAR(100) UNIQUE NOT NULL,
       created_at DATETIME DEFAULT CURRENT_TIMESTAMP
   );
   

Duplicate entry (Erreur de données dupliquées)

Message d’erreur

mariadb.IntegrityError: Duplicate entry 'alice@example.com' for key 'users.email'

Cause

• La colonne email possède une contrainte UNIQUE, donc les valeurs dupliquées ne peuvent pas être insérées

Solution

• Vérifier les doublons avant d’insérer des données
• Utiliser ON DUPLICATE KEY UPDATE

Code Python pour éviter les doublons

try:
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice", "alice@example.com"))
    conn.commit()
except mariadb.IntegrityError:
    print("Error: The email address already exists.")

Ou utiliser ON DUPLICATE KEY UPDATE

INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com')
ON DUPLICATE KEY UPDATE name = 'Alice Updated';

Incorrect number of bindings (Mauvais nombre de liaisons)

Message d’erreur

mariadb.ProgrammingError: Incorrect number of bindings supplied. The current statement uses 2, and there are 1 supplied.

Cause

• Le nombre de paramètres requis par la requête SQL ne correspond pas au nombre d’arguments fournis

Solution

• Assurez-vous que le nombre de placeholders correspond au nombre de paramètres

Code incorrect

cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice"))

Code correct

cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice", "alice@example.com"))

Résumé

Dans cette section, nous avons expliqué les erreurs courantes qui surviennent lors de l’utilisation de MariaDB avec Python et comment les résoudre.

• Access denied for user (Erreur d’authentification)
• Can't connect to MySQL server (Erreur de connexion)
• Unknown database (Base de données inexistante)
• Table doesn't exist (Table inexistante)
• Duplicate entry (Erreur de données dupliquées)
• Incorrect number of bindings (Mauvais nombre de paramètres)

8. Conclusion

Dans cet article, nous avons expliqué comment travailler avec MariaDB en utilisant Python, des concepts de base aux sujets plus avancés.
En comprenant les opérations fondamentales de bases de données et en implémentant correctement la gestion des erreurs et des transactions, vous pouvez effectuer des opérations de données plus sûres et plus efficaces.

Récapitulatif de l’article

Configuration de l’environnement

• Comment installer MariaDB (Windows / Mac / Linux)
• Comment installer la bibliothèque de connecteur MariaDB (mariadb) pour Python

Connexion à MariaDB

• Méthodes de connexion de base à la base de données
• Connexions sécurisées utilisant des variables d’environnement
• Solutions aux erreurs de connexion courantes

Création de bases de données et de tables

• Création de bases de données (SQL / Python)
• Création de tables et choix des types de données
• Vérification et suppression des tables existantes

Opérations CRUD (Créer, Lire, Mettre à jour, Supprimer)

• Opérations de données de base avec Python
• Utilisation de paramètres pour prévenir les injections SQL
• Gestion correcte des erreurs

Transactions et rollback

• L’importance des transactions (propriétés ACID)
• Comment restaurer les données en cas d’erreur (rollback)
• Gestion manuelle des transactions en désactivant AutoCommit

Gestion des erreurs (Erreurs courantes et solutions)

• Erreurs d’authentification (Access denied for user)
• Erreurs de connexion (Can't connect to MySQL server)
• Erreurs de base de données ou de table non trouvée
• Erreurs de données dupliquées (Duplicate entry)
• Gestion des interblocages et mise en œuvre d’une logique de nouvelle tentative

Points clés lors de la combinaison de Python et MariaDB

1. Utiliser des paramètres

   cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("Alice", "alice@example.com"))
   

→ Liez des variables au lieu de les intégrer directement dans les requêtes SQL afin de prévenir les injections SQL.

2. Gérer correctement les transactions

• Utilisez conn.commit() pour valider explicitement les modifications .
• Utilisez conn.rollback() en cas d’erreur pour maintenir l’intégrité des données .

3. Mettre en œuvre une gestion d’erreurs complète

• Utilisez des blocs try-except pour capturer les erreurs potentielles à l’avance .
• Préparez des stratégies de gestion spécifiques pour des erreurs telles que OperationalError et IntegrityError .

4. Considérer les performances

• Insertions en masse (insérer plusieurs enregistrements à la fois)
• Indexation appropriée (améliorer les performances de recherche)

Ressources pour aller plus loin

Si vous souhaitez approfondir votre compréhension de l’intégration de Python et MariaDB, consultez les ressources suivantes :

Documentation officielle

• MariaDB Official Documentation

Contenu d’apprentissage associé

• SQL Basics (W3Schools)
• Database Operations with Python (Real Python)

Livres recommandés

• SQL, 2nd Edition: Database Operations from Scratch – Apprenez les fondamentaux de SQL en profondeur
• Effective Python: 90 Specific Ways to Improve Your Python Programs – Apprenez les meilleures pratiques Python

Résumé

En intégrant MariaDB avec Python, vous pouvez activer la gestion de données par script et l’automatisation.
En implémentant non seulement les opérations CRUD de base mais aussi une gestion correcte des erreurs et des transactions, vous pouvez créer un système plus sûr et plus efficace.

Comme prochaine étape, envisagez d’apprendre la gestion efficace des données et l’intégration d’API pour appliquer vos connaissances aux opérations de base de données pratiques.