Parcourir les aide-mémoire · Ingénierie des données

Technologie: Ingénierie des donnéesCatégorie: Qualité des donnéesNiveau: IntermédiaireMis à jour

Contrôles de qualité des données

Mettez en place des contrôles de qualité des données concrets pour le schéma, la complétude, l’unicité, la validité, l’intégrité référentielle, la fraîcheur, la réconciliation et la dérive des pipelines, sans vous appuyer sur des seuils universels arbitraires.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Valider les colonnes obligatoires
  5. 2. Détecter les colonnes inattendues
  6. 3. Valider les types de données Spark
  7. 4. Vérifier les champs obligatoirement non nuls
  8. 5. Vérifier le pourcentage de valeurs nulles
  9. 6. Éviter d’analyser la table à plusieurs reprises
  10. 7. Vérifier l’unicité de la clé métier
  11. 8. Valider l’unicité d’une clé composite
  12. 9. Ne pas utiliser dropDuplicates() comme contrôle de qualité
  13. 10. Examiner des exemples de doublons
  14. 11. Valider le grain des lignes après les jointures
  15. 12. Valider une plage numérique
  16. 13. Valider des valeurs de domaine bornées
  17. 14. Valider les codes de devise
  18. 15. Valider des motifs de chaînes
  19. 16. Vérifier les chaînes vides séparément des nulls
  20. 17. Normaliser les espaces avant la validation lorsque c’est pertinent
  21. 18. Valider des plages de dates
  22. 19. Valider les dates futures impossibles
  23. 20. Valider l’analyse des horodatages
  24. 21. Conserver les valeurs brutes pendant l’analyse
  25. 22. Valider l’intégrité référentielle
  26. 23. Faire attention au calendrier des données de référence
  27. 24. Mettre en quarantaine les enregistrements invalides
  28. 25. Ajouter des codes de motif
  29. 26. Valider la présence des fichiers source
  30. 27. Valider le nombre de fichiers source
  31. 28. Valider la complétude des partitions
  32. 29. Valider la fraîcheur
  33. 30. Distinguer la fraîcheur de la source de celle du pipeline
  34. 31. Comparer le nombre de lignes à l’historique
  35. 32. Fonder les seuils d’anomalie sur des faits
  36. 33. Valider avec prudence les chargements à zéro ligne
  37. 34. Réconcilier les totaux financiers
  38. 35. Réconcilier par segment métier
  39. 36. Réconcilier au grain attendu
  40. 37. Vérifier les doublons lors de la préparation d’un MERGE
  41. 38. Valider avant de faire avancer le watermark
  42. 39. Valider aussi après l’écriture
  43. 40. Vérifier l’idempotence
  44. 41. Conserver les identifiants de lot
  45. 42. Détecter les fichiers source répétés
  46. 43. Utiliser les hachages avec prudence
  47. 44. Ne pas hacher aveuglément une sérialisation instable
  48. 45. Valider les règles de comparaison tenant compte des nulls
  49. 46. Valider la dérive de schéma
  50. 47. Détecter délibérément l’élargissement ou le rétrécissement des types
  51. 48. Valider la précision et l’échelle des décimaux
  52. 49. Valider les hypothèses de fuseau horaire
  53. 50. Vérifier le comportement aux limites de date
  54. 51. Valider les énumérations par rapport à une table de référence
  55. 52. Valider les attentes un-à-plusieurs
  56. 53. Vérifier les lignes enfants orphelines
  57. 54. Valider les relations entre agrégats
  58. 55. Valider les relations de proportion
  59. 56. Détecter les combinaisons impossibles
  60. 57. Valider les transitions de cycle de vie
  61. 58. Vérifier les champs de séquence monotones
  62. 59. Valider les identifiants d’événement
  63. 60. Les contrôles de qualité des données peuvent être des avertissements ou bloquants
  64. 61. Utiliser la gravité de manière délibérée
  65. 62. Éviter un score de qualité global unique
  66. 63. Attribuer des identifiants de règle stables
  67. 64. Enregistrer les résultats des règles
  68. 65. Conserver des échantillons d’échecs
  69. 66. Protéger les données sensibles dans les journaux de qualité
  70. 67. Réconcilier le nombre de lignes avant et après les filtres
  71. 68. Garder une comptabilité explicite des rejets
  72. 69. Vérifier la multiplication des lignes dans les jointures
  73. 70. Appliquer le principe des contrôles de type validate dans les pipelines distribués
  74. 71. Valider le nombre de lignes par partition
  75. 72. Valider les totaux par partition
  76. 73. Détecter les partitions ou lots en double
  77. 74. Valider les limites incrémentales
  78. 75. Utiliser des fenêtres temporelles semi-ouvertes de manière cohérente
  79. 76. Vérifier les enregistrements arrivés en retard
  80. 77. Détecter la dérive des distributions
  81. 78. Vérifier la distribution catégorielle
  82. 79. Vérifier le résumé numérique
  83. 80. Utiliser les percentiles avec prudence
  84. 81. Comparer les métriques actuelles et historiques
  85. 82. Détecter les colonnes entièrement nulles
  86. 83. Vérifier les colonnes constantes
  87. 84. Faire attention aux contrôles distinct coûteux
  88. 85. Échantillonner uniquement pour l’exploration, pas pour les garanties finales
  89. 86. Éviter de collecter de grands ensembles invalides sur le driver
  90. 87. Limiter les exemples dans les alertes
  91. 88. Conserver séparément les preuves complètes des échecs
  92. 89. Valider le schéma cible après l’écriture
  93. 90. Valider l’unicité de la cible après un MERGE
  94. 91. Comparer les clés de la source et de la cible
  95. 92. Le périmètre de la réconciliation doit correspondre
  96. 93. Valider les comptages avant un écrasement destructif
  97. 94. Ajouter des garde-fous aux reconstructions
  98. 95. Les règles de qualité doivent être versionnées avec le code
  99. 96. Distinguer les défauts de la source de ceux du pipeline
  100. 97. Les contrôles de qualité ont besoin d’un responsable
  101. 98. Définir le chemin de correction
  102. 99. La qualité des données s’applique à plusieurs couches
  103. 100. Utiliser un processus de qualité reproductible
  104. Interpréter le résultat
  105. Points à vérifier
  106. Le nombre de lignes chute soudainement
  107. Le nombre de lignes augmente soudainement
  108. Des clés en double apparaissent après une jointure
  109. Le taux de nulls grimpe brusquement
  110. Les totaux financiers divergent alors que le nombre de lignes correspond
  111. Le contrôle de fraîcheur échoue alors que la durée du pipeline est normale
  112. Notes de production
  113. Les contrôles consomment des ressources de calcul
  114. Les règles bloquantes doivent être déterministes
  115. L’état de la qualité doit être auditable
  116. La quarantaine n’est pas une poubelle
  117. Les seuils doivent reposer sur des faits
  118. Les contrôles de qualité ne doivent bloquer par défaut que là où le métier l’exige
  119. Erreurs fréquentes
  120. 1. Utiliser un score de qualité générique unique
  121. 2. Supprimer les doublons sans les examiner
  122. 3. Considérer chaque null comme une erreur
  123. 4. Considérer zéro ligne comme toujours invalide
  124. 5. S’appuyer uniquement sur le nombre de lignes
  125. 6. Contrôler la qualité uniquement avant l’écriture
  126. 7. Utiliser des seuils arbitraires
  127. 8. Collecter toutes les lignes incorrectes sur le driver
  128. 9. Faire avancer les watermarks avant que les contrôles bloquants soient passés
  129. 10. Alerter sans responsable ni chemin de correction
  130. Étape suivante
  131. Pour aller plus loin

