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

Tecnología: Ingeniería de datosCategoría: Calidad de datosNivel: IntermedioActualizado

Controles de calidad de datos

Crea controles de calidad de datos prácticos para esquema, completitud, unicidad, validez, integridad referencial, frescura, conciliación y deriva de pipelines sin depender de umbrales universales arbitrarios.

En esta página
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Validar las columnas obligatorias
  5. 2. Detectar columnas inesperadas
  6. 3. Validar los tipos de datos de Spark
  7. 4. Comprobar los campos obligatorios no nulos
  8. 5. Comprobar el porcentaje de nulos
  9. 6. Evitar recorrer la tabla repetidamente
  10. 7. Comprobar la unicidad de la clave de negocio
  11. 8. Validar la unicidad de una clave compuesta
  12. 9. No usar dropDuplicates() como control de calidad
  13. 10. Inspeccionar ejemplos de duplicados
  14. 11. Validar el grano de las filas después de los joins
  15. 12. Validar un rango numérico
  16. 13. Validar valores de dominio acotados
  17. 14. Validar códigos de moneda
  18. 15. Validar patrones de cadenas
  19. 16. Comprobar las cadenas vacías por separado de los nulos
  20. 17. Normalizar los espacios en blanco antes de validar cuando corresponda
  21. 18. Validar rangos de fechas
  22. 19. Validar fechas futuras imposibles
  23. 20. Validar el parseo de marcas de tiempo
  24. 21. Conservar los valores sin procesar durante el parseo
  25. 22. Validar la integridad referencial
  26. 23. Tener cuidado con los tiempos de los datos de referencia
  27. 24. Poner en cuarentena los registros no válidos
  28. 25. Añadir códigos de motivo
  29. 26. Validar la presencia de los archivos de origen
  30. 27. Validar el número de archivos de origen
  31. 28. Validar la completitud de las particiones
  32. 29. Validar la frescura
  33. 30. Separar la frescura de la fuente de la frescura del pipeline
  34. 31. Comparar el número de filas con el historial
  35. 32. Basar los umbrales de anomalía en evidencia
  36. 33. Validar con cuidado las cargas de cero filas
  37. 34. Conciliar los totales financieros
  38. 35. Conciliar por segmento de negocio
  39. 36. Conciliar al grano esperado
  40. 37. Comprobar duplicados al preparar un MERGE
  41. 38. Validar antes de avanzar el watermark
  42. 39. Validar también después de escribir
  43. 40. Comprobar la idempotencia
  44. 41. Conservar los identificadores de lote
  45. 42. Detectar archivos de origen repetidos
  46. 43. Usar hashes con cuidado
  47. 44. No aplicar hash a ciegas sobre una serialización inestable
  48. 45. Validar las reglas de comparación seguras ante nulos
  49. 46. Validar la deriva del esquema
  50. 47. Detectar deliberadamente la ampliación o reducción de tipos
  51. 48. Validar la precisión y la escala de los decimales
  52. 49. Validar las suposiciones de zona horaria
  53. 50. Comprobar el comportamiento en los límites de fecha
  54. 51. Validar las enumeraciones contra una tabla de referencia
  55. 52. Validar las expectativas de uno a muchos
  56. 53. Comprobar filas hijas huérfanas
  57. 54. Validar las relaciones entre agregados
  58. 55. Validar relaciones de proporción
  59. 56. Detectar combinaciones imposibles
  60. 57. Validar las transiciones del ciclo de vida
  61. 58. Comprobar los campos de secuencia monótona
  62. 59. Validar los identificadores de evento
  63. 60. Los controles de calidad de datos pueden ser de advertencia o bloqueantes
  64. 61. Usar la severidad de forma deliberada
  65. 62. Evitar una única puntuación de calidad global
  66. 63. Asignar identificadores de regla estables
  67. 64. Registrar los resultados de las reglas
  68. 65. Conservar muestras de los fallos
  69. 66. Proteger los datos sensibles en los logs de calidad
  70. 67. Conciliar el número de filas antes y después de los filtros
  71. 68. Mantener explícita la contabilidad de rechazos
  72. 69. Validar los joins para detectar multiplicación de filas
  73. 70. Aplicar conceptualmente controles de tipo validate en pipelines distribuidos
  74. 71. Validar el número de filas por partición
  75. 72. Validar los totales por partición
  76. 73. Detectar particiones o lotes duplicados
  77. 74. Validar los límites incrementales
  78. 75. Usar ventanas de tiempo semiabiertas de forma coherente
  79. 76. Comprobar los registros que llegan tarde
  80. 77. Detectar la deriva de las distribuciones
  81. 78. Comprobar la distribución categórica
  82. 79. Comprobar el resumen numérico
  83. 80. Usar los percentiles con cuidado
  84. 81. Comparar las métricas actuales con las históricas
  85. 82. Detectar columnas completamente nulas
  86. 83. Comprobar las columnas constantes
  87. 84. Tener cuidado con los controles distinct costosos
  88. 85. Muestrear solo para explorar, no para las garantías finales
  89. 86. Evitar recopilar grandes conjuntos no válidos en el driver
  90. 87. Limitar los ejemplos en las alertas
  91. 88. Conservar por separado la evidencia completa de los fallos
  92. 89. Validar el esquema de destino después de escribir
  93. 90. Validar la unicidad del destino después de un MERGE
  94. 91. Comparar las claves de origen y de destino
  95. 92. El ámbito de la conciliación debe coincidir
  96. 93. Validar los conteos antes de una sobrescritura destructiva
  97. 94. Añadir salvaguardas a las reconstrucciones
  98. 95. Las reglas de calidad deben versionarse junto con el código
  99. 96. Separar los defectos de la fuente de los defectos del pipeline
  100. 97. Los controles de calidad necesitan un responsable
  101. 98. Definir la ruta de corrección
  102. 99. La calidad de datos corresponde a varias capas
  103. 100. Usar un flujo de calidad repetible
  104. Qué significa el resultado
  105. Qué revisar
  106. El número de filas cae de repente
  107. El número de filas aumenta de repente
  108. Aparecen claves duplicadas después de un join
  109. La tasa de nulos se dispara
  110. Los totales financieros no cuadran, pero el número de filas sí
  111. El control de frescura falla, pero la duración del pipeline es normal
  112. Notas de producción
  113. Los controles consumen cómputo
  114. Las reglas bloqueantes deben ser deterministas
  115. El estado de la calidad debe ser auditable
  116. La cuarentena no es un cubo de basura
  117. Los umbrales deben basarse en evidencia
  118. Los controles de calidad solo deben bloquear por defecto donde el negocio lo requiera
  119. Errores comunes
  120. 1. Usar una única puntuación de calidad genérica
  121. 2. Eliminar duplicados sin investigarlos
  122. 3. Tratar cada nulo como un error
  123. 4. Tratar cero filas como siempre no válido
  124. 5. Depender solo del número de filas
  125. 6. Comprobar la calidad solo antes de escribir
  126. 7. Usar umbrales arbitrarios
  127. 8. Recopilar todas las filas incorrectas en el driver
  128. 9. Avanzar los watermarks antes de superar los controles bloqueantes
  129. 10. Alertar sin un responsable ni una ruta de corrección
  130. Siguiente paso
  131. Para profundizar

