← Blog
Un petit meuble lavande à deux tiroirs crème avec une poignée orange sur fond clair.
Publié le
2026-11-16

DuckDB ou SQLite : quelle base choisir ?

Évaluez d’abord SQLite pour l’état local d’une application, les petites transactions et une base qui accompagne l’application. Évaluez d’abord DuckDB pour les lectures analytiques, les jointures et les agrégations portant sur une part importante d’un jeu de données. Les deux savent stocker des tables, modifier des enregistrements et exécuter du SQL. La comparaison utile part de votre charge et de la manière dont les processus accèdent aux données.

Ce guide propose un petit exemple Python qui effectue des opérations équivalentes dans les deux moteurs. Il a passé 16 tests locaux sous Windows avec CPython 3.12.14, SQLite 3.53.1 et DuckDB 2.0.0. Ce sont des contrôles de comportement, pas un classement de performances, un test de concurrence ou un benchmark de VM Hivenet.

DuckDB ou SQLite : les points de comparaison

QuestionSQLiteDuckDB
Pour quel besoin commencer l’évaluation ?État local d’une application et mises à jour transactionnellesRequêtes analytiques et transformations par lots
Comment cet exemple s’exécute-t-il ?Dans le processus PythonDans le processus Python
Peut-il modifier une ligne et agréger une table ?OuiOui
Quelles règles de typage l’exemple utilise-t-il ?Une table STRICT avec des montants INTEGERUne table typée avec des montants BIGINT
Que faut-il décider séparément ?Écritures concurrentes, sauvegardes, accès et stockageOrganisation des processus d’écriture, sauvegardes, accès et stockage
Ce guide désigne-t-il le moteur le plus rapide ?NonNon

La conception de DuckDB privilégie les charges analytiques et l’exécution vectorisée orientée colonnes. Les cas d’usage de SQLite comprennent le stockage applicatif et l’analyse de données. Ce sont des points de départ pour l’évaluation, pas une règle interdisant l’analyse avec SQLite ou la modification d’un enregistrement avec DuckDB.

Choisir selon l’application, pas l’extension du fichier

Un récepteur de webhooks peut devoir rechercher un identifiant d’événement, enregistrer une requête acceptée et mettre à jour un statut de traitement. Un rapport nocturne peut devoir parcourir des millions d’événements, joindre des tables de référence et calculer des totaux. Les deux utilisent SQL, mais leurs requêtes, leur fréquence d’écriture et leurs besoins de reprise diffèrent.

Notre guide de webhooks Python utilise SQLite comme petit stockage persistant d’événements. Il illustre un état applicatif, pas un benchmark analytique. Avant de reprendre cette organisation, définissez combien de processus écrivent, combien de temps les transactions restent ouvertes et ce qui arrive lorsqu’une requête est répétée.

Une équipe peut conserver l’état opérationnel dans un stockage et analyser une copie cohérente ailleurs. Dans ce cas, définissez le périmètre de la copie, le délai acceptable, le traitement des suppressions et les contrôles de rapprochement. Une deuxième base ajoute une copie à exploiter ; elle ne simplifie pas automatiquement le système.

Exécuter les mêmes opérations dans les deux moteurs

Utilisez Python 3.12 avec son module sqlite3, puis installez dans votre environnement de projet la version de DuckDB testée ici. La documentation Python de DuckDB exige Python 3.11 ou une version ultérieure. La bibliothèque SQLite fournie avec Python peut varier ; vérifiez sqlite3.sqlite_version. Cet exemple exige SQLite 3.37 ou une version ultérieure pour les tables STRICT.

python -m pip install duckdb==2.0.0

Enregistrez le code suivant dans compare_engines.py. Il crée deux bases temporaires privées, insère six commandes, valide une modification, en annule une autre, puis revérifie les résultats après fermeture et réouverture de chaque fichier. Les montants de ce petit jeu de test sont des centimes entiers ; un montant inconnu reste distinct de zéro. Le programme n’ouvre aucune base métier existante.

"""Compare correctness on isolated local databases, not query speed."""
from contextlib import contextmanager
from pathlib import Path
import sqlite3
from tempfile import TemporaryDirectory
import duckdb

ROWS = [
    ("001", "books", 1200, "café"),
    ("002", "books", 800, None),
    ("003", "tools", 3000, ""),
    ("004", "tools", None, "awaiting price"),
    ("005", "books", 0, "promo"),
    ("006", "tools", 1500, "Zürich"),
]


