Supprimer une table MySQL avec Python (mysql-connector-python)

Supprimer une table l'efface définitivement — ainsi que toutes ses lignes et ses index — de la base de données MySQL. Cette page vous montre comment exécuter DROP TABLE en toute sécurité depuis Python à l'aide de la bibliothèque mysql-connector-python, explique la différence entre DROP TABLE et TRUNCATE TABLE, et aborde les pièges courants tels que les contraintes de clés étrangères et les suppressions accidentelles en production.

Prérequis

Avant d'exécuter les exemples, vous aurez besoin de :

Serveur MySQL en cours d'exécution localement ou à distance
Python 3.8+ avec mysql-connector-python installé :
```
pip install mysql-connector-python
```
Une base de données et un utilisateur disposant du privilège DROP sur cette base de données

Si vous n'avez pas encore connecté Python à MySQL, consultez d'abord MySQL Get Started. Pour comprendre comment créer la table que vous allez supprimer, consultez MySQL Create Table.

DROP TABLE vs TRUNCATE TABLE

Avant d'écrire du code, choisissez la bonne commande :

Commande	Supprime les lignes	Supprime la structure	Auto-commit	Réinitialise AUTO_INCREMENT
`DROP TABLE`	Oui	Oui	Oui (DDL)	N/A — la table est supprimée
`TRUNCATE TABLE`	Oui	Non	Oui (DDL)	Oui
`DELETE FROM`	Oui	Non	Non (DML, nécessite un commit)	Non

Utilisez DROP TABLE lorsque vous souhaitez supprimer entièrement la table — la définition du schéma disparaît avec les données. Utilisez TRUNCATE TABLE lorsque vous souhaitez conserver la structure de la table mais vider toutes les lignes rapidement. Utilisez DELETE FROM lorsque vous souhaitez un contrôle au niveau des lignes avec la possibilité d'annuler l'opération.

Basique : Supprimer une table

Le schéma minimal se connecte à MySQL, crée un curseur et exécute DROP TABLE IF EXISTS :

import mysql.connector
from mysql.connector import Error

try:
    connection = mysql.connector.connect(
        host="localhost",
        database="testdb",
        user="your_username",
        password="your_password"
    )

    if connection.is_connected():
        cursor = connection.cursor()
        cursor.execute("DROP TABLE IF EXISTS customers")
        print("Table 'customers' dropped successfully")

except Error as e:
    print(f"Error: {e}")

finally:
    if connection and connection.is_connected():
        cursor.close()
        connection.close()
        print("MySQL connection closed")

Pourquoi IF EXISTS ? Sans lui, MySQL lève une erreur si la table n'existe pas (Table 'testdb.customers' doesn't exist). En ajoutant IF EXISTS, l'opération est simplement ignorée — plus sûr dans les scripts qui peuvent s'exécuter plusieurs fois.

Auto-commit DDL. DROP TABLE est une instruction DDL (Data Definition Language). MySQL valide automatiquement les DDL, vous n'avez donc pas besoin d'appeler connection.commit() après.

Supprimer une table uniquement si elle existe (vérification préalable)

IF EXISTS est l'approche la plus simple, mais parfois vous devez journaliser si la table était réellement présente avant de la supprimer. Interrogez information_schema.tables pour vérifier :

import mysql.connector
from mysql.connector import Error

def table_exists(cursor, database, table):
    query = """
        SELECT COUNT(*)
        FROM information_schema.tables
        WHERE table_schema = %s
        AND table_name = %s
    """
    cursor.execute(query, (database, table))
    return cursor.fetchone()[0] == 1

try:
    connection = mysql.connector.connect(
        host="localhost",
        database="testdb",
        user="your_username",
        password="your_password"
    )

    if connection.is_connected():
        cursor = connection.cursor()
        db_name = "testdb"
        table_name = "customers"

        if table_exists(cursor, db_name, table_name):
            cursor.execute(f"DROP TABLE `{table_name}`")
            print(f"Table '{table_name}' dropped.")
        else:
            print(f"Table '{table_name}' does not exist — nothing to drop.")

except Error as e:
    print(f"Error: {e}")

finally:
    if connection and connection.is_connected():
        cursor.close()
        connection.close()

Notez que les backticks autour du nom de la table protègent contre les collisions avec les mots réservés et les noms contenant des espaces.

Supprimer plusieurs tables

Pour supprimer plusieurs tables à la fois, passez une liste séparée par des virgules à MySQL ou effectuez une boucle en Python :

Option 1 — Instruction SQL unique

cursor.execute("DROP TABLE IF EXISTS orders, order_items, customers")
print("All three tables dropped")

MySQL supprime les tables en un seul aller-retour. L'ordre n'a pas d'importance lorsque les vérifications de clés étrangères sont désactivées, mais si les clés sont actives, MySQL applique l'intégrité référentielle (voir la section sur les clés étrangères ci-dessous).

Option 2 — Boucle en Python

