
La compression Parquet utilise des codecs comme Snappy, Zstandard et Gzip pour réduire le volume stocké dans un fichier Parquet. Le choix dépend des outils qui liront vos fichiers, de la façon dont vos données se compressent et du coût de leur écriture et de leur lecture. Un fichier plus petit constitue un résultat utile, mais ne permet pas de déterminer quel codec rendra votre traitement le plus rapide.
Un point de départ pratique consiste à comparer Snappy et Zstandard à une référence sans compression, puis à ajouter Gzip s'il compte pour vos outils existants ou pour la comparaison. Ce guide utilise un jeu de données reproductible et quatre réglages. Chaque variante est relue et vérifiée avant que sa taille soit présentée.
Recensez les applications qui consommeront les fichiers, y compris les anciens traitements par lots et les outils d'export. Vérifiez leurs versions réelles avec des fichiers représentatifs. Une lecture réussie dans PyArrow valide ce chemin précis ; elle ne prouve pas la compatibilité avec tous les moteurs SQL ou toutes les bibliothèques utilisées ensuite.
| Réglage | Pourquoi l'inclure dans la comparaison ? | Que reste-t-il à vérifier ? |
|---|---|---|
| Sans compression | Une référence qui conserve la structure Parquet et les choix d'encodage | L'acceptabilité du volume supplémentaire stocké et transféré |
| Snappy | Un codec conçu pour privilégier la vitesse avec une compression modérée | Le comportement réel en écriture et en lecture pour votre traitement |
| Zstandard | Un candidat réglable lorsque la taille des fichiers compte | La prise en charge par les lecteurs et l'effet du niveau choisi |
| Gzip | Un point de comparaison pour les chaînes de traitement qui l'utilisent ou l'exigent déjà | La compatibilité des lecteurs et le coût de traitement |
Le projet Snappy décrit sa priorité donnée à la vitesse, tandis que Zstandard propose plusieurs compromis de compression. Ces objectifs aident à choisir les candidats. Ils ne mesurent pas les performances de vos fichiers Parquet.
Parquet applique les codecs aux données contenues dans les pages. Choisir Gzip dans un outil d'écriture Parquet ne consiste pas à envelopper le fichier terminé dans une archive .gz distincte. La spécification de compression Parquet décrit les formats des codecs. La compression n'apporte, à elle seule, ni contrôle d'accès ni chiffrement.
L'encodage et la compression sont deux choix distincts. L'encodage par dictionnaire de Parquet peut représenter les valeurs répétées par des entrées de dictionnaire et des identifiants. Un codec compresse ensuite les données encodées des pages. Un fichier Parquet sans compression peut donc bénéficier de l'encodage par dictionnaire.
Modifier simultanément les groupes de lignes, le tri, les dictionnaires et le codec rend le résultat difficile à expliquer. Cette expérience conserve ces choix et ne change que le codec et son niveau indiqué. Elle utilise 100 000 lignes dans leur ordre initial, cinq groupes de 20 000 lignes, les statistiques activées, la version Parquet 2.6 et la version 1.0 des pages de données.
Les six colonnes contiennent des identifiants entiers séquentiels, des horodatages UTC, quatre valeurs de région répétées, des montants entiers pouvant être nuls, des chaînes hexadécimales SHA-256 uniques et des booléens. Deux colonnes comportent des valeurs nulles. Seule la région utilise un dictionnaire. Les longues chaînes hexadécimales donnent volontairement à cet exemple un profil différent d'une table composée uniquement de catégories répétées.
Nous utilisons Zstandard au niveau 3 et Gzip au niveau 6. Ces nombres ne représentent pas une intensité équivalente d'un codec à l'autre. Snappy ne dispose pas d'un niveau réglable dans cette API. La référence PyArrow Codec décrit la disponibilité et les niveaux pris en charge ; le script vérifie la présence des trois codecs avant de les utiliser.
Dans un environnement Python isolé, installez la version utilisée ici avec python -m pip install pyarrow==26.0.1. Enregistrez le code suivant dans compare_codecs.py, puis lancez python compare_codecs.py. Notre exécution utilisait Python 3.12.14 et PyArrow 26.0.1 sous Windows.
import hashlib
import json
import platform
import tempfile
from datetime import datetime, timedelta, timezone
from pathlib import Path
import pyarrow as pa
import pyarrow.parquet as pq
ROWS = 100_000
ROW_GROUP = 20_000
VARIANTS = [
("none", "NONE", None),
("snappy", "snappy", None),
("zstd", "zstd", 3),
("gzip", "gzip", 6),
]
def make_table():
start = datetime(2026, 1, 1, tzinfo=timezone.utc)
return pa.table({
"event_id": pa.array(range(ROWS), type=pa.int64()),
"event_time": pa.array(
[start + timedelta(seconds=i) for i in range(ROWS)],
type=pa.timestamp("us", tz="UTC"),
),
"region": pa.array([
None if i % 13 == 0 else ("eu", "us", "ap", "af")[i % 4]
for i in range(ROWS)
], type=pa.string()),
"amount_cents": pa.array([
None if i % 11 == 0 else (i * 7919) % 100_000
for i in range(ROWS)
], type=pa.int64()),
"request_id": pa.array([
hashlib.sha256(f"event-{i}".encode()).hexdigest()
for i in range(ROWS)
], type=pa.string()),
"accepted": pa.array([i % 5 != 0 for i in range(ROWS)]),
})
def compare(table, folder):
results = []
for label, codec, level in VARIANTS:
if label != "none" and not pa.Codec.is_available(codec):
raise RuntimeError(f"Codec unavailable: {codec}")
path = folder / f"{label}.parquet"
if path.exists():
raise FileExistsError(path)
pq.write_table(
table, path, compression=codec, compression_level=level,
row_group_size=ROW_GROUP, use_dictionary=["region"],
write_statistics=True, version="2.6", data_page_version="1.0",
data_page_size=1_048_576, dictionary_pagesize_limit=1_048_576,
use_byte_stream_split=False, write_batch_size=1024,
store_schema=True,
)
restored = pq.read_table(path)
if not table.schema.equals(restored.schema, check_metadata=True):
raise AssertionError(f"Schema changed: {label}")
if not table.equals(restored):
raise AssertionError(f"Values changed: {label}")
metadata = pq.read_metadata(path)
expected = "UNCOMPRESSED" if label == "none" else codec.upper()
chunks = [metadata.row_group(r).column(c)
for r in range(metadata.num_row_groups)
for c in range(metadata.num_columns)]
if any(chunk.compression != expected for chunk in chunks):
raise AssertionError(f"Unexpected codec metadata: {label}")
results.append({
"codec": label, "level": level, "bytes": path.stat().st_size,
"row_groups": metadata.num_row_groups,
"schema_equal": True, "values_equal": True,
"chunk_codec": expected,
})
baseline = results[0]["bytes"]
for result in results:
result["percent_of_uncompressed"] = round(
100 * result["bytes"] / baseline, 2
)
return results
if __name__ == "__main__":
folder = Path(tempfile.mkdtemp(prefix="parquet-codecs-", dir="."))
results = compare(make_table(), folder)
report = {
"python": platform.python_version(), "pyarrow": pa.__version__,
"platform": platform.platform(), "rows": ROWS,
"folder": str(folder.resolve()), "results": results,
}
(folder / "results.json").write_text(json.dumps(report, indent=2))
print(json.dumps(report, indent=2))
Chaque exécution crée un nouveau dossier local dont le nom commence par parquet-codecs-. Il contient quatre fichiers et results.json. Aucune opération sur un bucket n'est effectuée. L'exemple conserve les données en mémoire : il sert à une petite comparaison reproductible, pas à un traitement en flux d'un jeu de données de production volumineux.
Les réglages d'écriture sont explicites pour permettre de reproduire la comparaison. Consultez la référence de write_table pour les adapter. PyArrow permet aussi de choisir un codec par colonne, mais cette expérience utilise un même codec pour toutes les colonnes d'un fichier afin de garder le résultat lisible.
Les valeurs suivantes correspondent aux tailles complètes des fichiers locaux, métadonnées Parquet incluses. Le pourcentage est calculé par taille compressée / taille sans compression × 100. Il indique la part de la taille de référence qui reste, pas le pourcentage économisé.
| Réglage | Niveau | Taille en octets | Part de la taille sans compression |
|---|---|---|---|
| Sans compression | Non défini | 9 208 315 | 100,00 % |
| Snappy | Non défini | 7 998 797 | 86,86 % |
| Zstandard | 3 | 4 161 934 | 45,20 % |
| Gzip | 6 | 4 550 532 | 49,42 % |
Zstandard au niveau 3 a produit le plus petit fichier de cette exécution : 4 161 934 octets, soit 45,20 % de la taille sans compression. Gzip au niveau 6 suit avec 4 550 532 octets. Après relecture, les quatre fichiers contenaient les mêmes valeurs et le même schéma typé.
Ce classement dépend de ces données et de ces réglages. Une table composée surtout de contenus binaires déjà compressés, de chaînes courtes, de catégories répétées ou ordonnée différemment peut donner d'autres résultats. Cette mesure n'établit ni un pourcentage universel d'économie, ni un niveau préférable pour tous les jeux de données, ni un avantage de vitesse. Nous n'avons mesuré ni les durées d'écriture et de lecture, ni la consommation CPU.
La taille totale du fichier diffère aussi du nombre d'octets lus par une requête. Une requête qui sélectionne deux colonnes peut se comporter autrement qu'un export complet. Incluez vos projections et vos filtres réels lorsque vous testerez les requêtes.
Ouvrir un fichier sans exception constitue une vérification insuffisante pour une expérience sur un format. Le script compare la table relue à l'original dans son intégralité, ordre compris, et contrôle séparément le schéma typé. Il examine aussi le codec enregistré pour chaque bloc de colonne. La présence de zstd dans le nom du fichier ne prouve pas l'utilisation de Zstandard.
Notre validation complémentaire a réussi 37 contrôles. Pour chaque fichier, elle a vérifié toutes les valeurs, le schéma, cinq groupes de lignes égaux, le codec attendu dans les 30 blocs de colonnes, le dictionnaire limité à la région, les nombres de valeurs nulles dans les statistiques, la version du format et le nombre d'octets annoncé. Des contrôles ont confirmé qu'un ordre modifié et un changement de type de colonne seraient détectés.
Si vous adaptez l'exemple, conservez ces vérifications avant d'ajouter des mesures. Pour tester la compatibilité avec un autre moteur, répétez les contrôles de contenu dans ce moteur plutôt que de vous contenter d'une ouverture réussie. Si un outil modifie silencieusement un type ou réduit la précision d'un horodatage, un bon taux de compression ne rend pas cette sortie acceptable.
Une fois les fichiers validés, choisissez l'opération qui compte : écritures quotidiennes, lectures analytiques répétées, export complet ou restauration occasionnelle. Testez-la avec un volume représentatif. Gardez la machine, la version du lecteur, la requête, les réglages de threads et l'ordre des données constants pendant la comparaison des codecs.
Pour les durées, consignez les passages de préparation et les répétitions, présentez la dispersion des résultats et précisez si les caches étaient remplis ou vides. Mesurez le pic de mémoire et l'utilisation du CPU s'ils influencent la capacité nécessaire. Une lecture locale en cache ne mesure pas un stockage objet distant ; une mesure très courte peut surtout refléter le démarrage du programme.
Évaluez le volume stocké avec la fréquence de traitement. Le choix diffère entre un fichier écrit une fois puis lu occasionnellement et des données réécrites chaque heure et interrogées en continu. Le guide d'optimisation des coûts cloud, en anglais présente une méthode plus large pour comparer les dépenses au travail accompli. Rien ne permet de supposer que le plus petit fichier local entraîne automatiquement le coût d'exploitation total le plus faible.
La compression change le volume stocké ; la conservation détermine combien de temps vous le gardez. Traitez ces décisions séparément. Pour les transitions et l'expiration propres à AWS, consultez le guide des règles de cycle de vie S3, en anglais. Ne déduisez pas la prise en charge de toutes les fonctions AWS de la compatibilité S3 d'un autre fournisseur.
Hivenet Object Storage propose un stockage compatible S3 pour les jeux de données et d'autres objets. La page produit permet de demander un accès et de contacter l'équipe commerciale. Pour évaluer son adéquation, préparez un ensemble de fichiers représentatifs, leurs tailles mesurées, les exigences des lecteurs et le mode d'accès prévu.
Si vous avez aussi besoin d'une infrastructure CPU que vous exploitez pour écrire ou lire ces fichiers, évaluez Compute avec Hivenet, page en anglais pour ce traitement. Cette comparaison locale n'a testé ni bucket Hivenet, ni requête distante, ni service analytique géré. Le prochain test utile porte sur votre parcours complet d'écriture et de lecture, avec le point d'accès de stockage et les outils prévus.
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.