Cas pratique - Nettoyage d'un fichier CSV avec SQL

1. Introduction

Les données brutes sont rarement exploitables directement. Avant toute analyse ou modélisation, une étape de nettoyage est indispensable : suppression des doublons, traitement des valeurs manquantes, standardisation des formats, correction des incohérences.

Dans ce cas pratique, nous allons nettoyer un dataset de ventes de 63 000 lignes généré aléatoirement avec Faker. Les problèmes sont variés et réalistes : doublons, valeurs manquantes, dates mal formatées, paiements non standardisés, quantités aberrantes, prix à zéro, et incohérences de calcul.

Figure 1 : Le dataset brut contient 63 000 lignes.

3. Environnement technique

Pour ce cas pratique, nous utilisons :

• SQLite : base de données légère, sans installation serveur
• DB Browser for SQLite : interface graphique pour exécuter les requêtes
• Fichier unique : `sales_cleaning.db` – portable et reproductible

Figure 4 : Import du fichier CSV dans DB Browser.

DELETE FROM raw_sales WHERE Transaction_ID = 'Transaction_ID';

4. Inspection initiale des données

4.1 Comptage des lignes

SELECT COUNT(*) FROM raw_sales;

Résultat : 63 000 lignes

4.2 Structure des colonnes

PRAGMA table_info(raw_sales);

Observation : La colonne `Quantity` est au format TEXT au lieu de INTEGER – à corriger.

4.3 Identification des problèmes

Valeurs manquantes :

• Customer_Email : 2 845 NULL (~4,5%)
• Product_Category : 908 NULL (~1,4%)
• Quantity : 1 711 NULL (~2,7%)
• Unit_Price : 2 915 NULL (~4,6%)

Dates incohérentes : mélange de YYYY-MM-DD, YYYY/MM/DD, MM-DD-YYYY, et même du texte (“Jan 2024 (approx)”).

Payment_Method : 9 valeurs distinctes (“Credit Card”, “cc”, “PayPal”, “ppal”, etc.) – à standardiser.

Casse et espaces : “HOME GOODS”, “Home Goods”, “home goods” – à uniformiser.

Quantités aberrantes : valeurs négatives (-1) et absurdes (9999).

Prix à zéro : 20 lignes avec Unit_Price = 0 (à corriger).

Incohérence Total_Amount : 11 059 lignes où Total_Amount ≠ Quantity × Unit_Price.

5. Nettoyage des données

5.1 Création d’une table de travail

CREATE TABLE clean_sales AS SELECT * FROM raw_sales;

5.2 Correction des types de données

CREATE TABLE clean_sales_fixed AS
SELECT 
    Transaction_ID,
    Sale_Date,
    Customer_ID,
    Customer_Email,
    Product_Category,
    Product_Name,
    CAST(Quantity AS INTEGER) AS Quantity,
    Unit_Price,
    Total_Amount,
    Store_Location,
    Payment_Method
FROM clean_sales;

DROP TABLE clean_sales;
ALTER TABLE clean_sales_fixed RENAME TO clean_sales;

5.3 Suppression des doublons

DELETE FROM clean_sales
WHERE rowid NOT IN (
    SELECT MIN(rowid) 
    FROM clean_sales 
    GROUP BY Transaction_ID, Sale_Date, Customer_ID, Customer_Email, 
             Product_Category, Product_Name, Quantity, Unit_Price, 
             Total_Amount, Store_Location, Payment_Method
);

Résultat : 167 doublons supprimés.

5.4 Standardisation des dates

ALTER TABLE clean_sales ADD COLUMN Sale_Date_Clean TEXT;

UPDATE clean_sales 
SET Sale_Date_Clean = SUBSTR(Sale_Date, 1, 10)
WHERE Sale_Date GLOB '*-*-*' AND LENGTH(Sale_Date) = 10;

UPDATE clean_sales 
SET Sale_Date_Clean = Sale_Date
WHERE Sale_Date_Clean IS NULL;

5.5 Nettoyage du texte (UPPER + TRIM)

UPDATE clean_sales SET Product_Category = UPPER(TRIM(Product_Category));
UPDATE clean_sales SET Store_Location = UPPER(TRIM(Store_Location));

5.6 Standardisation des méthodes de paiement

UPDATE clean_sales 
SET Payment_Method = CASE 
    WHEN Payment_Method IN ('Credit Card', 'cc') THEN 'Credit Card'
    WHEN Payment_Method IN ('PayPal', 'ppal') THEN 'PayPal'
    WHEN Payment_Method IN ('Debit Card', 'debit') THEN 'Debit Card'
    WHEN Payment_Method IS NULL THEN 'Unknown'
    ELSE Payment_Method
END;

5.7 Correction des quantités aberrantes

UPDATE clean_sales SET Quantity = NULL WHERE Quantity < 0 OR Quantity > 1000;

5.8 Correction des prix à zéro

UPDATE clean_sales SET Unit_Price = NULL WHERE Unit_Price = 0;

Résultat : 20 lignes corrigées.

5.9 Imputation des valeurs manquantes

Imputation de Quantity (médiane)

UPDATE clean_sales 
SET Quantity = (
    SELECT AVG(Quantity) 
    FROM (
        SELECT Quantity 
        FROM clean_sales 
        WHERE Quantity IS NOT NULL 
        ORDER BY Quantity 
        LIMIT 2 - (SELECT COUNT(*) FROM clean_sales WHERE Quantity IS NOT NULL) % 2 
        OFFSET (SELECT (COUNT(*) - 1) / 2 FROM clean_sales WHERE Quantity IS NOT NULL)
    )
) 
WHERE Quantity IS NULL;

Imputation de Unit_Price (moyenne)

UPDATE clean_sales 
SET Unit_Price = (SELECT AVG(Unit_Price) FROM clean_sales WHERE Unit_Price IS NOT NULL)
WHERE Unit_Price IS NULL;

Résultat : 2 935 lignes imputées.

5.10 Recalcul de Total_Amount

UPDATE clean_sales 
SET Total_Amount = Quantity * Unit_Price 
WHERE Total_Amount != Quantity * Unit_Price;

Résultat : 15 445 lignes recalculées.

6. Vérification finale

SELECT 
    COUNT(CASE WHEN Customer_Email IS NULL THEN 1 END) AS missing_email,
    COUNT(CASE WHEN Quantity IS NULL THEN 1 END) AS missing_quantity,
    COUNT(CASE WHEN Unit_Price IS NULL THEN 1 END) AS missing_price
FROM clean_sales;

7. Export du dataset propre

-- Dans DB Browser : Fichier → Exporter → Table(s) CSV
-- Ou via SQLite CLI :
.headers on
.mode csv
.output clean_sales_data.csv
SELECT * FROM clean_sales;

Télécharger le dataset nettoyé clean_sales_data.csv (7.64 Mo)

Fichier SQLite sales_cleaning.db (22.81 Mo)

8. Bonnes pratiques à retenir

10. Conclusion

Ce cas pratique montre comment SQL permet de nettoyer efficacement un dataset de taille réelle (63 000 lignes) avec des problèmes variés. En une vingtaine de requêtes, nous avons :

• Supprimé 167 doublons
• Corrigé les types de données
• Traité 2 845 emails manquants
• Imputé 1 711 quantités et 2 915 prix unitaires
• Standardisé 62 833 catégories et localisations
• Unifié 9 méthodes de paiement en 4 catégories
• Recalculé 15 445 montants totaux incohérents

11. Articles connexes