Problème

Un pipeline peut se terminer avec succès et produire malgré tout des données incorrectes.

Les défaillances typiques sont les suivantes :

  • des lignes manquantes
  • des clés métier en double
  • des valeurs nulles inattendues
  • des valeurs invalides
  • une dérive de schéma
  • des clés étrangères rompues
  • des données obsolètes
  • des chargements en double
  • des agrégats incorrects
  • des partitions partiellement chargées
  • des changements de type silencieux

L’objectif est de rendre les contrôles de qualité des données propres au jeu de données et au contrat métier, de détecter les défaillances au plus tôt et d’orienter les données incorrectes vers la bonne étape suivante, au lieu de s’appuyer sur un « score de qualité » générique.

Réponse rapide

Un ensemble solide de contrôles en production couvre généralement :

Schéma
→ colonnes et types attendus

Complétude
→ les valeurs obligatoires sont présentes

Unicité
→ les clés sont uniques au grain attendu

Validité
→ les valeurs respectent les règles du domaine

Intégrité référentielle
→ les références étrangères/métier existent

Fraîcheur
→ les données sont arrivées à temps

Volume
→ les nombres de lignes/partitions sont plausibles

Réconciliation
→ les totaux métier correspondent aux attentes de la source de confiance

Dérive
→ les distributions ou les contrats ont changé de façon inattendue

Exemple de 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 règle essentielle est :

les contrôles doivent faire respecter un contrat connu
et non inventer des seuils arbitraires

Code / commandes

1. Valider les colonnes obligatoires

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)}"
    )

Utilisez ce contrôle avant les transformations qui supposent l’existence de ces champs.


