",
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
]
```