JSONL vs Parquet: como escolher o formato de dados certo
Uma comparação completa entre JSONL (JSON Lines) e Apache Parquet. Entenda as vantagens e limitações de cada um em compressão, desempenho de consultas, validação de schema e suporte no ecossistema para escolher o formato mais adequado às suas cargas de trabalho de dados.
O que é JSONL?
JSONL (JSON Lines) é um formato de dados em texto no qual cada linha contém um único objeto JSON completo, separado dos demais por uma quebra de linha. É uma extensão natural do JSON, um formato amplamente utilizado, criada especificamente para streaming e dados de logs. Como cada linha é um documento JSON independente, é possível acrescentar dados ao arquivo sem reescrever o conteúdo existente e processá-lo linha por linha com um consumo adicional mínimo de memória.
O JSONL se tornou o formato padrão para troca de dados de treinamento de machine learning (fine-tuning da OpenAI, datasets do Hugging Face), logs de aplicações, fluxos de eventos e qualquer cenário em que os dados chegam aos poucos. Por ser legível, é fácil inspecionar seu conteúdo com qualquer editor de texto ou ferramentas de linha de comando como grep, head e jq.
{"id": 1, "name": "Alice", "role": "engineer", "salary": 95000}
{"id": 2, "name": "Bob", "role": "designer", "salary": 88000}
{"id": 3, "name": "Charlie", "role": "manager", "salary": 105000}O que é Parquet?
O Apache Parquet é um formato binário de armazenamento colunar, projetado para executar consultas analíticas com eficiência em grandes conjuntos de dados. Em vez de armazenar os dados linha por linha, como o JSONL, o Parquet organiza os valores por coluna. Assim, para ler um único campo em milhões de linhas, basta percorrer a coluna correspondente, sem ler cada registro inteiro. Essa organização permite altas taxas de compressão, pois os valores de uma mesma coluna tendem a ter tipos e distribuições semelhantes.
O Parquet surgiu no ecossistema Apache Hadoop e hoje é o padrão de fato para armazenamento em data lakes no AWS S3, Google Cloud Storage e Azure Blob Storage. Tem ampla integração com Apache Spark, Apache Hive, Presto, DuckDB, Snowflake, BigQuery e praticamente todos os mecanismos de análise modernos. Os arquivos Parquet incluem um schema rígido nos metadados, permitindo que os sistemas que os leem conheçam os tipos exatos e a estrutura dos dados sem depender de documentação externa.
import pyarrow.parquet as pq
import pandas as pd
# Escreve um DataFrame em Parquet
df = pd.DataFrame({
'id': [1, 2, 3],
'name': ['Alice', 'Bob', 'Charlie'],
'role': ['engineer', 'designer', 'manager'],
'salary': [95000, 88000, 105000]
})
df.to_parquet('employees.parquet')
# Lê colunas específicas (vantagem colunar)
df = pq.read_table('employees.parquet', columns=['name', 'salary']).to_pandas()JSONL vs Parquet: comparação lado a lado
A tabela a seguir resume as principais diferenças entre JSONL e Parquet nos aspectos mais relevantes para escolher um formato de dados para seu projeto.
| Característica | JSONL | Parquet |
|---|---|---|
| Organização dos dados | Orientado a linhas, em texto. Cada linha contém um objeto JSON completo. | Orientado a colunas, em formato binário. Os valores são armazenados por coluna, em grupos de linhas. |
| Codificação | Texto simples em UTF-8. Legível e editável em qualquer editor de texto. | Binário, com codificação por dicionário, RLE e bit-packing. Não pode ser lido diretamente como texto. |
| Compressão | Compressão externa opcional (gzip, zstd). Os nomes dos campos se repetem em cada linha. | Compressão colunar integrada (Snappy, Zstd, Gzip). Arquivos 2-10x menores. |
| Desempenho das consultas | Precisa percorrer o arquivo inteiro em qualquer consulta. Sem column pruning ou predicate pushdown. | Column pruning e predicate pushdown permitem pular dados irrelevantes. As consultas analíticas são ordens de magnitude mais rápidas. |
| Schema | Sem schema obrigatório. Cada linha pode ter campos e tipos diferentes. Flexível, mas sujeito a erros. | Schema rígido e tipado nos metadados do arquivo. Validado tanto na leitura quanto na escrita. |
| Streaming / Acréscimo de dados ao final | Excelente. Basta acrescentar uma linha ao final do arquivo. Ideal para ingestão em tempo real. | Limitado. Para acrescentar dados, é necessário reescrever arquivos ou criar novas partições de arquivos. |
| Leitura direta por pessoas | Sim. Inspecione com cat, head, grep, jq ou qualquer editor de texto. | Não. A inspeção exige ferramentas específicas (parquet-tools, PyArrow, DuckDB). |
| Ecossistema | Universal. Compatível com qualquer linguagem de programação que tenha um parser JSON. | Voltado à análise de dados. Ampla integração com Spark, Hive, Presto, DuckDB, Snowflake e BigQuery. |
Benchmarks de desempenho
A diferença de desempenho entre JSONL e Parquet fica muito mais evidente em grande escala. Os benchmarks abaixo são representativos de um conjunto de dados com 10 milhões de linhas e 20 colunas, contendo strings, inteiros, floats e timestamps.
Tamanho do arquivo (compressão)
Leitura completa da tabela
Velocidade de escrita
Consulta a uma única coluna
Benchmarks realizados com Python (pandas + PyArrow) em um MacBook Pro com chip M2 e 16 GB de RAM. Os resultados na prática variam conforme o hardware, a distribuição dos dados e o codec de compressão.
Quando usar JSONL ou Parquet
- Ingestão de logs em tempo real e streaming de eventos
- Dados de treinamento de ML para OpenAI, Anthropic e Hugging Face
- Troca de dados entre microsserviços e APIs
- Dados semiestruturados com schemas que variam de um registro para outro
- Prototipagem rápida e depuração quando é importante poder ler os dados diretamente
- Dados append-only onde registros chegam continuamente
- Conjuntos de dados pequenos a médios (menos de 1 GB) que não exigem consultas analíticas
- Armazenamento em data lakes no S3, GCS ou Azure Blob
- Consultas analíticas com Spark, Presto, DuckDB ou Snowflake
- Agregações por coluna (SUM, AVG, COUNT) em bilhões de linhas
- Requisitos rigorosos de validação de schema e governança de dados
- Arquivamento de longo prazo quando o custo de armazenamento é importante (arquivos 2-10x menores)
- Feature stores e pipelines de features de ML que leem colunas específicas
- Conjuntos de dados maiores que 1 GB para os quais o desempenho das consultas é essencial
Arquitetura híbrida: ingestão em JSONL e armazenamento em Parquet
Em plataformas de dados em produção, JSONL e Parquet podem ser usados em conjunto. Uma abordagem comum e eficaz é usar JSONL na ingestão e Parquet no armazenamento de longo prazo e nas análises. Essa arquitetura híbrida combina os pontos fortes dos dois formatos: a simplicidade do JSONL para capturar dados em tempo real e a eficiência do Parquet nas consultas feitas nas etapas seguintes.
O pipeline tem três etapas. Primeiro, os eventos ou registros brutos são acrescentados aos arquivos JSONL conforme chegam, já que o formato permite acrescentar dados rapidamente e sem locks. Depois, um job periódico em lote, executado a cada hora, diariamente ou quando o arquivo atinge determinado tamanho, lê os arquivos JSONL acumulados, valida e transforma os dados e os converte para Parquet. Por fim, os arquivos Parquet resultantes são armazenados em um data lake particionado por data, região ou outras dimensões para permitir consultas eficientes.
1. Ingerir dados em JSONL
Colete eventos brutos, logs e respostas de APIs em arquivos JSONL. O acréscimo de dados é rápido, dispensa um schema e facilita a depuração em tempo real.
2. Transformar e validar
Leia os lotes de JSONL periodicamente, valide o schema, limpe e normalize os dados e trate os registros malformados.
3. Armazenar em Parquet
Grave os dados validados em arquivos Parquet particionados no seu data lake. Faça consultas com Spark, DuckDB ou qualquer mecanismo de análise.
import json
import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq
from pathlib import Path
from datetime import datetime
def jsonl_to_parquet(jsonl_dir: str, parquet_dir: str):
"""Converte arquivos JSONL acumulados em Parquet particionado."""
records = []
for jsonl_file in Path(jsonl_dir).glob('*.jsonl'):
with open(jsonl_file, 'r') as f:
for line in f:
line = line.strip()
if line:
records.append(json.loads(line))
if not records:
return
df = pd.DataFrame(records)
# Adiciona coluna de partição
df['date'] = datetime.now().strftime('%Y-%m-%d')
table = pa.Table.from_pandas(df)
pq.write_to_dataset(
table,
root_path=parquet_dir,
partition_cols=['date'],
compression='zstd'
)
print(f'Convertidos {len(records)} registros para Parquet')
jsonl_to_parquet('raw_events/', 'data_lake/')Experimente nossas ferramentas gratuitas para JSONL
Está trabalhando com arquivos JSONL? Use nossas ferramentas gratuitas para visualizar, validar e converter dados JSONL na hora, direto no navegador. Não é preciso instalar nada nem fazer upload de arquivos.
Estratégias para processar gigabytes de dados JSONL: leitura por streaming, gerenciamento de memória, divisão de arquivos, compressão e ferramentas online.
Comprima arquivos JSONL com gzip, zstd, lz4 e snappy. Aprenda taxas de compressão, streaming de dados comprimidos e otimização de JSONL para armazenamento e transferência.
Aprenda a usar JSONL como formato de intercâmbio em pipelines de ETL. Veja streaming com Apache Kafka, DAGs do Airflow, carregamento no Snowflake e no BigQuery e o projeto de pipelines tolerantes a falhas.
Exporte dados JSONL para planilhas CSV. Ideal para análises no Excel ou no Google Sheets.
Domine as boas práticas de JSONL para formatação, consistência de schema, tratamento de erros, otimização de desempenho e organização de arquivos. Evite problemas comuns com exemplos práticos.