def connect(engine, path):
    if engine == "sqlite":
        # Explicit SQL BEGIN/COMMIT/ROLLBACK, without implicit transactions.
        return sqlite3.connect(path, isolation_level=None)
    if engine == "duckdb":
        return duckdb.connect(str(path))
    raise ValueError("unknown engine")


@contextmanager
def transaction(con):
    con.execute("BEGIN")
    try:
        yield
    except BaseException:
        con.execute("ROLLBACK")
        raise
    else:
        con.execute("COMMIT")


def initialize(con, engine):
    amount_type = "INTEGER" if engine == "sqlite" else "BIGINT"
    suffix = " STRICT" if engine == "sqlite" else ""
    # Both SQL fragments above are constants selected by the program.
    with transaction(con):
        con.execute(f"""CREATE TABLE orders (
            id TEXT PRIMARY KEY NOT NULL,
            category TEXT NOT NULL,
            amount_cents {amount_type} CHECK (amount_cents >= 0),
            note TEXT
        ){suffix}""")
        con.executemany("INSERT INTO orders VALUES (?, ?, ?, ?)", ROWS)


def snapshot(con):
    rows = con.execute(
        "SELECT id, category, amount_cents, note FROM orders ORDER BY id"
    ).fetchall()
    totals = con.execute("""
        SELECT category, COUNT(*), COUNT(amount_cents), SUM(amount_cents)
        FROM orders GROUP BY category ORDER BY category
    """).fetchall()
    return {"rows": rows, "totals": totals}


def run_database(engine, path):
    # This local demo is intended for a fresh, privately owned temporary path.
    if Path(path).exists():
        raise FileExistsError(path)
    con = connect(engine, path)
    try:
        initialize(con, engine)
        with transaction(con):
            con.execute("UPDATE orders SET amount_cents = ? WHERE id = ?",
                        (3500, "003"))
        con.execute("BEGIN")
        con.execute("UPDATE orders SET amount_cents = ? WHERE id = ?",
                    (999999, "001"))
        con.execute("ROLLBACK")
        before_close = snapshot(con)
    finally:
        con.close()
    reopened = connect(engine, path)
    try:
        after_reopen = snapshot(reopened)
        assert after_reopen == before_close
        return after_reopen
    finally:
        reopened.close()


def main():
    with TemporaryDirectory() as directory:
        root = Path(directory)
        sqlite_result = run_database("sqlite", root / "orders.sqlite")
        duckdb_result = run_database("duckdb", root / "orders.duckdb")
        assert sqlite_result == duckdb_result
        expected_rows = [r if r[0] != "003" else
                         ("003", "tools", 3500, "") for r in ROWS]
        assert sqlite_result["rows"] == expected_rows
        assert sqlite_result["totals"] == [
            ("books", 3, 3, 2000), ("tools", 3, 2, 5000)]
        print("SQLite and DuckDB results match")
        print("Rows after reopen:", len(sqlite_result["rows"]))
        print("Committed update (003): 3500 cents")
        print("Rolled-back update (001): 1200 cents")
        for category, count, priced, total in sqlite_result["totals"]:
            print(f"{category}: rows={count}, priced={priced}, total={total} cents")


if __name__ == "__main__":
    main()

Lancez-le :

python compare_engines.py

Sortie attendue :

SQLite and DuckDB results match
Rows after reopen: 6
Committed update (003): 3500 cents
Rolled-back update (001): 1200 cents
books: rows=3, priced=3, total=2000 cents
tools: rows=3, priced=2, total=5000 cents

Le même sous-ensemble SQL fonctionne ici, avec une définition de table explicite pour chaque moteur. La connexion SQLite utilise isolation_level=None pour laisser le code gérer les transactions par SQL. Les valeurs sont transmises par paramètres. Les deux fragments SQL insérés sont des constantes du programme, pas des entrées utilisateur. Consultez la documentation sqlite3 de Python et celle des transactions DuckDB pour les API concernées.

Interpréter les résultats à leur juste portée

Après réouverture, les deux bases contiennent six lignes identiques. La commande 003 conserve son montant validé de 3 500 centimes ; la commande 001 garde 1 200 centimes, car sa modification a été annulée. La catégorie tools compte trois lignes, mais seulement deux montants connus. Son total est de 5 000 centimes. Un montant inconnu n’est pas assimilé à une commande chiffrée à zéro.

