Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Référence 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.