Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Documentazione di riferimento del tipo di regola DQDL Questa sezione fornisce un riferimento per ogni tipo di regola supportato da AWS Glue Data Quality. **Nota** Attualmente DQDL non supporta dati di colonna annidati o di tipo elenco. I valori tra parentesi nella tabella seguente verranno sostituiti con le informazioni fornite negli argomenti delle regole. Le regole richiedono in genere un argomento aggiuntivo per l'espressione. | RuleType | Description | Arguments (Argomenti) | Metriche riportate | Supportato come regola? | Supportato come analizzatore? | Restituisce risultati a livello di riga? | Supporto per regole dinamiche? | Genera osservazioni | Supporta la sintassi della clausola Where? | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | AggregateMatch | Verifica se due set di dati corrispondono confrontando parametri di riepilogo come l'importo totale delle vendite. È utile agli istituti finanziari per confrontare se tutti i dati vengono importati dai sistemi di origine. | Una o più aggregazioni | Quando i nomi della prima e della seconda colonna di aggregazione corrispondono: `Column.[Column].AggregateMatch` Quando i nomi della prima e della seconda colonna di aggregazione non corrispondono: `Column.[Column1,Column2].AggregateMatch` | Sì | No | No | No | No | No | | AllStatistics | Analizzatore autonomo per raccogliere più metriche per la colonna fornita in un set di dati. | Un nome di colonna singolo | Per le colonne di tutti i tipi: `Dataset.*.RowCount` `Column.[Column].Completeness` `Column.[Column].Uniqueness` Metriche aggiuntive per le colonne con valori stringa: `ColumnLength metrics` Metriche aggiuntive per le colonne con valori numerici: `ColumnValues metrics` | No | Sì | No | No | No | No | | ColumnCorrelation | Verifica il grado di correlazione tra due colonne. | Esattamente due nomi di colonne | Multicolumn.[Column1,Column2].ColumnCorrelation | Sì | Sì | No | Sì | No | Sì | | ColumnCount | Verifica se delle colonne vengono eliminate. | Nessuno | Dataset.\$1.ColumnCount | Sì | Sì | No | Sì | Sì | No | | ColumnDataType | Verifica se una colonna è conforme a un tipo di dati. | Esattamente un nome di colonna | Column.[Column].ColumnDataType.Compliance | Sì | No | No | Sì, nell'espressione di soglia a livello di riga | No | Sì | | ColumnExists | Verifica se esistono colonne in un set di dati. Ciò consente ai clienti di creare piattaforme di dati self-service per garantire la disponibilità di determinate colonne. | Esattamente un nome di colonna | N/D | Sì | No | No | No | No | No | | ColumnLength | Verifica se la lunghezza dei dati è coerente. | Esattamente un nome di colonna | `Column.[Column].MaximumLength` `Column.[Column].MinimumLength` Metrica aggiuntiva quando viene fornita la soglia a livello di riga: `Column.[Column].ColumnValues.Compliance` | Sì | Sì | Sì, quando viene fornita la soglia a livello di riga | No | Sì. Genera solo osservazioni analizzando la lunghezza minima e quella massima | Sì | | ColumnNamesMatchPattern | Verifica se i nomi delle colonne corrispondono ai modelli definiti. È utile ai team di governance per far rispettare la coerenza dei nomi delle colonne. | Un'espressione regolare per i nomi delle colonne | Dataset.\$1.ColumnNamesPatternMatchRatio | Sì | No | No | No | No | No | | ColumnValues | Verifica se i dati sono coerenti per valori definiti. Questa regola supporta le espressioni regolari. | Esattamente un nome di colonna | `Column.[Column].Maximum` `Column.[Column].Minimum` Metrica aggiuntiva quando viene fornita la soglia a livello di riga: `Column.[Column].ColumnValues.Compliance` | Sì | Sì | Sì, quando viene fornita la soglia a livello di riga | No | Sì. Genera solo osservazioni analizzando i valori minimi e quelli massimi | Sì | | Completezza | Verifica la presenza di dati vuoti o NULLs mancanti. | Esattamente un nome di colonna | `Column.[Column].Completeness` | Sì | Sì | Sì | Sì | Sì | Sì | | CustomSql | I clienti possono implementare quasi tutti i tipi di controlli di qualità dei dati in SQL. | Un'istruzione SQL (Facoltativo) Una soglia a livello di riga | `Dataset.*.CustomSQL` Metrica aggiuntiva quando viene fornita la soglia a livello di riga: `Dataset.*.CustomSQL.Compliance` | Sì | No | Sì, quando viene fornita la soglia a livello di riga | Sì | No | No | | DataFreshness | Verifica se i dati sono aggiornati. | Esattamente un nome di colonna | Column.[Column].DataFreshness.Compliance | Sì | No | Sì | No | No | Sì | | DatasetMatch | Confronta due set di dati e identifica se sono sincronizzati. | Nome di un set di dati di riferimento Una mappatura delle colonne (Facoltativo) Colonne da controllare per cercare corrispondenze | Dataset.[ReferenceDatasetAlias].DatasetMatch | Sì | No | Sì | Sì | No | No | | DistinctValuesCount | Verifica la presenza di valori duplicati. | Esattamente un nome di colonna | Column.[Column].DistinctValuesCount | Sì | Sì | Sì | Sì | Sì | Sì | | DetectAnomalies | Verifica la presenza di anomalie nelle metriche riportate di un altro tipo di regola. | Un tipo di regola | Metriche riportate dall'argomento del tipo di regola | Sì | No | No | No | No | No | | Entropia | Verifica l'entropia dei dati. | Esattamente un nome di colonna | Column.[Column].Entropy | Sì | Sì | No | Sì | No | Sì | | IsComplete | Verifica se il 100% dei dati è completo. | Esattamente un nome di colonna | Column.[Column].Completeness | Sì | No | Sì | No | No | Sì | | IsPrimaryKey | Verifica se una colonna è una chiave primaria (non NULL e univoca). | Esattamente un nome di colonna | Per colonna singola: `Column.[Column].Uniqueness` Per più colonne: `Multicolumn.[CommaDelimitedColumns].Uniqueness` | Sì | No | Sì | No | No | Sì | | IsUnique | Verifica se il 100% dei dati è univoco. | Esattamente un nome di colonna | Column.[Column].Uniqueness | Sì | No | Sì | No | No | Sì | | Media | Verifica se la media corrisponde alla soglia impostata. | Esattamente un nome di colonna | Column.[Column].Mean | Sì | Sì | Sì | Sì | No | Sì | | ReferentialIntegrity | Verifica se due set di dati hanno un'integrità referenziale. | Uno o più nomi di colonne dal set di dati Uno o più nomi di colonne dal set di dati di riferimento | Column.[ReferenceDatasetAlias].ReferentialIntegrity | Sì | No | Sì | Sì | No | No | | RowCount | Verifica se il conteggio dei record corrisponde a una soglia. | Nessuno | Dataset.\$1.RowCount | Sì | Sì | No | Sì | Sì | Sì | | RowCountMatch | Verifica se il conteggio dei record tra due set di dati corrisponde. | Alias del set di dati di riferimento | Dataset.[ReferenceDatasetAlias].RowCountMatch | Sì | No | No | Sì | No | No | | StandardDeviation | Verifica se la deviazione standard corrisponde alla soglia. | Esattamente un nome di colonna | Column.[Column].StandardDeviation | Sì | Sì | Sì | Sì | No | Sì | | SchemaMatch | Verifica se il numero di record tra due set di dati corrisponde. | Alias del set di dati di riferimento | Dataset.[ReferenceDatasetAlias].SchemaMatch | Sì | No | No | Sì | No | No | | Somma | Verifica se la somma corrisponde a una soglia impostata. | Esattamente un nome di colonna | Column.[Column].Sum | Sì | Sì | No | Sì | No | Sì | | Univocità | Verifica se l'unicità del set di dati corrisponde alla soglia. | Esattamente un nome di colonna | Column.[Column].Uniqueness | Sì | Sì | Sì | Sì | No | Sì | | UniqueValueRatio | Verifica se la porzione di valore univoco corrisponde alla soglia. | Esattamente un nome di colonna | Column.[Column].UniqueValueRatio | Sì | Sì | Sì | Sì | No | Sì | | FileFreshness | Controlla se i file in Amazon S3 sono aggiornati. | Percorso del file o della cartella e soglia. | `Dataset.*.FileFreshness.Compliance` `Dataset.*.FileCount` | Sì | No | No | No | No | No | | FileMatch | Controlla se il contenuto del file corrisponde a un checksum o a un altro file. Questa regola usa i checksum per verificare se due file sono uguali. | Percorso del file o della cartella di origine e percorso del file o della cartella di destinazione. | Non viene generata alcuna statistica. | Sì | No | No | No | No | No | | FileSize | Controlla se la dimensione di un file corrisponde a una condizione specificata. | Percorso del file o della cartella e soglia. | `Dataset.*.FileSize.Compliance` `Dataset.*.FileCount` `Dataset.*.MaximumFileSize` `Dataset.*.MinimumFileSize` | Sì | No | No | No | No | No | | FileUniqueness | Controlla se i file sono unici utilizzando i checksum. | Percorso del file o della cartella e soglia. | `Dataset.*.FileUniquenessRatio` `Dataset.*.FileCount` | Sì | No | No | No | No | No | **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) + [Completezza](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) + [Entropia](dqdl-rule-types-Entropy.md) + [IsComplete](dqdl-rule-types-IsComplete.md) + [IsPrimaryKey](dqdl-rule-types-IsPrimaryKey.md) + [IsUnique](dqdl-rule-types-IsUnique.md) + [Media](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) + [Somma](dqdl-rule-types-Sum.md) + [SchemaMatch](dqdl-rule-types-SchemaMatch.md) + [Univocità](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 Verifica il rapporto di aggregazioni a due colonne rispetto a una determinata espressione. Questo tipo di regola funziona su più set di dati. Le aggregazioni a due colonne vengono valutate e viene prodotto un rapporto dividendo il risultato dell'aggregazione della prima colonna per il risultato dell'aggregazione della seconda colonna. Il rapporto viene confrontato con l'espressione fornita per produrre una risposta booleana. **Sintassi** **Aggregazione di colonne** ``` AggregateMatch (.) ``` + **AGG\$1OPERATION**: l'operazione da utilizzare per l'aggregazione. Attualmente, sono supportati `sum` e `avg`. **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **OPTIONAL\$1REFERENCE\$1ALIAS**: è necessario fornire questo parametro se la colonna proviene da un set di dati di riferimento e non dal set di dati primario. Se utilizzi questa regola nel AWS Glue Data Catalog, il tuo alias di riferimento deve seguire il formato ". . **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **COL\$1NAME**: il nome della colonna da aggregare. **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short **Esempio: media** ``` "avg(rating)" ``` **Esempio: somma** ``` "sum(amount)" ``` **Esempio: media della colonna nel set di dati di riferimento** ``` "avg(reference.rating)" ``` **Regola** ``` AggregateMatch ``` + **AGG\$1EXP\$11**: l'aggregazione della prima colonna. Tipi di colonna supportati: Byte, Decimal, Double, Float, Integer, Long, Short **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **AGG\$1EXP\$12**: l'aggregazione della seconda colonna. Tipi di colonna supportati: Byte, Decimal, Double, Float, Integer, Long, Short **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: aggrega corrispondenza utilizzando la somma** La seguente regola di esempio verifica se la somma dei valori nella colonna `amount` è esattamente uguale alla somma dei valori nella colonna `total_amount`. ``` AggregateMatch "sum(amount)" "sum(total_amount)" = 1.0 ``` **Esempio: aggrega corrispondenza utilizzando la media** La seguente regola di esempio verifica se la media dei valori nella colonna `ratings` è pari almeno al 90% della media dei valori nella colonna `ratings` del set di dati `reference`. Il set di dati di riferimento viene fornito come origine dati aggiuntiva nell'esperienza ETL o Catalogo dati. In AWS Glue ETL, puoi usare: ``` AggregateMatch "avg(ratings)" "avg(reference.ratings)" >= 0.9 ``` Nel AWS Glue Data Catalog, puoi usare: ``` AggregateMatch "avg(ratings)" "avg(database_name.tablename.ratings)" >= 0.9 ``` **Comportamento nullo** La regola `AggregateMatch` ignorerà le righe con valori NULL nel calcolo dei metodi di aggregazione (somma/media). Esempio: ``` +---+-----------+ |id |units | +---+-----------+ |100|0 | |101|null | |102|20 | |103|null | |104|40 | +---+-----------+ ``` La media della colonna `units` sarà (0 \$1 20 \$1 40) / 3 = 20. Le righe 101 e 103 non vengono considerate in questo calcolo. # ColumnCorrelation Verifica la *correlazione* tra due colonne rispetto a una determinata espressione. AWS Glue Data Quality utilizza il coefficiente di correlazione di Pearson per misurare la correlazione lineare tra due colonne. Il risultato è un numero compreso tra -1 e 1 che misura la forza e la direzione della relazione. **Sintassi** ``` ColumnCorrelation ``` + **COL\$11\$1NAME**: il nome della prima colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **COL\$12\$1NAME**: il nome della seconda colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: correlazione tra colonne** La seguente regola di esempio verifica se il coefficiente di correlazione tra le colonne `height` e `weight` ha una forte correlazione positiva (un valore del coefficiente maggiore di 0,8). ``` ColumnCorrelation "height" "weight" > 0.8 ``` ``` ColumnCorrelation "weightinkgs" "Salary" > 0.8 where "weightinkgs > 40" ``` **Regole dinamiche di esempio** + `ColumnCorrelation "colA" "colB" between min(last(10)) and max(last(10))` + `ColumnCorrelation "colA" "colB" < avg(last(5)) + std(last(5))` **Comportamento nullo** La regola `ColumnCorrelation` ignorerà le righe con valori `NULL` nel calcolo della correlazione. Esempio: ``` +---+-----------+ |id |units | +---+-----------+ |100|0 | |101|null | |102|20 | |103|null | |104|40 | +---+-----------+ ``` Le righe 101 e 103 verranno ignorate e la `ColumnCorrelation` sarà 1,0. # ColumnCount Verifica il conteggio delle righe del set di dati primario rispetto a una determinata espressione. Nell'espressione, è possibile specificare il numero di colonne o un intervallo di colonne utilizzando operatori come `>` e `<`. **Sintassi** ``` ColumnCount ``` + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: controllo numerico del conteggio delle colonne** La seguente regola di esempio controlla se il conteggio delle colonne rientra in un determinato intervallo. ``` ColumnCount between 10 and 20 ``` **Regole dinamiche di esempio** + `ColumnCount >= avg(last(10))` + `ColumnCount between min(last(10))-1 and max(last(10))+1` # ColumnDataType Controlla se i valori in una determinata colonna possono essere trasmessi in Apache Spark nel tipo fornito. Accetta un'espressione `with threshold` per verificare la presenza di un sottoinsieme di valori nella colonna. **Sintassi** ``` ColumnDataType = ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. Tipi di colonne supportati: tipo stringa **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **EXPECTED\$1TYPE**: il tipo di valori previsto nella colonna. Valori supportati: Boolean, Date, Timestamp, Integer, Double, Float, Long **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **EXPRESSION**: un'espressione facoltativa per specificare la percentuale di valori che devono essere del tipo previsto. **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short **Esempio: il tipo di dato nella colonna rappresentato come stringa è intero** La seguente regola di esempio verifica se i valori nella colonna specificata, che è di tipo stringa, possono essere convertiti in numeri interi. ``` ColumnDataType "colA" = "INTEGER" ``` **Esempio: verifica di un sottoinsieme dei valori delle colonne, di tipo intero ma rappresentati come stringhe** La seguente regola di esempio verifica se più del 90% dei valori nella colonna data, che è di tipo stringa, possono essere convertiti in numeri interi. ``` ColumnDataType "colA" = "INTEGER" with threshold > 0.9 ``` # ColumnExists Verifica se esiste una colonna. **Sintassi** ``` ColumnExists ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: qualsiasi tipo di colonna **Esempio: la colonna esiste** La seguente regola di esempio verifica se la colonna denominata `Middle_Name` esiste. ``` ColumnExists "Middle_Name" ``` # ColumnLength Verifica se la lunghezza di ogni riga in una colonna è conforme a una determinata espressione. **Sintassi** ``` ColumnLength ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonne supportati**: String + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: lunghezza della riga della colonna** La seguente regola di esempio verifica se il valore in ogni riga della colonna denominata `Postal_Code` è lungo 5 caratteri. ``` ColumnLength "Postal_Code" = 5 ColumnLength "weightinkgs" = 2 where "weightinkgs > 10" ``` **Comportamento nullo** La regola `ColumnLength` considera i valori `NULL` come stringhe di lunghezza pari a 0. Per una riga `NULL`: ``` ColumnLength "Postal_Code" > 4 # this will fail ``` ``` ColumnLength "Postal_Code" < 6 # this will succeed ``` Il seguente esempio di regola composta fornisce un modo per rifiutare esplicitamente i valori `NULL`: ``` (ColumnLength "Postal_Code" > 4) AND (ColumnValues "Postal_Code" != NULL) ``` # ColumnNamesMatchPattern Verifica se i nomi di tutte le colonne del set di dati primario corrispondono all'espressione regolare specificata. **Sintassi** ``` ColumnNamesMatchPattern ``` + **PATTERN**: il modello in base al quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short **Esempio: i nomi delle colonne corrispondono al modello** La seguente regola di esempio verifica se tutte le colonne iniziano con il prefisso "aws\$1" ``` ColumnNamesMatchPattern "aws_.*" ColumnNamesMatchPattern "aws_.*" where "weightinkgs > 10" ``` # ColumnValues Esegue un'espressione rispetto ai valori di una colonna. **Sintassi** ``` ColumnValues ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: qualsiasi tipo di colonna + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: valori consentiti** La seguente regola di esempio verifica se ogni valore nella colonna specificata si trova in un set di valori consentiti (compresi valori null, vuoti e stringhe contenenti solo spazi bianchi). ``` ColumnValues "Country" in [ "US", "CA", "UK", NULL, EMPTY, WHITESPACES_ONLY ] ColumnValues "gender" in ["F", "M"] where "weightinkgs < 10" ``` **Esempio: espressione regolare** La seguente regola di esempio verifica i valori di una colonna rispetto a un'espressione regolare. ``` ColumnValues "First_Name" matches "[a-zA-Z]*" ``` **Esempio: valori data** La seguente regola di esempio verifica i valori di una colonna data rispetto a un'espressione data. ``` ColumnValues "Load_Date" > (now() - 3 days) ``` **Esempio: valori numerici** La seguente regola di esempio verifica se i valori delle colonne corrispondono a un determinato vincolo numerico. ``` ColumnValues "Customer_ID" between 1 and 2000 ``` **Comportamento nullo** Per tutte le regole `ColumnValues` (diverse da `!=` e`NOT IN`), le righe `NULL` non soddisfano la regola. Se la regola ha esito negativo a causa di un valore null, il motivo dell'errore è il seguente: ``` Value: NULL does not meet the constraint requirement! ``` Il seguente esempio di regola composta fornisce un modo per accettare esplicitamente i valori `NULL`: ``` (ColumnValues "Age" > 21) OR (ColumnValues "Age" = NULL) ``` ColumnValues Le regole negate che utilizzano la `not in` sintassi `!=` and verranno passate per le `NULL` righe. Esempio: ``` ColumnValues "Age" != 21 ``` ``` ColumnValues "Age" not in [21, 22, 23] ``` Gli esempi seguenti forniscono un modo per rifiutare esplicitamente i valori `NULL` ``` (ColumnValues "Age" != 21) AND (ColumnValues "Age" != NULL) ``` ``` ColumnValues "Age" not in [21, 22, 23, NULL] ``` # Completezza Verifica la percentuale di valori completi (non nulli) in una colonna rispetto a una determinata espressione. **Sintassi** ``` Completeness ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: qualsiasi tipo di colonna + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: percentuale di valore nullo** Le seguenti regole di esempio controllano se più del 95% dei valori in una colonna sono completi. ``` Completeness "First_Name" > 0.95 Completeness "First_Name" > 0.95 where "weightinkgs > 10" ``` **Regole dinamiche di esempio** + `Completeness "colA" between min(last(5)) - 1 and max(last(5)) + 1` + `Completeness "colA" <= avg(last(10))` **Comportamento nullo** Nota sui formati di dati CSV: le righe vuote nelle colonne CSV possono presentare diversi comportamenti. + Se una colonna è di tipo `String`, la riga vuota verrà riconosciuta come una stringa vuota e non violerà la regola `Completeness`. + Se una colonna è di un altro tipo di dati come `Int`, la riga vuota verrà riconosciuta come `NULL` e non rispetterà la regola `Completeness`. # CustomSQL Questo tipo di regola è stato esteso per supportare due casi d'uso: + Esegui un'istruzione SQL personalizzata su un set di dati e controlla il valore restituito rispetto a una determinata espressione. + Esegui un'istruzione SQL personalizzata specificando un nome di colonna nell'istruzione SELECT in base alla quale eseguire un confronto con alcune condizioni per ottenere risultati a livello di riga. **Sintassi** ``` CustomSql ``` + **SQL\$1STATEMENT**: un'istruzione SQL che restituisce un singolo valore numerico, racchiuso tra virgolette doppie. + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: SQL personalizzato per recuperare il risultato di una regola generale** Questa regola di esempio utilizza un'istruzione SQL per recuperare il numero di record per un set di dati. La regola verifica quindi che il conteggio dei record sia compreso tra 10 e 20. ``` CustomSql "select count(*) from primary" between 10 and 20 ``` **Esempio: SQL personalizzato per recuperare i risultati a livello di riga** Questa regola di esempio utilizza un'istruzione SQL personalizzata specificando un nome di colonna nell'istruzione SELECT in base alla quale eseguire un confronto con alcune condizioni per ottenere risultati a livello di riga. Un'espressione di condizione di soglia definisce una soglia di quanti record devono avere esito negativo perché l'intera regola abbia esito negativo. Tieni presente che una regola non può contenere contemporaneamente una condizione e una parola chiave. ``` CustomSql "select Name from primary where Age > 18" ``` or ``` CustomSql "select Name from primary where Age > 18" with threshold > 3 ``` **Importante** L'alias `primary` sostituisce il nome del set di dati che si desidera valutare. Quando lavori con job ETL visivi sulla console, `primary` rappresenta sempre il `DynamicFrame` passato alla trasformazione `EvaluateDataQuality.apply()`. Quando si utilizza il AWS Glue Data Catalog per eseguire attività di qualità dei dati su una tabella, `primary` rappresenta la tabella. Se utilizzi Catalogo dati AWS Glue, puoi anche utilizzare i nomi effettivi delle tabelle: ``` CustomSql "select count(*) from database.table" between 10 and 20 ``` È inoltre possibile effettuare il join di più tabelle per confrontare diversi elementi di dati: ``` CustomSql "select count(*) from database.table inner join database.table2 on id1 = id2" between 10 and 20 ``` In ETL di AWS Glue, CustomSQL è in grado di identificare i record che non hanno superato i controlli di qualità dei dati. Affinché ciò funzioni, è necessario restituire i record che fanno parte della tabella primaria per la quale si sta valutando la qualità dei dati. I record restituiti come parte della query sono considerati riusciti, mentre i record che non vengono restituiti sono considerati non riusciti. Ciò funziona unendo il risultato della query CustomSQL con il set di dati originale. In base alla complessità della query SQL, potrebbero esserci implicazioni sulle prestazioni. Per farlo: + Bisogna selezionare almeno 1 colonna dalla tabella principale. + `select count(*) from primary` è una query valida per la regola OVERALL CustomSQL DQ, ma non per Row Level Custom SQL. + Questa regola genererà un errore durante la valutazione: `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.` + Nella query SQL, seleziona una "chiave primaria" dalla tabella oppure seleziona un set di colonne che formano una chiave composita. Altrimenti, potrebbero verificarsi risultati incoerenti, a causa della corrispondenza di righe duplicate, e un calo delle prestazioni. + Seleziona le chiavi SOLO dalla tabella principale e non dalle tabelle di riferimento. La regola seguente garantirà che i record con età < 100 vengano identificati come riusciti e i record al di sopra vengano contrassegnati come non riusciti. ``` CustomSql "select id from primary where age < 100" ``` Questa regola CustomSQL sarà soddisfatta quando il 50% dei record hanno un'età > 10 e identificherà anche i record che non soddisfano la regola. I record restituiti da questa regola CustomSQL verranno considerati superati, mentre quelli non restituiti verranno considerati non superati. ``` CustomSQL "select ID, CustomerID from primary where age > 10" with threshold > 0.5 ``` Nota: la regola CustomSQL avrà esito negativo se si restituiscono record che non sono disponibili nel set di dati. # DataFreshness Verifica l'aggiornamento dei dati in una colonna valutando la differenza tra l'ora corrente e i valori di una colonna di date. È possibile specificare un'espressione basata sul tempo per questo tipo di regola per assicurarsi che i valori delle colonne siano aggiornati. **Sintassi** ``` DataFreshness ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonne supportati**: Data + **EXPRESSION**: un'espressione numerica in ore o giorni. È necessario specificare l'unità di tempo nell'espressione. **Esempio: freschezza dei dati** Le seguenti regole di esempio controllano la freschezza dei dati, ovvero quanto sono aggiornati. ``` DataFreshness "Order_Date" <= 24 hours DataFreshness "Order_Date" between 2 days and 5 days ``` **Comportamento nullo** Le regole `DataFreshness` avranno esito negativo per le righe con valori `NULL`. Se la regola ha esito negativo a causa di un valore null, il motivo dell'errore è il seguente: ``` 80.00 % of rows passed the threshold ``` dove il 20% delle righe che hanno dato esito negativo include le righe con valori `NULL`. Il seguente esempio di regola composta fornisce un modo per accettare esplicitamente i valori `NULL`: ``` (DataFreshness "Order_Date" <= 24 hours) OR (ColumnValues "Order_Date" = NULL) ``` **Aggiornamento dei dati per oggetti Amazon S3** A volte è necessario verificare l'aggiornamento dei dati in base alla data e all'ora di creazione del file Amazon S3. A tale scopo, puoi usare il seguente codice per ottenere il timestamp, aggiungerlo al dataframe e poi applicare i controlli relativi all'aggiornamento dei dati. ``` 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 Verifica se i dati nel set di dati primario corrispondono ai dati in un set di dati di riferimento. Il join dei due set di dati viene effettuato utilizzando le mappature delle colonne chiave fornite. È possibile fornire mappature di colonne aggiuntive se si desidera verificare l'uguaglianza dei dati solo in quelle colonne. Nota che, **DataSetMatch**per funzionare, le tue chiavi di join devono essere uniche e non devono essere NULL (deve essere una chiave primaria). Se non soddisfi queste condizioni, riceverai il messaggio di errore "Provided key map not suitable for given data frames". Nei casi in cui non è possibile disporre di chiavi di unione univoche, si consiglia di utilizzare altri tipi di regole, ad esempio la corrispondenza nei dati **AggregateMatch**di riepilogo. **Sintassi** ``` DatasetMatch ``` + **REFERENCE\$1DATASET\$1ALIAS**: l'alias del set di dati di riferimento con cui confronti i dati del set di dati primario. + **KEY\$1COLUMN\$1MAPPINGS**: un elenco separato da virgole di nomi di colonne che formano una chiave nei set di dati. Se i nomi delle colonne non sono uguali in entrambi i set di dati, è necessario separarli con un `->` + **OPTIONAL\$1MATCH\$1COLUMN\$1MAPPINGS**: puoi fornire questo parametro se desideri verificare la corrispondenza dei dati solo in determinate colonne. Utilizza la stessa sintassi delle mappature delle colonne chiave. Se questo parametro non viene fornito, abbineremo i dati in tutte le colonne rimanenti. Le colonne rimanenti (non chiave) devono avere gli stessi nomi in entrambi i set di dati. + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: abbina i set di dati definiti utilizzando la colonna ID** La seguente regola di esempio verifica che più del 90% del set di dati primario corrisponda al set di dati di riferimento, utilizzando la colonna "ID" per il join dei due set di dati. In questo caso confronta tutte le colonne. ``` DatasetMatch "reference" "ID" >= 0.9 ``` **Esempio: abbina i set di dati del set utilizzando più colonne chiave** Nell'esempio seguente, il set di dati primario e il set di dati di riferimento hanno nomi diversi per le colonne chiave. `ID_1` e `ID_2` insieme formano una chiave composita nel set di dati primario. `ID_ref1` e `ID_ref2` insieme formano una chiave composita nel set di dati di riferimento. In questo scenario, è possibile utilizzare la sintassi speciale per fornire i nomi delle colonne. ``` DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" >= 0.9 ``` **Esempio: abbina i set di dati del set utilizzando più colonne chiave e verifica che le colonne specifiche corrispondano** Questo esempio si basa sull'esempio precedente. Vogliamo verificare che solo la colonna contenente gli importi corrisponda. Questa colonna è denominata `Amount1` nel set di dati primario e `Amount2` nel set di dati di riferimento. Vuoi una corrispondenza esatta. ``` DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" "Amount1->Amount2" >= 0.9 ``` # DistinctValuesCount Seleziona il numero di valori distinti in una colonna rispetto a una determinata espressione. **Sintassi** ``` DistinctValuesCount ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: qualsiasi tipo di colonna + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: conteggio dei valori distinti delle colonne** La seguente regola di esempio verifica che la colonna denominata `State` contenga più di 3 valori distinti. ``` DistinctValuesCount "State" > 3 DistinctValuesCount "Customer_ID" < 6 where "Customer_ID < 10" ``` **Regole dinamiche di esempio** + `DistinctValuesCount "colA" between avg(last(10))-1 and avg(last(10))+1` + `DistinctValuesCount "colA" <= index(last(10),2) + std(last(5))` # Entropia Verifica se il valore di *entropy* di una colonna corrisponde a una determinata espressione. L'entropia misura il livello di informazioni contenute in un messaggio. Data la distribuzione della probabilità sui valori in una colonna, l'entropia descrive quanti bit sono necessari per identificare un valore. **Sintassi** ``` Entropy ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: qualsiasi tipo di colonna + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: entropia delle colonne** La seguente regola di esempio verifica che la colonna denominata `Feedback` abbia un valore di entropia maggiore di uno. ``` Entropy "Star_Rating" > 1 Entropy "First_Name" > 1 where "Customer_ID < 10" ``` **Regole dinamiche di esempio** + `Entropy "colA" < max(last(10))` + `Entropy "colA" between min(last(10)) and max(last(10))` # IsComplete Verifica se tutti i valori in una colonna sono completi (non nulli). **Sintassi** ``` IsComplete ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: qualsiasi tipo di colonna **Esempio: valori nulli** L'esempio seguente verifica se tutti i valori in una colonna denominata `email` non sono nulli. ``` 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" ``` **Comportamento nullo** Nota sui formati di dati CSV: le righe vuote nelle colonne CSV possono presentare diversi comportamenti. + Se una colonna è di tipo `String`, la riga vuota verrà riconosciuta come una stringa vuota e non violerà la regola `Completeness`. + Se una colonna è di un altro tipo di dati come `Int`, la riga vuota verrà riconosciuta come `NULL` e non rispetterà la regola `Completeness`. # IsPrimaryKey Verifica se una colonna contiene una chiave primaria. Una colonna contiene una chiave primaria se tutti i valori nella colonna sono univoci e completi (non nulli). Puoi anche verificare la presenza di chiavi primarie con più colonne. **Sintassi** ``` IsPrimaryKey ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: qualsiasi tipo di colonna **Esempio: chiave primaria** La seguente regola di esempio verifica se la colonna denominata `Customer_ID` contiene una chiave primaria. ``` IsPrimaryKey "Customer_ID" IsPrimaryKey "Customer_ID" where "Customer_ID < 10" ``` **Esempio: chiave primaria con più colonne. Ognuno degli esempi seguenti è valido.** ``` IsPrimaryKey "colA" "colB" IsPrimaryKey "colA" "colB" "colC" IsPrimaryKey colA "colB" "colC" ``` # IsUnique Verifica se tutti i valori in una colonna sono univoci e restituisce un valore booleano. **Sintassi** ``` IsUnique ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: qualsiasi tipo di colonna **Esempi** La seguente regola di esempio verifica se tutti i valori in una colonna denominata `email` sono univoci. ``` IsUnique "email" IsUnique "Customer_ID" where "Customer_ID < 10"] ``` La seguente regola di esempio controlla più colonne. ``` IsUnique "vendorid" "tpep_pickup_datetime" ``` # Media Verifica se la media di tutti i valori in una colonna corrisponde a una determinata espressione. **Sintassi** ``` Mean ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: valore medio** La seguente regola di esempio verifica se la media di tutti i valori di una colonna supera una soglia. ``` Mean "Star_Rating" > 3 Mean "Salary" < 6200 where "Customer_ID < 10" ``` **Regole dinamiche di esempio** + `Mean "colA" > avg(last(10)) + std(last(2))` + `Mean "colA" between min(last(5)) - 1 and max(last(5)) + 1` **Comportamento nullo** La regola `Mean` ignorerà le righe con valori `NULL` nel calcolo della media. Esempio: ``` +---+-----------+ |id |units | +---+-----------+ |100|0 | |101|null | |102|20 | |103|null | |104|40 | +---+-----------+ ``` La media della colonna `units` sarà (0 \$1 20 \$1 40) / 3 = 20. Le righe 101 e 103 non vengono considerate in questo calcolo. # ReferentialIntegrity Verifica in che misura i valori di un set di colonne nel set di dati primario siano un sottoinsieme dei valori di un set di colonne in un set di dati di riferimento. **Sintassi** ``` ReferentialIntegrity ``` + **PRIMARY\$1COLS**: un elenco separato da virgole dei nomi delle colonne nel set di dati primario. **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **REFERENCE\$1DATASET\$1COLS**: questo parametro contiene due parti separate da un punto. La prima parte è l'alias del set di dati di riferimento. La seconda parte è l'elenco separato da virgole dei nomi delle colonne nel set di dati di riferimento racchiuso tra parentesi. **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: verifica l'integrità referenziale di una colonna di codice postale** La seguente regola di esempio verifica che più del 90% dei valori nella colonna `zipcode` del set di dati primario siano presenti nella colonna `zipcode` del set di dati `reference`. ``` ReferentialIntegrity "zipcode" "reference.zipcode" >= 0.9 ``` **Esempio: verifica l'integrità referenziale delle colonne relative alla città e allo stato** Nell'esempio seguente, nel set di dati primario e nel set di dati di riferimento sono presenti colonne contenenti informazioni sulla città e sullo stato. I nomi delle colonne sono diversi in entrambi i set di dati. La regola verifica se il set di valori delle colonne nel set di dati primario è esattamente uguale al set di valori delle colonne nel set di dati di riferimento. ``` ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" = 1.0 ``` **Regole dinamiche di esempio** + `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 Verifica il numero di righe di un set di dati rispetto a una determinata espressione. Nell'espressione, è possibile specificare il numero di righe o un intervallo di righe utilizzando operatori come `>` e `<`. **Sintassi** ``` RowCount ``` + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: controllo numerico del conteggio delle righe** La seguente regola di esempio controlla se il conteggio delle righe rientra in un determinato intervallo. ``` RowCount between 10 and 100 RowCount between 1 and 50 where "Customer_ID < 10" ``` **Regole dinamiche di esempio** ``` RowCount > avg(last(10)) *0.8 ``` # RowCountMatch Verifica il rapporto tra il conteggio delle righe del set di dati primario e il conteggio delle righe di un set di dati di riferimento rispetto all'espressione data. **Sintassi** ``` RowCountMatch ``` + **REFERENCE\$1DATASET\$1ALIAS**: l'alias del set di dati di riferimento con cui confrontare il conteggio delle righe. **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: controllo del conteggio delle righe rispetto a un set di dati di riferimento** La seguente regola di esempio verifica se il conteggio delle righe del set di dati primario è almeno il 90% del conteggio delle righe del set di dati di riferimento. ``` RowCountMatch "reference" >= 0.9 ``` # StandardDeviation Verifica la deviazione standard di tutti i valori di una colonna rispetto a una determinata espressione. **Sintassi** ``` StandardDeviation ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: deviazione standard** La seguente regola di esempio verifica se la deviazione standard dei valori in una colonna denominata `colA` è inferiore a un valore specificato. ``` StandardDeviation "Star_Rating" < 1.5 StandardDeviation "Salary" < 3500 where "Customer_ID < 10" ``` **Regole dinamiche di esempio** + `StandardDeviation "colA" > avg(last(10) + 0.1` + `StandardDeviation "colA" between min(last(10)) - 1 and max(last(10)) + 1` **Comportamento nullo** La regola `StandardDeviation` ignorerà le righe con valori `NULL` nel calcolo della deviazione standard. Esempio: ``` +---+-----------+-----------+ |id |units1 |units2 | +---+-----------+-----------+ |100|0 |0 | |101|null |0 | |102|20 |20 | |103|null |0 | |104|40 |40 | +---+-----------+-----------+ ``` La deviazione standard della colonna `units1` non terrà conto delle righe 101 e 103 e risulterà pari a 16,33. La deviazione standard per la colonna `units2` darà come risultato 16. # Somma Verifica la somma di tutti i valori in una colonna rispetto a una determinata espressione. **Sintassi** ``` Sum ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: somma** La seguente regola di esempio verifica se la somma di tutti i valori in una colonna supera una determinata soglia. ``` Sum "transaction_total" > 500000 Sum "Salary" < 55600 where "Customer_ID < 10" ``` **Regole dinamiche di esempio** + `Sum "ColA" > avg(last(10))` + `Sum "colA" between min(last(10)) - 1 and max(last(10)) + 1` **Comportamento nullo** La regola `Sum` ignorerà le righe con valori `NULL` nel calcolo della somma. Esempio: ``` +---+-----------+ |id |units | +---+-----------+ |100|0 | |101|null | |102|20 | |103|null | |104|40 | +---+-----------+ ``` La somma della colonna `units` non terrà conto delle righe 101 e 103 e darà come risultato (0 \$1 20 \$1 40) = 60. # SchemaMatch Verifica se lo schema del set di dati primario corrisponde allo schema del set di dati di riferimento. Il controllo dello schema viene eseguito colonna per colonna. Lo schema di due colonne corrisponde se i nomi sono identici e i tipi sono identici. L'ordine delle colonne non è rilevante. **Sintassi** ``` SchemaMatch ``` + **REFERENCE\$1DATASET\$1ALIAS**: l'alias del set di dati di riferimento con cui confrontare gli schemi. **Tipi di colonna supportati**: Byte, Decimal, Double, Float, Integer, Long, Short + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio SchemaMatch**: La seguente regola di esempio verifica se lo schema del set di dati primario corrisponde esattamente allo schema di un set di dati di riferimento. ``` SchemaMatch "reference" = 1.0 ``` # Univocità Verifica la percentuale di valori univoci in una colonna rispetto a una determinata espressione. I valori univoci si verificano esattamente una volta. **Sintassi** ``` Uniqueness ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: qualsiasi tipo di colonna + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio** La seguente regola di esempio verifica se la percentuale di valori univoci in una colonna corrisponde a determinati criteri numerici. ``` Uniqueness "email" = 1.0 Uniqueness "Customer_ID" != 1.0 where "Customer_ID < 10" ``` La seguente regola di esempio controlla più colonne. ``` Uniqueness "vendorid" "tpep_pickup_datetime" = 1 ``` **Regole dinamiche di esempio** + `Uniqueness "colA" between min(last(10)) and max(last(10))` + `Uniqueness "colA" >= avg(last(10))` # UniqueValueRatio Verifica il *rapporto di valori univoci* in una colonna rispetto a una determinata espressione. Un rapporto di valori univoci è la frazione di valori univoci divisa per il numero di tutti i valori distinti in una colonna. I valori univoci si verificano esattamente una volta, mentre i valori distinti si verificano *almeno* una volta. Ad esempio, il set `[a, a, b]` contiene un valore univoco (`b`) e due valori distinti (`a` e `b`). Quindi il rapporto di valori univoci del set è ½ = 0,5. **Sintassi** ``` UniqueValueRatio ``` + **COL\$1NAME**: il nome della colonna in base alla quale si desidera valutare la regola di qualità dei dati. **Tipi di colonna supportati**: qualsiasi tipo di colonna + **EXPRESSION**: un'espressione da eseguire sulla risposta del tipo di regola per produrre un valore booleano. Per ulteriori informazioni, consulta [Espressioni](dqdl.md#dqdl-syntax-rule-expressions). **Esempio: rapporto di valori univoci** Questo esempio controlla il rapporto tra i valori univoci di una colonna rispetto a un intervallo di valori. ``` UniqueValueRatio "test_score" between 0 and 0.5 UniqueValueRatio "Customer_ID" between 0 and 0.9 where "Customer_ID < 10" ``` **Regole dinamiche di esempio** + `UniqueValueRatio "colA" > avg(last(10))` + `UniqueValueRatio "colA" <= index(last(10),2) + std(last(5))` # DetectAnomalies Rileva le anomalie per una determinata regola relativa alla qualità dei dati. Ogni esecuzione della DetectAnomalies regola comporta il salvataggio del valore valutato per la regola data. Quando vengono raccolti dati sufficienti, l'algoritmo di rilevamento delle anomalie prende tutti i dati storici relativi a quella determinata regola ed esegue il rilevamento delle anomalie. DetectAnomalies la regola fallisce quando viene rilevata un'anomalia. È possibile ottenere ulteriori informazioni sull'anomalia rilevata tramite le osservazioni. **Sintassi** ``` DetectAnomalies ``` `RULE_NAME`: il nome della regola che desideri valutare e per la quale desideri rilevare le anomalie. Regole supportate: + "RowCount" + "Completezza" + "Univocità" + "Media" + "Somma" + "StandardDeviation" + "Entropia" + "DistinctValuesCount" + "UniqueValueRatio" + "ColumnLength" + "ColumnValues" + "ColumnCorrelation" + "CustomSQL" + "ColumnCount" `RULE_PARAMETERS`: alcune regole richiedono parametri aggiuntivi per l'esecuzione. Fai riferimento alla documentazione fornita sulle regole per visualizzare i parametri richiesti. **Esempio: anomalie per RowCount** Ad esempio, se vogliamo rilevare RowCount anomalie, forniamo RowCount come regola il nome. ``` DetectAnomalies "RowCount" ``` **Esempio: anomalie per ColumnLength** Ad esempio, se vogliamo rilevare ColumnLength anomalie, forniamo ColumnLength come regola il nome e il nome della colonna. ``` DetectAnomalies "ColumnLength" "id" ``` # FileFreshness FileFreshness assicura che i file di dati siano aggiornati in base alle condizioni fornite. Utilizza l'ora dell'ultima modifica dei file per garantire che i file di dati o l'intera cartella lo siano up-to-date. Questa regola comprende due metriche: + FileFreshness conformità basata sulla regola impostata + Numero di file sottoposti a scansione dalla regola ``` {"Dataset.*.FileFreshness.Compliance":1,"Dataset.*.FileCount":1} ``` Il rilevamento delle anomalie non tiene in considerazione questi parametri. **Controllo dell'aggiornamento dei file** La seguente regola garantisce che tickets.parquet sia stato creato nelle ultime 24 ore. ``` FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/tickets.parquet" > (now() - 24 hours) ``` **Controllo dell'aggiornamento delle cartelle** La seguente regola viene applicata se tutti i file nella cartella sono stati creati o modificati nelle ultime 24 ore. ``` FileFreshness "s3://bucket/" >= (now() -1 days) FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" >= (now() - 24 hours) ``` **Controllo dell'aggiornamento di cartelle o file con soglia** La seguente regola viene applicata se il 10% dei file nella cartella "tickets" è stato creato o modificato negli ultimi 10 giorni. ``` FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" < (now() - 10 days) with threshold > 0.1 ``` **Controllo di file o cartelle con date specifiche** Puoi controllare l'aggiornamento dei file per giorni specifici. ``` 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" ``` **Controllo di file o cartelle con l'orario** Puoi usarlo FileFreshness per assicurarti che i file arrivino in determinati orari. ``` 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" ``` Considerazioni chiave: + FileFreshness può valutare i file utilizzando unità di giorni, ore e minuti + Per l'ora, supporta il formato AM/PM e il formato a 24 ore + Gli orari sono calcolati in UTC, salvo diversamente specificato + Le date sono calcolate in UTC alle ore 00:00 FileFreshness che sono lavori basati sul tempo come segue: ``` FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45" ``` + Per prima cosa, l'ora "21:45" viene combinata con la data odierna in formato UTC per creare un campo data-ora + Successivamente, la data e l'ora vengono convertite nel fuso orario specificato + Infine, la regola viene valutata **Tag delle regole opzionali basati su file:** I tag permettono di controllare il comportamento delle regole. **recentFiles** Questo tag limita il numero di file elaborati mantenendo il file più recente per primo. ``` FileFreshness "s3://amzn-s3-demo-bucket/" between (now() - 100 minutes) and (now() + 10 minutes) with recentFiles = 1 ``` **uriRegex** **Nota** Il `uriRegex` tag è disponibile in AWS Glue 5.0 e versioni successive. Questo tag filtra i file applicando un pattern regex al percorso del file. Vengono elaborati solo i file i cui percorsi corrispondono al modello. Puoi anche usare un lookahead negativo per escludere i file che corrispondono a uno schema. ``` # 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$).*" ``` **Ordinamento del filtro** **Nota** Il `filterOrder` tag è disponibile in AWS Glue 5.0 e versioni successive. Quando si utilizzano più tag di filtro, `recentFiles` `uriRegex` singolarmente e contemporaneamente, il `filterOrder` tag controlla l'ordine in cui vengono applicati. L'ordine predefinito è quindi il `recentFiles` primo`uriRegex`. ``` FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with recentFiles = 1 with uriRegex = "inventory_" with filterOrder = ["uriRegex","recentFiles"] ``` Nell'esempio precedente, il `uriRegex` filtro viene applicato prima per selezionare solo i file che corrispondono a «inventory\$1», quindi `recentFiles = 1` prende il file più recente da quel set filtrato. In caso contrario`filterOrder`, il comportamento predefinito prenderebbe prima il singolo file più recente e poi applicherebbe l'espressione regolare, il che potrebbe non avere alcuna corrispondenza tra i file se il file più recente non corrisponde al modello. **Nota** Tutti i valori dell'`filterOrder`elenco devono fare riferimento ad altri tag di filtro (`recentFiles`o`uriRegex`) presenti anche nella stessa regola. Tag non filtranti come `timeZone` o non `failFast` sono validi in`filterOrder`. **FailFast** Se impostata su`"true"`, la regola restituisce immediatamente l'errore sul primo file che non soddisfa la condizione di aggiornamento, anziché valutare tutti i file e calcolare un rapporto di conformità. ``` FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with failFast = "true" ``` **timezone** Sostituzioni di fuso orario accettate. Consulta [Fusi orari consentiti](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html) per i fusi orari supportati. ``` 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" ``` **Dedurre i nomi dei file direttamente dai data frame** Non è sempre necessario fornire un percorso del file. Ad esempio, quando si crea la regola nel AWS Glue Data Catalog, potrebbe essere difficile trovare le cartelle utilizzate dalle tabelle del catalogo. AWS Glue Data Quality può trovare le cartelle o i file specifici utilizzati per popolare il tuo dataframe e può rilevare se sono nuovi. **Nota** Questa funzione funziona solo quando i file vengono letti correttamente in sala operatoria. DynamicFrame DataFrame ``` FileFreshness > (now() - 24 hours) ``` Questa regola individuerà il percorso della cartella o i file usati per popolare il frame dinamico o il frame di dati. Funziona con i percorsi Amazon S3 o le tabelle AWS Glue Data Catalog basate su Amazon S3. Occorre tenere presente alcuni aspetti: 1. In AWS Glue ETL, è necessario disporre di **EvaluateDataQuality**Transform subito dopo una trasformazione di Amazon S3 o AWS Glue Data Catalog. ![\[La schermata mostra un nodo Evaluate Data Quality connesso a un nodo Amazon S3.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/data-quality-file-freshness.png) 1. Questa regola non funzionerà nelle sessioni interattive di AWS Glue. Se provi a farlo in entrambi i casi o quando AWS Glue non riesce a trovare i file, AWS Glue genererà il seguente errore: `“Unable to parse file path from DataFrame”` # FileMatch La FileMatch regola consente di confrontare i file con altri file o checksum. Questo può essere utile in alcuni scenari: 1. Convalida dei file ricevuti da fonti esterne: è possibile eseguire il confronto con i checksum FileMatch per assicurarsi di aver ricevuto i file corretti da fonti esterne. Ciò contribuisce a verificare l'integrità dei dati che stai acquisendo. 1. Confronto dei dati in due cartelle diverse: FileMatch può essere utilizzato per confrontare i file tra due cartelle. Questa regola include una metrica: il numero di file che sono stati scansionati dalla regola. ``` {"Dataset.*.FileCount":1} ``` **Convalidare i file con un checksum:** FileMatch accetta un file e un set di checksum per garantire che almeno un checksum corrisponda al file. ``` 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"] ``` Sono supportati i seguenti algoritmi standard: + MD5 + SHA-1 + SHA-256 Se non fornisci un algoritmo, quello predefinito è SHA-256. **Convalidare tutti i file in una cartella con un set di checksum:** ``` FileMatch "s3://amzn-s3-demo-bucket /" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5" FileMatch "s3://amzn-s3-demo-bucket /internal-folder/" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"] ``` **Confrontare i file in diverse cartelle** ``` # 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 controllerà il contenuto dei file `original_bucket` e si assicurerà che corrispondano a ciò che c'è dentro. `archive_bucket` Se non corrispondono esattamente, la regola non verrà applicata. Può anche verificare il contenuto delle cartelle interne o dei singoli file. FileMatch possono anche confrontare i singoli file l'uno con l'altro. ``` FileMatch "s3://amzn-s3-demo-bucket /file_old.json" "s3://amzn-s3-demo-bucket /file_new.json" ``` **Dedurre i nomi dei file direttamente dai data frame** Non è sempre necessario fornire un percorso del file. Ad esempio, quando crei la regola nel AWS Glue Data Catalog (supportato da Amazon S3), potrebbe essere difficile trovare le cartelle utilizzate dalle tabelle del catalogo. AWS Glue Data Quality può trovare le cartelle o i file specifici utilizzati per popolare il tuo frame di dati. **Nota** Questa funzione funziona solo quando i file vengono letti correttamente in sala operatoria DynamicFrame . DataFrame ``` FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5" FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-1" FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-256" FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] ``` Se il checksum fornito è diverso da quello calcolato, ti FileMatch avviserà della differenza. ![\[La schermata mostra una regola con lo stato DQ di Rule failed. FileMatch spiega l'errore.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/data-quality-file-match.png) **Tag delle regole opzionali basati su file:** I tag permettono di controllare il comportamento delle regole. **recentFiles** Questo tag limita il numero di file elaborati mantenendo il file più recente per primo. ``` FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1 ``` **uriRegex** **Nota** Il `uriRegex` tag è disponibile in AWS Glue 5.0 e versioni successive. Questo tag filtra i file applicando un pattern regex al percorso del file. Vengono elaborati solo i file i cui percorsi corrispondono al modello. Puoi anche usare un lookahead negativo per escludere i file che corrispondono a uno schema. ``` # 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$).*" ``` **Ordinamento del filtro** **Nota** Il `filterOrder` tag è disponibile in AWS Glue 5.0 e versioni successive. Quando si utilizzano più tag di filtro, `recentFiles` `uriRegex` singolarmente e contemporaneamente, il `filterOrder` tag controlla l'ordine in cui vengono applicati. L'ordine predefinito è quindi il `recentFiles` primo`uriRegex`. ``` FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1 with uriRegex = "\.json$" with filterOrder = ["uriRegex","recentFiles"] ``` **matchFileName** Questo tag garantisce che i file non abbiano nomi duplicati. Il comportamento predefinito è false. ``` FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac04179sam4713e5ef8f319"] with matchFileName = "true" ``` Occorre tenere presente alcuni aspetti: 1. In AWS Glue ETL, è necessario disporre di **EvaluateDataQuality**Transform subito dopo una trasformazione di Amazon S3 o AWS Glue Data Catalog. ![\[La schermata mostra una regola con lo stato DQ di Rule failed. FileMatch spiega l'errore.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/data-quality-file-match-transform.png) 1. Questa regola non funzionerà nelle sessioni interattive di AWS Glue. # FileUniqueness FileUniqueness consente di garantire che non vi siano file duplicati nei dati ricevuti dai produttori di dati. Raccoglie le seguenti statistiche sui dati: 1. Numero di file sottoposti a scansione dalla regola 1. Il livello di unicità dei file ``` Dataset.*.FileUniquenessRatio: 1.00, Dataset.*.FileCount: 8.00 ``` **Trovare file duplicati in una cartella:** ``` FileUniqueness "s3://bucket/" > 0.5 FileUniqueness "s3://bucket/folder/" = 1 ``` **Inferire i nomi delle cartelle direttamente dai data frame per rilevare i duplicati:** Non è sempre necessario fornire un percorso del file. Ad esempio, quando si crea la regola nel AWS Glue Data Catalog, potrebbe essere difficile trovare le cartelle utilizzate dalle tabelle del catalogo. AWS Glue Data Quality può trovare le cartelle o i file specifici utilizzati per popolare il tuo frame di dati. **Nota** Quando si utilizza l'inferenza, le regole basate su file possono rilevare solo i file letti correttamente in sala operatoria. DynamicFrame DataFrame ``` FileUniqueness > 0.5 ``` **Tag delle regole opzionali basati su file:** I tag permettono di controllare il comportamento delle regole. **recentFiles** Questo tag limita il numero di file elaborati mantenendo il file più recente per primo. ``` FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with recentFiles = 1 ``` **uriRegex** **Nota** Il `uriRegex` tag è disponibile in AWS Glue 5.0 e versioni successive. Questo tag filtra i file applicando un pattern regex al percorso del file. Vengono elaborati solo i file i cui percorsi corrispondono al modello. Puoi anche usare un lookahead negativo per escludere i file che corrispondono a uno schema. ``` # 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$).*" ``` **Ordinamento del filtro** **Nota** Il `filterOrder` tag è disponibile in AWS Glue 5.0 e versioni successive. Quando si utilizzano più tag di filtro, `recentFiles` `uriRegex` singolarmente e contemporaneamente, il `filterOrder` tag controlla l'ordine in cui vengono applicati. L'ordine predefinito è quindi il `recentFiles` primo`uriRegex`. ``` FileUniqueness "s3://bucket/" > 0.5 with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"] ``` **matchFileName** Questo tag garantisce che i file non abbiano nomi duplicati. Il comportamento predefinito è false. ``` FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with matchFileName = "true" ``` Occorre tenere presente alcuni aspetti: 1. In AWS Glue ETL, è necessario disporre di **EvaluateDataQuality**Transform subito dopo una trasformazione di Amazon S3 o AWS Glue Data Catalog. 1. Questa regola non funzionerà nelle sessioni interattive di AWS Glue. # FileSize Il FileSize tipo di regola consente di garantire che i file soddisfino determinati criteri di dimensione dei file. Ciò è utile nei seguenti casi d'uso: 1. Assicurarsi che i produttori non inviino file vuoti o di dimensioni notevolmente inferiori per l'elaborazione. 1. Assicurarsi che i bucket di destinazione non contengano file di dimensioni ridotte che potrebbero causare problemi di prestazioni. FileSize raccoglie le seguenti metriche: 1. Conformità: restituisce la percentuale di file che soddisfano la soglia della regola stabilita 1. Numero di file: numero dei file sottoposti a scansione dalla regola 1. Dimensione minima dei file in byte 1. Dimensione massima dei file in byte ``` Dataset.*.FileSize.Compliance: 1.00, Dataset.*.FileCount: 8.00, Dataset.*.MaximumFileSize: 327413121.00, Dataset.*.MinimumFileSize: 204558920.00 ``` Il rilevamento delle anomalie non è supportato per queste metriche. **Convalidare la dimensione dei file** Questa regola viene applicata quando file.dat è superiore a 2 MB. ``` FileSize "s3://amzn-s3-demo-bucket/file.dat" > 2 MB ``` Le unità supportate includono B (byte), MB (megabyte), GB (giga byte) e TB (terra byte). **Convalidare la dimensione dei file nelle cartelle** ``` FileSize "s3://bucket/" > 5 B FileSize "s3://bucket/" < 2 GB ``` Questa regola viene applicata se il 70% dei file in s3://amzn-s3-demo-bucket ha dimensioni comprese tra 2 GB e 1 TB. ``` FileSize "s3://amzn-s3-demo-bucket/" between 2 GB and 1 TB with threshold > 0.7 ``` **Dedurre i nomi dei file direttamente dai data frame** Non è sempre necessario fornire un percorso del file. Ad esempio, quando si crea la regola nel Data Catalog, può essere difficile individuare le cartelle utilizzate dalle tabelle del catalogo. AWS Glue Data Quality può trovare le cartelle o i file specifici utilizzati per popolare il tuo frame di dati. **Nota** Questa funzione funziona solo quando i file vengono letti correttamente in sala operatoria DynamicFrame . DataFrame ``` FileSize < 10 MB with threshold > 0.7 ``` **Tag delle regole opzionali basati su file:** I tag permettono di controllare il comportamento delle regole. **recentFiles** Questo tag limita il numero di file elaborati mantenendo il file più recente per primo. ``` FileSize "s3://amzn-s3-demo-bucket/" > 5 B with recentFiles = 1 ``` **uriRegex** **Nota** Il `uriRegex` tag è disponibile in AWS Glue 5.0 e versioni successive. Questo tag filtra i file applicando un pattern regex al percorso del file. Vengono elaborati solo i file i cui percorsi corrispondono al modello. Puoi anche usare un lookahead negativo per escludere i file che corrispondono a uno schema. ``` # 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$).*" ``` **Ordinamento del filtro** **Nota** Il `filterOrder` tag è disponibile in AWS Glue 5.0 e versioni successive. Quando si utilizzano più tag di filtro `uriRegex` contemporaneamente, il `filterOrder` tag controlla l'ordine in cui vengono applicati. `recentFiles` L'ordine predefinito è quindi il `recentFiles` primo`uriRegex`. ``` FileSize "s3://bucket/" > 5 B with recentFiles = 5 with uriRegex = "\.dat$" with filterOrder = ["uriRegex","recentFiles"] ``` **FailFast** Se impostata su`"true"`, la regola restituisce immediatamente l'errore sul primo file che non soddisfa la condizione di dimensione, anziché valutare tutti i file e calcolare un rapporto di conformità. ``` FileSize "s3://bucket/" > 2 MB with failFast = "true" ``` Occorre tenere presente alcuni aspetti: 1. In AWS Glue ETL, devi avere Evaluate DataQuality Transform subito dopo la trasformazione di Amazon S3 o Data Catalog. 1. Questa regola non funzionerà nelle sessioni interattive di AWS Glue.