Problema

Un pipeline puede completarse correctamente y aun así producir datos incorrectos.

Los fallos típicos incluyen:

  • filas faltantes
  • claves de negocio duplicadas
  • nulos inesperados
  • valores no válidos
  • deriva del esquema
  • claves externas rotas
  • datos obsoletos
  • cargas duplicadas
  • agregados incorrectos
  • particiones cargadas parcialmente
  • cambios de tipo silenciosos

El objetivo es que los controles de calidad de datos sean específicos del conjunto de datos y del contrato de negocio, detectar los fallos lo antes posible y dirigir los datos incorrectos al siguiente paso adecuado, en lugar de depender de una «puntuación de calidad» genérica.

Respuesta rápida

Un conjunto sólido de controles en producción suele cubrir:

Esquema
→ columnas y tipos esperados

Completitud
→ los valores obligatorios están presentes

Unicidad
→ las claves son únicas en el grano esperado

Validez
→ los valores cumplen las reglas del dominio

Integridad referencial
→ las referencias externas/de negocio existen

Frescura
→ los datos llegaron cuando se esperaba

Volumen
→ los conteos de filas/particiones son plausibles

Conciliación
→ los totales de negocio coinciden con lo esperado según la fuente de confianza

Deriva
→ las distribuciones o los contratos cambiaron de forma inesperada

Ejemplo base en PySpark:

from pyspark.sql import functions as F

result = (
    df.agg(
        F.count("*").alias("row_count"),
        F.countDistinct("order_id").alias("distinct_order_id"),
        F.sum(
            F.when(F.col("order_id").isNull(), 1).otherwise(0)
        ).alias("null_order_id"),
        F.sum("amount").alias("amount_total"),
        F.min("order_date").alias("min_order_date"),
        F.max("order_date").alias("max_order_date"),
    )
    .collect()[0]
)

La regla clave es:

los controles deben hacer cumplir un contrato conocido
no inventar umbrales arbitrarios

Código / comandos

1. Validar las columnas obligatorias

required_columns = {
    "order_id",
    "customer_id",
    "order_date",
    "amount",
}

actual_columns = set(df.columns)

missing = required_columns - actual_columns

if missing:
    raise ValueError(
        f"Missing required columns: {sorted(missing)}"
    )

Úsalo antes de las transformaciones que dan por hecho que esos campos existen.


2. Detectar columnas inesperadas

allowed_columns = {
    "order_id",
    "customer_id",
    "order_date",
    "amount",
    "currency",
}

unexpected = set(df.columns) - allowed_columns

if unexpected:
    print(
        f"Unexpected columns: {sorted(unexpected)}"
    )

Que falle o solo avise depende de tu política de evolución del esquema.


3. Validar los tipos de datos de Spark

expected_types = {
    "order_id": "string",
    "customer_id": "string",
    "order_date": "date",
    "amount": "decimal(18,2)",
}

actual_types = {
    field.name: field.dataType.simpleString()
    for field in df.schema.fields
}

mismatches = {
    name: {
        "expected": expected,
        "actual": actual_types.get(name),
    }
    for name, expected in expected_types.items()
    if actual_types.get(name) != expected
}

if mismatches:
    raise ValueError(
        f"Schema type mismatches: {mismatches}"
    )

Usa tipos explícitos en los pipelines críticos.


4. Comprobar los campos obligatorios no nulos

from pyspark.sql import functions as F

required_not_null = [
    "order_id",
    "order_date",
]

