Du Navigateur à la Base de Données : Le Chemin le Plus Court pour les Tableaux Web

Vous avez trouvé des données sur un site web. Vous en avez besoin dans votre base de données.

Quel est le chemin le plus rapide du point A au point B ?

Ce guide couvre les workflows pratiques pour importer des tableaux HTML dans SQLite, PostgreSQL, MySQL et d'autres bases de données — avec un minimum de friction.

Le Workflow Général

Chaque pipeline navigateur-vers-base-de-données suit les mêmes étapes :

1. Extraire — Sortir le tableau de la page web
2. Nettoyer — Corriger le formatage, les types et la structure
3. Charger — Insérer dans la base de données

La question est où effectuer chaque étape et avec quels outils.

Chemin 1 : Le CSV Comme Intermédiaire

L'approche la plus courante. Fonctionne avec n'importe quelle base de données.

Étape 1 : Exporter en CSV

Utilisez une extension de navigateur comme HTML Table Exporter ou copiez-collez dans un tableur et enregistrez en CSV.

Point clé : Le choix du délimiteur. Les virgules fonctionnent sauf si vos données contiennent des virgules. Les points-virgules ou les tabulations sont plus sûrs pour les données complexes.

Étape 2 : Charger dans la Base de Données

SQLite :

sqlite3 mydb.db
.mode csv
.import data.csv tablename

Ou avec les en-têtes :

sqlite3 mydb.db <<EOF
.mode csv
.headers on
.import data.csv tablename
EOF

PostgreSQL :

COPY tablename FROM '/path/to/data.csv' 
WITH (FORMAT csv, HEADER true);

Ou avec psql :

\copy tablename FROM 'data.csv' WITH (FORMAT csv, HEADER true);

MySQL :

LOAD DATA INFILE '/path/to/data.csv'
INTO TABLE tablename
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY '\n'
IGNORE 1 ROWS;

Avantages et Inconvénients

✅ Compatibilité universelle

✅ Fichier intermédiaire facile à inspecter

✅ Possibilité de corriger manuellement avant le chargement

❌ Étape supplémentaire

❌ Inférence de types basique

Chemin 2 : Directement en Requêtes SQL

Exporter le tableau directement sous forme de requêtes INSERT.

Exporter en SQL

Certains outils d'export génèrent du SQL directement. Le résultat ressemble à :

INSERT INTO table_name (col1, col2, col3) VALUES
('valeur1', 'valeur2', 123),
('valeur4', 'valeur5', 456);

Charger

Il suffit d'exécuter le fichier SQL :

# SQLite
sqlite3 mydb.db < data.sql

# PostgreSQL
psql -d mydb -f data.sql

# MySQL
mysql mydb < data.sql

Avantages et Inconvénients

✅ Une seule étape de l'export à la base de données

✅ Le SQL est portable entre les bases (en grande partie)

❌ Grands jeux de données = fichiers SQL volumineux

❌ Nécessite de définir le schéma de table au préalable

Chemin 3 : Pipeline Python + Pandas

Flexibilité maximale. Idéal pour les imports répétés ou le nettoyage complexe.

Workflow Complet

import pandas as pd
from sqlalchemy import create_engine

# Étape 1 : Charger le CSV (exporté depuis le navigateur)
df = pd.read_csv('data.csv')

# Étape 2 : Nettoyer
df.columns = df.columns.str.lower().str.replace(' ', '_')  # Normaliser les noms de colonnes
df['date'] = pd.to_datetime(df['date'])  # Parser les dates
df['amount'] = df['amount'].str.replace('[$,]', '', regex=True).astype(float)  # Nettoyer les devises

# Étape 3 : Charger dans la base de données
engine = create_engine('sqlite:///mydb.db')
# Ou : create_engine('postgresql://user:pass@localhost/mydb')
# Ou : create_engine('mysql+pymysql://user:pass@localhost/mydb')

df.to_sql('tablename', engine, if_exists='replace', index=False)

Correspondance des Types

Pandas infère les types, mais vous pouvez être explicite :

df.to_sql('tablename', engine, 
          if_exists='replace', 
          index=False,
          dtype={
              'id': Integer(),
              'name': String(100),
              'created_at': DateTime(),
              'amount': Float()
          })

Avantages et Inconvénients

✅ Contrôle total sur le nettoyage et les types

✅ Gère les transformations complexes

✅ Reproductible et scriptable