2. Détecter les colonnes inattendues

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

unexpected = set(df.columns) - allowed_columns

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

Le choix entre échec et avertissement dépend de votre politique d’évolution du schéma.


3. Valider les types de données 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}"
    )

Utilisez des types explicites pour les pipelines critiques.


4. Vérifier les champs obligatoirement non nuls

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)

Une clé métier principale ne devrait souvent contenir aucune valeur nulle.

N’appliquez pas de règle « zéro nul » aux champs facultatifs.


5. Vérifier le pourcentage de valeurs nulles

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)

Utilisez des pourcentages pour surveiller la dérive.

Ne supposez pas qu’il existe un pourcentage de nulls acceptable universel.


6. Éviter d’analyser la table à plusieurs reprises

Au lieu d’exécuter :

count()
compter les nulls
compter les doublons
somme du montant

comme des actions distinctes, regroupez les contrôles dans une seule agrégation lorsque c’est possible.

Les analyses distribuées sont coûteuses.


7. Vérifier l’unicité de la clé métier

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

duplicate_count = duplicates.count()

Si order_id est censé définir une seule ligne, tout doublon constitue une violation du contrat.


8. Valider l’unicité d’une clé composite

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

Utilisez le grain métier réel, et non une colonne unique choisie arbitrairement.


9. Ne pas utiliser dropDuplicates() comme contrôle de qualité

À éviter :

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

Cela fait disparaître les preuves.

Commencez par détecter et examiner les doublons.

Résolvez-les ensuite à l’aide d’une règle métier documentée.


10. Examiner des exemples de doublons

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)

Déterminez si les doublons sont :

  • de véritables doublons de la source
  • des nouvelles tentatives
  • des enregistrements versionnés
  • une multiplication due à une jointure
  • plusieurs événements légitimes

11. Valider le grain des lignes après les jointures

Supposons que la sortie doive contenir une ligne par commande.

Vérifiez :

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

summary.show()

Si :

rows > distinct_orders

déterminez si plusieurs lignes par commande sont attendues.


12. Valider une plage numérique

Exemple :

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

Ne considérez les valeurs négatives comme invalides que si le contrat métier l’indique.

Les retours et remboursements peuvent légitimement être négatifs.


13. Valider des valeurs de domaine bornées

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

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

Utilisez un ensemble de valeurs gouverné.


14. Valider les codes de devise

Exemple :

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

En production, utilisez le référentiel des devises prises en charge par l’organisation plutôt que de coder en dur des hypothèses globales incomplètes.


15. Valider des motifs de chaînes

Exemple :

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

N’utilisez une expression régulière que si le contrat de l’identifiant est réellement défini.

N’inventez pas de contraintes de format à partir de simples échantillons.


16. Vérifier les chaînes vides séparément des nulls

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

Une valeur nulle et une chaîne vide sont deux états différents.

Ne les regroupez pas, sauf si la règle métier indique qu’ils sont équivalents.


17. Normaliser les espaces avant la validation lorsque c’est pertinent

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

Ne normalisez pas silencieusement des identifiants dont les espaces de début ou de fin ont une signification.


18. Valider des plages de dates

Exemple :

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

Il s’agit d’une règle sémantique défendable.


19. Valider les dates futures impossibles

Si les règles métier interdisent les événements datés dans le futur :

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

N’utilisez ce contrôle que lorsque les dates futures sont réellement invalides.


20. Valider l’analyse des horodatages

Si les horodatages de la source sont des chaînes :

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()
)

Examinez les échecs avant d’écraser le champ texte d’origine.


21. Conserver les valeurs brutes pendant l’analyse

Bonne pratique :

event_ts_raw
event_ts_parsed

Cela aide à diagnostiquer les problèmes de format de la source.

Ne détruisez pas la valeur d’origine avant que la validation ait réussi.


22. Valider l’intégrité référentielle

Exemple :

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

Il s’agit des lignes de commande dont la clé client est absente du jeu de données de référence.


23. Faire attention au calendrier des données de référence

Une ligne de dimension manquante peut signifier :

clé source invalide

ou :

dimension arrivée en retard

Ne classez pas automatiquement chaque résultat d’anti-jointure comme une donnée corrompue.


24. Mettre en quarantaine les enregistrements invalides

Modèle :

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

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

Écrivez les enregistrements invalides avec :

validation_reason
batch_id
source_file
ingestion_time

Ne les supprimez pas silencieusement s’ils ont une importance opérationnelle.


25. Ajouter des codes de motif

Exemple :

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())
)

Lorsque plusieurs problèmes surviennent simultanément, envisagez un tableau ou une liste de motifs plutôt qu’un motif unique écrasé.


26. Valider la présence des fichiers source