tables_to_drop = ["order_items", "orders", "customers"]

for table in tables_to_drop:
    cursor.execute(f"DROP TABLE IF EXISTS `{table}`")
    print(f"Dropped: {table}")

La boucle est utile lorsque la liste des tables est construite dynamiquement à l'exécution.

Gestion des contraintes de clés étrangères

Si la table orders possède une clé étrangère qui référence customers, supprimer customers en premier lève l'erreur suivante :

mysql.connector.errors.IntegrityError: 1217 (23000): Cannot delete or update a parent row: a foreign key constraint fails

Vous avez deux options :

Option A — Supprimer d'abord les tables enfants

# Drop the referencing table before the referenced table
cursor.execute("DROP TABLE IF EXISTS orders")
cursor.execute("DROP TABLE IF EXISTS customers")

Option B — Désactiver temporairement les vérifications de clés étrangères

cursor.execute("SET FOREIGN_KEY_CHECKS = 0")
cursor.execute("DROP TABLE IF EXISTS customers")
cursor.execute("DROP TABLE IF EXISTS orders")
cursor.execute("SET FOREIGN_KEY_CHECKS = 1")
print("Tables dropped with FK checks disabled")

Réactivez FOREIGN_KEY_CHECKS immédiatement après la suppression. Le laisser désactivé peut corrompre silencieusement l'intégrité référentielle tout au long de la session.

TRUNCATE TABLE : Supprimer toutes les lignes mais conserver la structure

Si vous souhaitez uniquement vider une table plutôt que la supprimer entièrement, utilisez TRUNCATE TABLE :

cursor.execute("TRUNCATE TABLE logs")
print("All rows deleted; table 'logs' still exists")

TRUNCATE TABLE est bien plus rapide que DELETE FROM sur les grandes tables, car il libère directement les pages de données plutôt que de supprimer ligne par ligne. Comme DROP TABLE, c'est du DDL qui valide automatiquement.

Exemple complet et autonome

Le script suivant crée une table de test, vérifie qu'elle existe, la supprime et confirme sa disparition — illustrant le cycle de vie complet en un seul endroit :

import mysql.connector
from mysql.connector import Error

DB_CONFIG = {
    "host": "localhost",
    "database": "testdb",
    "user": "your_username",
    "password": "your_password",
}

def table_exists(cursor, table):
    cursor.execute(
        "SELECT COUNT(*) FROM information_schema.tables "
        "WHERE table_schema = DATABASE() AND table_name = %s",
        (table,)
    )
    return cursor.fetchone()[0] == 1

def main():
    connection = None
    try:
        connection = mysql.connector.connect(**DB_CONFIG)
        cursor = connection.cursor()

        # 1. Create a test table
        cursor.execute(
            "CREATE TABLE IF NOT EXISTS temp_demo "
            "(id INT AUTO_INCREMENT PRIMARY KEY, note VARCHAR(100))"
        )
        print("Created table: temp_demo")

        # 2. Verify it exists
        if table_exists(cursor, "temp_demo"):
            print("Confirmed: temp_demo exists")

        # 3. Drop the table
        cursor.execute("DROP TABLE IF EXISTS temp_demo")
        print("Dropped table: temp_demo")

        # 4. Confirm it is gone
        if not table_exists(cursor, "temp_demo"):
            print("Confirmed: temp_demo no longer exists")

    except Error as e:
        print(f"MySQL error: {e}")

    finally:
        if connection and connection.is_connected():
            cursor.close()
            connection.close()
            print("Connection closed")

if __name__ == "__main__":
    main()

Sortie attendue (en supposant que la base de données et les identifiants sont corrects) :

Created table: temp_demo
Confirmed: temp_demo exists
Dropped table: temp_demo
Confirmed: temp_demo no longer exists
Connection closed

Conseils de sécurité en production

Un DROP TABLE accidentel en production est l'une des erreurs de base de données les plus courantes (et les plus douloureuses). Suivez ces bonnes pratiques :

Ne jamais interpoler les entrées utilisateur directement dans les instructions DROP TABLE. Utilisez toujours une liste d'autorisations de noms de tables connus.
Faites une sauvegarde avant de supprimer. Même un mysqldump rapide de la table est une assurance bon marché.
Utilisez IF EXISTS dans les scripts qui s'exécutent dans les pipelines CI/CD — l'idempotence évite les échecs lors des ré-exécutions.
Restreignez le privilège DROP en production. Les comptes de service applicatifs en ont rarement besoin ; accordez-le uniquement aux utilisateurs de migration.
Testez avec un essai à blanc. Journalisez le SQL qui serait exécuté sans l'exécuter réellement, confirmez qu'il est correct, puis exécutez-le.

Pages associées

MySQL Get Started — installer et se connecter
MySQL Create Table — définir les schémas de tables
MySQL Create Database — gérer les bases de données
MySQL Delete — supprimer des lignes individuelles plutôt que toute la table
MySQL Update — modifier des lignes existantes