Interroger votre Azure Data Lake avec DuckDB

DuckDB est un système de gestion de base de données SQL OLAP (Online Analytical Processing) haute performance, embarqué directement dans l’application. Contrairement aux bases de données client-serveur traditionnelles, DuckDB s’exécute en mode in-process, à la manière de SQLite, mais en étant optimisé pour les charges analytiques plutôt que transactionnelles.

On peut le voir comme un « SQLite pour l’analytics » : aucune configuration nécessaire, aucune dépendance externe, et la capacité d’exécuter des requêtes analytiques complexes sur des jeux de données allant de quelques mégaoctets à plusieurs centaines de gigaoctets, directement depuis une machine locale.

Modes de fonctionnement

DuckDB propose deux modes de fonctionnement principaux pour s’adapter à différents cas d’usage :

• In-Memory (Transient) : Les données existent uniquement pendant la durée du processus. Ce mode est idéal pour l’analyse exploratoire, les transformations temporaires et les requêtes ponctuelles lorsque la persistance n’est pas nécessaire.
• Persistant (Disk-based) : Un fichier unique et portable permet de stocker les données. Ce mode est parfaitement adapté à la création de data warehouses locaux, à la mise en cache de résultats traités ou au maintien de jeux de données analytiques entre plusieurs sessions.

Fonctionnalités clés du moteur

L’architecture de DuckDB est pensée pour la performance analytique :

• Moteur d’exécution vectorisé : Les données sont traitées par lots (vecteurs) plutôt que ligne par ligne, ce qui permet des optimisations CPU SIMD (Single Instruction, Multiple Data) et un débit très élevé.
• Exécution parallèle automatique : DuckDB intègre un ordonnanceur « work-stealing » qui parallélise automatiquement les requêtes sur les cœurs CPU disponibles.
• Gestion intelligente de la mémoire : Lorsque les jeux de données dépassent la RAM disponible, DuckDB bascule automatiquement sur le disque (out-of-core) de manière transparente.
• Stockage en colonnes : Les données sont stockées et traitées colonne par colonne, ce qui améliore fortement les taux de compression et les performances des requêtes analytiques.

Installation

Démarrer avec DuckDB est remarquablement simple : aucun serveur à installer, aucun fichier de configuration, aucune dépendance externe.

Installation via le CLI

Téléchargez et installez l’exécutable autonome correspondant à votre plateforme.

Installation Python

pip install duckdb

C’est tout. Aucun serveur de base de données à configurer, aucun port à ouvrir, aucun utilisateur à créer.

À noter : des clients existent également pour d’autres langages (Go, Java, JavaScript, C/C++, R, Rust, etc.).

Comment utiliser DuckDB

CLI

Le CLI DuckDB fournit un shell SQL interactif pour des analyses rapides :

# Start in-memory 
session duckdb 

# Or connect to a persistent database 
duckdb my_analytics.db

Opérations courantes :

-- Query local files directly (no import needed!)
SELECT * FROM 'data/sales.parquet' LIMIT 10;

-- Query CSV files with automatic schema detection
SELECT * FROM 'data.csv';

-- Export results
COPY (SELECT * FROM 'data/sales.parquet' WHERE year = 2024) 
TO 'output/sales_2024.parquet' (FORMAT PARQUET);

-- Show available tables
SHOW TABLES;

-- Describe table structure
DESCRIBE my_table;

Python

L’intégration Python est l’un des points forts de DuckDB :

import duckdb

# Create a connection
con = duckdb.connect()  # in-memory
# con = duckdb.connect('my_db.db')  # persistent

# Query local files
result = con.execute("""
    SELECT category, SUM(amount) as total
    FROM 'sales/*.parquet'
    GROUP BY category
    ORDER BY total DESC
""")

# Get results as a Pandas DataFrame
df = con.execute("SELECT * FROM 'data.parquet'").df()

# Get results as a Polars DataFrame
pl_df = con.execute("SELECT * FROM 'data.parquet'").pl()

# You can then work with classic DataFrames

Interroger un ADLS (Azure Data Lake Storage)

DuckDB se connecte nativement à Azure Blob Storage et ADLS Gen2 via l’extension azure, ce qui permet d’interroger des données cloud comme si elles étaient locales.

Initialisation

INSTALL azure; 
LOAD azure;

Remarque : ces commandes sont optionnelles. L’extension Azure est automatiquement téléchargée et installée dès qu’un mot-clé d’extension est utilisé (par exemple TYPE AZURE).

Méthodes d’authentification

Le système unifié de gestion des SECRETS de DuckDB offre plusieurs modes d’authentification :

1. Chaîne de connexion (idéal pour le développement local)

CREATE SECRET azure_secret (
    TYPE AZURE,
    CONNECTION_STRING 'DefaultEndpointsProtocol=https;AccountName=myaccount;AccountKey=...;EndpointSuffix=core.windows.net'
);

2. Service Principal (pour des workloads hors Azure)

CREATE SECRET my_azure_spn (
    TYPE AZURE,
    PROVIDER SERVICE_PRINCIPAL,
    TENANT_ID '00000000-0000-0000-0000-000000000000',
    CLIENT_ID '00000000-0000-0000-0000-000000000000',
    CLIENT_SECRET 'my-client-secret-value',
    ACCOUNT_NAME 'myaccount'
);

3. Managed Identity (pour des workloads hébergés sur Azure)