null_checks = [
    F.sum(
        F.when(F.col(c).isNull(), 1).otherwise(0)
    ).alias(f"{c}_nulls")
    for c in required_not_null
]

result = df.agg(*null_checks)
result.show(truncate=False)

Una clave de negocio principal a menudo no debería tener ningún nulo.

No apliques reglas de cero nulos a campos opcionales.


5. Comprobar el porcentaje de nulos

row_count = df.count()

null_stats = df.agg(
    *[
        (
            F.sum(
                F.when(F.col(c).isNull(), 1).otherwise(0)
            ) / F.lit(row_count)
        ).alias(f"{c}_null_pct")
        for c in df.columns
    ]
)

null_stats.show(truncate=False)

Usa porcentajes para monitorear la deriva.

No supongas que existe un porcentaje de nulos aceptable universal.


6. Evitar recorrer la tabla repetidamente

En lugar de ejecutar:

count()
contar nulos
contar duplicados
sumar el importe

como acciones separadas, combina los controles en una sola agregación cuando sea viable.

Los recorridos distribuidos son costosos.


7. Comprobar la unicidad de la clave de negocio

duplicates = (
    df.groupBy("order_id")
    .count()
    .filter(F.col("count") > 1)
)

duplicate_count = duplicates.count()

Si se espera que order_id defina una sola fila, cualquier duplicado es una violación del contrato.


8. Validar la unicidad de una clave compuesta

duplicates = (
    df.groupBy(
        "merchant_id",
        "order_id",
    )
    .count()
    .filter(F.col("count") > 1)
)

Usa el grano de negocio real, no una sola columna elegida arbitrariamente.


9. No usar dropDuplicates() como control de calidad

Mal:

df = df.dropDuplicates(["order_id"])

Esto oculta la evidencia.

Primero detecta e inspecciona los duplicados.

Después resuélvelos con una regla de negocio documentada.


10. Inspeccionar ejemplos de duplicados

duplicate_keys = (
    df.groupBy("order_id")
    .count()
    .filter(F.col("count") > 1)
    .select("order_id")
)

examples = (
    df.join(
        duplicate_keys,
        on="order_id",
        how="inner",
    )
    .orderBy("order_id")
)

examples.show(100, truncate=False)

Revisa si los duplicados son:

  • duplicados reales de la fuente
  • reintentos
  • registros versionados
  • multiplicación por joins
  • varios eventos legítimos

11. Validar el grano de las filas después de los joins

Supón que la salida debe tener una fila por pedido.

Comprueba:

summary = df.agg(
    F.count("*").alias("rows"),
    F.countDistinct("order_id").alias("distinct_orders"),
)

summary.show()

Si:

rows > distinct_orders

investiga si se esperan varias filas por pedido.


12. Validar un rango numérico

Ejemplo:

invalid = df.filter(
    F.col("amount") < 0
)

Trata los valores negativos como no válidos solo si el contrato de negocio así lo indica.

Las devoluciones y los reembolsos pueden ser negativos legítimamente.


13. Validar valores de dominio acotados

allowed_status = [
    "pending",
    "completed",
    "cancelled",
]

invalid_status = df.filter(
    ~F.col("status").isin(allowed_status)
    & F.col("status").isNotNull()
)

Usa un conjunto de valores gobernado.


14. Validar códigos de moneda

Ejemplo:

invalid_currency = df.filter(
    ~F.col("currency").isin(
        "USD",
        "CAD",
        "EUR",
    )
)

En producción, usa la referencia de monedas admitidas por la organización en lugar de codificar de forma fija suposiciones globales incompletas.


15. Validar patrones de cadenas

Ejemplo:

invalid_ids = df.filter(
    ~F.col("order_id").rlike(r"^[A-Z0-9\-]+$")
)

Usa expresiones regulares solo cuando el contrato del identificador esté realmente definido.

No inventes restricciones de formato a partir de simples muestras.


16. Comprobar las cadenas vacías por separado de los nulos

empty_names = df.filter(
    F.trim(F.col("customer_name")) == ""
)

Un nulo y una cadena vacía son estados distintos.

No los combines salvo que la regla de negocio diga que son equivalentes.


17. Normalizar los espacios en blanco antes de validar cuando corresponda

df = df.withColumn(
    "country_code",
    F.trim(F.col("country_code"))
)

No normalices en silencio identificadores en los que los espacios iniciales o finales tienen significado.


18. Validar rangos de fechas

Ejemplo:

invalid_dates = df.filter(
    F.col("end_date") < F.col("start_date")
)

Es una regla semántica defendible.


19. Validar fechas futuras imposibles

Si las reglas de negocio prohíben eventos con fecha futura:

invalid = df.filter(
    F.col("event_date") > F.current_date()
)

Úsalo solo donde las fechas futuras sean realmente no válidas.


20. Validar el parseo de marcas de tiempo

Si las marcas de tiempo de la fuente son cadenas:

parsed = df.withColumn(
    "event_ts_parsed",
    F.to_timestamp("event_ts")
)

bad = parsed.filter(
    F.col("event_ts").isNotNull()
    & F.col("event_ts_parsed").isNull()
)

Inspecciona los fallos antes de sobrescribir el campo de texto original.


21. Conservar los valores sin procesar durante el parseo

Buen patrón:

event_ts_raw
event_ts_parsed

Esto ayuda a diagnosticar problemas de formato de la fuente.

No destruyas el valor original antes de que la validación sea correcta.


22. Validar la integridad referencial