Pour des flux quotidiens attendus :

orders_20261004.csv
customers_20261004.csv

un travail réussi ne devrait pas s’exécuter avec une seule des sources requises.

Comparez les fichiers attendus et reçus avant le traitement.


27. Valider le nombre de fichiers source

Exemple :

attendu :
1 fichier de contrôle
12 fichiers horaires

reçu :
11 fichiers horaires

Le choix entre échouer ou attendre dépend du contrat d’ingestion.


28. Valider la complétude des partitions

Si une partition par jour est attendue :

expected_dates = ...
actual_dates = ...

missing_dates = expected_dates - actual_dates

Une table peut contenir des lignes valides et pourtant manquer une journée entière.


29. Valider la fraîcheur

Exemple :

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

latest.show()

Comparez avec le SLA réel du jeu de données.

N’inventez pas de seuil de fraîcheur global.


30. Distinguer la fraîcheur de la source de celle du pipeline

Suivez :

heure de l’événement source
heure d’ingestion
heure de fin du traitement

Exemple :

la source a 2 heures de retard
le pipeline la traite en 2 minutes

Le pipeline est rapide, mais les données métier sont obsolètes.


31. Comparer le nombre de lignes à l’historique

Stockez des métriques par exécution :

batch_id
row_count

Comparez ensuite le volume actuel aux références récentes.

N’échouez pas sur des variations en pourcentage arbitraires sans comprendre la saisonnalité naturelle et le comportement de la source.


32. Fonder les seuils d’anomalie sur des faits

Pour certains flux, une variation de 5 % est significative.

Pour d’autres, le volume quotidien varie légitimement de 200 %.

Construisez les seuils à partir de :

  • la distribution historique
  • le calendrier métier
  • la saisonnalité connue
  • le contrat de la source

33. Valider avec prudence les chargements à zéro ligne

Zéro ligne peut signifier :

période creuse légitime
défaillance de la source
bug de filtre
fichier manquant
mauvais watermark

Ne considérez pas automatiquement zéro comme un succès ou un échec sans contexte.


34. Réconcilier les totaux financiers

Exemple :

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

totals.show()

Comparez avec le total de contrôle ou de la source de confiance lorsqu’il est disponible.


35. Réconcilier par segment métier

Exemple :

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

Les totaux globaux peuvent masquer un segment surchargé ou sous-chargé.


36. Réconcilier au grain attendu

Les dimensions utiles peuvent inclure :

date
tenant
merchant
devise
système source

Choisissez des dimensions alignées sur la façon dont le métier valide les données.


37. Vérifier les doublons lors de la préparation d’un MERGE

Avant un MERGE 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"
    )

Cela évite les mises à jour ambiguës.


38. Valider avant de faire avancer le watermark

Ordre correct :

lire la source
→ transformer
→ valider
→ écrire
→ réconcilier
→ valider/enregistrer le watermark

Ne faites pas avancer l’état avant que les contrôles de qualité bloquants soient passés.


39. Valider aussi après l’écriture

Les contrôles avant écriture confirment le jeu de données candidat.

Les contrôles après écriture confirment le résultat stocké.

Contrôles après écriture utiles :

nombre de lignes de la cible
nombre de clés distinctes de la cible
totaux métier de la cible
couverture des partitions de la cible

40. Vérifier l’idempotence

Relancez le même lot et vérifiez que la cible ne double pas.

Exemple :

même batch_id
mêmes enregistrements source
→ même état final de la table

Il s’agit d’une propriété de qualité, et pas seulement d’une question d’orchestration.


41. Conserver les identifiants de lot

Colonnes utiles :

batch_id
source_file
ingested_at
pipeline_run_id

Cela aide à retracer les chargements en double ou manquants.


42. Détecter les fichiers source répétés

Suivez le manifeste de la source :

source_file
file_size
checksum/hash
received_at
processed_batch_id

Un nom de fichier répété ne prouve pas à lui seul que le contenu est dupliqué.

Un hachage ou des identifiants fournis par la source peuvent aider.


43. Utiliser les hachages avec prudence

Un hachage d’enregistrement peut aider à identifier les lignes inchangées ou en double.

Exemple :

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,
    )
)

Définissez soigneusement le formatage canonique.

Les nulls, les décimaux, les horodatages et les espaces peuvent modifier le hachage de manière inattendue.


44. Ne pas hacher aveuglément une sérialisation instable

Modèle à éviter :

hacher la chaîne JSON entière

si l’ordre ou le formatage des champs peut changer alors que la sémantique reste identique.

Canonicalisez d’abord les champs.


45. Valider les règles de comparaison tenant compte des nulls

Lorsque vous comparez des enregistrements actuels et antérieurs, n’oubliez pas que :

