Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
Référence DQDL (Data Quality Definition Language)
Le langage DQDL (Data Quality Definition Language) est un langage spécifique au domaine que vous utilisez pour définir des règles pour AWS Glue Data Quality.
Ce guide présente les concepts clés de DQDL pour vous aider à vous familiariser avec ce langage. Il fournit également une référence pour les types de règles DQDL, avec syntaxe et exemples. Avant d'utiliser ce guide, nous vous recommandons de vous familiariser avec AWS Glue Data Quality. Pour plus d’informations, consultez AWS Glue Qualité des données.
Note
DynamicRules ne sont pris en charge que dans l'AWS GlueETL.
Table des matières
- Syntaxe DQDL
- Référence du type de règle DQDL
- AggregateMatch
- ColumnCorrelation
- ColumnCount
- ColumnDataType
- ColumnExists
- ColumnLength
- ColumnNamesMatchPattern
- ColumnValues
- Intégralité
- CustomSQL
- DataFreshness
- DatasetMatch
- DistinctValuesCount
- Entropie
- IsComplete
- IsPrimaryKey
- IsUnique
- Mean
- ReferentialIntegrity
- RowCount
- RowCountMatch
- StandardDeviation
- Somme
- SchemaMatch
- Unicité
- UniqueValueRatio
- DetectAnomalies
Syntaxe DQDL
Un document DQDL est sensible à la casse et contient un jeu de règles, qui regroupe les règles individuelles de qualité des données. Pour construire un jeu de règles, vous devez créer une liste nommée Rules (en majuscules), délimitée par une paire de crochets. La liste doit contenir une ou plusieurs règles DQDL séparées par des virgules, comme dans l'exemple suivant.
Rules = [ IsComplete "order-id", IsUnique "order-id" ]
Structure des règles
La structure d'une règle DQDL dépend du type de la règle. Toutefois, les règles DQDL respectent généralement le format suivant.
<RuleType> <Parameter> <Parameter> <Expression>
RuleType est le nom sensible à la casse du type de règle que vous souhaitez configurer. Par exemple, IsComplete, IsUnique ou CustomSql. Les paramètres varient en fonction du type de règle. Pour obtenir une référence complète des types de règles DQDL et de leurs paramètres, consultez Référence du type de règle DQDL.
Règles composites
DQDL prend en charge les opérateurs logiques suivants que vous pouvez utiliser pour combiner des règles. Ces règles sont appelées règles composites.
- and
-
L'opérateur logique
andgénèretruesi et seulement si les règles qu'il connecte sonttrue. Sinon, la règle combinée génèrefalse. Chaque règle que vous connectez à l'opérateuranddoit être entourée de parenthèses.L'exemple suivant utilise l'opérateur
andpour combiner deux règles DQDL.(IsComplete "id") and (IsUnique "id") - or
-
L'opérateur logique
orgénèretruesi et seulement si une ou plusieurs des règles qu'il connecte sonttrue. Chaque règle que vous connectez à l'opérateurordoit être entourée de parenthèses.L'exemple suivant utilise l'opérateur
orpour combiner deux règles DQDL.(RowCount "id" > 100) or (IsPrimaryKey "id")
Le même opérateur peut être utilisé pour connecter plusieurs règles. La combinaison de règles suivante est donc autorisée.
(Mean "Star_Rating" > 3) and (Mean "Order_Total" > 500) and (IsComplete "Order_Id")
Il est toutefois impossible de combiner les opérateurs logiques en une seule expression. Par exemple, la combinaison suivante n'est pas autorisée.
(Mean "Star_Rating" > 3) and (Mean "Order_Total" > 500) or (IsComplete "Order_Id")
Comment fonctionnent les règles composites
Par défaut, les règles composites sont évaluées en tant que règles individuelles pour l'ensemble de données ou de la table, puis les résultats sont combinés. En d'autres termes, il évalue d'abord l'ensemble de la colonne, puis applique l'opérateur. Ce comportement par défaut est expliqué ci-dessous à l'aide d'un exemple :
# Dataset +------+------+ |myCol1|myCol2| +------+------+ | 2| 1| | 0| 3| +------+------+ # Overall outcome +----------------------------------------------------------+-------+ |Rule |Outcome| +----------------------------------------------------------+-------+ |(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)|Failed | +----------------------------------------------------------+-------+
Dans l'exemple ci-dessus, évaluez d'AWS Glue Data Qualityabord (ColumnValues "myCol1" > 1) ce qui entraînera un échec. Ensuite, il évaluera (ColumnValues "myCol2" > 2) ce qui échouera également. La combinaison des deux résultats sera considérée comme un échec.
Toutefois, si vous préférez un comportement de type SQL, dans lequel vous devez évaluer la ligne entière, vous devez définir explicitement le ruleEvaluation.scope paramètre comme indiqué additionalOptions dans l'extrait de code ci-dessous.
object GlueApp { val datasource = glueContext.getCatalogSource( database="<db>", tableName="<table>", transformationContext="datasource" ).getDynamicFrame() val ruleset = """ Rules = [ (ColumnValues "age" >= 26) OR (ColumnLength "name" >= 4) ] """ val dq_results = EvaluateDataQuality.processRows( frame=datasource, ruleset=ruleset, additionalOptions=JsonOptions(""" { "compositeRuleEvaluation.method":"ROW" } """ ) ) }
Dans AWS Glue Studio et AWS Glue Data Catalog, vous pouvez facilement configurer cette option dans l'interface utilisateur, comme indiqué ci-dessous.
Une fois définies, les règles composites se comporteront comme une règle unique évaluant la ligne entière. L'exemple suivant illustre ce comportement.
# Row Level outcome +------+------+------------------------------------------------------------+---------------------------+ |myCol1|myCol2|DataQualityRulesPass |DataQualityEvaluationResult| +------+------+------------------------------------------------------------+---------------------------+ |2 |1 |[(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)]|Passed | |0 |3 |[(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)]|Passed | +------+------+------------------------------------------------------------+---------------------------+
Certaines règles ne peuvent pas être prises en charge dans cette fonctionnalité car leur résultat global repose sur des seuils ou des ratios. Ils sont listés ci-dessous.
Règles basées sur les ratios :
-
Intégralité
-
DatasetMatch
-
ReferentialIntegrity
-
Unicité
Règles dépendantes des seuils :
Lorsque les règles suivantes sont incluses dans un seuil, elles ne sont pas prises en charge. Cependant, les règles qui n'impliquent pas with threshold restent prises en charge.
-
ColumnDataType
-
ColumnValues
-
CustomSQL
Expressions
Si un type de règle ne produit pas de réponse booléenne, vous devez fournir une expression en tant que paramètre afin de créer une réponse booléenne. Par exemple, la règle suivante vérifie la moyenne de toutes les valeurs d’une colonne par rapport à une expression afin de renvoyer un résultat vrai ou faux.
Mean "colA" between 80 and 100
Certains types de règles tels que IsUnique et IsComplete renvoient déjà une réponse booléenne.
Le tableau suivant répertorie les expressions pouvant être utilisées dans les règles DQDL.
Expressions DQDL prises en charge | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Expression | Description | Exemple | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
= x |
Se traduit par true si la réponse du type de règle est égale à x. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
! = x |
x devient vrai si la réponse du type de règle n'est pas égale à x. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
> x |
Se traduit par true si la réponse du type de règle est supérieure à x. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
< x |
Se traduit par true si la réponse du type de règle est inférieure à x. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
>= x |
Se traduit par true si la réponse du type de règle est supérieure ou égale à x. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
<= x |
Se traduit par true si la réponse du type de règle est inférieure ou égale à x. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
entre x et y |
Se traduit par true si la réponse du type de règle se situe dans une plage spécifiée (exclusif). Utilisez ce type d’expression uniquement pour les types numériques et date. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
pas entre x et y |
Prend la valeur true si la réponse du type de règle ne se situe pas dans une plage spécifiée (incluse). Vous ne devez utiliser ce type d'expression que pour les types numériques et les dates. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
dans [a, b, c,... ] |
Se traduit par true si la réponse du type de règle se trouve dans le jeu spécifié. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
pas dans [a, b, c,... ] |
Résout true si la réponse du type de règle ne se trouve pas dans l'ensemble spécifié. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
correspond à /ab+c/i |
Se traduit par true si la réponse du type de règle correspond à une expression régulière. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
ne correspond pas à /ab+c/i |
Résout true si la réponse du type de règle ne correspond pas à une expression régulière. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
now() |
Fonctionne uniquement avec le type de règle ColumnValues pour créer une expression de date. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
correspond à [...] /ne correspond pas/ne correspond pas à [...] with threshold |
Spécifie le pourcentage de valeurs qui correspondent aux conditions de la règle. Fonctionne uniquement avec ColumnValues les types de CustomSQL règlesColumnDataType, et. |
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Mots-clés pour NULL, EMPTY et WHITESPACES_ONLY
Si vous souhaitez vérifier si une colonne de chaîne contient une valeur nulle, vide ou une chaîne contenant uniquement des espaces, vous pouvez utiliser les mots clés suivants :
-
NULL/null — Ce mot clé prend la valeur true pour une
nullvaleur d'une colonne de chaîne.ColumnValues "colA" != NULL with threshold > 0.5renverrait vrai si plus de 50 % de vos données ne contiennent pas de valeurs nulles.(ColumnValues "colA" = NULL) or (ColumnLength "colA" > 5)renverrait vrai pour toutes les lignes qui ont une valeur nulle ou dont la longueur est supérieure à 5. Notez que cela nécessitera l'utilisation de l'option « compositeRuleEvaluation .method » = « ROW ». -
EMPTY/empty — Ce mot clé prend la valeur true pour une valeur de chaîne vide (« ») dans une colonne de chaînes. Certains formats de données transforment les valeurs nulles d'une colonne de chaînes en chaînes vides. Ce mot clé permet de filtrer les chaînes vides dans vos données.
(ColumnValues "colA" = EMPTY) or (ColumnValues "colA" in ["a", "b"])renverrait vrai si une ligne est vide, « a » ou « b ». Notez que cela nécessite l'utilisation de l'option « compositeRuleEvaluation .method » = « ROW ». -
WHITESPACES_ONLY/whitespaces_only — Ce mot clé prend la valeur true pour une chaîne contenant uniquement des espaces blancs (« ») dans une colonne de chaîne.
ColumnValues "colA" not in ["a", "b", WHITESPACES_ONLY]renverrait vrai si une ligne n'est ni « a », ni « b », ni simplement des espaces.Règles prises en charge :
Pour une expression numérique ou basée sur une date, si vous souhaitez vérifier si une colonne contient une valeur nulle, vous pouvez utiliser les mots clés suivants.
-
NULL/null — Ce mot clé prend la valeur true pour une valeur nulle dans une colonne de chaîne.
ColumnValues "colA" in [NULL, "2023-01-01"]renverrait vrai si une date de votre colonne est nulle2023-01-01ou nulle.(ColumnValues "colA" = NULL) or (ColumnValues "colA" between 1 and 9)renverrait vrai pour toutes les lignes qui ont une valeur nulle ou dont les valeurs sont comprises entre 1 et 9. Notez que cela nécessitera l'utilisation de l'option « compositeRuleEvaluation .method » = « ROW ».Règles prises en charge :
Filtrer avec la clause Where
Vous pouvez filtrer vos données lorsque vous créez des règles. Cela est utile lorsque vous souhaitez appliquer des règles conditionnelles.
<DQDL Rule> where "<valid SparkSQL where clause> "
Le filtre doit être spécifié avec le where mot clé, suivi d'une instruction SparkSQL valide entre guillemets. ("")
Si vous souhaitez ajouter la clause Where à une règle avec un seuil, la clause Where doit être spécifiée avant la condition de seuil.
<DQDL Rule> where "valid SparkSQL statement>" with threshold <threshold condition>
Avec cette syntaxe, vous pouvez écrire des règles comme les suivantes.
Completeness "colA" > 0.5 where "colB = 10" ColumnValues "colB" in ["A", "B"] where "colC is not null" with threshold > 0.9 ColumnLength "colC" > 10 where "colD != Concat(colE, colF)"
Nous allons vérifier que l'instruction SparkSQL fournie est valide. Si elle n'est pas valide, l'évaluation des règles échouera et nous lancerons IllegalArgumentException l'annonce au format suivant :
Rule <DQDL Rule> where "<invalid SparkSQL>" has provided an invalid where clause : <SparkSQL Error>
Comportement de la clause Where lorsque l'identification des enregistrements d'erreur au niveau des lignes est activée
Avec AWS Glue Data Quality, vous pouvez identifier les enregistrements spécifiques qui ont échoué. Lorsque vous appliquez une clause WHERE à des règles qui prennent en charge les résultats au niveau des lignes, nous étiquetons les lignes filtrées par la clause WHERE comme suitPassed.
Si vous préférez étiqueter séparément les lignes filtrées comme suitSKIPPED, vous pouvez définir les paramètres suivants additionalOptions pour la tâche ETL.
object GlueApp { val datasource = glueContext.getCatalogSource( database="<db>", tableName="<table>", transformationContext="datasource" ).getDynamicFrame() val ruleset = """ Rules = [ IsComplete "att2" where "att1 = 'a'" ] """ val dq_results = EvaluateDataQuality.processRows( frame=datasource, ruleset=ruleset, additionalOptions=JsonOptions(""" { "rowLevelConfiguration.filteredRowLabel":"SKIPPED" } """ ) ) }
À titre d'exemple, reportez-vous à la règle et à la trame de données suivantes :
IsComplete att2 where "att1 = 'a'"
| id | att1 | att2 | Résultats au niveau des lignes (par défaut) | Résultats au niveau des lignes (option ignorée) | Commentaires |
|---|---|---|---|---|---|
| 1 | a | f | PASSÉ | PASSÉ | |
| 2 | b | d | PASSÉ | SKIPPED | La ligne est filtrée, car elle ne l'att1est pas "a" |
| 3 | a | null | ÉCHEC | ÉCHEC | |
| 4 | a | f | PASSÉ | PASSÉ | |
| 5 | b | null | PASSÉ | SKIPPED | La ligne est filtrée, car elle ne l'att1est pas "a" |
| 6 | a | f | PASSÉ | PASSÉ |
Règles dynamiques
Vous pouvez désormais créer des règles dynamiques pour comparer les métriques actuelles produites par vos règles avec leurs valeurs historiques. Ces comparaisons historiques sont rendues possibles en utilisant l’opérateur last() dans les expressions. Par exemple, la règle RowCount >
last() fonctionne lorsque le nombre de lignes de l’exécution en cours est supérieur au nombre de lignes précédent le plus récent pour le même jeu de données. last() prend un argument de nombre naturel facultatif décrivant le nombre de métriques précédentes à prendre en compte ; last(k) où k
>= 1 renvoyera aux dernières métriques k.
-
Si aucun point de données n’est disponible,
last(k)renverra la valeur par défaut 0,0. -
Si moins de
kmétriques sont disponibles,last(k)renverra toutes les métriques précédentes.
Pour former des expressions valides, utilisez last(k), où k > 1 nécessite une fonction d’agrégation pour réduire plusieurs résultats historiques en un seul nombre. Par exemple, RowCount > avg(last(5)) vérifiera si le nombre de lignes du jeu de données actuel est strictement supérieur à la moyenne des cinq dernières lignes du même jeu de données. RowCount > last(5) générera une erreur, car le nombre de lignes du jeu de données actuel ne peut pas être comparé de manière significative à une liste.
Fonctions d’agrégation prises en charge :
-
avg -
median -
max -
min -
sum -
std(écart-type) -
abs(valeur absolue) -
index(last(k), i)permet de sélectionner laie valeur la plus récente parmi les dernièresk.iest indexé à partir de zéro, doncindex(last(3), 0)renverra le point de données le plus récent etindex(last(3), 3)générera une erreur, car il n’y a que trois points de données et nous essayons d’indexer le 4e le plus récent.
Exemples d'expressions
ColumnCorrelation
ColumnCorrelation "colA" "colB" < avg(last(10))
DistinctValuesCount
DistinctValuesCount "colA" between min(last(10))-1 and max(last(10))+1
La plupart des types de règles comportant des conditions ou des seuils numériques prennent en charge les règles dynamiques. Consultez le tableau fourni, Analyseurs et règles pour vérifier si les règles dynamiques sont disponibles pour le type de règle que vous utilisez.
Analyseurs
Note
Les analyseurs ne sont pas pris en charge dans AWS Glue Data Catalog.
Les règles DQDL utilisent des fonctions appelées analyseurs pour rassembler des informations sur vos données. Ces informations sont utilisées par l’expression booléenne d’une règle afin de décider si cette dernière doit être considérée comme réussie ou échouée. Par exemple, la RowCount règle RowCount > 5 utilisera un analyseur de nombre de lignes pour découvrir le nombre de lignes de votre ensemble de données et comparer ce nombre à l'expression > 5 pour vérifier s'il existe plus de cinq lignes dans le jeu de données actuel.
Il est parfois préférable, plutôt que de créer des règles, de créer des analyseurs et de les configurer pour qu’ils génèrent des statistiques utiles à la détection d’anomalies. Dans de tels cas, vous pouvez créer des analyseurs. Les analyseurs se distinguent des règles de la manière suivante.
| Caractéristiques | Analyseurs | Règles |
|---|---|---|
| Partie du jeu de règles | Oui | Oui |
| Génère des statistiques | Oui | Oui |
| Génère des observations | Oui | Oui |
| Peut évaluer et affirmer une condition | Non | Oui |
| Vous pouvez configurer des actions telles que l’arrêt des tâches en cas d’échec ou la poursuite du traitement des tâches | Non | Oui |
Les analyseurs peuvent exister indépendamment sans règles, vous offrant ainsi la possibilité de les configurer rapidement et de créer progressivement des règles de qualité des données.
Certains types de règles peuvent être saisis dans le bloc Analyzers de votre jeu de règles afin d’exécuter les règles nécessaires aux analyseurs et rassembler des informations sans avoir à valider une quelconque condition. Certains analyseurs ne sont pas associés à des règles et ne peuvent être saisis que dans le bloc Analyzers. Le tableau ci-dessous précise pour chaque élément s’il est pris en charge en tant que règle ou en tant qu’analyseur autonome, avec des informations supplémentaires pour chaque type de règle.
Exemple d'ensemble de règles avec analyseur
Le jeu de règles suivant utilise :
-
une règle dynamique permettant de vérifier si la croissance d’un jeu de données est supérieure à sa moyenne mobile au cours des trois dernières exécutions de tâches
-
un analyseur
DistinctValuesCountpermettant d’enregistrer le nombre de valeurs distinctes dans la colonneNamedu jeu de données -
un analyseur
ColumnLengthpermettant de suivre la tailleNameminimale et maximale au fil du temps
Les résultats des métriques de l’analyseur peuvent être consultés dans l’onglet Qualité des données de votre exécution de tâche.
Rules = [ RowCount > avg(last(3)) ] Analyzers = [ DistinctValuesCount "Name", ColumnLength "Name" ]
Commentaires
Vous pouvez utiliser le caractère « # » pour ajouter un commentaire à votre document DQDL. Tout ce qui se trouve après le caractère « # » et jusqu'à la fin de la ligne est ignoré par DQDL.
Rules = [ # More items should generally mean a higher price, so correlation should be positive ColumnCorrelation "price" "num_items" > 0 ]
Référence du type de règle DQDL
Cette section fournit une référence pour chaque type de règle pris en charge par AWS Glue Data Quality.
Note
Le langage DQDL ne prend actuellement pas en charge les données de colonnes imbriquées ou de type liste.
Les valeurs entre crochets dans le tableau ci-dessous seront remplacées par les informations fournies dans les arguments des règles.
Les règles nécessitent généralement un argument supplémentaire pour l'expression.
| Ruletype | Description | Arguments | Métriques rapportées | Prise en charge en tant que règle ? | Prise en charge en tant qu’analyseur ? | Renvoie des résultats au niveau des lignes ? | Prise en charge des règles dynamiques ? | Génère des observations | Supporte la syntaxe de la clause Where ? |
|---|---|---|---|---|---|---|---|---|---|
| AggregateMatch | Vérifie si deux jeux de données correspondent en comparant des métriques récapitulatives telles que le montant total des ventes. Utile pour permettre aux institutions financières de vérifier si toutes les données sont ingérées à partir de systèmes sources. | Une ou plusieurs agrégations |
Lorsque les noms de la première et de la deuxième colonne d’agrégation correspondent :
Lorsque les noms de la première et de la deuxième colonne d’agrégation sont différents :
|
Oui | Non | Non | Non | Non | Non |
| AllStatistics | Analyseur autonome permettant de rassembler plusieurs métriques pour la colonne fournie ou pour toutes les colonnes d’un jeu de données. | Un nom de colonne unique, OU « AllColumns » |
Pour les colonnes de tous types :
Métriques supplémentaires pour les colonnes à valeur de chaîne :
Métriques supplémentaires pour les colonnes à valeur numérique :
|
Non | Oui | Non | Non | Non | Non |
| ColumnCorrelation | Vérifie dans quelle mesure deux colonnes sont corrélées. | Exactement deux noms de colonne | Multicolumn.[Column1],[Column2].ColumnCorrelation |
Oui | Oui | Non | Oui | Non | Oui |
| ColumnCount | Vérifie si des colonnes sont supprimées. | Aucun | Dataset.*.ColumnCount |
Oui | Non | Non | Oui | Oui | Non |
| ColumnDataType | Vérifie si une colonne est conforme à un type de données. | Exactement un nom de colonne | Column.[Column].ColumnDataType.Compliance |
Oui | Non | Non | Oui, dans l’expression de seuil au niveau de la ligne | Non | Oui |
| ColumnExists | Vérifie si des colonnes existent dans un jeu de données. Cela permet aux clients de créer des plateformes de données en libre-service pour s'assurer que certaines colonnes sont disponibles. | Exactement un nom de colonne | N/A | Oui | Non | Non | Non | Non | Non |
| ColumnLength | Vérifie si la longueur des données est cohérente. | Exactement un nom de colonne |
Métrique supplémentaire lorsque le seuil au niveau de la ligne est fourni :
|
Oui | Oui | Oui, lorsque le seuil au niveau de la ligne est fourni | Non | Oui. Génère uniquement des observations en analysant les longueurs minimale et maximale | Oui |
| ColumnNamesMatchPattern | Vérifie si les noms de colonnes correspondent aux modèles définis. Utile pour les équipes de gouvernance afin d'assurer la cohérence des noms de colonnes. | Une expression régulière pour les noms de colonne | Dataset.*.ColumnNamesPatternMatchRatio |
Oui | Non | Non | Non | Non | Non |
| ColumnValues | Vérifie si les données sont cohérentes par rapport aux valeurs définies. Cette règle prend en charge les expressions régulières. | Exactement un nom de colonne |
Métrique supplémentaire lorsque le seuil au niveau de la ligne est fourni :
|
Oui | Oui | Oui, lorsque le seuil au niveau de la ligne est fourni | Non | Oui. Génère uniquement des observations en analysant les valeurs minimales et maximales | Oui |
| Intégralité | Vérifie la présence d'espaces vides ou de valeurs NULL dans les données. | Exactement un nom de colonne |
|
Oui | Oui | Oui | Oui | Oui | Oui |
| CustomSql | Les clients peuvent implémenter presque tous les types de contrôles de qualité des données dans SQL. |
Une instruction SQL (Facultatif) Un seuil au niveau de la ligne |
Métrique supplémentaire lorsque le seuil au niveau de la ligne est fourni :
|
Oui | Non | Oui, lorsque le seuil au niveau de la ligne est fourni | Oui | Non | Non |
| DataFreshness | Vérifie si les données sont récentes. | Exactement un nom de colonne | Column.[Column].DataFreshness.Compliance |
Oui | Non | Oui | Non | Non | Oui |
| DatasetMatch | Compare deux jeux de données et détermine s'ils sont synchronisés. |
Nom d’un jeu de données de référence Un mappage de colonnes (Facultatif) Colonnes pour vérifier les correspondances |
Dataset.[ReferenceDatasetAlias].DatasetMatch |
Oui | Non | Oui | Oui | Non | Non |
| DistinctValuesCount | Vérifie la présence de valeurs dupliquées. | Exactement un nom de colonne | Column.[Column].DistinctValuesCount |
Oui | Oui | Oui | Oui | Oui | Oui |
| DetectAnomalies | Vérifie la présence d’anomalies dans les métriques rapportées par un autre type de règle. | Un type de règle | Métrique(s) rapportée(s) par l’argument du type de règle | Oui | Non | Non | Non | Non | Non |
| Entropie | Vérifie l'entropie des données. | Exactement un nom de colonne | Column.[Column].Entropy |
Oui | Oui | Non | Oui | Non | Oui |
| IsComplete | Vérifie si 100 % des données sont complètes. | Exactement un nom de colonne | Column.[Column].Completeness |
Oui | Non | Oui | Non | Non | Oui |
| IsPrimaryKey | Vérifie si une colonne est une clé primaire (non NULL et unique). | Exactement un nom de colonne |
Pour une seule colonne :
Pour plusieurs colonnes :
|
Oui | Non | Oui | Non | Non | Oui |
| IsUnique | Vérifie si 100 % des données sont uniques. | Exactement un nom de colonne | Column.[Column].Uniqueness |
Oui | Non | Oui | Non | Non | Oui |
| Mean | Vérifie si la moyenne correspond au seuil défini. | Exactement un nom de colonne | Column.[Column].Mean |
Oui | Oui | Oui | Oui | Non | Oui |
| ReferentialIntegrity | Vérifie si deux jeux de données ont une intégrité référentielle. |
Un ou plusieurs noms de colonne provenant du jeu de données Un ou plusieurs noms de colonne provenant du jeu de données de référence |
Column.[ReferenceDatasetAlias].ReferentialIntegrity |
Oui | Non | Oui | Oui | Non | Non |
| RowCount | Vérifie si le nombre d'enregistrements correspond à un seuil. | Aucun | Dataset.*.RowCount |
Oui | Oui | Non | Oui | Oui | Oui |
| RowCountMatch | Vérifie si le nombre d'enregistrements entre deux jeux de données correspond. | Alias de jeu de données de référence | Dataset.[ReferenceDatasetAlias].RowCountMatch |
Oui | Non | Non | Oui | Non | Non |
| StandardDeviation | Vérifie si l'écart type correspond au seuil. | Exactement un nom de colonne | Column.[Column].StandardDeviation |
Oui | Oui | Oui | Oui | Non | Oui |
| SchemaMatch | Vérifie si le schéma entre deux jeux de données correspond. | Alias de jeu de données de référence | Dataset.[ReferenceDatasetAlias].SchemaMatch |
Oui | Non | Non | Oui | Non | Non |
| Somme | Vérifie si la somme correspond à un seuil défini. | Exactement un nom de colonne | Column.[Column].Sum |
Oui | Oui | Non | Oui | Non | Oui |
| Unicité | Vérifie si l'unicité du jeu de données correspond au seuil. | Exactement un nom de colonne | Column.[Column].Uniqueness |
Oui | Oui | Oui | Oui | Non | Oui |
| UniqueValueRatio | Vérifie si le ratio de valeur unique correspond au seuil. | Exactement un nom de colonne | Column.[Column].UniqueValueRatio |
Oui | Oui | Oui | Oui | Non | Oui |
Rubriques
- AggregateMatch
- ColumnCorrelation
- ColumnCount
- ColumnDataType
- ColumnExists
- ColumnLength
- ColumnNamesMatchPattern
- ColumnValues
- Intégralité
- CustomSQL
- DataFreshness
- DatasetMatch
- DistinctValuesCount
- Entropie
- IsComplete
- IsPrimaryKey
- IsUnique
- Mean
- ReferentialIntegrity
- RowCount
- RowCountMatch
- StandardDeviation
- Somme
- SchemaMatch
- Unicité
- UniqueValueRatio
- DetectAnomalies
AggregateMatch
Vérifie le ratio de deux agrégations de colonnes par rapport à une expression donnée. Ce type de règle fonctionne sur plusieurs jeux de données. Les deux agrégations de colonnes sont évaluées et un ratio est produit en divisant le résultat de la première agrégation de colonnes par le résultat de la seconde agrégation de colonnes. Le ratio est vérifié par rapport à l'expression fournie pour produire une réponse booléenne.
Syntaxe
Agrégation de colonnes
ColumnExists<AGG_OPERATION>(<OPTIONAL_REFERENCE_ALIAS>.<COL_NAME>)
AGG_OPERATION : l'opération à utiliser pour l'agrégation. À l'heure actuelle,
sumetavgsont pris en charge.Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
OPTIONAL_REFERENCE_ALIAS : ce paramètre doit être fourni si la colonne provient d'un jeu de données de référence et non du jeu de données principal. Si vous utilisez cette règle dans le catalogue de données AWS Glue, votre alias de référence doit suivre le format « »<database_name>. <table_name>. <column_name>
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
COL_NAME : le nom de la colonne à agréger.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
Exemple : moyenne
"avg(rating)"
Exemple : somme
"sum(amount)"
Exemple : moyenne de la colonne dans le jeu de données de référence
"avg(reference.rating)"
Règle
AggregateMatch<AGG_EXP_1><AGG_EXP_2><EXPRESSION>
AGG_EXP_1 : la première agrégation de colonnes.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
AGG_EXP_2 : la deuxième agrégation de colonnes.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : correspondance agrégée à l'aide de la somme
L'exemple de règle suivant vérifie si la somme des valeurs de la colonne amount est exactement égale à la somme des valeurs de la colonne total_amount.
AggregateMatch "sum(amount)" "sum(total_amount)" = 1.0
Exemple : correspondance agrégée à l'aide de la moyenne
L'exemple de règle suivant vérifie si la moyenne des valeurs de la colonne ratings est égale à au moins 90 % de la moyenne des valeurs de la colonne ratings dans le jeu de données reference. Le jeu de données de référence est fourni en tant que source de données supplémentaire dans l'expérience ETL ou le catalogue de données.
Dans AWS Glue ETL, vous pouvez utiliser :
AggregateMatch "avg(ratings)" "avg(reference.ratings)" >= 0.9
Dans le catalogue de données AWS Glue, vous pouvez utiliser :
AggregateMatch "avg(ratings)" "avg(database_name.tablename.ratings)" >= 0.9
Comportement nul
La AggregateMatch règle ignorera les lignes contenant des valeurs NULL dans le calcul des méthodes d'agrégation (somme/moyenne). Par exemple :
+---+-----------+ |id |units | +---+-----------+ |100|0 | |101|null | |102|20 | |103|null | |104|40 | +---+-----------+
La moyenne de la colonne units sera (0 + 20 + 40)/3 = 20. Les lignes 101 et 103 ne sont pas prises en compte dans ce calcul.
ColumnCorrelation
Vérifie la corrélation entre deux colonnes par rapport à une expression donnée. AWS Glue Data Quality utilise le coefficient de corrélation de Pearson pour mesurer la corrélation linéaire entre deux colonnes. Le résultat est un nombre compris entre -1 et 1 qui mesure la force et la direction de la relation.
Syntaxe
ColumnCorrelation<COL_1_NAME><COL_2_NAME><EXPRESSION>
COL_1_NAME – Nom de la première colonne par rapport à laquelle vous souhaitez évaluer la règle de qualité des données.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
COL_2_NAME – Nom de la deuxième colonne par rapport à laquelle vous souhaitez évaluer la règle de qualité des données.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : corrélation de colonnes
L'exemple de règle suivant vérifie si le coefficient de corrélation entre les colonnes height et weight présente une forte corrélation positive (valeur de coefficient supérieure à 0,8).
ColumnCorrelation "height" "weight" > 0.8
ColumnCorrelation "weightinkgs" "Salary" > 0.8 where "weightinkgs > 40"
Exemples de règles dynamiques
ColumnCorrelation "colA" "colB" between min(last(10)) and max(last(10))ColumnCorrelation "colA" "colB" < avg(last(5)) + std(last(5))
Comportement nul
La ColumnCorrelation règle ignorera les lignes contenant NULL des valeurs dans le calcul de la corrélation. Par exemple :
+---+-----------+ |id |units | +---+-----------+ |100|0 | |101|null | |102|20 | |103|null | |104|40 | +---+-----------+
Les lignes 101 et 103 seront ignorées, et ColumnCorrelation ce sera 1.0.
ColumnCount
Vérifie le nombre de colonnes du jeu de données principal par rapport à une expression donnée. Dans l'expression, vous pouvez spécifier le nombre de colonnes ou une plage de colonnes à l'aide d'opérateurs tels que > et <.
Syntaxe
ColumnCount<EXPRESSION>
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : vérification numérique du nombre de colonnes
L'exemple de règle suivant vérifie si le nombre de colonnes est compris dans une plage donnée.
ColumnCount between 10 and 20
Exemples de règles dynamiques
ColumnCount >= avg(last(10))ColumnCount between min(last(10))-1 and max(last(10))+1
ColumnDataType
Vérifie le type de données inhérent aux valeurs d'une colonne donnée par rapport au type attendu fourni. Accepte une expression with threshold pour vérifier la présence d'un sous-ensemble des valeurs de la colonne.
Syntaxe
ColumnDataType<COL_NAME>=<EXPECTED_TYPE>ColumnDataType<COL_NAME>=<EXPECTED_TYPE>with threshold<EXPRESSION>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : type de chaîne
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
EXPECTED_TYPE : le type attendu des valeurs de la colonne.
Valeurs prises en charge : booléen, date, horodatage, entier, double, flottant, long
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
EXPRESSION : une expression facultative pour spécifier le pourcentage de valeurs qui doivent être du type attendu.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
Exemple : les entiers de type colonne en tant que chaînes
L'exemple de règle suivant vérifie si les valeurs de la colonne donnée, qui est de type chaîne, sont réellement des entiers.
ColumnDataType "colA" = "INTEGER"
Exemple : les entiers de type colonne en tant que chaînes de caractères vérifient un sous-ensemble de valeurs.
L'exemple de règle suivant vérifie si plus de 90 % des valeurs de la colonne donnée, qui est de type chaîne, sont réellement des entiers.
ColumnDataType "colA" = "INTEGER" with threshold > 0.9
ColumnExists
Vérifie si une colonne existe.
Syntaxe
ColumnExists<COL_NAME>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : n'importe quel type de colonne
Exemple : une colonne existe
L'exemple de règle suivant vérifie si la colonne nommée Middle_Name existe.
ColumnExists "Middle_Name"
ColumnLength
Vérifie si la longueur de chaque ligne d'une colonne est conforme à une expression donnée.
Syntaxe
ColumnLength<COL_NAME><EXPRESSION>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : chaîne
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : longueur de ligne de colonne
L'exemple de règle suivant vérifie si la valeur de chaque ligne de la colonne nommée Postal_Code est constituée de 5 caractères.
ColumnLength "Postal_Code" = 5 ColumnLength "weightinkgs" = 2 where "weightinkgs > 10"
Comportement nul
La ColumnLength règle traite NULL s comme des chaînes de 0 longueur. Pour une NULL ligne :
ColumnLength "Postal_Code" > 4 # this will fail
ColumnLength "Postal_Code" < 6 # this will succeed
L'exemple de règle composée suivant fournit un moyen d'annuler explicitement des NULL valeurs :
(ColumnLength "Postal_Code" > 4) AND (ColumnValues != NULL)
ColumnNamesMatchPattern
Vérifie si les noms de toutes les colonnes du jeu de données principal correspondent à l'expression régulière donnée.
Syntaxe
ColumnNamesMatchPattern<PATTERN>
PATTERN : le modèle par rapport auquel vous souhaitez évaluer la règle de qualité des données.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
Exemple : les noms de colonnes correspondent au modèle
L'exemple de règle suivant vérifie si toutes les colonnes commencent par le préfixe « aws_ »
ColumnNamesMatchPattern "aws_.*" ColumnNamesMatchPattern "aws_.*" where "weightinkgs > 10"
ColumnValues
Exécute une expression en fonction des valeurs d'une colonne.
Syntaxe
ColumnValues<COL_NAME><EXPRESSION>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : n'importe quel type de colonne
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : valeurs autorisées
L'exemple de règle suivant vérifie si chaque valeur de la colonne spécifiée fait partie d'un ensemble de valeurs autorisées (y compris les valeurs nulles, vides et les chaînes contenant uniquement des espaces).
ColumnValues "Country" in [ "US", "CA", "UK", NULL, EMPTY, WHITESPACES_ONLY ] ColumnValues "gender" in ["F", "M"] where "weightinkgs < 10"
Exemple : expression régulière
L'exemple de règle suivant compare les valeurs d'une colonne à une expression régulière.
ColumnValues "First_Name" matches "[a-zA-Z]*"
Exemple : valeurs de date
L'exemple de règle suivant compare les valeurs d'une colonne de date à une expression de date.
ColumnValues "Load_Date" > (now() - 3 days)
Exemple : valeurs numériques
L'exemple de règle suivant vérifie si les valeurs des colonnes correspondent à une certaine contrainte numérique.
ColumnValues "Customer_ID" between 1 and 2000
Comportement nul
Pour toutes les ColumnValues règles (autres que != etNOT IN), NULL les lignes ne seront pas respectées. Si la règle échoue en raison d'une valeur nulle, la raison de l'échec s'affichera comme suit :
Value: NULL does not meet the constraint requirement!
L'exemple de règle composée suivant fournit un moyen d'autoriser explicitement les NULL valeurs :
(ColumnValues "Age" > 21) OR (ColumnValues "Age" = NULL)
ColumnValues Les règles annulées utilisant la not in syntaxe != et seront transmises aux NULL lignes. Par exemple :
ColumnValues "Age" != 21
ColumnValues "Age" not in [21, 22, 23]
Les exemples suivants fournissent un moyen de rejeter explicitement des NULL valeurs
(ColumnValues "Age" != 21) AND (ColumnValues "Age" != NULL)
ColumnValues "Age" not in [21, 22, 23, NULL]
Intégralité
Compare le pourcentage de valeurs complètes (non nulles) d'une colonne à une expression donnée.
Syntaxe
Completeness<COL_NAME><EXPRESSION>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : n'importe quel type de colonne
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : pourcentage de valeur nulle
Les exemples de règles suivants vérifient si plus de 95 % des valeurs d'une colonne sont complètes.
Completeness "First_Name" > 0.95 Completeness "First_Name" > 0.95 where "weightinkgs > 10"
Exemples de règles dynamiques
Completeness "colA" between min(last(5)) - 1 and max(last(5)) + 1Completeness "colA" <= avg(last(10))
Comportement nul
Remarque sur les formats de données CSV : les lignes vides des colonnes CSV peuvent afficher plusieurs comportements.
-
Si une colonne est de
Stringtype, la ligne vide sera reconnue comme une chaîne vide et ne dérogera pas à laCompletenessrègle. -
Si une colonne est d'un autre type de données
Int, la ligne vide sera reconnueNULLet ne respectera pas laCompletenessrègle.
CustomSQL
Ce type de règle a été étendu pour prendre en charge deux cas d'utilisation :
Exécutez une instruction SQL personnalisée sur un jeu de données et compare la valeur renvoyée à une expression donnée.
Exécutez une instruction SQL personnalisée dans laquelle vous spécifiez un nom de colonne dans votre instruction SELECT, que vous comparez à une certaine condition pour obtenir des résultats au niveau des lignes.
Syntaxe
CustomSql<SQL_STATEMENT><EXPRESSION>
SQL_STATEMENT – Instruction SQL qui renvoie une valeur numérique unique, entourée de guillemets doubles.
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : SQL personnalisé pour récupérer le résultat global d'une règle
Cet exemple de règle utilise une instruction SQL pour récupérer le nombre d'enregistrements d'un jeu de données. La règle vérifie ensuite que le nombre d'enregistrements est compris entre 10 et 20.
CustomSql "select count(*) from primary" between 10 and 20
Exemple : SQL personnalisé pour récupérer les résultats au niveau des lignes
Cet exemple de règle utilise une instruction SQL dans laquelle vous spécifiez un nom de colonne dans votre instruction SELECT, que vous comparez à une certaine condition pour obtenir des résultats au niveau des lignes. Une expression de condition de seuil définit le nombre d'enregistrements qui doivent échouer pour que l'ensemble de la règle échoue. Notez qu'une règle ne peut pas contenir à la fois une condition et un mot clé.
CustomSql "select Name from primary where Age > 18"
or
CustomSql "select Name from primary where Age > 18" with threshold > 3
Important
L'alias primary est le nom du jeu de données que vous souhaitez évaluer. Lorsque vous utilisez des tâches ETL visuelles sur la console, primary représente toujours le DynamicFrame qui est transmis à la transformation EvaluateDataQuality.apply(). Lorsque vous utilisez le catalogue de données AWS Glue pour exécuter des tâches de qualité des données sur une table, primary représente la table.
Si vous êtes dans le catalogue AWS Glue, vous pouvez également utiliser les noms de table réels :
CustomSql "select count(*) from database.table" between 10 and 20
Vous pouvez également joindre plusieurs tables pour comparer différents éléments de données :
CustomSql "select count(*) from database.table inner join database.table2 on id1 = id2" between 10 and 20
Dans AWS Glue ETL, l'utilisation de CustomSQL permet d'identifier les enregistrements qui ont échoué aux contrôles de qualité des données. Pour que cela fonctionne, vous devez renvoyer les enregistrements qui font partie de la table principale dont vous évaluez la qualité des données. Les enregistrements renvoyés dans le cadre de la requête sont considérés comme réussis et les enregistrements non renvoyés sont considérés comme ayant échoué.
La règle suivante permet de s'assurer que les enregistrements dont l'âge est inférieur à 100 sont identifiés comme réussis et que les enregistrements dont l'âge est supérieur sont marqués comme échoués.
CustomSql "select id from primary where age < 100"
Cette règle CustomSQL sera validée si 50 % des enregistrements ont un âge supérieur à 10 et identifiera également les enregistrements qui ont échoué. Les enregistrements renvoyés par cette règle CustomSQL seront considérés comme réussis, tandis que ceux non renvoyés seront considérés comme ayant échoué.
CustomSQL "select ID, CustomerID from primary where age > 10" with threshold > 0.5
Remarque : la règle CustomSQL échoue si vous renvoyez des enregistrements qui ne sont pas disponibles dans le jeu de données.
DataFreshness
Vérifie l'actualisation des données d'une colonne en évaluant la différence entre l'heure actuelle et les valeurs d'une colonne de date. Pour ce type de règle, vous pouvez spécifier une expression temporelle afin de vérifier que les valeurs des colonnes sont à jour.
Syntaxe
DataFreshness<COL_NAME><EXPRESSION>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonne pris en charge : Date
EXPRESSION – Expression numérique exprimée en heures ou en jours. Vous devez spécifier l'unité de temps dans votre expression.
Exemple : actualisation des données
Les exemples de règles suivants vérifient l'actualisation des données.
DataFreshness "Order_Date" <= 24 hours DataFreshness "Order_Date" between 2 days and 5 days
Comportement nul
Les DataFreshness règles échoueront pour les lignes contenant des NULL valeurs. Si la règle échoue en raison d'une valeur nulle, la raison de l'échec s'affichera comme suit :
80.00 % of rows passed the threshold
où 20 % des lignes qui ont échoué incluent les lignes avecNULL.
L'exemple de règle composée suivant fournit un moyen d'autoriser explicitement les NULL valeurs :
(DataFreshness "Order_Date" <= 24 hours) OR (ColumnValues "Order_Date" = NULL)
Data Freshness pour les objets Amazon S3
Vous devrez parfois valider l'actualité des données en fonction de l'heure de création du fichier Amazon S3. Pour ce faire, vous pouvez utiliser le code suivant pour obtenir l'horodatage et l'ajouter à votre dataframe, puis appliquer des contrôles de fraîcheur des données.
df = glueContext.create_data_frame.from_catalog(database = "default", table_name = "mytable") df = df.withColumn("file_ts", df["_metadata.file_modification_time"]) Rules = [ DataFreshness "file_ts" < 24 hours ]
DatasetMatch
Vérifie si les données du jeu de données principal correspondent aux données d'un jeu de données de référence. Les deux jeux de données sont joints à l'aide des mappages de colonnes clés fournis. Des mappages de colonnes supplémentaires peuvent être fournis si vous souhaitez vérifier l'égalité des données uniquement dans ces colonnes. Notez que DataSetMatchpour fonctionner, vos clés de jointure doivent être uniques et ne pas être NULL (elles doivent être une clé primaire). Si vous ne remplissez pas ces conditions, le message d'erreur suivant affiche : « La clé de distribution fournie ne convient pas à des cadres de données donnés ». Dans les cas où vous ne pouvez pas avoir de clés jointes uniques, envisagez d'utiliser d'autres types de règles, par exemple AggregateMatchpour établir une correspondance sur des données récapitulatives.
Syntaxe
DatasetMatch<REFERENCE_DATASET_ALIAS><JOIN CONDITION WITH MAPPING><OPTIONAL_MATCH_COLUMN_MAPPINGS><EXPRESSION>
REFERENCE_DATASET_ALIAS : l'alias du jeu de données de référence avec lequel vous comparez les données du jeu de données principal.
KEY_COLUMN_MAPPINGS : une liste de noms de colonnes séparés par des virgules qui forment une clé dans les jeux de données. Si les noms de colonnes ne sont pas identiques dans les deux jeux de données, vous devez les séparer par
->OPTIONAL_MATCH_COLUMN_MAPPINGS : vous pouvez fournir ce paramètre si vous souhaitez vérifier les données correspondantes uniquement dans certaines colonnes. Il utilise la même syntaxe que les mappages de colonnes clés. Si ce paramètre n'est pas fourni, la correspondance portera sur les données de toutes les autres colonnes. Les autres colonnes non-clés doivent porter le même nom dans les deux jeux de données.
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : faire correspondre des jeux de données à l'aide de la colonne ID
L'exemple de règle suivant vérifie que plus de 90 % du jeu de données principal correspond au jeu de données de référence, en utilisant la colonne « ID » pour joindre les deux jeux de données. Dans ce cas, toutes les colonnes sont comparées.
DatasetMatch "reference" "ID" >= 0.9
Exemple : faire correspondre des jeux de données en utilisant plusieurs colonnes clés
Dans l'exemple suivant, le jeu de données principal et le jeu de données de référence portent des noms différents pour les colonnes clés. ID_1 et ID_2 forment ensemble une clé composite dans le jeu de données principal. ID_ref1 et ID_ref2 forment ensemble une clé composite dans le jeu de données de référence. Dans ce scénario, vous pouvez utiliser la syntaxe spéciale pour fournir les noms des colonnes.
DatasetMatch "reference" "ID_1->ID_ref1,ID_ref2->ID_ref2" >= 0.9
Exemple : faire correspondre des jeux de données à l'aide de plusieurs colonnes clés et vérifie qu'une colonne spécifique correspond
Cet exemple s'appuie sur l'exemple précédent. Nous voulons vérifier que seule la colonne contenant les montants correspond. Cette colonne est nommée Amount1 dans le jeu de données principal et Amount2 dans le jeu de données de référence. Une correspondance exacte est désirée.
DatasetMatch "reference" "ID_1->ID_ref1,ID_ref2->ID_ref2" "Amount1->Amount2" >= 0.9
DistinctValuesCount
Vérifie le nombre de valeurs distinctes dans une colonne par rapport à une expression donnée.
Syntaxe
DistinctValuesCount<COL_NAME><EXPRESSION>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : n'importe quel type de colonne
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : nombre de valeurs de colonne distinctes
L'exemple de règle suivant vérifie que la colonne nommée State contient plus de 3 valeurs distinctes.
DistinctValuesCount "State" > 3 DistinctValuesCount "Customer_ID" < 6 where "Customer_ID < 10"
Exemples de règles dynamiques
DistinctValuesCount "colA" between avg(last(10))-1 and avg(last(10))+1DistinctValuesCount "colA" <= index(last(10),2) + std(last(5))
Entropie
Vérifie si la valeur d'entropie d'une colonne correspond à une expression donnée. L'entropie mesure le niveau d'information contenu dans un message. Compte tenu de la distribution de probabilité des valeurs d'une colonne, l'entropie décrit le nombre de bits nécessaires pour identifier une valeur.
Syntaxe
Entropy<COL_NAME><EXPRESSION>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : n'importe quel type de colonne
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : entropie de colonne
L'exemple de règle suivant vérifie que la colonne nommée Feedback possède une valeur d'entropie supérieure à un.
Entropy "Star_Rating" > 1 Entropy "First_Name" > 1 where "Customer_ID < 10"
Exemples de règles dynamiques
Entropy "colA" < max(last(10))Entropy "colA" between min(last(10)) and max(last(10))
IsComplete
Vérifie si toutes les valeurs d'une colonne sont complètes (non nulles).
Syntaxe
IsComplete<COL_NAME>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : n'importe quel type de colonne
Exemple : valeurs nulles
L'exemple suivant vérifie si toutes les valeurs d'une colonne nommée email ne sont pas nulles.
IsComplete "email" IsComplete "Email" where "Customer_ID between 1 and 50" IsComplete "Customer_ID" where "Customer_ID < 16 and Customer_ID != 12" IsComplete "passenger_count" where "payment_type<>0"
Comportement nul
Remarque sur les formats de données CSV : les lignes vides des colonnes CSV peuvent afficher plusieurs comportements.
-
Si une colonne est de
Stringtype, la ligne vide sera reconnue comme une chaîne vide et ne dérogera pas à laCompletenessrègle. -
Si une colonne est d'un autre type de données
Int, la ligne vide sera reconnueNULLet ne respectera pas laCompletenessrègle.
IsPrimaryKey
Vérifie si une colonne contient une clé primaire. Une colonne contient une clé primaire si toutes les valeurs de la colonne sont uniques et complètes (non nulles).
Syntaxe
IsPrimaryKey<COL_NAME>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : n'importe quel type de colonne
Exemple : clé primaire
L'exemple de règle suivant vérifie si la colonne nommée Customer_ID contient une clé primaire.
IsPrimaryKey "Customer_ID" IsPrimaryKey "Customer_ID" where "Customer_ID < 10"
Exemple : clé primaire avec plusieurs colonnes. Tous les exemples suivants sont valides.
IsPrimaryKey "colA" "colB" IsPrimaryKey "colA" "colB" "colC" IsPrimaryKey colA "colB" "colC"
IsUnique
Vérifie si toutes les valeurs d'une colonne sont uniques et renvoie une valeur booléenne.
Syntaxe
IsUnique<COL_NAME>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : n'importe quel type de colonne
Exemple : valeurs de colonne uniques
L'exemple de règle suivant vérifie si toutes les valeurs d'une colonne nommée email sont uniques.
IsUnique "email" IsUnique "Customer_ID" where "Customer_ID < 10"]
Mean
Vérifie si la moyenne de toutes les valeurs d'une colonne correspond à une expression donnée.
Syntaxe
Mean<COL_NAME><EXPRESSION>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : valeur moyenne
L'exemple de règle suivant vérifie si la moyenne de toutes les valeurs d'une colonne dépasse un seuil.
Mean "Star_Rating" > 3 Mean "Salary" < 6200 where "Customer_ID < 10"
Exemples de règles dynamiques
Mean "colA" > avg(last(10)) + std(last(2))Mean "colA" between min(last(5)) - 1 and max(last(5)) + 1
Comportement nul
La Mean règle ignorera les lignes contenant NULL des valeurs dans le calcul de la moyenne. Par exemple :
+---+-----------+ |id |units | +---+-----------+ |100|0 | |101|null | |102|20 | |103|null | |104|40 | +---+-----------+
La moyenne de la colonne units sera (0 + 20 + 40)/3 = 20. Les lignes 101 et 103 ne sont pas prises en compte dans ce calcul.
ReferentialIntegrity
Vérifie dans quelle mesure les valeurs d'un ensemble de colonnes du jeu de données principal sont un sous-ensemble des valeurs d'un ensemble de colonnes d'un jeu de données de référence.
Syntaxe
ReferentialIntegrity<PRIMARY_COLS><REFERENCE_DATASET_COLS><EXPRESSION>
PRIMARY_COLS : une liste de noms de colonnes séparés par des virgules dans le jeu de données principal.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
REFERENCE_DATASET_COLS : ce paramètre contient deux parties séparées par un point. La première partie est l'alias du jeu de données de référence. La deuxième partie est la liste des noms de colonnes du jeu de données de référence, séparés par des virgules et placés entre accolades.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : vérifier l'intégrité référentielle d'une colonne de code postal
L'exemple de règle suivant vérifie que plus de 90 % des valeurs de la colonne zipcode du jeu de données principal sont présentes dans la colonne zipcode du jeu de données reference.
ReferentialIntegrity "zipcode" "reference.zipcode" >= 0.9
Exemple : vérifier l'intégrité référentielle des colonnes de ville et d'État
Dans l'exemple suivant, des colonnes contenant des informations sur la ville et l'État existent dans le jeu de données principal et dans le jeu de données de référence. Les noms des colonnes sont différents dans les deux jeux de données. La règle vérifie si l'ensemble de valeurs des colonnes du jeu de données principal est exactement égal à l'ensemble de valeurs des colonnes du jeu de données de référence.
ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" = 1.0
Exemples de règles dynamiques
ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" > avg(last(10))ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" between min(last(10)) - 1 and max(last(10)) + 1
RowCount
Vérifie le nombre de lignes d'un jeu de données par rapport à une expression donnée. Dans l'expression, vous pouvez spécifier le nombre de lignes ou une plage de lignes à l'aide d'opérateurs tels que > et <.
Syntaxe
RowCount<EXPRESSION>
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : vérification numérique du nombre de lignes
L'exemple de règle suivant vérifie si le nombre de lignes est compris dans une plage donnée.
RowCount between 10 and 100 RowCount between 1 and 50 where "Customer_ID < 10"
Exemples de règles dynamiques
RowCount > avg(lats(10)) *0.8
RowCountMatch
Vérifie le rapport entre le nombre de lignes du jeu de données principal et le nombre de lignes d'un jeu de données de référence par rapport à l'expression donnée.
Syntaxe
RowCountMatch<REFERENCE_DATASET_ALIAS><EXPRESSION>
REFERENCE_DATASET_ALIAS : alias du jeu de données de référence par rapport auquel comparer le nombre de lignes.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : vérification du nombre de lignes par rapport à un jeu de données de référence
L'exemple de règle suivant vérifie si le nombre de lignes du jeu de données principal est au moins égal à 90 % du nombre de lignes du jeu de données de référence.
RowCountMatch "reference" >= 0.9
StandardDeviation
Vérifie l'écart type de toutes les valeurs d'une colonne par rapport à une expression donnée.
Syntaxe
StandardDeviation<COL_NAME><EXPRESSION>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : écart type
L'exemple de règle suivant vérifie si l'écart type des valeurs d'une colonne nommée colA est inférieur à une valeur spécifiée.
StandardDeviation "Star_Rating" < 1.5 StandardDeviation "Salary" < 3500 where "Customer_ID < 10"
Exemples de règles dynamiques
StandardDeviation "colA" > avg(last(10) + 0.1StandardDeviation "colA" between min(last(10)) - 1 and max(last(10)) + 1
Comportement nul
La StandardDeviation règle ignorera les lignes contenant NULL des valeurs dans le calcul de l'écart type. Par exemple :
+---+-----------+-----------+ |id |units1 |units2 | +---+-----------+-----------+ |100|0 |0 | |101|null |0 | |102|20 |20 | |103|null |0 | |104|40 |40 | +---+-----------+-----------+
L'écart type de la colonne ne units1 tiendra pas compte des lignes 101 et 103 et aboutira à 16,33. L'écart type pour la colonne units2 sera de 16.
Somme
Vérifie la somme de toutes les valeurs d'une colonne par rapport à une expression donnée.
Syntaxe
Sum<COL_NAME><EXPRESSION>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : somme
L'exemple de règle suivant vérifie si la somme de toutes les valeurs d'une colonne dépasse un seuil donné.
Sum "transaction_total" > 500000 Sum "Salary" < 55600 where "Customer_ID < 10"
Exemples de règles dynamiques
Sum "ColA" > avg(last(10))Sum "colA" between min(last(10)) - 1 and max(last(10)) + 1
Comportement nul
La Sum règle ignorera les lignes contenant des NULL valeurs dans le calcul de la somme. Par exemple :
+---+-----------+ |id |units | +---+-----------+ |100|0 | |101|null | |102|20 | |103|null | |104|40 | +---+-----------+
La somme des colonnes ne units tiendra pas compte des lignes 101 et 103 et donnera (0 + 20 + 40) = 60.
SchemaMatch
Vérifie si le schéma du jeu de données principal correspond au schéma d'un jeu de données de référence. La vérification du schéma s'effectue colonne par colonne. Le schéma de deux colonnes correspond si les noms et les types sont identiques. L'ordre des colonnes n'importe pas.
Syntaxe
SchemaMatch<REFERENCE_DATASET_ALIAS><EXPRESSION>
REFERENCE_DATASET_ALIAS : alias du jeu de données de référence par rapport auquel comparer les schémas.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : SchemaMatch
L'exemple de règle suivant vérifie si le schéma du jeu de données principal correspond exactement au schéma d'un jeu de données de référence.
SchemaMatch "reference" = 1.0
Unicité
Vérifie le pourcentage de valeurs uniques dans une colonne par rapport à une expression donnée. Les valeurs uniques n'apparaissent qu'une seule fois.
Syntaxe
Uniqueness<COL_NAME><EXPRESSION>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : n'importe quel type de colonne
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : pourcentage d'unicité
L'exemple de règle suivant vérifie si le pourcentage de valeurs uniques d'une colonne correspond à certains critères numériques.
Uniqueness "email" = 1.0 Uniqueness "Customer_ID" != 1.0 where "Customer_ID < 10"
Exemples de règles dynamiques
Uniqueness "colA" between min(last(10)) and max(last(10))Uniqueness "colA" >= avg(last(10))
UniqueValueRatio
Vérifie le ratio de valeurs uniques d'une colonne par rapport à une expression donnée. Un ratio de valeurs uniques correspond à la fraction de valeurs uniques divisée par le nombre de toutes les valeurs distinctes d'une colonne. Les valeurs uniques n'apparaissent qu'une seule fois, alors que les valeurs distinctes apparaissent au moins une fois.
Par exemple, le jeu [a, a, b] contient une valeur unique (b) et deux valeurs distinctes (a et b). Le ratio de valeurs uniques du jeu est donc ½ = 0,5.
Syntaxe
UniqueValueRatio<COL_NAME><EXPRESSION>
COL_NAME – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : n'importe quel type de colonne
EXPRESSION – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez Expressions.
Exemple : ratio de valeurs uniques
Cet exemple vérifie le ratio de valeurs uniques d'une colonne par rapport à une plage de valeurs.
UniqueValueRatio "test_score" between 0 and 0.5 UniqueValueRatio "Customer_ID" between 0 and 0.9 where "Customer_ID < 10"
Exemples de règles dynamiques
UniqueValueRatio "colA" > avg(last(10))UniqueValueRatio "colA" <= index(last(10),2) + std(last(5))
DetectAnomalies
Détecte les anomalies pour une règle de qualité des données donnée. Chaque exécution d'une DetectAnomalies règle entraîne l'enregistrement de la valeur évaluée pour la règle donnée. Lorsque suffisamment de données sont collectées, l'algorithme de détection des anomalies prend toutes les données historiques pour cette règle donnée et exécute la détection des anomalies. DetectAnomalies la règle échoue lorsqu'une anomalie est détectée. Plus d’informations sur l’anomalie détectée peuvent être obtenues à partir des observations.
Syntaxe
DetectAnomalies<RULE_NAME><RULE_PARAMETERS>
RULE_NAME : le nom de la règle pour laquelle vous souhaitez évaluer et détecter des anomalies. Règles prises en charge :
"RowCount"
"Completeness"
"Uniqueness"
"Mean"
"Sum"
"StandardDeviation"
"Entropy"
"DistinctValuesCount"
"UniqueValueRatio"
"ColumnLength"
"ColumnValues"
"ColumnCorrelation"
RULE_PARAMETERS : certaines règles nécessitent des paramètres supplémentaires pour s’exécuter. Reportez-vous à la documentation de la règle concernée pour connaître les paramètres requis.
Exemple : Anomalies pour RowCount
Par exemple, si nous voulons détecter des RowCount anomalies, nous indiquons RowCount le nom de la règle.
DetectAnomalies "RowCount"
Exemple : Anomalies pour ColumnLength
Par exemple, si nous voulons détecter des ColumnLength anomalies, nous indiquons le nom de la ColumnLength règle et le nom de la colonne.
DetectAnomalies "ColumnLength" "id"