Ejemplo:

missing_customers = (
    orders.alias("o")
    .join(
        customers.select("customer_id").alias("c"),
        on="customer_id",
        how="left_anti",
    )
)

Son filas de pedidos cuya clave de cliente no está presente en el conjunto de datos de referencia.


23. Tener cuidado con los tiempos de los datos de referencia

Una fila de dimensión faltante puede significar:

clave de origen incorrecta

o:

dimensión que llega tarde

No clasifiques automáticamente cada resultado de un anti-join como datos corruptos.


24. Poner en cuarentena los registros no válidos

Patrón:

valid = df.filter(
    F.col("order_id").isNotNull()
)

invalid = df.filter(
    F.col("order_id").isNull()
)

Escribe los registros no válidos con:

validation_reason
batch_id
source_file
ingestion_time

No los descartes en silencio si importan operativamente.


25. Añadir códigos de motivo

Ejemplo:

invalid = (
    df.withColumn(
        "validation_reason",
        F.when(
            F.col("order_id").isNull(),
            F.lit("missing_order_id"),
        )
        .when(
            F.col("amount").isNull(),
            F.lit("missing_amount"),
        )
    )
    .filter(F.col("validation_reason").isNotNull())
)

Si hay varios problemas simultáneos, considera usar un array o lista de motivos en lugar de un único motivo que se sobrescribe.


26. Validar la presencia de los archivos de origen

Para feeds diarios esperados:

orders_20261004.csv
customers_20261004.csv

un job correcto no debería ejecutarse con solo una de las fuentes requeridas.

Compara los archivos esperados con los recibidos antes de procesar.


27. Validar el número de archivos de origen

Ejemplo:

esperado:
1 archivo de control
12 archivos horarios

recibido:
11 archivos horarios

Que falle o espere depende del contrato de ingesta.


28. Validar la completitud de las particiones

Si se espera una partición por día:

expected_dates = ...
actual_dates = ...

missing_dates = expected_dates - actual_dates

Una tabla puede tener filas válidas y aun así faltarle un día entero.


29. Validar la frescura

Ejemplo:

latest = df.agg(
    F.max("ingested_at").alias("latest_ingested_at")
)

latest.show()

Compárala con el SLA real del conjunto de datos.

No inventes un umbral de frescura global.


30. Separar la frescura de la fuente de la frescura del pipeline

Registra:

hora del evento en origen
hora de ingesta
hora de finalización del procesamiento

Ejemplo:

la fuente llega 2 horas tarde
el pipeline la procesa en 2 minutos

El pipeline es rápido, pero los datos de negocio están obsoletos.


31. Comparar el número de filas con el historial

Guarda métricas por ejecución:

batch_id
row_count

Después compara el volumen actual con las líneas base recientes.

No hagas fallar el proceso por cambios porcentuales arbitrarios sin entender la estacionalidad natural y el comportamiento de la fuente.


32. Basar los umbrales de anomalía en evidencia

En algunos feeds, un cambio del 5 % es significativo.

En otros, el volumen diario cambia legítimamente un 200 %.

Construye los umbrales a partir de:

  • la distribución histórica
  • el calendario de negocio
  • la estacionalidad conocida
  • el contrato de la fuente

33. Validar con cuidado las cargas de cero filas

Cero filas puede significar:

periodo tranquilo legítimo
fallo de la fuente
bug en un filtro
archivo faltante
watermark incorrecto

No trates automáticamente el cero como éxito o como fallo sin contexto.


34. Conciliar los totales financieros

Ejemplo:

totals = df.agg(
    F.count("*").alias("rows"),
    F.sum("amount").alias("amount_total"),
)

totals.show()

Compáralos con el total de control o de la fuente de confianza cuando esté disponible.


35. Conciliar por segmento de negocio

Ejemplo:

(
    df.groupBy("merchant_id")
    .agg(
        F.count("*").alias("rows"),
        F.sum("amount").alias("amount_total"),
    )
    .orderBy("merchant_id")
)

Los totales globales pueden ocultar que un segmento se cargó de más o de menos.


36. Conciliar al grano esperado

Algunas dimensiones útiles pueden ser:

fecha
tenant
merchant
moneda
sistema de origen

Elige dimensiones alineadas con la forma en que el negocio valida los datos.


37. Comprobar duplicados al preparar un MERGE

Antes de un MERGE de Delta:

source_dupes = (
    source.groupBy("order_id")
    .count()
    .filter(F.col("count") > 1)
)

if source_dupes.limit(1).count() > 0:
    raise ValueError(
        "MERGE source contains duplicate order_id values"
    )

Esto evita actualizaciones ambiguas.


38. Validar antes de avanzar el watermark

Orden correcto:

leer la fuente
→ transformar
→ validar
→ escribir
→ conciliar
→ confirmar/guardar el watermark

No avances el estado antes de que se superen los controles de calidad bloqueantes.


39. Validar también después de escribir

Los controles previos a la escritura confirman el conjunto de datos candidato.

Los controles posteriores a la escritura confirman el resultado almacenado.

Controles útiles posteriores a la escritura:

número de filas del destino
número de claves distintas del destino
totales de negocio del destino
cobertura de particiones del destino

40. Comprobar la idempotencia

Vuelve a ejecutar el mismo lote y verifica que el destino no se duplique.

Ejemplo:

mismo batch_id
mismos registros de origen
→ mismo estado final de la tabla