NULL = NULL

n’est pas vrai selon la sémantique SQL normale.

Utilisez une comparaison null-safe lorsque le moteur la prend en charge et que le sens métier l’exige.


46. Valider la dérive de schéma

Suivez :

colonnes ajoutées
colonnes supprimées
changements de type
changements de nullabilité

Classez les changements :

compatible
avertissement
cassant

Ne traitez pas chaque nouvelle colonne nullable comme un échec bloquant si votre contrat autorise une évolution compatible.


47. Détecter délibérément l’élargissement ou le rétrécissement des types

Exemples :

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

Leurs implications en matière de compatibilité sont différentes.

Ne comparez pas les schémas uniquement par nom de colonne.


48. Valider la précision et l’échelle des décimaux

Les champs financiers doivent respecter la précision et l’échelle attendues.

Une conversion inattendue en virgule flottante justifie un échec précoce.


49. Valider les hypothèses de fuseau horaire

Vérifiez si les horodatages sont :

UTC
heure locale
avec décalage horaire
naïf

Un décalage de fuseau horaire peut produire des dates apparemment valides mais incorrectes.


50. Vérifier le comportement aux limites de date

Exemple :

23:30 UTC

peut correspondre à une autre date métier locale.

Si les rapports quotidiens reposent sur l’heure locale, validez le regroupement après la conversion de fuseau horaire.


51. Valider les énumérations par rapport à une table de référence

Au lieu de listes codées en dur :

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

Utile lorsque les valeurs de domaine sont gouvernées à l’extérieur.


52. Valider les attentes un-à-plusieurs

Exemple :

une commande
→ plusieurs lignes de détail

C’est valide.

La règle de qualité devrait être :

un seul en-tête de commande par order_id

et non :

order_id unique dans le jeu de données joint commandes-lignes

Les contrôles doivent correspondre au grain des données.


53. Vérifier les lignes enfants orphelines

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

Examinez l’ordre de la source et le comportement des arrivées tardives avant de supprimer ou de rejeter.


54. Valider les relations entre agrégats

Exemple :

order_total
≈
somme(order_line_amount)

Utilisez une comparaison exacte ou avec tolérance selon les règles de devise et d’arrondi.

N’inventez pas de tolérances arbitraires.


55. Valider les relations de proportion

Exemple :

discount <= subtotal

ou :

tax >= 0

uniquement si ces règles sont vraies pour le domaine.


56. Détecter les combinaisons impossibles

Exemple :

statut = annulé
ET
shipped_at IS NOT NULL

si cet état est impossible dans le cycle de vie métier.

Ces contrôles croisés entre champs ont souvent plus de valeur que des contrôles de nulls génériques.


57. Valider les transitions de cycle de vie

Pour les entités avec état :

en attente
→ approuvé
→ terminé

Une transition comme :

terminé
→ en attente

peut être invalide.

Cela nécessite une validation tenant compte de l’historique et de l’état.


58. Vérifier les champs de séquence monotones

Si la source fournit :

sequence_number

validez :

  • les doublons
  • les trous, si les trous ne sont pas autorisés
  • les régressions
  • les arrivées dans le désordre

Ne supposez pas que chaque séquence est sans trou, sauf si c’est documenté.


59. Valider les identifiants d’événement

Pour les pipelines d’événements, un identifiant d’événement stable permet :

dédoublonnage
replay
idempotence
traçabilité

Vérifiez l’unicité sur la fenêtre de rétention appropriée.


60. Les contrôles de qualité des données peuvent être des avertissements ou bloquants

Classez les contrôles :

BLOQUANT
→ le pipeline doit s’arrêter/mettre en quarantaine

AVERTISSEMENT
→ continuer mais alerter

MÉTRIQUE
→ enregistrer pour le suivi des tendances

Toutes les anomalies ne doivent pas arrêter la production.


61. Utiliser la gravité de manière délibérée

Exemple :

clé primaire manquante
→ bloquant

nombre de lignes légèrement inhabituel
→ avertissement/métrique

nouvelle colonne facultative
→ avertissement

La gravité doit découler de l’impact métier.


62. Éviter un score de qualité global unique

Un score comme :

97 % de qualité

peut masquer :

0,1 % de clés primaires manquantes

ce qui peut être inacceptable.

Suivez les règles individuelles et leur impact métier.


63. Attribuer des identifiants de règle stables

Exemple :

DQ_ORDER_001
→ order_id ne doit pas être nul

DQ_ORDER_002
→ order_id unique dans les commandes Silver

DQ_ORDER_003
→ la devise du montant doit être reconnue

Cela facilite :

  • les alertes
  • les tableaux de bord
  • la documentation
  • le suivi des tendances