CREATE SECRET azure_mi (
    TYPE AZURE,
    PROVIDER CREDENTIAL_CHAIN,
    ACCOUNT_NAME 'myaccount'
);

Formats ABFSS et AZ

DuckDB prend en charge plusieurs formats d’URI pour le stockage Azure.

Format ABFSS (Azure Blob File System Secure)

-- Standard ADLS Gen2 path format
SELECT * FROM 'abfss://<container>@<storageaccount>.dfs.core.windows.net/path/to/file.parquet';

-- Simplified format (when account is specified in secret)
SELECT * FROM 'abfss://<container>/path/to/file.parquet';

Format AZ (Azure Blob Storage)

SELECT * FROM 'az://container/path/to/file.parquet';

Les deux formats supportent les glob patterns :

-- Query all parquet files in a directory
SELECT * FROM 'abfss://datalake/raw/sales/*.parquet';

-- Query files across partitioned directories
SELECT * FROM 'abfss://datalake/raw/sales/year=*/month=*/*.parquet';

Requêtes complexes sur plusieurs stockages

L’une des fonctionnalités les plus puissantes de DuckDB est sa capacité à joindre des données provenant de sources différentes dans une seule requête : fichiers locaux, comptes de stockage cloud multiples ou DataFrames en mémoire.

Exemple : jointure avec des données de référence dans un autre stockage

-- Set up secrets for multiple storage accounts
CREATE SECRET adlsduckdb (
    TYPE AZURE,
    PROVIDER CREDENTIAL_CHAIN,
    ACCOUNT_NAME 'adlsduckdb'
);

CREATE SECRET adlsmasterdata (
    TYPE AZURE,
    PROVIDER CREDENTIAL_CHAIN,
    ACCOUNT_NAME 'adlsmasterdata'
);

select count(*) from 
'abfss://data@adlsduckdb.dfs.core.windows.net/orders.parquet' orders join          -- from main data lake
'abfss://masterdata@adlsmasterdata.dfs.core.windows.net/customer.parquet' customer -- from master data lake
on customer.c_custkey = orders.o_custkey;

Mélanger données cloud et locales

-- Enrich cloud data with local reference data
SELECT 
    cloud_data.*,
    local_mapping.display_name
FROM 'abfss://datalake/raw/events/*.parquet' cloud_data
JOIN 'local_reference/code_mappings.csv' local_mapping
    ON cloud_data.code = local_mapping.code;

Intégration Python avancée

L’intégration Python de DuckDB permet un échange de données zero-copy avec Pandas ou Polars.

Avec Pandas

import duckdb
import pandas as pd

# Create a pandas DataFrame
df = pd.DataFrame({
    'id': [1, 2, 3],
    'value': [100, 200, 300]
})

# Query pandas DataFrame directly - zero copy!
result = duckdb.query("SELECT * FROM df WHERE value > 150").df()

# Register DataFrame as a virtual table
con = duckdb.connect()
con.register('my_table', df)
con.execute("SELECT * FROM my_table").fetchall()

Avec Polars

import duckdb
import polars as pl

# Create a Polars DataFrame
df = pl.DataFrame({
    'id': [1, 2, 3],
    'value': [100, 200, 300]
})

# Query Polars DataFrame directly
result = duckdb.query("SELECT * FROM df WHERE value > 150").pl()

# Use Polars lazy frames for optimized execution
lazy_df = df.lazy()
result = duckdb.query("SELECT * FROM lazy_df").pl()

Limitations en local

Malgré ses capacités impressionnantes, DuckDB présente certaines limites à connaître :

Limitations de concurrence

• Un seul écrivain : DuckDB ne prend en charge qu’une seule connexion d’écriture concurrente vers un fichier de base de données. En revanche, plusieurs connexions en lecture sont supportées.
• Pas d’écriture multi-processus : contrairement aux bases de données client-serveur, il n’est pas possible d’avoir plusieurs processus écrivant simultanément dans la même base de données.

Contraintes mémoire

• Performance dépendante de la RAM : bien que DuckDB puisse basculer sur le disque, des performances optimales nécessitent une quantité de RAM suffisante en fonction du volume de données et de la complexité des requêtes.
• Jointures volumineuses : les jointures de type hash sur des tables très volumineuses peuvent nécessiter beaucoup de mémoire ou une configuration fine des limites mémoire.

Dépendance réseau

• Latence cloud : l’interrogation de stockages distants (ADLS, S3) est soumise à la latence réseau. Il est recommandé de mettre en cache localement les données fréquemment utilisées.
• Pas de streaming natif : DuckDB est conçu pour le traitement batch et non pour l’analytique en streaming temps réel.

Compatibilité des extensions

• Extensions spécifiques à la plateforme : certaines extensions peuvent ne pas être disponibles sur toutes les plateformes (Windows, Linux, macOS, ARM).
• Dépendance aux versions : les extensions doivent correspondre exactement à la version de DuckDB utilisée.

Aller plus loin : DuckDB comme moteur de requêtes

Au-delà d’une base de données, on peut utiliser DuckDB comme moteur de requêtes dans des workflows data de petite à moyenne taille, en remplacement ou en complément de Pandas et Polars.

Sa capacité à monter en charge permet également son intégration dans des environnements Big Data et dans des plateformes comme Fabric ou BigQuery.

Ressources utiles

Vous trouverez ici des ressources complémentaires sur DuckDB :

• Documentation officielle DuckDB
• Dépôt GitHub DuckDB
• Référence des extensions DuckDB
• Documentation de l’extension Azure