Es una propiedad de calidad, no solo una cuestión de orquestación.


41. Conservar los identificadores de lote

Columnas útiles:

batch_id
source_file
ingested_at
pipeline_run_id

Esto ayuda a rastrear cargas duplicadas o faltantes.


42. Detectar archivos de origen repetidos

Registra el manifiesto de la fuente:

source_file
file_size
checksum/hash
received_at
processed_batch_id

Un nombre de archivo repetido por sí solo no demuestra que el contenido esté duplicado.

Un hash o los identificadores que proporciona la fuente pueden ayudar.


43. Usar hashes con cuidado

Un hash de registro puede ayudar a identificar filas sin cambios o duplicadas.

Ejemplo:

from pyspark.sql import functions as F

df = df.withColumn(
    "record_hash",
    F.sha2(
        F.concat_ws(
            "||",
            F.col("customer_id"),
            F.col("status"),
            F.col("amount").cast("string"),
        ),
        256,
    )
)

Define con cuidado el formato canónico.

Los nulos, los decimales, las marcas de tiempo y los espacios en blanco pueden cambiar el hash de forma inesperada.


44. No aplicar hash a ciegas sobre una serialización inestable

Mal patrón:

calcular el hash de toda la cadena JSON

si el orden o el formato de los campos puede cambiar mientras la semántica sigue siendo la misma.

Canonicaliza primero los campos.


45. Validar las reglas de comparación seguras ante nulos

Al comparar registros actuales con los anteriores, recuerda que:

NULL = NULL

no es verdadero según la semántica SQL normal.

Usa una comparación null-safe cuando el motor la admita y el significado de negocio lo requiera.


46. Validar la deriva del esquema

Registra:

columnas añadidas
columnas eliminadas
cambios de tipo
cambios de nulabilidad

Clasifica los cambios:

compatible
advertencia
incompatible

No trates cada nueva columna nullable como un fallo bloqueante si tu contrato permite una evolución compatible.


47. Detectar deliberadamente la ampliación o reducción de tipos

Ejemplos:

int → long
decimal(18,2) → decimal(18,4)
string → int

Tienen implicaciones de compatibilidad distintas.

No compares esquemas solo por nombre de columna.


48. Validar la precisión y la escala de los decimales

Los campos financieros deben coincidir con la precisión y la escala esperadas.

Una conversión inesperada a coma flotante justifica fallar pronto.


49. Validar las suposiciones de zona horaria

Comprueba si las marcas de tiempo están en:

UTC
hora local
con offset
sin zona horaria (naive)

Un desplazamiento de zona horaria puede producir fechas aparentemente válidas pero incorrectas.


50. Comprobar el comportamiento en los límites de fecha

Ejemplo:

23:30 UTC

puede corresponder a otra fecha de negocio local.

Si los informes diarios se basan en la hora local, valida la agrupación después de la conversión de zona horaria.


51. Validar las enumeraciones contra una tabla de referencia

En lugar de listas codificadas de forma fija:

invalid = (
    facts.alias("f")
    .join(
        valid_statuses.alias("s"),
        F.col("f.status") == F.col("s.status"),
        "left_anti",
    )
)

Útil cuando los valores del dominio se gobiernan externamente.


52. Validar las expectativas de uno a muchos

Ejemplo:

un pedido
→ muchas líneas de detalle

Esto es válido.

La regla de calidad debería ser:

una cabecera de pedido por order_id

no:

order_id único en el conjunto de datos unido de pedidos y líneas

Los controles deben coincidir con el grano de los datos.


53. Comprobar filas hijas huérfanas

orphans = (
    order_lines.alias("l")
    .join(
        orders.select("order_id").alias("o"),
        on="order_id",
        how="left_anti",
    )
)

Investiga el orden de la fuente y el comportamiento de las llegadas tardías antes de eliminar o rechazar.


54. Validar las relaciones entre agregados

Ejemplo:

order_total
≈
suma(order_line_amount)

Usa una comparación exacta o con tolerancia según las reglas de moneda y redondeo.

No inventes tolerancias arbitrarias.


55. Validar relaciones de proporción

Ejemplo:

discount <= subtotal

o:

tax >= 0

solo si esas reglas se cumplen en el dominio.


56. Detectar combinaciones imposibles

Ejemplo:

estado = cancelado
Y
shipped_at IS NOT NULL

si ese estado es imposible en el ciclo de vida del negocio.

Estos controles entre campos suelen aportar más valor que los controles de nulos genéricos.


57. Validar las transiciones del ciclo de vida

Para entidades con estado:

pendiente
→ aprobado
→ completado

Una transición como:

completado
→ pendiente

puede no ser válida.

Esto requiere una validación que tenga en cuenta el historial y el estado.


58. Comprobar los campos de secuencia monótona

Si la fuente proporciona:

sequence_number

valida:

  • los duplicados
  • los huecos, si no se permiten huecos
  • las regresiones
  • las llegadas fuera de orden

No supongas que todas las secuencias carecen de huecos salvo que esté documentado.


59. Validar los identificadores de evento

En los pipelines de eventos, un identificador de evento estable permite:

deduplicación
replay
idempotencia
trazabilidad

Comprueba la unicidad dentro de la ventana de retención adecuada.


60. Los controles de calidad de datos pueden ser de advertencia o bloqueantes

Clasifica los controles:

BLOQUEANTE
→ el pipeline debe detenerse/poner en cuarentena