64. Enregistrer les résultats des règles

Schéma utile :

run_id
dataset
rule_id
status
failed_count
checked_count
severity
observed_value
expected_rule
checked_at

Cela crée une piste d’audit.


65. Conserver des échantillons d’échecs

Pour les règles en échec, stockez un échantillon borné :

rule_id
clé métier
valeur invalide
fichier source
lot

Ne stockez pas toutes les lignes incorrectes dans les métadonnées de supervision si le volume peut être énorme.

Utilisez des tables ou fichiers de quarantaine pour le détail complet.


66. Protéger les données sensibles dans les journaux de qualité

N’exposez pas :

mots de passe
jetons
données personnelles complètes
données de paiement

dans les journaux de validation.

Utilisez des clés métier ou des échantillons masqués lorsque c’est possible.


67. Réconcilier le nombre de lignes avant et après les filtres

Exemple :

lignes source
-
lignes invalides
-
lignes dédoublonnées
=
lignes cibles valides

Cette comptabilité rend la perte de lignes explicable.


68. Garder une comptabilité explicite des rejets

Exemple :

10 000 lignes source
9 950 valides
30 en double
20 invalides

C’est beaucoup plus utile que :

pipeline réussi

69. Vérifier la multiplication des lignes dans les jointures

Avant la jointure :

100 000 commandes

Après la jointure avec une dimension supposée un-à-un :

125 000 lignes

Cela indique des clés de dimension en double ou un mauvais grain de jointure.


70. Appliquer le principe des contrôles de type validate dans les pipelines distribués

Même lorsque le framework ne propose pas d’équivalent au validate="many_to_one" de pandas, imposez explicitement la même attente.

Exemple :

la clé de dimension doit être unique avant la jointure

Vérifiez-le.


71. Valider le nombre de lignes par partition

Exemple :

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

Les contrôles par partition détectent une journée manquante masquée par un total global normal.


72. Valider les totaux par partition

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

Utile pour les pipelines financiers et transactionnels.


73. Détecter les partitions ou lots en double

Vérifiez si les mêmes :

batch_id
partition_date
fichier source

ont été validés plus d’une fois.

Cela révèle souvent des bogues de nouvelle tentative.


74. Valider les limites incrémentales

Pour les chargements par watermark, enregistrez :

watermark de début
watermark de fin
lignes source
lignes cibles

Vérifiez ensuite qu’aucun intervalle n’a été :

ignoré
chevauché involontairement
retraité sans idempotence

75. Utiliser des fenêtres temporelles semi-ouvertes de manière cohérente

Exemple :

[start, end)

Cela permet aux lots adjacents de s’enchaîner sans chevauchement des horodatages de fin.

Les égalités d’horodatage et les arrivées tardives exigent toutefois une conception explicite.


76. Vérifier les enregistrements arrivés en retard

Mesurez :

ingestion_time - event_time

Suivez la distribution dans le temps.

Appuyez-vous sur le comportement réel de la source pour définir la politique de retard.


77. Détecter la dérive des distributions

Exemples :

répartition par pays
répartition par statut
distribution des montants
taux de nulls
nombre de clients distincts

Comparez à l’historique.

Ne déclenchez pas d’alerte à chaque fluctuation naturelle.


78. Vérifier la distribution catégorielle

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

Un statut nouveau ou inconnu peut indiquer un changement dans la source.


79. Vérifier le résumé numérique

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

Appuyez-vous sur les tendances et le contexte plutôt que sur des valeurs « acceptables » universelles.


80. Utiliser les percentiles avec prudence

Pour des métriques asymétriques, des percentiles approximatifs peuvent être plus informatifs que la moyenne.

Exemple :

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

Le comportement des percentiles approximatifs dépend du moteur et de la configuration.


81. Comparer les métriques actuelles et historiques

Stockez des métriques par exécution afin de pouvoir répondre à :

Le taux de nulls a-t-il bondi ?
Le nombre de lignes s’est-il effondré ?
Une catégorie a-t-elle disparu ?
La distribution des montants a-t-elle changé ?

Le contexte des tendances est plus utile que des seuils isolés.


82. Détecter les colonnes entièrement nulles

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 champ obligatoire entièrement nul signale souvent une défaillance de l’analyseur, du schéma ou de la source.


83. Vérifier les colonnes constantes

Un champ qui n’a soudain plus qu’une seule valeur distincte peut indiquer :

  • un bogue de valeur codée en dur dans la source
  • un problème d’analyseur
  • une valeur par défaut en amont
  • une condition métier légitime

Suivez :

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

Utilisez ce contrôle de manière sélective, sur des colonnes gérables ou à forte valeur.


84. Faire attention aux contrôles distinct coûteux

