Riferimento al linguaggio di definizione della qualità dei dati (DQDL)

Data Quality Definition Language (DQDL) è un linguaggio specifico del dominio utilizzato per definire le regole per AWS Glue Data Quality.

Questa guida introduce i DQDL concetti chiave per aiutarti a comprendere il linguaggio. Fornisce inoltre un riferimento per i tipi di DQDL regole con sintassi ed esempi. Prima di utilizzare questa guida, ti consigliamo di avere dimestichezza con AWS Glue Data Quality. Per ulteriori informazioni, consulta AWS Glue Qualità dei dati.

DQDLsintassi

Un DQDL documento fa distinzione tra maiuscole e minuscole e contiene un set di regole che raggruppa le singole regole di qualità dei dati. Per costruire un set di regole, è necessario creare un elenco denominato Rules (in maiuscolo), delimitato da una coppia di parentesi quadre. L'elenco deve contenere una o più DQDL regole separate da virgole come nell'esempio seguente.

Rules = [
   IsComplete "order-id",
   IsUnique "order-id"
]

Struttura delle regole

La struttura di una DQDL regola dipende dal tipo di regola. Tuttavia, DQDL le regole generalmente si adattano al formato seguente.

<RuleType> <Parameter> <Parameter> <Expression>

RuleType è il nome (sensibile al maiuscolo/minuscolo) del tipo di regola che si desidera configurare. Ad esempio, IsComplete, IsUnique o CustomSql. I parametri delle regole sono diversi per ogni tipo di regola. Per un riferimento completo dei tipi di DQDL regole e dei relativi parametri, vedereDQDLriferimento al tipo di regola.

Regole composite

È possibile utilizzare lo stesso operatore per connettere più regole, quindi la seguente combinazione di regole è consentita.

(Mean "Star_Rating" > 3) and (Mean "Order_Total" > 500) and (IsComplete "Order_Id")

Tuttavia, non è possibile combinare gli operatori logici in un'unica espressione. Ad esempio, la combinazione seguente non è consentita.

(Mean "Star_Rating" > 3) and (Mean "Order_Total" > 500) or (IsComplete "Order_Id")

Come funzionano le regole composite

Per impostazione predefinita, le regole composite vengono valutate come regole individuali nell'intero set di dati o nella tabella e quindi i risultati vengono combinati. In altre parole, valuta prima l'intera colonna e poi applica l'operatore. Questo comportamento predefinito è spiegato di seguito con un esempio:

# Dataset

+------+------+
|myCol1|myCol2|
+------+------+
|     2|     1|
|     0|     3|
+------+------+

# Overall outcome

+----------------------------------------------------------+-------+
|Rule                                                      |Outcome|
+----------------------------------------------------------+-------+
|(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)|Failed |
+----------------------------------------------------------+-------+
      

Nell'esempio precedente, valuta AWS Glue Data Quality (ColumnValues "myCol1" > 1) innanzitutto cosa comporterà un errore. Quindi valuterà anche (ColumnValues "myCol2" > 2) quale fallirà. La combinazione di entrambi i risultati verrà indicata comeFAILED.

Tuttavia, se si preferisce un comportamento SQL simile, in cui è necessario valutare l'intera riga, è necessario impostare esplicitamente il ruleEvaluation.scope parametro come mostrato additionalOptions nel frammento di codice riportato di seguito.

object GlueApp {
  val datasource = glueContext.getCatalogSource(
    database="<db>",
    tableName="<table>",
    transformationContext="datasource"
  ).getDynamicFrame()

  val ruleset = """
    Rules = [
        (ColumnValues "age" >= 26) OR (ColumnLength "name" >= 4)        
    ]
  """

  val dq_results = EvaluateDataQuality.processRows(
    frame=datasource,
    ruleset=ruleset,
    additionalOptions=JsonOptions("""
        {
          "compositeRuleEvaluation.method":"ROW"
        }
      """
    )
  )
}     
      

In AWS Glue Data Catalog, è possibile configurare facilmente questa opzione nell'interfaccia utente come illustrato di seguito.

Una volta impostate, le regole composite si comporteranno come un'unica regola che valuta l'intera riga. L'esempio seguente illustra questo comportamento.

# Row Level outcome