ADVERTENCIA
→ continuar pero alertar

MÉTRICA
→ registrar para monitorizar tendencias

No todas las anomalías deben detener la producción.


61. Usar la severidad de forma deliberada

Ejemplo:

clave primaria faltante
→ bloqueante

número de filas ligeramente inusual
→ advertencia/métrica

nueva columna opcional
→ advertencia

La severidad debe seguir al impacto en el negocio.


62. Evitar una única puntuación de calidad global

Una puntuación como:

97 % de calidad

puede ocultar:

0,1 % de claves primarias faltantes

lo que puede ser inaceptable.

Haz seguimiento de las reglas individuales y de su impacto en el negocio.


63. Asignar identificadores de regla estables

Ejemplo:

DQ_ORDER_001
→ order_id no debe ser nulo

DQ_ORDER_002
→ order_id único en los pedidos de Silver

DQ_ORDER_003
→ la moneda del importe debe ser reconocida

Esto ayuda con:

  • las alertas
  • los dashboards
  • la documentación
  • el seguimiento de tendencias

64. Registrar los resultados de las reglas

Esquema útil:

run_id
dataset
rule_id
status
failed_count
checked_count
severity
observed_value
expected_rule
checked_at

Esto crea un registro de auditoría.


65. Conservar muestras de los fallos

Para las reglas que fallan, guarda una muestra acotada:

rule_id
clave de negocio
valor incorrecto
archivo de origen
lote

No guardes todas las filas incorrectas en los metadatos de monitoreo si el volumen puede ser enorme.

Usa tablas o archivos de cuarentena para el detalle completo.


66. Proteger los datos sensibles en los logs de calidad

No expongas:

contraseñas
tokens
PII completa
datos de pago

en los logs de validación.

Usa claves de negocio o muestras enmascaradas siempre que sea posible.


67. Conciliar el número de filas antes y después de los filtros

Ejemplo:

filas de origen
-
filas no válidas
-
filas deduplicadas
=
filas válidas en destino

Esta contabilidad hace que la pérdida de filas sea explicable.


68. Mantener explícita la contabilidad de rechazos

Ejemplo:

10.000 filas de origen
9.950 válidas
30 duplicadas
20 no válidas

Esto es mucho más útil que:

pipeline completado correctamente

69. Validar los joins para detectar multiplicación de filas

Antes del join:

100.000 pedidos

Después de hacer join con una dimensión supuestamente de uno a uno:

125.000 filas

Esto indica claves de dimensión duplicadas o un grano de join incorrecto.


70. Aplicar conceptualmente controles de tipo validate en pipelines distribuidos

Aunque el framework no tenga un equivalente al validate="many_to_one" de pandas, impón explícitamente la misma expectativa.

Ejemplo:

la clave de dimensión debe ser única antes del join

Compruébalo.


71. Validar el número de filas por partición

Ejemplo:

(
    df.groupBy("order_date")
    .agg(F.count("*").alias("rows"))
    .orderBy("order_date")
)

Los controles por partición detectan un día faltante oculto tras un total global normal.


72. Validar los totales por partición

(
    df.groupBy("order_date")
    .agg(
        F.count("*").alias("rows"),
        F.sum("amount").alias("amount_total"),
    )
    .orderBy("order_date")
)

Útil para pipelines financieros y transaccionales.


73. Detectar particiones o lotes duplicados

Comprueba si los mismos:

batch_id
partition_date
archivo de origen

se confirmaron más de una vez.

Esto suele revelar errores en los reintentos.


74. Validar los límites incrementales

En las cargas por watermark, registra:

watermark inicial
watermark final
filas de origen
filas de destino

Después verifica que ningún intervalo se haya:

omitido
solapado sin querer
reprocesado sin idempotencia

75. Usar ventanas de tiempo semiabiertas de forma coherente

Ejemplo:

[start, end)

Esto ayuda a que los lotes adyacentes encajen sin solapar las marcas de tiempo finales.

Aun así, los empates de marcas de tiempo y las llegadas tardías requieren un diseño explícito.


76. Comprobar los registros que llegan tarde

Mide:

ingestion_time - event_time

Haz seguimiento de la distribución a lo largo del tiempo.

Usa el comportamiento real de la fuente para definir la política de retraso.


77. Detectar la deriva de las distribuciones

Ejemplos:

distribución por país
distribución por estado
distribución de importes
tasa de nulos
número de clientes distintos

Compara con el historial.

No generes alertas por cada fluctuación natural.


78. Comprobar la distribución categórica

(
    df.groupBy("status")
    .count()
    .orderBy(F.desc("count"))
    .show()
)

Un estado nuevo o desconocido puede indicar un cambio en la fuente.


79. Comprobar el resumen numérico

df.select(
    F.min("amount").alias("min_amount"),
    F.max("amount").alias("max_amount"),
    F.avg("amount").alias("avg_amount"),
).show()

Usa las tendencias y el contexto en lugar de valores «aceptables» universales.


80. Usar los percentiles con cuidado

En métricas sesgadas, los percentiles aproximados pueden ser más informativos que la media.

Ejemplo:

df.selectExpr(
    "percentile_approx(amount, array(0.5, 0.95, 0.99)) AS percentiles"
).show(truncate=False)

El comportamiento de los percentiles aproximados depende del motor y de la configuración.


81. Comparar las métricas actuales con las históricas

Guarda métricas por ejecución para poder responder:

¿Se disparó la tasa de nulos?
¿Se desplomó el número de filas?
¿Desapareció una categoría?
¿Cambió la distribución de importes?

El contexto de tendencia es más útil que los umbrales aislados.


82. Detectar columnas completamente nulas

row_count = df.count()

all_null_exprs = [
    (
        F.sum(
            F.when(F.col(c).isNull(), 1).otherwise(0)
        ) == row_count
    ).alias(c)
    for c in df.columns
]

Un campo obligatorio completamente nulo suele indicar un fallo del parser, del esquema o de la fuente.


83. Comprobar las columnas constantes

Un campo que de repente tiene un único valor distinto puede indicar:

  • un error de valor fijo en la fuente
  • un problema del parser
  • un valor predeterminado aguas arriba
  • una condición de negocio legítima

Registra:

df.select(
    *[
        F.countDistinct(c).alias(c)
        for c in df.columns
    ]
)

Úsalo de forma selectiva en columnas manejables o de alto valor.


84. Tener cuidado con los controles distinct costosos

countDistinct puede generar mucho shuffle.

No ejecutes docenas de recorridos distinct completos sobre tablas enormes sin priorizar las claves y columnas importantes.

Combina el trabajo siempre que sea posible.


85. Muestrear solo para explorar, no para las garantías finales

sample = df.sample(
    withReplacement=False,
    fraction=0.01,
)

Una muestra puede revelar problemas.

No puede demostrar:

cero duplicados
cero claves no válidas
integridad referencial completa

Usa controles completos cuando el contrato exija certeza.


86. Evitar recopilar grandes conjuntos no válidos en el driver

Mal:

bad_rows = invalid.collect()

Si hay muchos fallos, escríbelos en un almacenamiento de cuarentena y recopila solo resúmenes o muestras pequeñas.


87. Limitar los ejemplos en las alertas

Alerta:

regla fallida
failed_count=1,248,321
sample_keys=[...]

No adjuntes un millón de filas incorrectas a los logs o a un correo electrónico.


88. Conservar por separado la evidencia completa de los fallos

Patrón:

tabla de resultados de calidad
→ resumen

tabla de cuarentena
→ filas fallidas completas

Esto separa el monitoreo de la corrección detallada.


89. Validar el esquema de destino después de escribir

target = spark.read.table("silver.orders")
target.printSchema()

Útil cuando intervienen la evolución del esquema o el comportamiento de sobrescritura.


90. Validar la unicidad del destino después de un MERGE

duplicates = (
    spark.read.table("silver.orders")
    .groupBy("order_id")
    .count()
    .filter(F.col("count") > 1)
)

No supongas que la lógica del MERGE conservó el grano previsto.


91. Comparar las claves de origen y de destino

Claves que faltan en el destino:

missing = (
    source.select("order_id").distinct()
    .join(
        target.select("order_id").distinct(),
        on="order_id",
        how="left_anti",
    )
)

Claves que sobran en el destino:

extra = (
    target.select("order_id").distinct()
    .join(
        source.select("order_id").distinct(),
        on="order_id",
        how="left_anti",
    )
)

Úsalo solo cuando los ámbitos de origen y destino sean realmente comparables.


92. El ámbito de la conciliación debe coincidir

No compares:

la fuente de hoy

con:

todo el historial del destino

sin aplicar el mismo ámbito de negocio, de fecha o de tenant.


93. Validar los conteos antes de una sobrescritura destructiva

Antes de reemplazar una partición o una tabla:

número de filas del nuevo candidato
vs
número esperado existente/de origen

Si el candidato está vacío de forma inesperada, detente antes de sobrescribir.


94. Añadir salvaguardas a las reconstrucciones

Ejemplo:

candidate_count = candidate.count()

if candidate_count == 0:
    raise ValueError(
        "Refusing to overwrite target with zero rows"
    )

Úsalo solo si cero filas nunca puede ser legítimo para esa reconstrucción.


95. Las reglas de calidad deben versionarse junto con el código

Un cambio de regla forma parte del comportamiento del pipeline.

Registra:

versión de la regla
commit del código
despliegue

Esto ayuda a explicar por qué los datos empezaron a fallar después de una versión.


96. Separar los defectos de la fuente de los defectos del pipeline

Clasifica los fallos:

calidad de la fuente
contrato de esquema
transformación del pipeline
datos de referencia
escritura en el destino

Esto ayuda a asignar correctamente la responsabilidad.


97. Los controles de calidad necesitan un responsable

Cada regla bloqueante debe tener:

responsable
runbook
acción esperada
ruta de escalado

Un control fallido sin responsable se convierte en ruido de alertas.


98. Definir la ruta de corrección

Para cada regla importante:

¿hacer fallar el pipeline?
¿poner en cuarentena las filas incorrectas?
¿continuar con una advertencia?
¿reintentar la fuente?
¿hacer un backfill más tarde?
¿abrir un incidente?

Decídelo antes de que ocurra un fallo en producción.


99. La calidad de datos corresponde a varias capas

Patrón típico:

Bronze
→ controles de ingesta/de la fuente

Silver
→ esquema, deduplicación, validez, reglas referenciales

Gold
→ conciliación de negocio, grano, coherencia de métricas

No pongas todas las reglas en una sola capa.


100. Usar un flujo de calidad repetible