countDistinct peut générer un shuffle important.

N’exécutez pas des dizaines d’analyses distinct complètes sur des tables massives sans prioriser les clés et colonnes importantes.

Regroupez le travail lorsque c’est possible.


85. Échantillonner uniquement pour l’exploration, pas pour les garanties finales

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

Un échantillon peut révéler des problèmes.

Il ne peut pas prouver :

zéro doublon
zéro clé invalide
intégrité référentielle complète

Utilisez des contrôles complets lorsque le contrat exige une certitude.


86. Éviter de collecter de grands ensembles invalides sur le driver

À éviter :

bad_rows = invalid.collect()

En cas d’échecs volumineux, écrivez dans un stockage de quarantaine et ne collectez que de petits résumés ou échantillons.


87. Limiter les exemples dans les alertes

Alerte :

règle en échec
failed_count=1,248,321
sample_keys=[...]

N’attachez pas un million de lignes incorrectes aux journaux ou à un e-mail.


88. Conserver séparément les preuves complètes des échecs

Modèle :

table des résultats de qualité
→ synthèse

table de quarantaine
→ lignes en échec complètes

Cela sépare la supervision de la correction détaillée.


89. Valider le schéma cible après l’écriture

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

Utile lorsque l’évolution du schéma ou le comportement d’écrasement entre en jeu.


90. Valider l’unicité de la cible après un MERGE

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

Ne supposez pas que la logique du MERGE a préservé le grain prévu.


91. Comparer les clés de la source et de la cible

Clés absentes de la cible :

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

Clés en trop dans la cible :

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

À utiliser uniquement lorsque les périmètres de la source et de la cible sont réellement comparables.


92. Le périmètre de la réconciliation doit correspondre

Ne comparez pas :

la source du jour

avec :

tout l’historique de la cible

sans appliquer le même périmètre métier, de date ou de tenant.


93. Valider les comptages avant un écrasement destructif

Avant de remplacer une partition ou une table :

nombre de lignes du nouveau candidat
vs
nombre attendu existant/source

Si le candidat est vide de manière inattendue, arrêtez-vous avant l’écrasement.


94. Ajouter des garde-fous aux reconstructions

Exemple :

candidate_count = candidate.count()

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

N’utilisez ce contrôle que si zéro ligne ne peut jamais être légitime pour cette reconstruction.


95. Les règles de qualité doivent être versionnées avec le code

Une modification de règle fait partie du comportement du pipeline.

Suivez :

version de la règle
commit du code
déploiement

Cela aide à expliquer pourquoi des données ont commencé à échouer après une mise en production.


96. Distinguer les défauts de la source de ceux du pipeline

Classez les échecs :

qualité de la source
contrat de schéma
transformation du pipeline
données de référence
écriture dans la cible

Cela aide à attribuer correctement la responsabilité.


97. Les contrôles de qualité ont besoin d’un responsable

Chaque règle bloquante doit avoir :

responsable
runbook
action attendue
chemin d’escalade

Un contrôle en échec sans responsable devient du bruit d’alerte.


98. Définir le chemin de correction

Pour chaque règle importante :

faire échouer le pipeline ?
mettre en quarantaine les lignes invalides ?
continuer avec un avertissement ?
relancer la source ?
rattraper plus tard (backfill) ?
ouvrir un incident ?

Décidez-en avant la défaillance en production.


99. La qualité des données s’applique à plusieurs couches

Modèle typique :

Bronze
→ contrôles d’ingestion/de la source

Silver
→ schéma, dédoublonnage, validité, règles référentielles

Gold
→ réconciliation métier, grain, cohérence des métriques

Ne placez pas toutes les règles dans une seule couche.


100. Utiliser un processus de qualité reproductible

1. Valider le schéma
2. Valider les clés obligatoires
3. Valider l’unicité/le grain
4. Valider les règles du domaine
5. Valider les références
6. Valider la fraîcheur/le volume
7. Réconcilier les totaux métier
8. Mettre les échecs en quarantaine
9. Conserver les résultats des règles
10. Avancer le watermark uniquement après le passage des contrôles requis

Interpréter le résultat

Type de contrôle Ce qu’il protège
Schéma Compatibilité du contrat
Non nul Complétude des données obligatoires
Unicité Grain métier attendu
Domaine/plage Validité sémantique
Intégrité référentielle Cohérence entre entités
Fraîcheur Disponibilité des données dans les délais
Volume Chargements manquants ou en double
Réconciliation Exactitude métier
Dérive des distributions Changements inattendus de la source ou du comportement
Idempotence Nouvelles tentatives et retraitements sûrs
Couverture des partitions Tranches temporelles ou de tenant manquantes