Les tests vérifient aussi l’Unicode, les chaînes vides, NULL, du texte paramétré ressemblant à du SQL, le rejet de contraintes violées, un montant impossible à convertir et l’annulation d’une écriture lorsque l’instruction suivante échoue. Le contrôle de chemin existant vérifie que la démonstration refuse une sortie déjà présente. Il vise un répertoire temporaire privé, pas un protocole de création concurrente de fichiers.

Des résultats identiques sur ce jeu de test ne prouvent pas une compatibilité SQL complète. Les conversions, les types disponibles, les extensions, les plans de requête et les limites numériques demandent leurs propres vérifications. SQLite STRICT autorise encore certaines conversions sans perte ; il ne rejette pas toute entrée d’un type différent. L’exemple applique un contrat commun restreint, sans prétendre que les systèmes de types sont identiques.

Fermer puis rouvrir vérifie la persistance après un arrêt normal. Cela ne simule pas une coupure électrique et ne valide pas la restauration d’une sauvegarde. Le programme ne mesure ni durée de requête, ni mémoire, ni écritures concurrentes, ni stockage distant, ni déploiement Linux.

Définir précisément les accès concurrents

SQLite autorise une seule écriture à la fois par fichier de base. Avec la journalisation WAL, les lectures et une écriture peuvent se chevaucher, sans permettre plusieurs écritures simultanées. WAL suppose aussi que les processus participants sont sur le même hôte. L’exemple conserve la journalisation par défaut et ne teste pas WAL.

En mode embarqué de DuckDB 2.0, plusieurs threads peuvent écrire au sein d’un seul processus d’écriture, sous réserve des règles de conflit. La documentation actuelle décrit aussi une voie client-serveur distincte, Quack, pour plusieurs processus. Ne généralisez pas la restriction du mode embarqué à tous les déploiements DuckDB. Quack reste hors du périmètre de cet exemple.

Précisez le nombre de processus, la durée des transactions, le comportement en cas de conflit et la politique de reprise avant de décider. Si plusieurs applications indépendantes doivent partager l’accès à une base, évaluez une architecture serveur prise en charge plutôt que de considérer un fichier sur stockage partagé comme un remplacement interchangeable.

Prévoir séparément sauvegardes et copies analytiques

Une base active et un export terminé ont des usages différents. SQLite fournit une API de sauvegarde pour obtenir une copie cohérente ; DuckDB documente l’export et l’import de bases. Les exports de DuckDB 2.0.0 omettent les déclencheurs, à recréer selon la documentation. Choisissez une procédure adaptée au moteur et testez la restauration, avec les contrôles applicatifs nécessaires pour vérifier que les données restaurées sont utilisables.

Copier un fichier de base en activité dans un bucket objet ne constitue pas, à lui seul, une procédure de sauvegarde. Les journaux, les écritures ouvertes et la cohérence de la copie comptent. Un export analytique terminé ne doit pas non plus être présenté comme une sauvegarde complète de l’application sans avoir vérifié ce qu’il préserve.

Pour comparer les charges équitablement, utilisez des données représentatives et incluez, selon le cas, le chargement, les requêtes, les écritures, les sorties et les transferts. Consignez les versions, réglages, limites de threads, exécutions à froid ou à chaud, puis répétez les mesures. Une requête sur six lignes ne justifie ni un dimensionnement de production ni l’affirmation qu’un moteur est plusieurs fois plus rapide.

Évaluer les besoins CPU et stockage de votre charge

Compute avec Hivenet fournit une infrastructure CPU pour les applications et traitements exploités par le client. Le stockage objet avec Hivenet fournit un stockage compatible S3 pour les jeux de données et fichiers applicatifs terminés. La configuration de la base, la sauvegarde et les contrôles d’accès restent des éléments de la charge que vous exploitez.

Apportez la taille des données, les types de requêtes, le nombre de processus d’écriture, la fréquence des traitements, les mesures mémoire et les besoins de reprise à l’évaluation d’une charge CPU. Partez du moteur adapté à ces exigences, puis testez la VM et la connexion au stockage envisagées. Distinguez l’accès à la base active de la gestion des exports terminés et des sauvegardes vérifiées.

Votre prochaine charge de travail sur Hivenet.

Choisissez une charge de travail d’IA, de calcul ou de stockage à tester sur Hivenet, ou échangez avec notre équipe sur sa mise en production.