+------+------+------------------------------------------------------------+---------------------------+
|myCol1|myCol2|DataQualityRulesPass                                        |DataQualityEvaluationResult|
+------+------+------------------------------------------------------------+---------------------------+
|2     |1     |[(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)]|Passed                     |
|0     |3     |[(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)]|Passed                     |
+------+------+------------------------------------------------------------+---------------------------+     
      

Alcune regole non possono essere supportate in questa funzionalità perché il loro risultato complessivo si basa su soglie o rapporti. Sono elencate di seguito.

Regole basate sui rapporti:

Regole dipendenti dalle soglie:

Quando le seguenti regole includono una soglia, non sono supportate. Tuttavia, le regole che non lo prevedono with threshold rimangono supportate.

Espressioni

Se un tipo di regola non produce una risposta booleana, è necessario fornire un'espressione come parametro per creare una risposta booleana. Ad esempio, la regola seguente controlla la media di tutti i valori di una colonna rispetto a un'espressione per restituire un risultato vero o falso.

Mean "colA" between 80 and 100

Alcuni tipi di regole, ad esempio IsUnique e IsComplete, restituiscono già una risposta booleana.

Nella tabella seguente sono elencate le espressioni che è possibile utilizzare nelle DQDL regole.

Completeness "colA" = "1.0",
ColumnValues "colA" = "2022-06-30"

ColumnValues "colA" != "a",
ColumnValues "colA" != "2022-06-30"

ColumnValues "colA" > 10

ColumnValues "colA" < 1000,
ColumnValues "colA" < "2022-06-30"

ColumnValues "colA" >= 10

ColumnValues "colA" <= 1000

Mean "colA" between 8 and 100,
ColumnValues "colA" between "2022-05-31" and "2022-06-30"

ColumnValues "colA" not between "2022-05-31" and "2022-06-30"

ColumnValues "colA" in [ 1, 2, 3 ],
ColumnValues "colA" in [ "a", "b", "c" ]

ColumnValues "colA" not in [ 1, 2, 3 ],
ColumnValues "colA" not in [ "a", "b", "c" ]

ColumnValues "colA" matches "[a-zA-Z]*"

ColumnValues "colA" not matches "[a-zA-Z]*"

ColumnValues "load_date" > (now() - 3 days)

ColumnValues "colA" in ["A", "B"] with threshold > 0.8,
ColumnValues "colA" matches "[a-zA-Z]*" with threshold between 0.2 and 0.9
ColumnDataType "colA" = "Timestamp" with threshold > 0.9

Parole chiave perNULL, EMPTY e WHITESPACES _ ONLY

Se vuoi verificare se una colonna di stringhe ha un valore nullo, vuoto o una stringa con solo spazi bianchi, puoi usare le seguenti parole chiave:

Per un'espressione numerica o basata sulla data, se vuoi convalidare se una colonna ha un valore nullo, puoi usare le seguenti parole chiave.

Filtraggio con la clausola Where

È possibile filtrare i dati durante la creazione di regole. Ciò è utile quando si desidera applicare regole condizionali.

<DQDL Rule> where "<valid SparkSQL where clause> "

Il filtro deve essere specificato con la where parola chiave, seguita da un'SQListruzione Spark valida racchiusa tra virgolette. ("")

Se alla regola desideri aggiungere la clausola where a una regola con una soglia, la clausola where deve essere specificata prima della condizione di soglia.

<DQDL Rule> where "valid SparkSQL statement>" with threshold <threshold condition>
        

Con questa sintassi è possibile scrivere regole come le seguenti.

Completeness "colA" > 0.5 where "colB = 10"
ColumnValues "colB" in ["A", "B"] where "colC is not null" with threshold > 0.9
ColumnLength "colC" > 10 where "colD != Concat(colE, colF)"

Verificheremo che l'SQListruzione Spark fornita sia valida. Se non è valida, la valutazione della regola avrà esito negativo e lanceremo l'annuncio IllegalArgumentException con il seguente formato:

Rule <DQDL Rule> where "<invalid SparkSQL>" has provided an invalid where clause :
<SparkSQL Error>

Comportamento della clausola Where quando l'identificazione del record di errore a livello di riga è attivata

Con AWS Glue Data Quality, puoi identificare record specifici che hanno avuto esito negativo. Quando applichiamo una clausola where a regole che supportano i risultati a livello di riga, etichetteremo le righe filtrate dalla clausola where come. Passed

Se preferisci etichettare separatamente le righe filtrate comeSKIPPED, puoi impostare quanto segue additionalOptions per il lavoro. ETL