Le principe fondamental est :

qualité des données = contrats métier/données explicites
et non des pourcentages génériques

Points à vérifier

Le nombre de lignes chute soudainement

Vérifiez :

  • des fichiers source manquants
  • des changements de filtre ou de watermark
  • une panne de la source
  • des échecs d’analyse du schéma
  • des partitions omises

Le nombre de lignes augmente soudainement

Vérifiez :

  • un chargement en double de la source
  • une multiplication due à une jointure
  • une duplication due aux nouvelles tentatives
  • un changement de comportement de la source

Des clés en double apparaissent après une jointure

Examinez l’unicité des clés du côté droit et la cardinalité de la jointure.

Le taux de nulls grimpe brusquement

Vérifiez le schéma de la source, l’analyse, les champs renommés et les valeurs par défaut en amont.

Les totaux financiers divergent alors que le nombre de lignes correspond

Vérifiez :

  • des montants en double
  • la devise
  • les filtres
  • l’arrondi
  • les conventions de signe
  • des lignes de détail supprimées ou dupliquées

Le contrôle de fraîcheur échoue alors que la durée du pipeline est normale

La source est peut-être en retard, plutôt que le pipeline lent.

Notes de production

Les contrôles consomment des ressources de calcul

Les analyses de table complète, les comptages distinct et les jointures référentielles peuvent être coûteux.

Priorisez les règles critiques et regroupez les agrégations.

Les règles bloquantes doivent être déterministes

Une règle qui échoue aléatoirement à cause d’un échantillonnage instable ne convient pas comme contrôle bloquant en production.

L’état de la qualité doit être auditable

Conservez :

règle
exécution
valeur observée
statut
horodatage

et pas seulement une ligne de journal « réussite/échec ».

La quarantaine n’est pas une poubelle

Les enregistrements en quarantaine nécessitent :

  • un motif
  • un responsable
  • une durée de rétention
  • un chemin de correction

Les seuils doivent reposer sur des faits

Ne copiez pas des seuils génériques comme :

5 % de nulls
10 % d’écart du nombre de lignes

sans justification métier ou historique.

Les contrôles de qualité ne doivent bloquer par défaut que là où le métier l’exige

Toutes les anomalies ne doivent pas interrompre l’ensemble de la livraison des données.

Appuyez-vous sur la gravité et l’impact.

Erreurs fréquentes

1. Utiliser un score de qualité générique unique

Des défaillances critiques peuvent être masquées par un score moyen élevé.

2. Supprimer les doublons sans les examiner

Cela détruit les preuves et peut écarter la mauvaise ligne.

3. Considérer chaque null comme une erreur

Une valeur nulle peut être valide pour des champs facultatifs.

4. Considérer zéro ligne comme toujours invalide

Certains flux n’ont légitimement aucune activité.

5. S’appuyer uniquement sur le nombre de lignes

Les totaux métier et les contrôles au niveau des clés peuvent révéler des erreurs que le nombre de lignes ne voit pas.

6. Contrôler la qualité uniquement avant l’écriture

Le comportement d’écriture dans la cible peut encore introduire des problèmes.

7. Utiliser des seuils arbitraires

Les seuils doivent découler des contrats et du comportement historique.

8. Collecter toutes les lignes incorrectes sur le driver

Cela peut faire planter de gros travaux distribués.

9. Faire avancer les watermarks avant que les contrôles bloquants soient passés

Cela peut faire sauter définitivement des données en échec.

10. Alerter sans responsable ni chemin de correction

Cela crée du bruit au lieu de fiabilité.

Étape suivante

Utilisez la règle en échec pour choisir l’action suivante.

  • Colonnes ou types manquants → examinez la source et la dérive de schéma avant la transformation.
  • Clés obligatoires nulles → mettez en quarantaine et remontez jusqu’à la source ou à l’analyseur.
  • Clés métier en double → examinez les nouvelles tentatives de la source, les jointures et la règle de dédoublonnage.
  • Échecs de référence → distinguez les mauvaises clés des dimensions arrivées en retard.
  • Anomalie de volume → comparez les fichiers source, le watermark, les partitions et l’historique récent.
  • Échec de fraîcheur → distinguez le retard de la source du retard de traitement.
  • Écart de réconciliation → comparez par date, tenant ou marchand et examinez la multiplication ou la perte de lignes.
  • Les contrôles passent avant l’écriture mais la cible est incorrecte → ajoutez des contrôles après écriture.
  • Les contrôles sont trop coûteux → priorisez les règles critiques, agrégez en une seule passe et exécutez les contrôles approfondis de manière sélective.
  • Besoin de positionnement architectural → passez à Architecture Medallion : référence rapide.

← Tous les aide-mémoire