Historique de Parquet et de GeoParquet

1. Apache Parquet – Le format d’origine

Historique :

• 2013 : Création par Twitter et Cloudera.
• 2014 : Donné à la Apache Software Foundation.
• Conçu comme un format colonnaire optimisé pour la lecture rapide et la compression efficace.

Objectif :

• Stockage efficace de données tabulaires massives, notamment dans les écosystèmes Big Data (Hadoop, Spark…).
• Supporte types complexes, schémas, partitions, compression, etc.

2. GeoParquet – Extension géospatiale de Parquet

Historique :

Objectif :

• Offrir un format geospatial performant pour les flux de données modernes, basé sur le succès de Parquet.
• Compatible avec l’écosystème Cloud / Data Lake.

Caractéristiques de GeoParquet

Spécifications techniques (GeoParquet)

• Fichier Parquet avec des colonnes géométriques,
• Métadonnées dans l’attribut geo au format JSON (voir exemple ci-dessous),
• Exemple :

{
  "version": "1.0.0",
  "primary_column": "geometry",
  "columns": {
    "geometry": {
      "encoding": "WKB",
      "geometry_type": "Point",
      "crs": "EPSG:4326",
      "edges": "planar",
      "orientation": "counterclockwise",
      "bbox": [-180, -90, 180, 90]
    }
  }
}

Pourquoi GeoParquet est important ?

GeoParquet est un format clé à l’intersection du géospatial et du Big Data. Il repose sur le format Parquet, largement utilisé dans les environnements analytiques modernes, tout en y ajoutant une sémantique géographique. Cette combinaison lui confère plusieurs avantages :

• Compatibilité Big Data + Géospatial : GeoParquet permet de manipuler efficacement des volumes massifs de données spatiales dans des environnements distribués ou cloud, tout en conservant la richesse des attributs géographiques.
• Adapté aux données massives : Il est particulièrement bien adapté au stockage et au traitement de grands jeux de données tels que les plans cadastraux, les données OpenStreetMap, ou les catalogues d’images satellitaires.
• Intégration aux outils modernes : Le format s’intègre nativement dans des outils récents et performants comme DuckDB, Dask, ou Arrow Flight, facilitant l’analyse rapide, le streaming ou la visualisation.
• Interopérabilité : GeoParquet est pris en charge par des bibliothèques Python courantes (GeoPandas, PyArrow, etc.), ainsi que par des logiciels SIG comme QGIS ou GeoServer, grâce au support assuré par GDAL.

En résumé, GeoParquet offre une solution moderne, portable et performante pour manipuler des données géographiques dans des écosystèmes à la fois SIG et Big Data.

Description technique du format GeoParquet

1. Base technique : Apache Parquet

GeoParquet est une extension du format Parquet, un format colonnaire binaire optimisé pour :

• la lecture rapide de grandes quantités de données,
• la compression efficace,
• et le traitement parallèle (big data / cloud).

Parquet repose sur :

• un schéma (type, nom, hiérarchie des champs),
• un stockage par colonnes, non par lignes,
• une structure en row groups, pages et encodages.

Parquet est agnostique aux types métiers (ex : il n’a pas de type « géométrie »).

Cela veut dire que le format Parquet ne connaît pas — et ne comprend pas nativement — les types de données « spécialisés » d’un domaine particulier (type métier), comme :

• les géométries (ex : points, polygones),
• les dates complexes (calendriers lunaires, etc.),
• les unités de mesure spécifiques (ex : altitudes en pieds),
• les objets 3D ou spatiaux.

Parquet ne gère que des types généraux et simples :

Donc Parquet ne sait pas ce qu’est un « POINT » ou un « POLYGON ». Il ne fait que stocker une série d’octets (par exemple : une géométrie encodée en WKB) comme une chaîne binaire (BYTE_ARRAY).

Exemple concret : fichier GeoParquet

Imaginons une colonne « geometry » contenant des polygones.

• Dans Parquet : cette colonne est vue comme une suite de blobs binaires (byte arrays).
• Dans GeoParquet : une métadonnée JSON dit : « cette colonne contient du WKB représentant des polygones EPSG:4326 ».

Parquet seul ne comprend pas ce que c’est. Seule une application qui lit la métadonnée geo peut interpréter correctement les données (ex : QGIS, GDAL, GeoPandas).

Résumé

2. Extension GeoParquet

a. Structure de fichier

