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