",
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 Data Catalog, vous pouvez facilement configurer cette option dans l'interface utilisateur, comme indiqué ci-dessous.
![\[La capture d’écran montre une fenêtre de paramètres de règles composites dans laquelle vous pouvez choisir la configuration d’évaluation des règles entre ligne et colonne. Si vous choisissez Row, les règles composites se comporteront comme une règle unique évaluant la ligne entière. Si vous choisissez Column, les règles composites évalueront les règles individuelles dans l’ensemble du jeu de données et combineront les résultats.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/composite-rule-settings.png)
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. Elles sont répertoriées ci-dessous.
Règles basées sur des ratios :
+ Exhaustivité
+ DatasetMatch
+ ReferentialIntegrity
+ Unicité
Règles dépendantes de 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 | Correspond à true si la réponse du type de règle est égale àx. | Completeness "colA" = "1.0",
ColumnValues "colA" = "2022-06-30"
|
| \$1=x | x devient vrai si la réponse du type de règle n'est pas égale àx. | ColumnValues "colA" != "a",
ColumnValues "colA" != "2022-06-30"
|
| > x | Correspond à true si la réponse du type de règle est supérieure àx. | ColumnValues "colA" > 10
|
| < x | Correspond à true si la réponse du type de règle est inférieure àx. | ColumnValues "colA" < 1000,
ColumnValues "colA" < "2022-06-30"
|
| >= x | Permet de déterminer true si la réponse du type de règle est supérieure ou égale àx. | ColumnValues "colA" >= 10
|
| <= x | Permet de déterminer true si la réponse du type de règle est inférieure ou égale àx. | ColumnValues "colA" <= 1000
|
| 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. | Mean "colA" between 8 and 100,
ColumnValues "colA" between "2022-05-31" and "2022-06-30"
|
| pas entre x et y | Se traduit par true si la réponse du type de règle ne se situe pas dans une plage spécifiée (inclusif). Vous ne devez utiliser ce type d’expression que pour les types numériques et les dates. | ColumnValues "colA" not between "2022-05-31" and "2022-06-30"
|
| dans [a, b, c, ...] | Se traduit par true si la réponse du type de règle se trouve dans le jeu spécifié. | ColumnValues "colA" in [ 1, 2, 3 ],
ColumnValues "colA" in [ "a", "b", "c" ]
|
| pas dans [a, b, c, ...] | Se traduit par true si la réponse du type de règle ne se trouve pas dans le jeu spécifié. | ColumnValues "colA" not in [ 1, 2, 3 ],
ColumnValues "colA" not in [ "a", "b", "c" ]
|
| allumettes /ab\$1c/i | Se traduit par true si la réponse du type de règle correspond à une expression régulière. | ColumnValues "colA" matches "[a-zA-Z]*"
|
| ne correspond pas /ab\$1c/i | Se traduit par true si la réponse du type de règle ne correspond pas à une expression régulière. | ColumnValues "colA" not matches "[a-zA-Z]*"
|
| now() | Fonctionne uniquement avec le type de règle ColumnValues pour créer une expression de date. | ColumnValues "load_date" > (now() - 3 days)
|
| matches/in […]/not matches/notdans [...] with threshold | Spécifie le pourcentage de valeurs qui correspondent aux conditions de la règle. Fonctionne uniquement avec les types de règles ColumnValues, ColumnDataType et CustomSQL. | ColumnValues "colA" in ["A", "B"] with threshold > 0.8,
ColumnValues "colA" matches "[a-zA-Z]*" with threshold between 0.2 and 0.9
ColumnDataType "colA" = "Timestamp" with threshold > 0.9
|
#### Mots-clés pour NULL, EMPTY et WHITESPACES\$1ONLY
Si vous souhaitez vérifier si une colonne de chaîne contient une valeur nulle, vide ou une chaîne contenant uniquement des espaces blancs, vous pouvez utiliser les mots clés suivants :
+ NULL/null : ce mot clé se traduit par true pour une valeur `null` d’une colonne de chaîne.
`ColumnValues "colA" != NULL with threshold > 0.5` renverrait true si plus de 50 % de vos données ne contiennent pas de valeurs nulles.
`(ColumnValues "colA" = NULL) or (ColumnLength "colA" > 5)` renverrait true 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é se traduit par true pour une valeur de chaîne vide (“”) dans une colonne de chaîne. 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 true si une ligne est vide, « a » ou « b ». *Notez que cela nécessite l'utilisation de l'option « compositeRuleEvaluation .method » = « ROW ».*
+ WHITESPACES\$1ONLY/whitespaces\$1only : 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 true si une ligne n’est ni « a » ni « b », ni de simples espaces blancs.
Règles prises en charge :
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
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é se traduit par true pour une valeur nulle d’une colonne de chaîne.
`ColumnValues "colA" in [NULL, "2023-01-01"]` renverrait true si une date de votre colonne est `2023-01-01` ou nulle.
`(ColumnValues "colA" = NULL) or (ColumnValues "colA" between 1 and 9)` renverrait true 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 :
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
#### Filtrage avec la clause Where
**Note**
La clause Where n'est prise en charge que dans AWS Glue 4.0.
Vous pouvez filtrer vos données lorsque vous créez des règles. Cela s’avère utile lorsque vous souhaitez appliquer des règles conditionnelles.
```
where " "
```
Le filtre doit être spécifié avec le mot clé `where`, suivi d’une instruction SparkSQL valide placée entre guillemets `("")`.
Si vous souhaitez ajouter la clause Where à une règle avec un seuil, elle doit être spécifiée avant la condition de seuil.
```
where "valid SparkSQL statement>" with threshold
```
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 un `IllegalArgumentException` au format suivant :
```
Rule where "" has provided an invalid where clause :
```
**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 en tant que `Passed`.
Si vous préférez étiqueter séparément les lignes filtrées en tant que `SKIPPED`, vous pouvez définir les paramètres `additionalOptions` suivants pour la tâche ETL.
```
object GlueApp {
val datasource = glueContext.getCatalogSource(
database="",
tableName="",
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 | PASSED | PASSED | |
| 2 | b | d | PASSED | SKIPPED | La ligne est filtrée, car att1 n’est pas "a". |
| 3 | a | null | ÉCHEC | ÉCHEC | |
| 4 | a | f | PASSED | PASSED | |
| 5 | b | null | PASSED | SKIPPED | La ligne est filtrée, car att1 n’est pas "a". |
| 6 | a | f | PASSED | PASSED | |
### Constantes
Dans DQDL, vous pouvez définir des valeurs constantes et les référencer tout au long de votre script. Cela permet d'éviter les problèmes liés aux limites de taille des requêtes, par exemple lorsque vous travaillez avec des instructions SQL volumineuses susceptibles de dépasser les limites autorisées. En affectant ces valeurs aux constantes, vous pouvez simplifier votre DQDL et éviter d'atteindre ces limites.
L'exemple suivant montre comment définir et utiliser une constante :
```
mySql = "select count(*) from primary"
Rules = [
CustomSql $mySql between 0 and 100
]
```
Dans cet exemple, la requête SQL est affectée à la constante`mySql`, qui est ensuite référencée dans la règle à l'aide du `$` préfixe.
### Étiquettes
Les étiquettes constituent un moyen efficace d'organiser et d'analyser les résultats relatifs à la qualité des données. Vous pouvez interroger les résultats à l'aide d'étiquettes spécifiques pour identifier les règles défaillantes au sein de catégories particulières, compter les résultats des règles par équipe ou par domaine et créer des rapports ciblés pour les différentes parties prenantes.
Par exemple, vous pouvez appliquer toutes les règles relatives à l'équipe financière à l'aide d'une étiquette `"team=finance"` et générer un rapport personnalisé pour présenter les indicateurs de qualité spécifiques à l'équipe financière. Vous pouvez étiqueter les règles de haute priorité avec `"criticality=high"` pour hiérarchiser les efforts de correction. Les étiquettes peuvent être créées dans le cadre du DQDL. Vous pouvez interroger les étiquettes dans le cadre des résultats des règles, des résultats au niveau des lignes et des réponses des API, ce qui facilite l'intégration à vos flux de travail de surveillance et de reporting existants.
**Note**
Les étiquettes ne sont disponibles que dans AWS Glue ETL et ne sont pas disponibles dans le Data Quality basé sur le catalogue de données AWS Glue.
#### Syntaxe pour les étiquettes DQDL
Le DQDL prend en charge les étiquettes par défaut et spécifiques aux règles. Les libellés par défaut sont définis au niveau de l'ensemble de règles et s'appliquent automatiquement à toutes les règles de cet ensemble de règles. Les règles individuelles peuvent également avoir leurs propres étiquettes, et comme les étiquettes sont implémentées sous forme de paires clé-valeur, les étiquettes spécifiques aux règles peuvent remplacer les étiquettes par défaut lorsque vous utilisez la même clé.
L'exemple suivant montre comment utiliser les libellés par défaut et spécifiques aux règles :
```
DefaultLabels=["frequency"="monthly"]
Rules = [
// Auto includes the default label ["frequency"="monthly"]
ColumnValues "col" > 21,
// Add ["foo"="bar"] to default label. Labels for this rule would be ["frequency"="monthly", "foo"="bar"]
Rule 1 with threshold > 0.8 labels=["foo"="bar"],
// Override default label. Labels for this rule would be ["frequency"="daily", "foo"="bar"]
Rule 2 with threshold > 0.8 labels=["foo"="bar", "frequency"="daily"]
// Labels must be applied to the entire composite rule (parentheses required)
(Rule 1 AND Rule 2) labels=["foo"="bar]
]
```
##### Contraintes liées aux étiquettes
Les étiquettes sont soumises aux contraintes suivantes :
+ Un maximum de 10 étiquettes par règle DQDL.
+ Les étiquettes sont spécifiées sous forme de liste de paires clé-valeur.
+ La clé et la valeur de l'étiquette distinguent les majuscules et minuscules.
+ La longueur maximale de la clé d'étiquette est de 128 caractères. La clé d'étiquette ne doit pas être vide ou nulle.
+ La longueur maximale de la valeur d'étiquette est de 256 caractères. La valeur de l'étiquette peut être vide ou nulle.
#### Récupération d'étiquettes DQDL
Vous pouvez récupérer des étiquettes DQDL à partir des résultats des règles, des résultats au niveau des lignes et des réponses d'API.
##### Résultats des règles
Les étiquettes DQDL sont toujours visibles dans les résultats des règles. Aucune configuration supplémentaire n'est nécessaire pour les activer.
##### Résultats au niveau des lignes
Les étiquettes DQDL sont désactivées par défaut dans les résultats au niveau des lignes, mais elles peuvent être activées dans. `AdditionalOptions` `EvaluateDataQuality`
L'exemple suivant montre comment activer les étiquettes dans les résultats au niveau des lignes :
```
val evaluateResult = EvaluateDataQuality.processRows(
frame=AmazonS3_node1754591511068,
ruleset=example_ruleset,
publishingOptions=JsonOptions("""{
"dataQualityEvaluationContext": "evaluateResult",
"enableDataQualityCloudWatchMetrics": "true",
"enableDataQualityResultsPublishing": "true"
}"""),
additionalOptions=JsonOptions("""{
"performanceTuning.caching":"CACHE_NOTHING",
"observations.scope":"ALL",
"rowLevelConfiguration.ruleWithLabels":"ENABLED"
}""")
)
```
Lorsqu'elle est activée, la trame de données de résultats au niveau des lignes inclut des étiquettes pour chaque règle dans les colonnes`DataQualityRulesPass`, et`DataQualityRulesFail`. `DataQualityRulesSkip`
##### Réponse de l'API
Les étiquettes DQDL sont toujours visibles dans les réponses de l'API sous un nouveau champ `Labels` de l'`RuleResults`objet.
L'exemple suivant montre des libellés dans une réponse d'API :
```
{
"ResultId": "dqresult-example",
"ProfileId": "dqprofile-example",
"Score": 0.6666666666666666,
"RulesetName": "EvaluateDataQuality_node1754591514205",
"EvaluationContext": "EvaluateDataQuality_node1754591514205",
"StartedOn": "2025-08-22T19:36:10.448000+00:00",
"CompletedOn": "2025-08-22T19:36:16.368000+00:00",
"JobName": "anniezc-test-labels",
"JobRunId": "jr_068f6d7a45074d9105d14e4dee09db12c3b95664b45f6ee44fa29ed7e5619ba8",
"RuleResults": [
{
"Name": "Rule_0",
"Description": "IsComplete colA",
"EvaluationMessage": "Input data does not include column colA!",
"Result": "FAIL",
"EvaluatedMetrics": {},
"EvaluatedRule": "IsComplete colA",
"Labels": {
"frequency": "monthly"
}
},
{
"Name": "Rule_1",
"Description": "Rule 1 with threshold > 0.8",
"Result": "PASS",
"EvaluatedMetrics": {},
"EvaluatedRule": "Rule 1 with threshold > 0.8",
"Labels": {
"frequency": "monthly",
"foo": "bar"
}
},
{
"Name": "Rule_3",
"Description": "Rule 2 with threshold > 0.8",
"Result": "PASS",
"EvaluatedMetrics": {},
"EvaluatedRule": "Rule 2 with threshold > 0.8",
"Labels": {
"frequency": "daily",
"foo": "bar"
}
}
]
}
```
### Règles dynamiques
**Note**
Les règles dynamiques ne sont prises en charge que dans AWS Glue ETL et ne le sont pas dans AWS Glue Data Catalog.
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 `k` mé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 la `i`e valeur la plus récente parmi les dernières `k`. `i` est indexé à partir de zéro, donc `index(last(3), 0)` renverra le point de données le plus récent et `index(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](#dqdl-analyzers-table) pour vérifier si les règles dynamiques sont disponibles pour le type de règle que vous utilisez.
**Exclure les statistiques des règles dynamiques**
Vous devrez parfois exclure les statistiques de données de vos calculs de règles dynamiques. Supposons que vous ayez effectué un chargement de données historiques et que vous ne vouliez pas que cela ait un impact sur vos moyennes. Pour ce faire, ouvrez le job dans AWS Glue ETL et choisissez l'onglet **Data Quality**, puis sélectionnez **Statistics** et sélectionnez les statistiques que vous souhaitez exclure. Vous pourrez voir un graphique de tendance ainsi qu’un tableau de statistiques. Sélectionnez les valeurs que vous souhaitez exclure, puis choisissez **Exclure les statistiques**. Les statistiques exclues ne seront désormais pas incluses dans les calculs de règles dynamiques.
![\[La capture d’écran affiche l’option permettant d’exclure ou d’inclure des statistiques dans le menu déroulant après avoir sélectionné une statistique.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/data-quality-excluding-statistics-from-dynamic-rules.png)
### 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 | Rules |
| --- | --- | --- |
| 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 `DistinctValuesCount` permettant d’enregistrer le nombre de valeurs distinctes dans la colonne `Name` du jeu de données
+ un analyseur `ColumnLength` permettant de suivre la taille `Name` minimale 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"
]
```
AWS Glue Data Quality prend en charge les analyseurs suivants.
| Nom de l’analyseur | Fonctionnalité |
| --- | --- |
| RowCount | Calcule le nombre de lignes pour un jeu de données |
| Completeness | Calcule le pourcentage de complétude d’une colonne |
| Uniqueness | Calcule le pourcentage d’unicité d’une colonne |
| Mean | Calcule la moyenne d’une colonne numérique |
| Sum | Calcule la somme d’une colonne numérique |
| StandardDeviation | Calcule l’écart type d’une colonne numérique |
| Entropy | Calcule l’entropie d’une colonne numérique |
| DistinctValuesCount | Calcule le nombre de valeurs distinctes dans une colonne |
| UniqueValueRatio | Calcule le ratio de valeurs uniques dans une colonne |
| ColumnCount | Calcule le nombre de colonnes d’un jeu de données |
| ColumnLength | Calcule la longueur d’une colonne |
| ColumnValues | Calcule le minimum et le maximum pour les colonnes numériques Calcule le minimum ColumnLength et le maximum ColumnLength pour les colonnes non numériques |
| ColumnCorrelation | Calcule les corrélations de colonnes pour des colonnes données |
| CustomSql | Calcule les statistiques renvoyées par le CustomSQL |
| AllStatistics | Calcule les statistiques suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/dqdl.html) |
### Commentaires
Vous pouvez utiliser le caractère « \$1 » pour ajouter un commentaire à votre document DQDL. Tout ce qui se trouve après le caractère « \$1 » 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 | Prise en charge de la syntaxe de 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 : `Column.[Column].AggregateMatch` Lorsque les noms de la première et de la deuxième colonne d’agrégation sont différents : `Column.[Column1,Column2].AggregateMatch` | Oui | Non | Non | Non | Non | Non |
| AllStatistics | Analyseur autonome permettant de rassembler plusieurs métriques pour la colonne fournie d’un jeu de données. | Un seul nom de colonne | Pour les colonnes de tous types : `Dataset.*.RowCount` `Column.[Column].Completeness` `Column.[Column].Uniqueness` Métriques supplémentaires pour les colonnes à valeur de chaîne : `ColumnLength metrics` Métriques supplémentaires pour les colonnes à valeur numérique : `ColumnValues metrics` | 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. | Aucune | Dataset.\$1.ColumnCount | Oui | Oui | 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 | `Column.[Column].MaximumLength` `Column.[Column].MinimumLength` Métrique supplémentaire lorsque le seuil au niveau de la ligne est fourni : `Column.[Column].ColumnValues.Compliance` | 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.\$1.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 | `Column.[Column].Maximum` `Column.[Column].Minimum` Métrique supplémentaire lorsque le seuil au niveau de la ligne est fourni : `Column.[Column].ColumnValues.Compliance` | 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 |
| Exhaustivité | Vérifie la présence de données vides ou NULLs incomplètes. | Exactement un nom de colonne | `Column.[Column].Completeness` | 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 | `Dataset.*.CustomSQL` Métrique supplémentaire lorsque le seuil au niveau de la ligne est fourni : `Dataset.*.CustomSQL.Compliance` | 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 : `Column.[Column].Uniqueness` Pour plusieurs colonnes : `Multicolumn.[CommaDelimitedColumns].Uniqueness` | 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. | Aucune | Dataset.\$1.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 |
| FileFreshness | Vérifie si les fichiers dans Amazon S3 sont récents. | Chemin d’accès au fichier ou au dossier et seuil. | `Dataset.*.FileFreshness.Compliance` `Dataset.*.FileCount` | Oui | Non | Non | Non | Non | Non |
| FileMatch | Vérifie si le contenu du fichier correspond à une somme de contrôle ou à un autre fichier. Cette règle utilise des sommes de contrôle pour s’assurer que deux fichiers sont identiques. | Chemin d’accès au fichier ou au dossier source et chemin d’accès au fichier ou au dossier cible. | Aucune statistique n’est générée. | Oui | Non | Non | Non | Non | Non |
| FileSize | Vérifie si la taille d’un fichier correspond à une condition spécifiée. | Chemin d’accès au fichier ou au dossier et seuil. | `Dataset.*.FileSize.Compliance` `Dataset.*.FileCount` `Dataset.*.MaximumFileSize` `Dataset.*.MinimumFileSize` | Oui | Non | Non | Non | Non | Non |
| FileUniqueness | Vérifie si les fichiers sont uniques à l’aide de sommes de contrôle. | Chemin d’accès au fichier ou au dossier et seuil. | `Dataset.*.FileUniquenessRatio` `Dataset.*.FileCount` | Oui | Non | Non | Non | Non | Non |
**Topics**
+ [AggregateMatch](dqdl-rule-types-AggregateMatch.md)
+ [ColumnCorrelation](dqdl-rule-types-ColumnCorrelation.md)
+ [ColumnCount](dqdl-rule-types-ColumnCount.md)
+ [ColumnDataType](dqdl-rule-types-ColumnDataType.md)
+ [ColumnExists](dqdl-rule-types-ColumnExists.md)
+ [ColumnLength](dqdl-rule-types-ColumnLength.md)
+ [ColumnNamesMatchPattern](dqdl-rule-types-ColumnNamesMatchPattern.md)
+ [ColumnValues](dqdl-rule-types-ColumnValues.md)
+ [Intégralité](dqdl-rule-types-Completeness.md)
+ [CustomSQL](dqdl-rule-types-CustomSql.md)
+ [DataFreshness](dqdl-rule-types-DataFreshness.md)
+ [DatasetMatch](dqdl-rule-types-DatasetMatch.md)
+ [DistinctValuesCount](dqdl-rule-types-DistinctValuesCount.md)
+ [Entropie](dqdl-rule-types-Entropy.md)
+ [IsComplete](dqdl-rule-types-IsComplete.md)
+ [IsPrimaryKey](dqdl-rule-types-IsPrimaryKey.md)
+ [IsUnique](dqdl-rule-types-IsUnique.md)
+ [Mean](dqdl-rule-types-Mean.md)
+ [ReferentialIntegrity](dqdl-rule-types-ReferentialIntegrity.md)
+ [RowCount](dqdl-rule-types-RowCount.md)
+ [RowCountMatch](dqdl-rule-types-RowCountMatch.md)
+ [StandardDeviation](dqdl-rule-types-StandardDeviation.md)
+ [Somme](dqdl-rule-types-Sum.md)
+ [SchemaMatch](dqdl-rule-types-SchemaMatch.md)
+ [Unicité](dqdl-rule-types-Uniqueness.md)
+ [UniqueValueRatio](dqdl-rule-types-UniqueValueRatio.md)
+ [DetectAnomalies](dqdl-rule-types-DetectAnomalies.md)
+ [FileFreshness](dqdl-rule-types-FileFreshness.md)
+ [FileMatch](dqdl-rule-types-FileMatch.md)
+ [FileUniqueness](dqdl-rule-types-FileUniqueness.md)
+ [FileSize](dqdl-rule-types-FileSize.md)
# 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**
```
AggregateMatch (.)
```
+ **AGG\$1OPERATION** : l'opération à utiliser pour l'agrégation. À l'heure actuelle, `sum` et `avg` sont pris en charge.
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **OPTIONAL\$1REFERENCE\$1ALIAS** : 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 « ». .
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **COL\$1NAME** : 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\$1EXP\$11** : 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\$1EXP\$12** : 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 de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-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 null**
La règle `AggregateMatch` 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 \$1 20 \$1 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\$11\$1NAME** – 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\$12\$1NAME** – 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](dqdl.md#dqdl-syntax-rule-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 null**
La règle `ColumnCorrelation` ignorera les lignes contenant des valeurs `NULL` 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 la valeur `ColumnCorrelation` 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 à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-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 si les valeurs d’une colonne donnée peuvent être converties vers le type fourni dans Apache Spark. Accepte une expression `with threshold` pour vérifier la présence d'un sous-ensemble des valeurs de la colonne.
**Syntaxe**
```
ColumnDataType =
```
+ **COL\$1NAME** – 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\$1TYPE** : 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, peuvent être converties en 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, peuvent être converties en entiers.
```
ColumnDataType "colA" = "INTEGER" with threshold > 0.9
```
# ColumnExists
Vérifie si une colonne existe.
**Syntaxe**
```
ColumnExists
```
+ **COL\$1NAME** – 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\$1NAME** – 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](dqdl.md#dqdl-syntax-rule-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 null**
La règle `ColumnLength` traite les `NULL` comme des chaînes de longueur 0. Pour une ligne `NULL` :
```
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 valeurs `NULL` :
```
(ColumnLength "Postal_Code" > 4) AND (ColumnValues "Postal_Code" != 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** : 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\$1 »
```
ColumnNamesMatchPattern "aws_.*"
ColumnNamesMatchPattern "aws_.*" where "weightinkgs > 10"
```
# ColumnValues
Exécute une expression en fonction des valeurs d’une colonne.
**Syntaxe**
```
ColumnValues
```
+ **COL\$1NAME** – 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](dqdl.md#dqdl-syntax-rule-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 (dont null, empty, et strings uniquement avec des espaces blancs).
```
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 null**
Pour toutes les règles `ColumnValues` (à l’exception de `!=` et de `NOT IN`), les lignes `NULL` dérogent à la règle. Si la règle échoue en raison d’une valeur null, 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 des valeurs `NULL` :
```
(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 déroger explicitement aux valeurs `NULL`.
```
(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\$1NAME** – 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](dqdl.md#dqdl-syntax-rule-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)) + 1`
+ `Completeness "colA" <= avg(last(10))`
**Comportement null**
Remarque sur les formats de données CSV : les lignes vides des colonnes CSV peuvent afficher plusieurs comportements.
+ Si une colonne est de type `String`, la ligne vide sera reconnue comme une chaîne vide et ne dérogera pas à la règle `Completeness`.
+ Si une colonne est d’un autre type de données, comme `Int`, la ligne vide sera reconnue comme `NULL` et dérogera à la règle `Completeness`.
# 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\$1STATEMENT** – 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 de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-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 pour laquelle 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é. Cela fonctionne en joignant le résultat de votre requête CustomSQL au jeu de données d’origine. La complexité de votre requête SQL peut avoir des répercussions sur les performances.
Pour cela :
+ Vous devez sélectionner au moins une colonne dans votre table principale.
+ `select count(*) from primary` est une requête valide pour la règle OVERALL CustomSQL DQ, mais pas pour le SQL personnalisé au niveau des lignes.
+ Cette règle va générer une erreur lors de l’évaluation : `The output from CustomSQL must contain at least one column that matches the input dataset for AWS Glue Data Quality to provide row level results. The SQL query is a valid query but the columns from the SQL result are not present in the Input Dataset. Ensure that matching columns are returned from the SQL.`
+ Dans votre requête SQL, sélectionnez une « clé primaire » dans votre table ou sélectionnez un ensemble de colonnes qui forment une clé composite. À défaut, vous risquez d’obtenir des résultats incohérents en raison de la correspondance de lignes dupliquées et d’une dégradation des performances.
+ Sélectionnez les clés UNIQUEMENT dans votre table principale et non dans vos tables de référence.
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\$1NAME** – 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 null**
Les règles `DataFreshness` échoueront pour les lignes contenant des valeurs `NULL`. Si la règle échoue en raison d’une valeur null, 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 avec `NULL`.
L’exemple de règle composée suivant fournit un moyen d’autoriser explicitement des valeurs `NULL` :
```
(DataFreshness "Order_Date" <= 24 hours) OR (ColumnValues "Order_Date" = NULL)
```
**Actualité des données 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 trame de données, puis appliquer des contrôles d’actualité 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 **DataSetMatch**pour 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 **AggregateMatch**pour établir une correspondance sur des données récapitulatives.
**Syntaxe**
```
DatasetMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS** : 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\$1COLUMN\$1MAPPINGS** : 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\$1MATCH\$1COLUMN\$1MAPPINGS** : 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 de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-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_2->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_2->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\$1NAME** – 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](dqdl.md#dqdl-syntax-rule-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))+1`
+ `DistinctValuesCount "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\$1NAME** – 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](dqdl.md#dqdl-syntax-rule-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\$1NAME** – 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 null**
Remarque sur les formats de données CSV : les lignes vides des colonnes CSV peuvent afficher plusieurs comportements.
+ Si une colonne est de type `String`, la ligne vide sera reconnue comme une chaîne vide et ne dérogera pas à la règle `Completeness`.
+ Si une colonne est d’un autre type de données, comme `Int`, la ligne vide sera reconnue comme `NULL` et dérogera à la règle `Completeness`.
# 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). Vous pouvez également vérifier la présence de clés primaires comportant plusieurs colonnes.
**Syntaxe**
```
IsPrimaryKey
```
+ **COL\$1NAME** – 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\$1NAME** – 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
**Exemples**
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"]
```
L’exemple de règle suivant vérifie plusieurs colonnes.
```
IsUnique "vendorid" "tpep_pickup_datetime"
```
# Mean
Vérifie si la moyenne de toutes les valeurs d’une colonne correspond à une expression donnée.
**Syntaxe**
```
Mean
```
+ **COL\$1NAME** – 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](dqdl.md#dqdl-syntax-rule-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 null**
La règle `Mean` ignorera les lignes contenant des valeurs `NULL` 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 \$1 20 \$1 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\$1COLS** : 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\$1DATASET\$1COLS** : 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 de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-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 à 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](dqdl.md#dqdl-syntax-rule-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(last(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\$1DATASET\$1ALIAS** : 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 de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-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\$1NAME** – 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](dqdl.md#dqdl-syntax-rule-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.1`
+ `StandardDeviation "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**Comportement null**
La règle `StandardDeviation` ignorera les lignes contenant des valeurs `NULL` 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 `units1` ne tiendra pas compte des lignes 101 et 103 et donnera 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\$1NAME** – 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](dqdl.md#dqdl-syntax-rule-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 null**
La règle `Sum` ignorera les lignes contenant des valeurs `NULL` dans le calcul de la somme. Par exemple :
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
La somme des colonnes `units` ne tiendra pas compte des lignes 101 et 103 et donnera (0 \$1 20 \$1 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\$1DATASET\$1ALIAS** : 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 de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-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\$1NAME** – 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 de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple**
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"
```
L’exemple de règle suivant vérifie plusieurs colonnes.
```
Uniqueness "vendorid" "tpep_pickup_datetime" = 1
```
**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\$1NAME** – 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 de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-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` : 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"
+ "CustomSQL"
+ "ColumnCount"
`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"
```
# FileFreshness
FileFreshness garantit que vos fichiers de données sont à jour en fonction de l'état que vous fournissez. Il utilise l'heure de dernière modification de vos fichiers pour s'assurer que les fichiers de données ou l'ensemble du dossier le sont up-to-date.
Cette règle regroupe deux métriques :
+ FileFreshness conformité en fonction de la règle que vous avez définie
+ Nombre de fichiers analysés par la règle.
```
{"Dataset.*.FileFreshness.Compliance":1,"Dataset.*.FileCount":1}
```
La détection des anomalies ne prend pas en compte ces métriques.
**Vérification de l’actualité des fichiers**
La règle suivante garantit que tickets.parquet a été créé au cours des dernières 24 heures.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/tickets.parquet" > (now() - 24 hours)
```
**Vérification de l’actualité du dossier**
La règle suivante s’applique si tous les fichiers du dossier ont été créés ou modifiés au cours des dernières 24 heures.
```
FileFreshness "s3://bucket/" >= (now() -1 days)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" >= (now() - 24 hours)
```
**Vérification de l’actualité d’un dossier ou d’un fichier avec un seuil**
La règle suivante s’applique si 10 % des fichiers du dossier « tickets » ont été créés ou modifiés au cours des 10 derniers jours.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" < (now() - 10 days) with threshold > 0.1
```
**Vérification de fichiers ou de dossiers avec des dates spécifiques**
Vous pouvez vérifier l’actualité des fichiers pour des jours spécifiques.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "2020-01-01"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "2023-01-01" and "2024-01-01"
```
**Vérification de fichiers ou de dossiers avec l’heure**
Vous pouvez l'utiliser FileFreshness pour vous assurer que les fichiers sont arrivés à certaines heures.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between now() and (now() - 45 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "9:30 AM" and "9:30 PM"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > (now() - 10 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > now()
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between (now() - 2 hours) and (now() + 15 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between (now() - 3 days) and (now() + 15 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "2001-02-07" and (now() + 15 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45""
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "2024-01-01"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "02:30" and "04:30"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "9:30 AM" and "22:15"
```
Considérations clés :
+ FileFreshness peut évaluer les fichiers en utilisant des unités de jours, d'heures et de minutes
+ Parfois, elle prend en charge le format matins/après-midi et 24 heures
+ Les heures sont calculées en UTC, sauf si une dérogation est spécifiée.
+ Les dates sont calculées en UTC à 00:00.
FileFreshness qui sont basés sur le temps fonctionnent comme suit :
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45"
```
+ Tout d’abord, l’heure « 21:45 » est combinée à la date du jour au format UTC pour créer un champ date-heure.
+ Ensuite, le champ date-heure est converti en un fuseau horaire que vous avez spécifié.
+ Enfin, la règle est évaluée.
**Balises de règles facultatives basées sur des fichiers :**
Les balises vous permettent de contrôler le comportement des règles.
**recentFiles**
Cette balise limite le nombre de fichiers traités en conservant le fichier le plus récent en premier.
```
FileFreshness "s3://amzn-s3-demo-bucket/" between (now() - 100 minutes) and (now() + 10 minutes) with recentFiles = 1
```
**URI Regex**
**Note**
Le `uriRegex` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Cette balise filtre les fichiers en appliquant un modèle regex au chemin du fichier. Seuls les fichiers dont le chemin correspond au modèle sont traités. Vous pouvez également utiliser une prévision négative pour exclure les fichiers qui correspondent à un modèle.
```
# Match only files with a .csv extension
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = "\.csv$"
# Match Parquet files that contain "orders_" in the path
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = ".*orders_.*\.parquet"
# Exclude files ending in .tmp using a negative lookahead
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = "(?!.*\.tmp$).*"
```
**Ordre du filtre**
**Note**
Le `filterOrder` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Lorsque vous utilisez plusieurs balises de filtre, telles que `recentFiles` et `uriRegex` ensemble, la `filterOrder` balise contrôle l'ordre dans lequel elles sont appliquées. L'ordre par défaut est `recentFiles` le premier, puis`uriRegex`.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with recentFiles = 1 with uriRegex = "inventory_" with filterOrder = ["uriRegex","recentFiles"]
```
Dans l'exemple ci-dessus, le `uriRegex` filtre est d'abord appliqué pour sélectionner uniquement les fichiers correspondant à « inventory\$1 », puis `recentFiles = 1` prend le fichier le plus récent de cet ensemble filtré. Dans le cas contraire`filterOrder`, le comportement par défaut prendrait d'abord le fichier le plus récent, puis appliquerait l'expression régulière, ce qui pourrait entraîner l'absence de correspondance de fichiers si le fichier le plus récent ne correspond pas au modèle.
**Note**
Toutes les valeurs de la `filterOrder` liste doivent faire référence à d'autres balises de filtre (`recentFiles`ou`uriRegex`) également présentes sur la même règle. Les balises non filtrantes telles que `timeZone` ou ne `failFast` sont pas valides dans`filterOrder`.
**Fail-vite**
Lorsqu'elle est définie sur`"true"`, la règle renvoie un échec immédiatement au premier fichier qui ne répond pas à la condition de fraîcheur, au lieu d'évaluer tous les fichiers et de calculer un ratio de conformité.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with failFast = "true"
```
**timeZone**
Dérogations de fuseau horaire acceptées, consultez [Allowed Time Zones](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html) pour connaître les fuseaux horaires pris en charge.
```
FileFreshness "s3://path/" > "21:45" with timeZone = "America/New_York"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "America/Chicago"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "Europe/Paris"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "Asia/Shanghai"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "Australia/Darwin"
```
**Déduction des noms de fichiers directement à partir de trames de données**
Il n’est pas toujours nécessaire de fournir un chemin d’accès au fichier. Par exemple, lorsque vous créez la règle dans le catalogue de données AWS Glue, il peut être difficile de trouver les dossiers utilisés par les tables du catalogue. AWS Glue Data Quality peut trouver les dossiers ou fichiers spécifiques utilisés pour remplir votre dataframe et détecter s'ils sont récents.
**Note**
Cette fonctionnalité ne fonctionne que lorsque les fichiers sont correctement lus dans le DynamicFrame ou DataFrame.
```
FileFreshness > (now() - 24 hours)
```
Cette règle permet de trouver le chemin d’accès au dossier ou aux fichiers utilisés pour renseigner l’image dynamique ou la trame de données. Cela fonctionne pour les chemins Amazon S3 ou les tables AWS Glue Data Catalog basées sur Amazon S3. Voici quelques considérations à prendre en compte :
1. Dans AWS Glue ETL, vous devez disposer de la **EvaluateDataQuality**transformation immédiatement après une transformation d'Amazon S3 ou de AWS Glue Data Catalog.
![\[La capture d’écran montre un nœud Evaluate Data Quality connecté à un nœud Amazon S3.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/data-quality-file-freshness.png)
1. Cette règle ne fonctionnera pas dans les sessions AWS Glue Interactive.
Si vous essayez de le faire dans les deux cas, ou si AWS Glue ne trouve pas les fichiers, AWS Glue générera le message d'erreur suivant : `“Unable to parse file path from DataFrame”`
# FileMatch
La FileMatch règle vous permet de comparer des fichiers à d'autres fichiers ou à des checksums. Elle peut être utile dans certains scénarios :
1. Validation des fichiers reçus de sources externes : vous pouvez vous FileMatch assurer que vous avez reçu les bons fichiers provenant de sources externes en les comparant aux sommes de contrôle. Cela permet de valider l’intégrité des données que vous ingérez.
1. Comparaison de données dans deux dossiers différents : FileMatch peut être utilisé pour comparer des fichiers entre deux dossiers.
Cette règle regroupe une métrique : le nombre de fichiers analysés par la règle.
```
{"Dataset.*.FileCount":1}
```
**Valider le fichier avec une somme de contrôle :**
FileMatch accepte un fichier et une somme de contrôle définie pour s'assurer qu'au moins une somme de contrôle correspond au fichier.
```
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-1"
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-256"
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"]
```
Les algorithmes standard suivants sont pris en charge :
+ MD5
+ SHA-1
+ SHA-256
Si vous ne fournissez aucun algorithme, la valeur par défaut est SHA-256.
**Valider tous les fichiers d’un dossier avec un ensemble de sommes de contrôle :**
```
FileMatch "s3://amzn-s3-demo-bucket /" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch "s3://amzn-s3-demo-bucket /internal-folder/" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"]
```
**Comparer des fichiers dans différents dossiers**
```
# Compare all files across two buckets
FileMatch "s3://original_bucket/" "s3://archive_bucket/"
# Compare files within specific subfolders
FileMatch "s3://original_bucket/internal-folder/" "s3://original_bucket/other-folder/"
# Compare only .json files across two folders
FileMatch "s3://original_bucket/" "s3://archive_bucket/" with uriRegex = "\.json$"
# Compare only the 5 most recent .csv files
FileMatch "s3://original_bucket/" "s3://archive_bucket/" with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"]
```
FileMatch vérifiera le contenu des fichiers `original_bucket` et s'assurera qu'ils correspondent à ce qu'ils contiennent`archive_bucket`. La règle échouera s’ils ne correspondent pas exactement. Elle peut également vérifier le contenu de dossiers internes ou de fichiers individuels.
FileMatch peut également vérifier les fichiers individuels les uns par rapport aux autres.
```
FileMatch "s3://amzn-s3-demo-bucket /file_old.json" "s3://amzn-s3-demo-bucket /file_new.json"
```
**Déduction des noms de fichiers directement à partir de trames de données**
Il n’est pas toujours nécessaire de fournir un chemin d’accès au fichier. Par exemple, lorsque vous créez la règle dans le catalogue de données AWS Glue (soutenu par Amazon S3), il peut être difficile de trouver les dossiers utilisés par les tables du catalogue. AWS Glue Data Quality peut trouver les dossiers ou fichiers spécifiques utilisés pour remplir votre bloc de données.
**Note**
Cette fonctionnalité ne fonctionne que lorsque les fichiers sont correctement lus dans le DynamicFrame ou DataFrame.
```
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-1"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-256"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"]
```
Si la somme de contrôle fournie est différente de celle calculée, elle vous FileMatch avertira de la différence.
![\[La capture d'écran montre une règle dont le statut DQ est Rule failed. FileMatch explique l'échec.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/data-quality-file-match.png)
**Balises de règles facultatives basées sur des fichiers :**
Les balises vous permettent de contrôler le comportement des règles.
**recentFiles**
Cette balise limite le nombre de fichiers traités en conservant le fichier le plus récent en premier.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1
```
**URI Regex**
**Note**
Le `uriRegex` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Cette balise filtre les fichiers en appliquant un modèle regex au chemin du fichier. Seuls les fichiers dont le chemin correspond au modèle sont traités. Vous pouvez également utiliser une prévision négative pour exclure les fichiers qui correspondent à un modèle.
```
# Match only files with a .json extension
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with uriRegex = "\.json$"
# Exclude files ending in .tmp using a negative lookahead
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with uriRegex = "(?!.*\.tmp$).*"
```
**Ordre du filtre**
**Note**
Le `filterOrder` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Lorsque vous utilisez plusieurs balises de filtre, telles que `recentFiles` et `uriRegex` ensemble, la `filterOrder` balise contrôle l'ordre dans lequel elles sont appliquées. L'ordre par défaut est `recentFiles` le premier, puis`uriRegex`.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1 with uriRegex = "\.json$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
Cette balise garantit que les fichiers ne comportent pas de noms en double. Le comportement par défaut est false.
```
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac04179sam4713e5ef8f319"] with matchFileName = "true"
```
Voici quelques considérations à prendre en compte :
1. Dans AWS Glue ETL, vous devez disposer de la **EvaluateDataQuality**transformation immédiatement après une transformation d'Amazon S3 ou de AWS Glue Data Catalog.
![\[La capture d'écran montre une règle dont le statut DQ est Rule failed. FileMatch explique l'échec.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/data-quality-file-match-transform.png)
1. Cette règle ne fonctionnera pas dans les sessions AWS Glue Interactive.
# FileUniqueness
L’unicité des fichiers vous permet de vous assurer qu’il n’y a pas de doublons dans les données que vous avez reçues de vos producteurs de données.
Elle rassemble les statistiques de données suivantes :
1. Nombre de fichiers analysés par la règle.
1. Le taux d’unicité des fichiers
```
Dataset.*.FileUniquenessRatio: 1.00, Dataset.*.FileCount: 8.00
```
**Rechercher des fichiers en double dans un dossier :**
```
FileUniqueness "s3://bucket/" > 0.5
FileUniqueness "s3://bucket/folder/" = 1
```
**Déduire les noms de dossiers directement à partir des trames de données pour détecter les doublons :**
Il n’est pas toujours nécessaire de fournir un chemin d’accès au fichier. Par exemple, lorsque vous créez la règle dans le catalogue de données AWS Glue, il peut être difficile de trouver les dossiers utilisés par les tables du catalogue. AWS Glue Data Quality peut trouver les dossiers ou fichiers spécifiques utilisés pour remplir votre bloc de données.
**Note**
Lors de l'utilisation de l'inférence, les règles basées sur les fichiers peuvent uniquement détecter les fichiers lus avec succès dans le DynamicFrame ou. DataFrame
```
FileUniqueness > 0.5
```
**Balises de règles facultatives basées sur des fichiers :**
Les balises vous permettent de contrôler le comportement des règles.
**recentFiles**
Cette balise limite le nombre de fichiers traités en conservant le fichier le plus récent en premier.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with recentFiles = 1
```
**URI Regex**
**Note**
Le `uriRegex` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Cette balise filtre les fichiers en appliquant un modèle regex au chemin du fichier. Seuls les fichiers dont le chemin correspond au modèle sont traités. Vous pouvez également utiliser une prévision négative pour exclure les fichiers qui correspondent à un modèle.
```
# Match only files with a .csv extension
FileUniqueness "s3://bucket/" > 0.5 with uriRegex = "\.csv$"
# Exclude files ending in .tmp using a negative lookahead
FileUniqueness "s3://bucket/" > 0.5 with uriRegex = "(?!.*\.tmp$).*"
```
**Ordre du filtre**
**Note**
Le `filterOrder` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Lorsque vous utilisez plusieurs balises de filtre, telles que `recentFiles` et `uriRegex` ensemble, la `filterOrder` balise contrôle l'ordre dans lequel elles sont appliquées. L'ordre par défaut est `recentFiles` le premier, puis`uriRegex`.
```
FileUniqueness "s3://bucket/" > 0.5 with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
Cette balise garantit que les fichiers ne comportent pas de noms en double. Le comportement par défaut est false.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with matchFileName = "true"
```
Voici quelques considérations à prendre en compte :
1. Dans AWS Glue ETL, vous devez disposer de la **EvaluateDataQuality**transformation immédiatement après une transformation d'Amazon S3 ou de AWS Glue Data Catalog.
1. Cette règle ne fonctionnera pas dans les sessions AWS Glue Interactive.
# FileSize
Le FileSize type de règle vous permet de vous assurer que les fichiers répondent à certains critères de taille de fichier. Cela s’avère utile dans les cas d’utilisation suivants :
1. Assurez-vous que les producteurs n’envoient pas de fichiers vides ou nettement plus petits en traitement.
1. Assurez-vous que vos compartiments cible ne contiennent pas de fichiers plus petits, ce qui pourrait entraîner des problèmes de performances.
FileSize rassemble les métriques suivantes :
1. Compliance : renvoie le pourcentage de fichiers qui atteignent le seuil de règle que vous avez établi
1. File Count : nombre de fichiers analysés par la règle
1. Taille minimale du fichier en octets
1. Taille maximale du fichier en octets
```
Dataset.*.FileSize.Compliance: 1.00,
Dataset.*.FileCount: 8.00,
Dataset.*.MaximumFileSize: 327413121.00,
Dataset.*.MinimumFileSize: 204558920.00
```
La détection des anomalies n’est pas prise en charge pour ces métriques.
**Valider la taille des fichiers**
Cette règle est acceptée lorsque l’élément file.dat est supérieur à 2 Mo.
```
FileSize "s3://amzn-s3-demo-bucket/file.dat" > 2 MB
```
Les unités prises en charge sont les suivantes : o (octets), Mo (mégaoctets), Go (gigaoctets) et To (téraoctets).
**Valider la taille des fichiers dans les dossiers**
```
FileSize "s3://bucket/" > 5 B
FileSize "s3://bucket/" < 2 GB
```
Cette règle sera acceptée si 70 % des fichiers dans s3://amzn-s3-demo-bucket ont une taille comprise entre 2 Go et 1 To.
```
FileSize "s3://amzn-s3-demo-bucket/" between 2 GB and 1 TB with threshold > 0.7
```
**Déduction des noms de fichiers directement à partir de trames de données**
Il n’est pas toujours nécessaire de fournir un chemin d’accès au fichier. Par exemple, lorsque vous créez la règle dans le catalogue de données, il peut être difficile de trouver les dossiers utilisés par les tables du catalogue. AWS Glue Data Quality peut trouver les dossiers ou fichiers spécifiques utilisés pour remplir votre bloc de données.
**Note**
Cette fonctionnalité ne fonctionne que lorsque les fichiers sont correctement lus dans le DynamicFrame ou DataFrame.
```
FileSize < 10 MB with threshold > 0.7
```
**Balises de règles facultatives basées sur des fichiers :**
Les balises vous permettent de contrôler le comportement des règles.
**recentFiles**
Cette balise limite le nombre de fichiers traités en conservant le fichier le plus récent en premier.
```
FileSize "s3://amzn-s3-demo-bucket/" > 5 B with recentFiles = 1
```
**URI Regex**
**Note**
Le `uriRegex` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Cette balise filtre les fichiers en appliquant un modèle regex au chemin du fichier. Seuls les fichiers dont le chemin correspond au modèle sont traités. Vous pouvez également utiliser une prévision négative pour exclure les fichiers qui correspondent à un modèle.
```
# Match only files with a .dat extension
FileSize "s3://bucket/" > 5 B with uriRegex = "\.dat$"
# Exclude files ending in .tmp using a negative lookahead
FileSize "s3://bucket/" > 5 B with uriRegex = "(?!.*\.tmp$).*"
```
**Ordre du filtre**
**Note**
Le `filterOrder` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Lorsque vous utilisez plusieurs balises de filtre telles que `recentFiles` et `uriRegex` ensemble, la `filterOrder` balise contrôle l'ordre dans lequel elles sont appliquées. L'ordre par défaut est `recentFiles` le premier, puis`uriRegex`.
```
FileSize "s3://bucket/" > 5 B with recentFiles = 5 with uriRegex = "\.dat$" with filterOrder = ["uriRegex","recentFiles"]
```
**FailFast**
Lorsqu'elle est définie sur`"true"`, la règle renvoie l'échec immédiatement au premier fichier qui ne répond pas à la condition de taille, au lieu d'évaluer tous les fichiers et de calculer un ratio de conformité.
```
FileSize "s3://bucket/" > 2 MB with failFast = "true"
```
Voici quelques considérations à prendre en compte :
1. Dans AWS Glue ETL, vous devez disposer d' DataQuality Evaluate Transform immédiatement après la transformation d'Amazon S3 ou de Data Catalog.
1. Cette règle ne fonctionnera pas dans les sessions AWS Glue Interactive.