GeoParquet est un fichier .parquet, mais contenant :

• des colonnes géométriques encodées en WKB (Well-Known Binary),
• des métadonnées JSON embarquées dans la clé geo du fichier Parquet.

Ces métadonnées décrivent :

b. Exemple de métadonnées GeoParquet

{
  "geo": {
    "version": "1.0.0",
    "primary_column": "geometry",
    "columns": {
      "geometry": {
        "encoding": "WKB",
        "geometry_type": "Polygon",
        "crs": "EPSG:4326",
        "edges": "planar",
        "orientation": "counterclockwise",
        "bbox": [102.0, 0.5, 103.0, 1.5]
      }
    }
  }
}

c. Champs techniques importants

3. Éléments internes (Parquet)

• Row groups : unités de traitement contenant un ensemble de lignes,
• Pages : segments internes compressés pour chaque colonne,
• Encodage : PLAIN, DICTIONARY, DELTA, etc.,
• Compression : Snappy (par défaut), GZIP, Zstd…

Chaque colonne, y compris géométrique, est stockée de manière séparée, ce qui rend l’accès sélectif très performant.

4. Spécification complète

Disponible ici :
https://github.com/opengeospatial/geoparquet
Spécification officielle GeoParquet 1.0.0 (PDF)

Exemple d’inspection technique (avec pyarrow)

import pyarrow.parquet as pq

# Charger un fichier GeoParquet

table = pq.read_table(« fichier.parquet »)

metadata = table.schema.metadata

# Accès aux métadonnées GeoParquet

print(metadata[b »geo »].decode(« utf-8 »))

Résumé

Travailler avec GeoParquet dans QGIS

Travailler avec GeoParquet dans QGIS est aujourd’hui possible, mais nécessite certaines précautions, car le support de ce format est encore en développement dans l’écosystème géospatial.

Voici un guide pratique étape par étape pour comprendre et utiliser le GeoParquet dans QGIS.

GeoParquet est une spécification pour stocker des données spatiales dans le format Apache Parquet, avec des métadonnées géométriques compatibles avec les SIG.
Il combine la vitesse et compacité de Parquet avec la structure géométrique de formats comme GeoJSON ou Shapefile.

1. Conditions pour l’utiliser dans QGIS

Versions nécessaires :

• QGIS ≥ 3.34 (ou 3.32 avec compilation GDAL récente)
• GDAL ≥ 3.6, avec le support de Parquet et Arrow activé

Vérifiez dans QGIS :

• Menu Préférences > Options > Informations système
• Cherchez dans GDAL/OGR  > vecteur la ligne :

  • Parquet – (rw+v): Apache Parquet

2. Ouvrir un fichier GeoParquet dans QGIS

Méthode 1 : Glisser-déposer

1. Crée ton fichier .parquet depuis Python ou un autre SIG.
2. Glisse le fichier dans QGIS.
3. Si QGIS reconnaît le format, il s’ouvrira comme une couche vectorielle.

Méthode 2 : Ajouter une couche vectorielle

1. Couches > Ajouter une couche > Ajouter une couche vectorielle
2. Source de données : sélectionne le fichier .parquet
3. Type de fichier : Tous les fichiers ou Fichiers Parquet
4. Valide.

3. Créer un GeoParquet depuis QGIS

QGIS ne permet pas encore d’exporter directement vers GeoParquet depuis l’interface graphique. Mais vous pouvez :

➤ Utiliser la console Python interne :

layer = iface.activeLayer()

gdf = QgsVectorLayerExporter.exportLayer(layer, ‘/chemin/couche.parquet’, ‘parquet’, layer.crs(), False)

➤ Ou passer par OGR en ligne de commande :

ogr2ogr -f Parquet sortie.parquet couche.shp

Par défaut, cette commande produit du Parquet sans métadonnées GeoParquet. Pour obtenir un vrai GeoParquet, il est préférable d’utiliser GeoPandas avec pyarrow.

4. Avantages dans QGIS

• Poids réduit par rapport au GeoJSON ou Shapefile
• Chargement rapide avec des millions d’entités
• Interopérable avec Python, DuckDB, Spark, etc.

Bonnes pratiques

Si cet article vous a intéressé et que vous pensez qu'il pourrait bénéficier à d'autres personnes, n'hésitez pas à le partager sur vos réseaux sociaux en utilisant les boutons ci-dessous. Votre partage est apprécié !

Atilio Francois