Cómo transformar columnas anidadas en ETL: paso a paso

João Barros 12 de August de 2026 4 min de lectura

Se explica cómo extraer y transformar columnas anidadas (JSON/struct) en una tabla relacional, una tarea común en ETL para preparar datos para análisis e informes. La transformación de columnas anidadas simplifica consultas e integraciones con herramientas como Power BI o SQL.

Requisitos previos

Python 3.8+ instalado
Bibliotecas: pandas y pyarrow (o json integrado)
Archivo de ejemplo en JSON o CSV con columnas JSON
Noções básicas de ETL y SQL

Paso 1: Entender el formato anidado

Analiza un registro de ejemplo e identifica las columnas que contienen objetos/arrays JSON. Saber si pretendes normalizar arrays en filas separadas o expandir solo objetos simples determina la estrategia.

# Exemplo de linha JSON num CSV
{
  "order_id": 1234,
  "customer": {"id": "C001", "name": "Ana"},
  "items": [{"sku": "A1", "qty": 2}, {"sku": "B2", "qty": 1}],
  "metadata": "{\"source\": \"web\"}"
}

Paso 2: Cargar los datos en un DataFrame

Lee el archivo en pandas. Usa dtype adecuado para evitar que pandas trate JSON como strings si ya están parseados.

import pandas as pd

# Se for CSV com uma coluna 'payload' em JSON
df = pd.read_csv('orders.csv')
# Ou se for um ficheiro JSON por linha (JSONL)
df = pd.read_json('orders.jsonl', lines=True)

print(df.head())

Paso 3: Expandir objetos JSON simples (columnas anidadas a columnas)

Cuando una columna contiene un objeto JSON (dict), usa json_normalize o pandas.json_normalize para expandir campos internos a columnas separadas.

from pandas import json_normalize

# Supondo coluna 'customer' com dicts
customers = json_normalize(df['customer'])
customers.columns = ['customer_' + c for c in customers.columns]
df = pd.concat([df.drop(columns=['customer']), customers], axis=1)

print(df.columns)

Paso 4: Transformar arrays en filas (explotar arrays)

Para campos que son arrays (p. ej.: 'items'), convierte cada elemento del array en una fila separada usando explode y luego normaliza los elementos.

# Assegurar que 'items' é lista de dicts
df['items'] = df['items'].apply(lambda x: x if isinstance(x, list) else [])

# explode transforma cada item numa linha própria, mantendo order_id
df_exploded = df.explode('items').reset_index(drop=True)

# Normaliza a coluna 'items' agora que contém um dict por linha
items = json_normalize(df_exploded['items'])
items.columns = ['item_' + c for c in items.columns]

# Junta com o resto
df_items = pd.concat([df_exploded.drop(columns=['items']), items], axis=1)

print(df_items.head())

Paso 5: Tratar campos inconsistentes y tipos

Valida tipos, maneja nulls y unifica nombres de columnas. Convierte fechas y números a tipos apropiados antes de la carga final.

# Exemplo: normalizar datas e preencher nulos
df_items['order_date'] = pd.to_datetime(df_items.get('order_date', None), errors='coerce')
df_items['item_qty'] = pd.to_numeric(df_items.get('item_qty', '0'), errors='coerce').fillna(0).astype(int)

# Renomear colunas para convenção SQL-friendly
df_items = df_items.rename(columns=lambda c: c.lower().replace(' ', '_'))

Paso 6: Guardar el resultado para carga (CSV/Parquet/SQL)

Elige el formato adecuado: CSV/Parquet para archivos, o inserta directamente en una tabla SQL. Parquet preserva tipos y es eficiente para análisis.

# Guardar em Parquet
df_items.to_parquet('orders_items.parquet', index=False)

# Ou guardar em CSV para uma carga simples
df_items.to_csv('orders_items.csv', index=False)

Verificar el resultado

Verifica que el conteo de filas tenga sentido: filas originales multiplicadas por los elementos del array. Confirma columnas creadas (p. ej.: customer_id, item_sku) y tipos (fechas e enteros). Prueba una muestra en Power BI o en una tabla SQL, si es posible.

# Exemplos de verificações
print('Linhas originais:', len(df))
print('Linhas após explode:', len(df_items))
print(df_items[['order_id','customer_id','item_sku','item_qty']].head())

Conclusión

Al transformar columnas anidadas en tablas relacionales preparas datos para análisis e integración con herramientas como Power BI o SQL. Próximos pasos: implementar este proceso en batch automatizado (Airflow/ETL tool) y añadir tests/validaciones. Consejo: empieza por crear scripts pequeños y validar con muestras antes de procesar todo el dataset — ¿qué columna anidada te causa más dolores de cabeza?