❌ Nécessite un environnement Python

❌ Excessif pour les imports ponctuels

Chemin 4 : DuckDB (Le Raccourci Moderne)

DuckDB lit les CSV directement et gère la plupart du nettoyage automatiquement.

Requête Directe

-- Requêter un CSV sans l'importer
SELECT * FROM 'data.csv';

-- Avec inférence de types
SELECT * FROM read_csv_auto('data.csv');

-- Créer une table à partir d'un CSV
CREATE TABLE mytable AS SELECT * FROM 'data.csv';

Du Navigateur à la Requête en Quelques Secondes

# Exporter le tableau en CSV depuis le navigateur
# Puis requêter immédiatement :
duckdb -c "SELECT column1, SUM(column2) FROM 'data.csv' GROUP BY column1;"

Pas de définition de schéma. Pas d'étape d'import. Juste une requête.

Avantages et Inconvénients

✅ Le plus rapide pour l'analyse ad-hoc

✅ Excellente inférence de types

✅ Interface SQL

❌ Pas une base de données traditionnelle (pour la persistance, exporter les résultats)

Gérer les Problèmes Courants

Noms de Colonnes avec Espaces

Les tableaux web ont souvent des en-têtes comme « Total Ventes » ou « Cumul Annuel ».

Corriger à l'export : Certains outils normalisent les en-têtes automatiquement.

Corriger à l'import :

df.columns = df.columns.str.replace(' ', '_').str.lower()

Ou en SQL après l'import :

ALTER TABLE mytable RENAME COLUMN "Total Sales" TO total_sales;

Formats de Nombres Mixtes

Les formats européen (1.234,56) vs américain (1,234.56) cassent les imports.

Corriger avant l'import : Utilisez un outil avec des préréglages de nettoyage, ou :

# Européen vers standard
df['value'] = df['value'].str.replace('.', '').str.replace(',', '.').astype(float)

Représentations de Valeurs Nulles

Les tableaux web affichent des blancs, « N/A », « — », « - » pour les données manquantes.

df = df.replace(['N/A', '—', '-', ''], pd.NA)

Ou dans DuckDB :

SELECT NULLIF(column, 'N/A') AS column FROM 'data.csv';

Dates dans Divers Formats

df['date'] = pd.to_datetime(df['date'], format='mixed', dayfirst=True)

Le paramètre format='mixed' gère les formats de dates incohérents dans la même colonne.

Choisir le Bon Chemin

Scénario	Chemin Recommandé
Import ponctuel, petit tableau	CSV + import direct dans la base
Import ponctuel, nécessite du nettoyage	Python + Pandas
Analyse rapide, pas de persistance nécessaire	DuckDB
Imports réguliers depuis la même source	Script Python (automatiser)
Besoin du format SQL pour partage/versioning	Export SQL direct

Exemple : Workflow Complet

Imaginons que vous avez un tableau de données produits sur un site web.

Étape 1 : Exporter avec HTML Table Exporter → CSV avec nombres nettoyés

Étape 2 : Validation rapide dans DuckDB :

SELECT COUNT(*), COUNT(DISTINCT product_id) FROM 'products.csv';
-- Vérifier les doublons

Étape 3 : Charger dans PostgreSQL :

import pandas as pd
from sqlalchemy import create_engine

df = pd.read_csv('products.csv')
engine = create_engine('postgresql://user:pass@localhost/inventory')
df.to_sql('products', engine, if_exists='replace', index=False)

Temps total : 2 minutes.

La Leçon à Retenir

Le chemin le plus court n'est pas toujours le plus direct.

Passer 30 secondes à nettoyer lors de l'export économise 10 minutes de débogage d'erreurs d'import. Utiliser le bon format intermédiaire (CSV vs SQL vs JSON) dépend de votre base de données cible et de la complexité des données.

Pour la plupart des workflows tableau web → base de données :

1. Exporter en CSV avec nettoyage des nombres/dates
2. Charger avec l'import CSV natif de votre base de données
3. N'utiliser Python que si vous avez besoin de transformations complexes

Les pipelines simples sont des pipelines maintenables.

Pour les workflows Python spécifiquement, consultez notre guide sur les meilleures extensions Chrome pour exporter des tableaux.

---

Besoin d'exports propres et prêts pour la base de données ? En savoir plus sur gauchogrid.com/fr/html-table-exporter ou essayez HTML Table Exporter gratuitement sur le Chrome Web Store.