1. Validar el esquema
2. Validar las claves obligatorias
3. Validar la unicidad/el grano
4. Validar las reglas del dominio
5. Validar las referencias
6. Validar la frescura/el volumen
7. Conciliar los totales de negocio
8. Poner en cuarentena los fallos
9. Persistir los resultados de las reglas
10. Avanzar el watermark solo cuando se superen los controles requeridos

Qué significa el resultado

Tipo de control Qué protege
Esquema Compatibilidad del contrato
No nulo Completitud de los datos obligatorios
Unicidad Grano de negocio esperado
Dominio/rango Validez semántica
Integridad referencial Coherencia entre entidades
Frescura Disponibilidad puntual de los datos
Volumen Cargas faltantes o duplicadas
Conciliación Corrección de negocio
Deriva de distribuciones Cambios inesperados en la fuente o el comportamiento
Idempotencia Reintentos y reprocesamientos seguros
Cobertura de particiones Franjas de tiempo o de tenant faltantes

El principio fundamental es:

calidad de datos = contratos de negocio/datos explícitos
no porcentajes genéricos

Qué revisar

El número de filas cae de repente

Revisa:

  • archivos de origen faltantes
  • cambios en filtros o en el watermark
  • una caída de la fuente
  • fallos al parsear el esquema
  • particiones omitidas

El número de filas aumenta de repente

Revisa:

  • una carga duplicada de la fuente
  • multiplicación por joins
  • duplicación por reintentos
  • un cambio de comportamiento de la fuente

Aparecen claves duplicadas después de un join

Inspecciona la unicidad de las claves del lado derecho y la cardinalidad del join.

La tasa de nulos se dispara

Revisa el esquema de la fuente, el parseo, los campos renombrados y los valores predeterminados aguas arriba.

Los totales financieros no cuadran, pero el número de filas sí

Revisa:

  • importes duplicados
  • la moneda
  • los filtros
  • el redondeo
  • las convenciones de signo
  • líneas de detalle eliminadas o duplicadas

El control de frescura falla, pero la duración del pipeline es normal

Puede que la fuente llegue tarde y no que el pipeline sea lento.

Notas de producción

Los controles consumen cómputo

Los recorridos de tabla completa, los conteos distinct y los joins referenciales pueden ser costosos.

Prioriza las reglas críticas y combina las agregaciones.

Las reglas bloqueantes deben ser deterministas

Una regla que falla aleatoriamente por un muestreo inestable no sirve como control bloqueante en producción.

El estado de la calidad debe ser auditable

Conserva:

regla
ejecución
valor observado
estado
marca de tiempo

y no solo una línea de log de éxito/fallo.

La cuarentena no es un cubo de basura

Los registros en cuarentena necesitan:

  • un motivo
  • un responsable
  • un periodo de retención
  • una ruta de corrección

Los umbrales deben basarse en evidencia

No copies umbrales genéricos como:

5 % de nulos
10 % de desviación en el número de filas

sin una justificación de negocio o histórica.

Los controles de calidad solo deben bloquear por defecto donde el negocio lo requiera

No todas las anomalías deben detener toda la entrega de datos.

Usa la severidad y el impacto.

Errores comunes

1. Usar una única puntuación de calidad genérica

Los fallos críticos pueden quedar ocultos dentro de una puntuación media alta.

2. Eliminar duplicados sin investigarlos

Esto destruye la evidencia y puede descartar la fila equivocada.

3. Tratar cada nulo como un error

Un nulo puede ser válido en campos opcionales.

4. Tratar cero filas como siempre no válido

Algunos feeds legítimamente no tienen actividad.

5. Depender solo del número de filas

Los totales de negocio y los controles a nivel de clave pueden revelar errores que el número de filas no detecta.

6. Comprobar la calidad solo antes de escribir

El comportamiento de escritura en el destino todavía puede introducir problemas.

7. Usar umbrales arbitrarios

Los umbrales deben surgir de los contratos y del comportamiento histórico.

8. Recopilar todas las filas incorrectas en el driver

Esto puede hacer que fallen jobs distribuidos grandes.

9. Avanzar los watermarks antes de superar los controles bloqueantes

Esto puede hacer que se omitan para siempre los datos fallidos.

10. Alertar sin un responsable ni una ruta de corrección

Esto genera ruido en lugar de fiabilidad.

Siguiente paso

Usa la regla que falló para elegir la siguiente acción.

  • Columnas o tipos faltantes → inspecciona la fuente y la deriva del esquema antes de la transformación.
  • Claves obligatorias nulas → ponlas en cuarentena y rastrea el origen hasta la fuente o el parser.
  • Claves de negocio duplicadas → inspecciona los reintentos de la fuente, los joins y la regla de deduplicación.
  • Fallos de referencia → distingue las claves incorrectas de las dimensiones que llegan tarde.
  • Anomalía de volumen → compara los archivos de origen, el watermark, las particiones y el historial reciente.
  • Fallo de frescura → separa el retraso de la fuente del retraso de procesamiento.
  • Descuadre en la conciliación → compara por fecha, tenant o comercio e inspecciona la multiplicación o pérdida de filas.
  • Los controles pasan antes de escribir, pero el destino es incorrecto → añade controles posteriores a la escritura.
  • Los controles son demasiado costosos → prioriza las reglas críticas, agrega en una sola pasada y ejecuta los controles profundos de forma selectiva.
  • Necesitas ubicarlo en la arquitectura → pasa a Referencia rápida de la arquitectura Medallion.

← Todas las guías rápidas