Explorar guías rápidas · Ingeniería de datos

Tecnología: Ingeniería de datosCategoría: Almacenamiento y formatos de archivoNivel: IntermedioActualizado

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
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. CSV: leer y escribir con pandas
  5. 2. CSV: definir los tipos de forma explícita
  6. 3. CSV: tratar los valores nulos de forma deliberada
  7. 4. CSV: especificar la codificación cuando sea necesario
  8. 5. CSV: usar bloques para archivos grandes
  9. 6. CSV: validar la forma de las filas
  10. 7. CSV: el entrecomillado importa
  11. 8. CSV: el delimitador forma parte del contrato
  12. 9. CSV: puntos fuertes
  13. 10. JSON: leer JSON delimitado por saltos de línea con pandas
  14. 11. JSON Lines es preferible a un único arreglo JSON gigante para archivos de tipo flujo
  15. 12. Arreglo JSON estándar
  16. 13. JSON: estructura anidada
  17. 14. Aplanar JSON anidado con cuidado
  18. 15. Los arreglos JSON pueden cambiar la granularidad de los datos
  19. 16. JSON: usar marcas de tiempo explícitas
  20. 17. JSON: el esquema es flexible, no inexistente
  21. 18. JSON: evitar documentos gigantes y profundamente anidados para analítica
  22. 19. JSON: puntos fuertes
  23. 20. Parquet: leer con pandas
  24. 21. Parquet: escribir con pandas
  25. 22. Parquet: leer con PySpark
  26. 23. Parquet: seleccionar solo las columnas necesarias
  27. 24. Parquet: filtrar pronto
  28. 25. Parquet almacena datos columnares tipados
  29. 26. Parquet es adecuado para analítica
  30. 27. Parquet sigue siendo solo un conjunto de archivos
  31. 28. Particionar Parquet de forma deliberada
  32. 29. Evitar particiones de cardinalidad muy alta
  33. 30. Evitar archivos Parquet diminutos
  34. 31. Evitar un único archivo Parquet gigante
  35. 32. Compresión de Parquet
  36. 33. La evolución del esquema en Parquet no es un protocolo transaccional
  37. 34. Delta: qué aporta
  38. 35. Delta: leer una tabla con PySpark
  39. 36. Delta: append
  40. 37. Delta: sobrescribir de forma deliberada
  41. 38. Delta: MERGE
  42. 39. El MERGE de Delta requiere claves de origen deterministas
  43. 40. Delta admite eliminaciones
  44. 41. Delta admite operaciones de actualización
  45. 42. Historial de una tabla Delta
  46. 43. Viaje en el tiempo en Delta
  47. 44. VACUUM afecta a la capacidad de recuperación histórica
  48. 45. Delta no es un servidor de base de datos
  49. 46. Delta no es «un tipo de archivo distinto que reemplaza a Parquet»
  50. 47. No modificar directamente los archivos de datos de Delta
  51. 48. No tratar a la ligera un directorio Delta como Parquet simple
  52. 49. Ejemplo de escaneo CSV frente a Parquet
  53. 50. JSON frente a Parquet para logs
  54. 51. CSV frente a JSON para intercambio
  55. 52. Parquet frente a Delta
  56. 53. CSV rara vez debería ser el formato analítico curado
  57. 54. JSON rara vez debería ser el formato analítico final de gran volumen
  58. 55. Conservar el origen en bruto cuando importa el linaje
  59. 56. Añadir metadatos de ingesta
  60. 57. Validar el esquema de forma explícita
  61. 58. Validar los tipos de datos después del análisis
  62. 59. Usar un esquema explícito para la ingesta con Spark
  63. 60. Evitar la inferencia del esquema en cada ejecución de producción
  64. 61. Los datos decimales merecen tipos explícitos
  65. 62. Las fechas y marcas de tiempo requieren una semántica de zona horaria clara
  66. 63. CSV no distingue tipos de forma nativa
  67. 64. JSON tiene tipos, pero sigue habiendo ambigüedad
  68. 65. Parquet conserva tipos físicos más ricos
  69. 66. La compresión depende del formato
  70. 67. Un CSV comprimido con gzip puede ser pequeño y aun así costoso de consultar
  71. 68. La divisibilidad importa en el procesamiento distribuido
  72. 69. Evitar un archivo por fila/evento
  73. 70. Los problemas de archivos pequeños son problemas operativos
  74. 71. El formato de archivo y la organización de la tabla son decisiones distintas
  75. 72. El formato y la compresión son decisiones distintas
  76. 73. El formato y la semántica de tabla son decisiones distintas
  77. 74. Evitar escribir en Delta si los consumidores solo entienden Parquet en bruto
  78. 75. Elegir el formato de intercambio según el consumidor
  79. 76. No convertir CSV en la fuente de verdad interna solo porque los usuarios quieren exportaciones CSV
  80. 77. No convertir JSON en la fuente de verdad solo porque la API de origen usa JSON
  81. 78. Combinar datos en bruto inmutables con tablas curadas mutables
  82. 79. Validar los viajes de ida y vuelta cuando importa la interoperabilidad
  83. 80. Elegir según la carga de trabajo, no según la popularidad
  84. Qué significa el resultado
  85. Qué revisar
  86. Las columnas CSV cambian de tipo entre ejecuciones
  87. El número de filas de JSON crece de forma inesperada tras aplanar
  88. Una consulta sobre Parquet sigue escaneando demasiados datos
  89. El MERGE de Delta falla o se comporta de forma ambigua
  90. El viaje en el tiempo de Delta ya no alcanza una versión antigua
  91. El almacenamiento tiene millones de archivos diminutos
  92. Notas de producción
  93. Los formatos de intercambio y los analíticos persiguen objetivos distintos
  94. El esquema debe ser explícito
  95. Delta requiere lectores/escritores compatibles con Delta
  96. La organización de los archivos puede importar tanto como el formato
  97. La retención afecta a la capacidad de recuperación
  98. Los consumidores externos definen las restricciones de interoperabilidad
  99. Errores comunes
  100. 1. Tratar CSV como datos tipados
  101. 2. Aplanar JSON sin definir la granularidad
  102. 3. Usar JSON para escaneos analíticos grandes y repetidos
  103. 4. Tratar Parquet como una tabla transaccional
  104. 5. Tratar Delta como una codificación que reemplaza a Parquet
  105. 6. Leer archivos Delta directamente como Parquet simple
  106. 7. Particionar por identificadores de alta cardinalidad
  107. 8. Crear un único archivo de salida gigante
  108. 9. Dejar que la inferencia del esquema defina los contratos de producción
  109. 10. Elegir un solo formato para todas las capas
  110. Siguiente paso
  111. 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.

Siguiente paso

Elige en función de la carga de trabajo.

  • Necesitas una exportación/importación plana sencilla → usa CSV.
  • Necesitas cargas útiles de API/eventos anidadas → usa JSON/JSON Lines.
  • Necesitas escaneos analíticos eficientes sobre datos inmutables → usa Parquet.
  • Necesitas MERGE, actualizaciones, eliminaciones, concurrencia e historial → usa Delta.
  • La ingesta de CSV/JSON es lenta una y otra vez → normaliza una sola vez a Parquet/Delta.
  • Las consultas sobre Parquet siguen siendo lentas → inspecciona el particionamiento, la poda, las columnas seleccionadas y la organización de los archivos.
  • Las escrituras en Delta entran en conflicto → inspecciona la concurrencia y los patrones de escritura.
  • El viaje en el tiempo importa → define una política de retención/VACUUM para Delta.
  • Los consumidores externos no pueden leer Delta → exporta a un formato interoperable adecuado.
  • Necesitas un diseño más amplio de la capa de tablas → pasa a Referencia rápida de la arquitectura Medallion.

← Todas las guías rápidas