object GlueApp {
  val datasource = glueContext.getCatalogSource(
    database="<db>",
    tableName="<table>",
    transformationContext="datasource"
  ).getDynamicFrame()

  val ruleset = """
    Rules = [
       IsComplete "att2" where "att1 = 'a'"        
    ]
  """

  val dq_results = EvaluateDataQuality.processRows(
    frame=datasource,
    ruleset=ruleset,
    additionalOptions=JsonOptions("""
        {
          "rowLevelConfiguration.filteredRowLabel":"SKIPPED"
        }
      """
    )
  )
}

Ad esempio, fai riferimento alla regola e al dataframe seguenti:

IsComplete att2 where "att1 = 'a'"

Regole dinamiche

Ora puoi creare regole dinamiche per confrontare le metriche correnti prodotte dalle tue regole con i relativi valori storici. Questi confronti storici sono abilitati utilizzando l'operatore last() nelle espressioni. Ad esempio, la regola RowCount > last() avrà esito positivo se il numero di righe nell'esecuzione corrente è maggiore del conteggio precedente più recente delle righe per lo stesso set di dati. last() utilizza un argomento facoltativo relativo ai numeri naturali che descrive il numero di metriche precedenti da prendere in considerazione; last(k) dove k >= 1 farà riferimento alle ultime k metriche.

Utilizza last(k) per formare espressioni valide, dove k > 1 richiede una funzione di aggregazione per ridurre più risultati storici a un unico numero. Ad esempio, RowCount > avg(last(5)) controllerà se il conteggio delle righe del set di dati corrente è strettamente maggiore della media dei conteggi delle ultime cinque righe per lo stesso set di dati. RowCount > last(5) produrrà un errore perché il conteggio delle righe del set di dati corrente non può essere confrontato in modo significativo con un elenco.

Funzioni di aggregazione supportate:

Espressioni di esempio

ColumnCorrelation

DistinctValuesCount

La maggior parte dei tipi di regole con condizioni o soglie numeriche supporta regole dinamiche; consulta la tabella fornita, Analizzatori e regole, per determinare se le regole dinamiche sono supportate per il tuo tipo di regola.

Analizzatori

DQDLle regole utilizzano funzioni chiamate analizzatori per raccogliere informazioni sui dati. Queste informazioni vengono utilizzate dall'espressione booleana di una regola per determinare se quest'ultima deve avere esito positivo o negativo. Ad esempio, la RowCount regola RowCount > 5 utilizzerà un analizzatore del conteggio delle righe per scoprire il numero di righe nel set di dati e confronterà tale conteggio con l'espressione > 5 per verificare se nel set di dati corrente esistono più di cinque righe.

A volte, invece di creare regole, consigliamo di creare analizzatori e fare in modo che generino statistiche da utilizzare per rilevare anomalie. In questi casi, puoi creare analizzatori. Gli analizzatori differiscono dalle regole nei modi indicati di seguito.

Gli analizzatori possono esistere indipendentemente senza regole, quindi puoi configurarli in modo rapido e creare regole di qualità dei dati in modo progressivo.

Alcuni tipi di regole possono essere inseriti nel blocco Analyzers del set di regole per eseguire quelle richieste per gli analizzatori e raccogliere informazioni senza applicare controlli per alcuna condizione. Esistono analizzatori che non sono associati ad alcuna regola e che possono essere inseriti solo nel blocco Analyzers. La tabella seguente indica se ogni elemento è supportato come regola o come analizzatore autonomo, insieme a dettagli aggiuntivi per ogni tipo di regola.

Esempio di set di regole con Analyzer

Il seguente set di regole utilizza:

I risultati delle metriche dell'analizzatore per l'esecuzione del processo possono essere visualizzati nella scheda Qualità dei dati.

Rules = [
   RowCount > avg(last(3))
]
Analyzers = [
   DistinctValuesCount "Name",
   ColumnLength "Name"
]     
        

AWS Glue Data Quality supporta i seguenti analizzatori.

Commenti

Puoi usare il carattere '#' per aggiungere un commento al DQDL documento. Qualsiasi cosa dopo il carattere '#' e fino alla fine della riga viene ignorata daDQDL.

Rules = [
    # More items should generally mean a higher price, so correlation should be positive
    ColumnCorrelation "price" "num_items" > 0
]