Explorar guías rápidas · Ingeniería de datos
CSV, JSON, Parquet o Delta
Elige entre CSV, JSON, Parquet y Delta según el esquema, el rendimiento analítico, la mutabilidad, la interoperabilidad, la fiabilidad y los requisitos de un data lake en producción.
En esta página
- Problema
- Respuesta rápida
- Código / comandos
- 1. CSV: leer y escribir con pandas
- 2. CSV: definir los tipos de forma explícita
- 3. CSV: tratar los valores nulos de forma deliberada
- 4. CSV: especificar la codificación cuando sea necesario
- 5. CSV: usar bloques para archivos grandes
- 6. CSV: validar la forma de las filas
- 7. CSV: el entrecomillado importa
- 8. CSV: el delimitador forma parte del contrato
- 9. CSV: puntos fuertes
- 10. JSON: leer JSON delimitado por saltos de línea con pandas
- 11. JSON Lines es preferible a un único arreglo JSON gigante para archivos de tipo flujo
- 12. Arreglo JSON estándar
- 13. JSON: estructura anidada
- 14. Aplanar JSON anidado con cuidado
- 15. Los arreglos JSON pueden cambiar la granularidad de los datos
- 16. JSON: usar marcas de tiempo explícitas
- 17. JSON: el esquema es flexible, no inexistente
- 18. JSON: evitar documentos gigantes y profundamente anidados para analítica
- 19. JSON: puntos fuertes
- 20. Parquet: leer con pandas
- 21. Parquet: escribir con pandas
- 22. Parquet: leer con PySpark
- 23. Parquet: seleccionar solo las columnas necesarias
- 24. Parquet: filtrar pronto
- 25. Parquet almacena datos columnares tipados
- 26. Parquet es adecuado para analítica
- 27. Parquet sigue siendo solo un conjunto de archivos
- 28. Particionar Parquet de forma deliberada
- 29. Evitar particiones de cardinalidad muy alta
- 30. Evitar archivos Parquet diminutos
- 31. Evitar un único archivo Parquet gigante
- 32. Compresión de Parquet
- 33. La evolución del esquema en Parquet no es un protocolo transaccional
- 34. Delta: qué aporta
- 35. Delta: leer una tabla con PySpark
- 36. Delta: append
- 37. Delta: sobrescribir de forma deliberada
- 38. Delta: MERGE
- 39. El MERGE de Delta requiere claves de origen deterministas
- 40. Delta admite eliminaciones
- 41. Delta admite operaciones de actualización
- 42. Historial de una tabla Delta
- 43. Viaje en el tiempo en Delta
- 44. VACUUM afecta a la capacidad de recuperación histórica
- 45. Delta no es un servidor de base de datos
- 46. Delta no es «un tipo de archivo distinto que reemplaza a Parquet»
- 47. No modificar directamente los archivos de datos de Delta
- 48. No tratar a la ligera un directorio Delta como Parquet simple
- 49. Ejemplo de escaneo CSV frente a Parquet
- 50. JSON frente a Parquet para logs
- 51. CSV frente a JSON para intercambio
- 52. Parquet frente a Delta
- 53. CSV rara vez debería ser el formato analítico curado
- 54. JSON rara vez debería ser el formato analítico final de gran volumen
- 55. Conservar el origen en bruto cuando importa el linaje
- 56. Añadir metadatos de ingesta
- 57. Validar el esquema de forma explícita
- 58. Validar los tipos de datos después del análisis
- 59. Usar un esquema explícito para la ingesta con Spark
- 60. Evitar la inferencia del esquema en cada ejecución de producción
- 61. Los datos decimales merecen tipos explícitos
- 62. Las fechas y marcas de tiempo requieren una semántica de zona horaria clara
- 63. CSV no distingue tipos de forma nativa
- 64. JSON tiene tipos, pero sigue habiendo ambigüedad
- 65. Parquet conserva tipos físicos más ricos
- 66. La compresión depende del formato
- 67. Un CSV comprimido con gzip puede ser pequeño y aun así costoso de consultar
- 68. La divisibilidad importa en el procesamiento distribuido
- 69. Evitar un archivo por fila/evento
- 70. Los problemas de archivos pequeños son problemas operativos
- 71. El formato de archivo y la organización de la tabla son decisiones distintas
- 72. El formato y la compresión son decisiones distintas
- 73. El formato y la semántica de tabla son decisiones distintas
- 74. Evitar escribir en Delta si los consumidores solo entienden Parquet en bruto
- 75. Elegir el formato de intercambio según el consumidor
- 76. No convertir CSV en la fuente de verdad interna solo porque los usuarios quieren exportaciones CSV
- 77. No convertir JSON en la fuente de verdad solo porque la API de origen usa JSON
- 78. Combinar datos en bruto inmutables con tablas curadas mutables
- 79. Validar los viajes de ida y vuelta cuando importa la interoperabilidad
- 80. Elegir según la carga de trabajo, no según la popularidad
- Qué significa el resultado
- Qué revisar
- Las columnas CSV cambian de tipo entre ejecuciones
- El número de filas de JSON crece de forma inesperada tras aplanar
- Una consulta sobre Parquet sigue escaneando demasiados datos
- El MERGE de Delta falla o se comporta de forma ambigua
- El viaje en el tiempo de Delta ya no alcanza una versión antigua
- El almacenamiento tiene millones de archivos diminutos
- Notas de producción
- Los formatos de intercambio y los analíticos persiguen objetivos distintos
- El esquema debe ser explícito
- Delta requiere lectores/escritores compatibles con Delta
- La organización de los archivos puede importar tanto como el formato
- La retención afecta a la capacidad de recuperación
- Los consumidores externos definen las restricciones de interoperabilidad
- Errores comunes
- 1. Tratar CSV como datos tipados
- 2. Aplanar JSON sin definir la granularidad
- 3. Usar JSON para escaneos analíticos grandes y repetidos
- 4. Tratar Parquet como una tabla transaccional
- 5. Tratar Delta como una codificación que reemplaza a Parquet
- 6. Leer archivos Delta directamente como Parquet simple
- 7. Particionar por identificadores de alta cardinalidad
- 8. Crear un único archivo de salida gigante
- 9. Dejar que la inferencia del esquema defina los contratos de producción
- 10. Elegir un solo formato para todas las capas
- Siguiente paso
- Para profundizar
Problema
Necesitas almacenar o intercambiar datos y debes elegir un formato que se ajuste a la carga de trabajo.
Una mala elección puede generar innecesariamente:
- costo de análisis sintáctico
- deriva del esquema
- sobrecarga de almacenamiento
- análisis lentos
- actualizaciones frágiles
- datos duplicados
- mala interoperabilidad
- recuperación difícil
El objetivo no es elegir un ganador universal.
El objetivo es usar el formato adecuado para el papel que desempeña en la plataforma de datos.
Respuesta rápida
Usa este modelo de decisión:
Intercambio sencillo y legible por personas
→ CSV
Cargas útiles de API/eventos anidadas o semiestructuradas
→ JSON
Análisis con muchas lecturas sobre archivos inmutables
→ Parquet
Tablas analíticas que necesitan transacciones ACID, actualizaciones, eliminaciones, MERGE, gestión del esquema e historial de la tabla
→ Delta
Un patrón habitual en producción es:
intercambio externo/con el origen
→ CSV / JSON
zona de aterrizaje en bruto duradera
→ formato nativo del origen o Parquet/Delta
analítica curada
→ tablas Delta respaldadas por Parquet
capa de servicio/almacén
→ tablas Delta / del almacén
La distinción práctica:
CSV / JSON
→ formatos de serialización
Parquet
→ formato de archivo analítico columnar
Delta
→ formato de tabla construido sobre Parquet + registro de transacciones
Código / comandos
1. CSV: leer y escribir con pandas
Lectura:
import pandas as pd
df = pd.read_csv(
"orders.csv",
dtype={
"order_id": "string",
"customer_id": "string",
},
parse_dates=["created_at"],
)
Escritura:
df.to_csv(
"orders.csv",
index=False,
)
Usa CSV cuando la interoperabilidad y la sencillez importen más que un esquema estricto o la eficiencia analítica.
2. CSV: definir los tipos de forma explícita
Mal:
df = pd.read_csv("orders.csv")
si los identificadores o las fechas deben interpretarse de forma fiable.
Mejor:
df = pd.read_csv(
"orders.csv",
dtype={
"order_id": "string",
"postal_code": "string",
},
parse_dates=["created_at"],
)
Esto ayuda a evitar problemas como:
00123
→ se interpreta como 123
identificador grande
→ se interpreta como numérico
texto con aspecto de fecha
→ se interpreta de forma incoherente
3. CSV: tratar los valores nulos de forma deliberada
Ejemplo:
df = pd.read_csv(
"orders.csv",
na_values=["", "NULL", "null"],
keep_default_na=True,
)
No supongas que toda cadena vacía o toda cadena "NULL" tiene el mismo significado de negocio.
Define explícitamente el contrato del origen.
4. CSV: especificar la codificación cuando sea necesario
df = pd.read_csv(
"orders.csv",
encoding="utf-8",
)
Si la codificación es desconocida, no la adivines en silencio en un pipeline de producción.
Captura los fallos e inspecciona el contrato del origen.
5. CSV: usar bloques para archivos grandes
for chunk in pd.read_csv(
"large_orders.csv",
chunksize=100_000,
):
process(chunk)
Úsalo cuando el archivo sea más grande de lo que conviene procesar en memoria.
Leer por bloques no convierte CSV en columnar ni indexado; solo controla el uso de memoria.
6. CSV: validar la forma de las filas
Fallo típico:
se esperaban 12 columnas
una fila contiene 13 delimitadores
En producción, registra el número de filas mal formadas y aísla los registros incorrectos en lugar de descartarlos en silencio.
7. CSV: el entrecomillado importa
Campo de ejemplo:
"Smith, John"
contiene una coma, pero debe seguir siendo una sola columna.
Usa lectores/escritores que cumplan el estándar en lugar de un split(",") manual.
8. CSV: el delimitador forma parte del contrato
Algunos sistemas usan:
,
;
|
\t
Ejemplo:
df = pd.read_csv(
"orders.psv",
sep="|",
)
No supongas que todo «CSV» usa una coma.
9. CSV: puntos fuertes
Adecuado para:
exportaciones sencillas
inspección manual
compatibilidad con hojas de cálculo
integraciones heredadas
archivos de intercambio pequeños
Puntos débiles:
sin esquema estricto
sin estructura anidada
tipado pobre
alto costo de escaneo
problemas de delimitadores/entrecomillado
10. JSON: leer JSON delimitado por saltos de línea con pandas
Para JSON Lines / NDJSON:
df = pd.read_json(
"events.jsonl",
lines=True,
)
Es habitual en conjuntos de datos de eventos y logs.
11. JSON Lines es preferible a un único arreglo JSON gigante para archivos de tipo flujo
JSON Lines:
{"eventId": 1, "type": "click"}
{"eventId": 2, "type": "view"}
{"eventId": 3, "type": "purchase"}
Cada línea es un valor JSON independiente.
Ventajas:
- escritura incremental
- procesamiento línea por línea
- recuperación parcial más sencilla
- habitual en pipelines de logs/eventos
12. Arreglo JSON estándar
Ejemplo:
[
{
"eventId": 1,
"type": "click"
},
{
"eventId": 2,
"type": "view"
}
]
Es útil para respuestas de API y documentos acotados.
Es menos práctico para añadir datos a grandes conjuntos de datos de eventos.
13. JSON: estructura anidada
Ejemplo:
{
"orderId": 123,
"customer": {
"customerId": 45,
"country": "US"
},
"items": [
{
"sku": "A1",
"qty": 2
}
]
}
JSON encaja de forma natural con datos anidados/semiestructurados.
CSV no.
14. Aplanar JSON anidado con cuidado
Con pandas:
import json
import pandas as pd
with open("orders.json", "r", encoding="utf-8") as f:
payload = json.load(f)
orders = pd.json_normalize(payload)
Si hay arreglos, define primero la granularidad prevista.
Aplanar datos anidados puede multiplicar las filas de forma inesperada.
15. Los arreglos JSON pueden cambiar la granularidad de los datos
Ejemplo:
1 pedido
con
5 artículos
Aplanar a una fila por artículo produce:
5 filas
No agregues después suponiendo que la granularidad original sigue siendo un pedido por fila.
16. JSON: usar marcas de tiempo explícitas
Prefiere representaciones estándar de tipo ISO:
{
"createdAt": "2026-10-04T15:30:00Z"
}
en lugar de cadenas que dependen de la configuración regional, como:
10/04/26 3:30 PM
Aun así, los clientes deben interpretar los valores según el contrato documentado.
17. JSON: el esquema es flexible, no inexistente
JSON no impone un esquema por sí mismo.
Aun así, los sistemas de producción deben definir:
- los campos obligatorios
- los tipos
- los campos que admiten nulos
- el versionado
- las reglas de compatibilidad
Una representación flexible no elimina la necesidad de un contrato de datos.
18. JSON: evitar documentos gigantes y profundamente anidados para analítica
Analizar JSON anidado una y otra vez puede ser costoso.
Un buen patrón es:
ingerir el JSON de origen
→ conservar la carga útil en bruto
→ analizar/normalizar una sola vez
→ escribir en Parquet/Delta analítico
19. JSON: puntos fuertes
Adecuado para:
API
eventos
logs
datos semiestructurados
registros anidados
evolución del esquema en el borde
Puntos débiles:
verboso
orientado a filas
nombres de campo repetidos
escaneos analíticos costosos
ambigüedad de tipos
20. Parquet: leer con pandas
df = pd.read_parquet(
"orders.parquet",
columns=[
"order_id",
"created_at",
"amount",
],
)
Seleccionar solo las columnas necesarias reduce la E/S.
Es una ventaja clave del almacenamiento columnar.
21. Parquet: escribir con pandas
df.to_parquet(
"orders.parquet",
index=False,
)
La compresión depende del motor y de la configuración predeterminada.
En producción, elige la compresión de forma deliberada cuando importen la interoperabilidad o el rendimiento.
22. Parquet: leer con PySpark
df = (
spark.read
.parquet("/data/orders")
)
23. Parquet: seleccionar solo las columnas necesarias
df = (
spark.read
.parquet("/data/orders")
.select(
"order_id",
"created_at",
"amount",
)
)
La poda de columnas reduce la cantidad de datos leídos.
24. Parquet: filtrar pronto
df = (
spark.read
.parquet("/data/orders")
.filter("order_date >= '2026-10-01'")
.select(
"order_id",
"order_date",
"amount",
)
)
El predicate pushdown y la poda de particiones pueden reducir el trabajo de escaneo cuando las estadísticas y la organización de los archivos lo permiten.
Verifícalo con el plan de consulta en lugar de suponer que todos los filtros se envían al origen.
25. Parquet almacena datos columnares tipados
A diferencia de CSV, Parquet puede conservar tipos como:
integer
decimal
timestamp
boolean
string
estructuras anidadas
Esto reduce el análisis sintáctico repetido y la inferencia del esquema.
26. Parquet es adecuado para analítica
Ventajas típicas:
poda de columnas
compresión
esquema tipado
soporte de predicate pushdown
escaneos eficientes
soporte de datos anidados
Esto lo hace mucho mejor que CSV/JSON para consultas analíticas repetidas.
27. Parquet sigue siendo solo un conjunto de archivos
Una carpeta de archivos Parquet no proporciona automáticamente:
transacciones de tabla ACID
actualizaciones atómicas en varios archivos
semántica de MERGE
historial de la tabla
coordinación de escrituras concurrentes
Ahí es donde los formatos de tabla como Delta aportan valor.
28. Particionar Parquet de forma deliberada
Ejemplo de organización de directorios:
/orders/order_date=2026-10-01/
/orders/order_date=2026-10-02/
Usa particiones cuando ayuden a los filtros habituales y al mantenimiento.
No particiones por todas las columnas posibles.
29. Evitar particiones de cardinalidad muy alta
Malos candidatos:
order_id
transaction_id
customer_email
Pueden crear una cantidad enorme de directorios/archivos pequeños.
Prefiere columnas de partición con un valor práctico para la gestión o el filtrado de datos.
30. Evitar archivos Parquet diminutos
Miles o millones de archivos diminutos aumentan:
- la sobrecarga de metadatos
- el costo de apertura de archivos
- el trabajo del planificador
- la sobrecarga de planificación de consultas
Compacta los archivos cuando la plataforma o la carga de trabajo lo requieran.
No existe un tamaño de archivo ideal universal.
31. Evitar un único archivo Parquet gigante
Un archivo enorme puede reducir el paralelismo y complicar la reescritura o la recuperación.
El tamaño de los archivos debe tener en cuenta:
- el motor
- el almacenamiento
- la carga de trabajo
- la concurrencia
- el particionamiento
32. Compresión de Parquet
Códecs habituales:
Snappy
Gzip
Zstandard
Compensación:
más compresión
↔
más CPU
Elige según la carga de trabajo y la interoperabilidad.
33. La evolución del esquema en Parquet no es un protocolo transaccional
Añadir, eliminar o cambiar campos en archivos Parquet separados puede producir esquemas mixtos.
Algunos motores pueden combinar esquemas, pero esto tiene implicaciones de corrección y rendimiento.
Gobierna los cambios de esquema de forma explícita.
34. Delta: qué aporta
Una tabla Delta suele estar formada por:
archivos de datos Parquet
+
registro de transacciones _delta_log
El registro de transacciones proporciona semántica de tabla, como:
- transacciones ACID
- controles de aplicación/evolución del esquema
- actualizaciones/eliminaciones
- MERGE
- historial de la tabla
- gestión de la concurrencia
- viaje en el tiempo/lectura de versiones
35. Delta: leer una tabla con PySpark
df = (
spark.read
.format("delta")
.table("silver.orders")
)
o por ruta:
df = (
spark.read
.format("delta")
.load("/tables/silver/orders")
)
Prefiere las referencias de tabla cuando tu plataforma o catálogo las gestione.
36. Delta: append
(
df.write
.format("delta")
.mode("append")
.saveAsTable("bronze.orders")
)
Usa append para registros inmutables/nuevos cuando el tratamiento de duplicados ya esté definido.
37. Delta: sobrescribir de forma deliberada
(
df.write
.format("delta")
.mode("overwrite")
.saveAsTable("silver.orders_rebuild")
)
La sobrescritura (overwrite) puede reemplazar los datos de la tabla.
Úsala solo al reconstruir el alcance previsto.
Para reemplazos limitados a ciertas particiones, usa el patrón de reemplazo de particiones que admita la plataforma en lugar de sobrescribir a ciegas toda la tabla.
38. Delta: MERGE
from delta.tables import DeltaTable
target = DeltaTable.forName(
spark,
"silver.orders",
)
(
target.alias("t")
.merge(
source=df.alias("s"),
condition="t.order_id = s.order_id",
)
.whenMatchedUpdateAll()
.whenNotMatchedInsertAll()
.execute()
)
Úsalo cuando las filas puedan insertarse o actualizarse.
Valida la unicidad del origen antes de hacer MERGE.
39. El MERGE de Delta requiere claves de origen deterministas
Origen incorrecto:
order_id 123 aparece dos veces
Un MERGE puede volverse ambiguo o fallar según la operación y el comportamiento del motor.
Comprueba la granularidad del origen:
from pyspark.sql import functions as F
duplicates = (
df.groupBy("order_id")
.count()
.filter(F.col("count") > 1)
)
Resuelve los duplicados antes de escribir.
40. Delta admite eliminaciones
Ejemplo:
target.delete(
"is_deleted = true"
)
La eliminación es transaccional a nivel de tabla.
Ten cuidado con los predicados amplios en producción.
41. Delta admite operaciones de actualización
Ejemplo:
target.update(
condition="status = 'pending'",
set={
"status": "'expired'"
},
)
Usa predicados acotados y revisados.
42. Historial de una tabla Delta
SQL:
DESCRIBE HISTORY silver.orders;
Úsalo para inspeccionar:
- la operación
- la versión
- la marca de tiempo
- los metadatos de usuario/job cuando estén disponibles
- los parámetros/métricas de la operación según la plataforma
El historial mejora la observabilidad, pero no sustituye un registro de auditoría de negocio.
43. Viaje en el tiempo en Delta
Ejemplo:
previous = (
spark.read
.format("delta")
.option("versionAsOf", 42)
.table("silver.orders")
)
o:
previous = (
spark.read
.format("delta")
.option(
"timestampAsOf",
"2026-10-04T12:00:00Z",
)
.table("silver.orders")
)
La disponibilidad del historial depende de los archivos de log y de datos conservados.
44. VACUUM afecta a la capacidad de recuperación histórica
El mantenimiento de Delta puede eliminar archivos de datos antiguos que ya no necesita el estado actual de la tabla.
Si la retención se reduce de forma agresiva, es posible que las versiones antiguas dejen de poder leerse.
No acortes la retención sin entender:
- los lectores activos
- los jobs de streaming
- los requisitos de viaje en el tiempo
- las necesidades de reversión/recuperación
45. Delta no es un servidor de base de datos
Delta proporciona semántica de tabla sobre archivos/almacenamiento de objetos.
No proporciona automáticamente:
- latencia OLTP a nivel de fila
- servicio de aplicaciones transaccionales arbitrarias con alta concurrencia
- procedimientos almacenados
- semántica de conexión de base de datos
Úsalo para cargas de trabajo analíticas/lakehouse.
46. Delta no es «un tipo de archivo distinto que reemplaza a Parquet»
Los archivos de datos subyacentes son Parquet.
El registro de transacciones de Delta añade comportamiento de tabla alrededor de esos archivos.
Esta distinción importa al diagnosticar problemas o integrarse con motores.
47. No modificar directamente los archivos de datos de Delta
Mal:
eliminar manualmente un archivo Parquet
reemplazar un archivo fuera del protocolo transaccional
Esto puede corromper la coherencia de la tabla, porque el registro de transacciones sigue haciendo referencia al estado de la tabla.
Escribe mediante herramientas compatibles con Delta.
48. No tratar a la ligera un directorio Delta como Parquet simple
Leer solo:
*.parquet
puede ignorar:
- eliminaciones
- actualizaciones
- el estado transaccional
- archivos eliminados del registro
- la semántica de versiones
Usa un lector compatible con Delta para las tablas Delta.
49. Ejemplo de escaneo CSV frente a Parquet
Supón que una consulta necesita:
order_id
amount
de un conjunto de datos de 50 columnas.
CSV normalmente requiere analizar filas que contienen todas las columnas.
Parquet puede leer solo los bloques de columnas necesarios.
Por eso Parquet suele ser mejor para los escaneos analíticos.
50. JSON frente a Parquet para logs
Buen flujo:
eventos en bruto
→ JSON Lines
→ normalizar
→ Parquet/Delta
JSON conserva la fidelidad al origen.
Parquet/Delta mejoran las consultas analíticas repetidas.
51. CSV frente a JSON para intercambio
Elige CSV cuando haya:
estructura tabular plana
máxima compatibilidad
exportación/importación sencilla
Elige JSON cuando haya:
datos anidados
campos opcionales
cargas útiles jerárquicas
semántica de API/eventos
52. Parquet frente a Delta
Elige Parquet cuando haya:
archivos analíticos inmutables
intercambio de archivos sencillo
ninguna necesidad de comportamiento de tabla transaccional
Elige Delta cuando:
la tabla es mutable
se requiere MERGE
hay escritores/lectores concurrentes
importa la aplicación del esquema
se necesita historial/viaje en el tiempo
53. CSV rara vez debería ser el formato analítico curado
CSV puede seguir siendo válido cuando la interoperabilidad lo exige.
Pero para analítica interna a escala, analizar una y otra vez grandes conjuntos de datos CSV suele ser una sobrecarga innecesaria.
Prefiere un formato columnar tipado.
54. JSON rara vez debería ser el formato analítico final de gran volumen
JSON es valioso en los límites de la ingesta.
La analítica curada suele beneficiarse de convertirlo a:
Parquet
o
Delta
una vez que se comprenden el esquema y la granularidad.
55. Conservar el origen en bruto cuando importa el linaje
Un patrón Bronze útil:
almacenar el archivo/la carga útil original
+
metadatos de ingesta
Esto ayuda con:
- la reejecución
- la auditoría
- las correcciones del parser
- los cambios de esquema
- las disputas con el origen
56. Añadir metadatos de ingesta
Columnas útiles:
source_file
ingested_at
batch_id
source_system
record_hash
No sobrescribas la semántica del origen con los metadatos de ingesta.
Conserva ambos.
57. Validar el esquema de forma explícita
Ejemplo en PySpark:
expected = {
"order_id",
"created_at",
"amount",
}
actual = set(df.columns)
missing = expected - actual
if missing:
raise ValueError(
f"Missing required columns: {sorted(missing)}"
)
La validación del esquema es especialmente importante para orígenes CSV/JSON.
58. Validar los tipos de datos después del análisis
Ejemplo:
df.printSchema()
Busca casos inesperados como:
string en lugar de timestamp
double en lugar de decimal
columna inferida que solo contiene nulos
No confíes en la inferencia para pipelines de producción críticos.
59. Usar un esquema explícito para la ingesta con Spark
Ejemplo:
from pyspark.sql.types import (
StructType,
StructField,
StringType,
TimestampType,
DecimalType,
)
schema = StructType([
StructField("order_id", StringType(), False),
StructField("created_at", TimestampType(), True),
StructField("amount", DecimalType(18, 2), True),
])
Después:
df = (
spark.read
.schema(schema)
.json("/landing/orders/*.json")
)
Esto evita una inferencia incoherente entre archivos.
60. Evitar la inferencia del esquema en cada ejecución de producción
La inferencia puede:
- escanear datos adicionales
- cambiar según las muestras del origen
- inferir tipos distintos tras cambios en el origen
Un esquema explícito es más predecible.
61. Los datos decimales merecen tipos explícitos
Los valores financieros no deberían almacenarse automáticamente como coma flotante.
Prefiere una precisión/escala decimal adecuada cuando se requiera aritmética exacta.
Ejemplo:
DECIMAL(18,2)
La precisión correcta depende de los requisitos de negocio.
62. Las fechas y marcas de tiempo requieren una semántica de zona horaria clara
Para intercambio:
2026-10-04T15:30:00Z
es más claro que una marca de tiempo local sin desfase.
Almacena explícitamente la semántica de zona horaria/UTC.
63. CSV no distingue tipos de forma nativa
Estos valores:
00123
123
true
2026-10-04
son todos texto en el archivo.
El lector decide sus tipos.
Es un motivo importante para validar el análisis.
64. JSON tiene tipos, pero sigue habiendo ambigüedad
JSON admite:
string
number
boolean
null
array
object
Pero no distingue:
el ancho de los enteros
la precisión decimal
el tipo timestamp
el tipo date
sin un contrato de esquema.
65. Parquet conserva tipos físicos más ricos
Esto mejora la interoperabilidad entre motores analíticos cuando se usan tipos compatibles.
Aun así, valida el comportamiento entre motores para:
- marcas de tiempo
- decimales
- tipos anidados
- anotaciones lógicas
66. La compresión depende del formato
Tendencia general:
CSV
→ normalmente grande salvo que se comprima externamente
JSON
→ verboso porque los nombres de campo se repiten
Parquet
→ fuerte compresión columnar
Delta
→ misma compresión de datos de Parquet + sobrecarga del registro de transacciones
El tamaño real depende de la distribución de los datos y del códec.
67. Un CSV comprimido con gzip puede ser pequeño y aun así costoso de consultar
La compresión reduce el tamaño de almacenamiento/transferencia.
No hace que CSV sea:
- tipado
- columnar
- legible de forma selectiva
Una consulta puede seguir necesitando descomprimir y analizar el flujo.
68. La divisibilidad importa en el procesamiento distribuido
Los archivos comprimidos grandes pueden reducir la eficiencia de la lectura en paralelo según el comportamiento de la compresión/el contenedor.
Parquet está diseñado para lecturas analíticas en paralelo.
No crees un único archivo de texto comprimido enorme esperando un rendimiento distribuido ideal.
69. Evitar un archivo por fila/evento
Todos los formatos sufren con un número excesivo de archivos.
El almacenamiento de objetos y los motores distribuidos tienen una sobrecarga no trivial de metadatos/apertura de archivos.
Agrupa los registros en archivos de tamaño razonable según la carga de trabajo.
70. Los problemas de archivos pequeños son problemas operativos
Síntomas:
- tiempo de planificación largo
- listado de directorios lento
- número excesivo de tareas
- sobrecarga de metadatos
- baja eficiencia de escaneo
Corrígelo en la ingesta/organización de la escritura en lugar de limitarte a añadir capacidad de cómputo.
71. El formato de archivo y la organización de la tabla son decisiones distintas
Ejemplo:
formato Parquet
+
partición por fecha
+
archivos de tamaño razonable
puede rendir bien.
Un mal particionamiento y los archivos diminutos pueden hacer que incluso Parquet sea lento.
72. El formato y la compresión son decisiones distintas
Ejemplo:
Parquet + Snappy
Parquet + Zstd
CSV + gzip
JSONL + gzip
Elige ambos de forma intencionada.
73. El formato y la semántica de tabla son decisiones distintas
Parquet
→ formato de archivo
Delta
→ formato/protocolo de tabla que usa archivos Parquet
Es una de las distinciones más importantes.
74. Evitar escribir en Delta si los consumidores solo entienden Parquet en bruto
Si el consumidor externo no puede interpretar la semántica de las tablas Delta, decide si conviene:
- exponer un acceso compatible a las tablas
- exportar una instantánea en Parquet
- exportar a CSV/JSON
- usar una interfaz de uso compartido/consulta
No pidas a los consumidores que lean el directorio Delta como si fuera Parquet cualquiera.
75. Elegir el formato de intercambio según el consumidor
Para entregas externas:
usuario de negocio
→ CSV puede ser lo más sencillo
integración de API
→ JSON
motor analítico
→ Parquet
plataforma compatible con lakehouse
→ Delta
La arquitectura debe tener en cuenta las capacidades de los sistemas posteriores.
76. No convertir CSV en la fuente de verdad interna solo porque los usuarios quieren exportaciones CSV
Mantén una representación interna tipada.
Exporta a CSV en el límite.
Así se preserva la calidad analítica y se mantiene la compatibilidad.
77. No convertir JSON en la fuente de verdad solo porque la API de origen usa JSON
Conserva el JSON en bruto si es necesario y después normalízalo en tablas analíticas gobernadas.
78. Combinar datos en bruto inmutables con tablas curadas mutables
Patrón habitual:
Bronze
→ append de datos en bruto/alineados con el origen
Silver
→ Delta limpio/deduplicado/actualizado mediante upsert
Gold
→ Delta/almacén listo para los consumidores
Esto separa la capacidad de reejecución de la mutabilidad de los datos curados.
79. Validar los viajes de ida y vuelta cuando importa la interoperabilidad
Ejemplo:
escribir el archivo
→ leerlo con el motor de destino
→ comparar el número de filas, el esquema y los campos clave
No supongas que una escritura correcta en una biblioteca implica compatibilidad perfecta en todas partes.
80. Elegir según la carga de trabajo, no según la popularidad
Orden de decisión:
1. ¿Qué consume los datos?
2. ¿Los datos son planos o anidados?
3. ¿Se requiere un tipado estricto?
4. ¿La carga de trabajo es analítica?
5. ¿Se requieren actualizaciones/eliminaciones/MERGE?
6. ¿La interoperabilidad importa más que la velocidad de consulta?
7. ¿Necesitamos transacciones/historial?
8. ¿Qué escala/organización de archivos se espera?
Después elige el formato.
Qué significa el resultado
| Formato | Uso ideal | Principal fortaleza | Principal limitación |
|---|---|---|---|
| CSV | Intercambio/exportación de datos planos | Compatibilidad universal | Tipado débil, analítica costosa |
| JSON | API/eventos/datos semiestructurados | Estructura anidada y flexible | Verboso, análisis repetidos costosos |
| Parquet | Archivos analíticos | Escaneos columnares tipados | Sin semántica de tabla transaccional por sí solo |
| Delta | Tablas lakehouse mutables | ACID + MERGE + historial sobre Parquet | Requiere herramientas compatibles con Delta |
Un modelo mental práctico es:
CSV
→ texto adecuado para hojas de cálculo
JSON
→ texto estructurado adecuado para aplicaciones/eventos
Parquet
→ archivos columnares adecuados para analítica
Delta
→ semántica de tabla analítica alrededor de Parquet
Qué revisar
Las columnas CSV cambian de tipo entre ejecuciones
Revisa:
- la inferencia del esquema
- los ceros a la izquierda
- los marcadores de nulos
- las filas mal formadas
- los cambios de configuración regional/formato de fecha
Usa un esquema explícito.
El número de filas de JSON crece de forma inesperada tras aplanar
Probablemente los arreglos anidados cambiaron la granularidad del resultado.
Valida las claves de negocio antes de agregar.
Una consulta sobre Parquet sigue escaneando demasiados datos
Revisa:
- las columnas seleccionadas
- los filtros
- la poda de particiones
- las estadísticas de los archivos
- la organización de los archivos
- los archivos pequeños
- el plan de consulta
El MERGE de Delta falla o se comporta de forma ambigua
Revisa:
- las claves duplicadas en el origen
- la granularidad del destino
- la condición de merge
- las escrituras concurrentes
El viaje en el tiempo de Delta ya no alcanza una versión antigua
Revisa la retención/VACUUM y la disponibilidad de los archivos de datos.
El almacenamiento tiene millones de archivos diminutos
Corrige la estrategia de agrupación/particionamiento/compactación en origen.
Notas de producción
Los formatos de intercambio y los analíticos persiguen objetivos distintos
CSV/JSON optimizan la compatibilidad y la fidelidad al origen.
Parquet/Delta optimizan el procesamiento analítico y un comportamiento de tabla gobernado.
El esquema debe ser explícito
Los formatos de texto, en especial, necesitan una gestión deliberada del esquema.
La inferencia es cómoda para explorar, no un contrato de producción sólido.
Delta requiere lectores/escritores compatibles con Delta
No eludas el protocolo transaccional modificando archivos manualmente.
La organización de los archivos puede importar tanto como el formato
El particionamiento y el comportamiento de los archivos pequeños pueden dominar el rendimiento.
La retención afecta a la capacidad de recuperación
El historial y el viaje en el tiempo de Delta dependen de los archivos de transacciones/datos conservados.
No reduzcas la retención a la ligera.
Los consumidores externos definen las restricciones de interoperabilidad
A veces CSV es la salida correcta aunque la plataforma interna use Delta.
Usa formatos distintos en límites distintos.
Errores comunes
1. Tratar CSV como datos tipados
El archivo almacena texto. Los lectores infieren/asignan los tipos.
2. Aplanar JSON sin definir la granularidad
Los arreglos pueden multiplicar los registros.
3. Usar JSON para escaneos analíticos grandes y repetidos
Normaliza una sola vez y escribe datos columnares.
4. Tratar Parquet como una tabla transaccional
Parquet por sí solo no proporciona semántica de tabla ACID.
5. Tratar Delta como una codificación que reemplaza a Parquet
Delta usa archivos de datos Parquet más un registro de transacciones.
6. Leer archivos Delta directamente como Parquet simple
Puedes ignorar el estado de la tabla y los archivos eliminados del registro.
7. Particionar por identificadores de alta cardinalidad
Esto crea un exceso de directorios/archivos.
8. Crear un único archivo de salida gigante
Esto puede reducir el paralelismo y aumentar el riesgo operativo.
9. Dejar que la inferencia del esquema defina los contratos de producción
El esquema puede derivar de forma inesperada.
10. Elegir un solo formato para todas las capas
El intercambio con el origen, el almacenamiento en bruto, la analítica curada y la entrega externa suelen necesitar formatos distintos.
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.