Referência de Data Quality Definition Language (DQDL)

A Data Quality Definition Language (DQDL) é uma linguagem específica de domínio que você usa para definir regras para o AWS Glue Data Quality.

Este guia apresenta os principais conceitos de DQDL para ajudar você a entender a linguagem. Ele também fornece uma referência para tipos de regras DQDL com sintaxe e exemplos. Antes de usar este guia, recomendamos que você se familiarize com o AWS Glue Data Quality. Para ter mais informações, consulte AWS Glue Qualidade de dados.

nota

DynamicRules só são compatíveis com AWS Glue ETL.

Sumário

• Sintaxe DQDL
  • Estrutura da regra
  • Regras compostas
    • Como as regras compostas funcionam
  • Expressões
    • Palavras-chave para NULL, EMPTY e WHITESPACES_ONLY
    • Filtrando com a cláusula Where
  • Regras dinâmicas
  • Analisadores
  • Comentários
• Referência de tipos de regra DQDL
  • AggregateMatch
  • ColumnCorrelation
  • ColumnCount
  • ColumnDataType
  • ColumnExists
  • ColumnLength
  • ColumnNamesMatchPattern
  • ColumnValues
  • Completeness
  • CustomSQL
  • DataFreshness
  • DatasetMatch
  • DistinctValuesCount
  • Entropia
  • IsComplete
  • IsPrimaryKey
  • IsUnique
  • Média
  • ReferentialIntegrity
  • RowCount
  • RowCountMatch
  • StandardDeviation
  • Sum
  • SchemaMatch
  • Exclusividade
  • UniqueValueRatio
  • DetectAnomalies

Sintaxe DQDL

Um documento DQDL diferencia maiúsculas de minúsculas e contém um conjunto de regras que agrupa regras individuais de qualidade de dados. Para estruturar um conjunto de regras, você deve criar uma lista denominada Rules (em maiúsculas), delimitada por colchetes. A lista deve conter uma ou mais regras DQDL separadas por vírgula, como no exemplo a seguir.

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

Estrutura da regra

A estrutura de uma regra DQDL depende do tipo de regra. No entanto, as regras DQDL geralmente se encaixam no formato a seguir.

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

RuleType é o nome com distinção entre maiúsculas e minúsculas do tipo de regra que você quer configurar. Por exemplo, IsComplete, IsUnique ou CustomSql. Os parâmetros da regra diferem para cada tipo de regra. Para obter uma referência completa dos tipos de regras DQDL e seus parâmetros, consulte Referência de tipos de regra DQDL.

Regras compostas

A DQDL é compatível com os seguintes operadores lógicos que você pode usar para combinar regras. Essas regras são chamadas de regras compostas.

e

O operador lógico and resultará em true se, e somente se, as regras que ele conecta forem true. Caso contrário, a regra combinada resultará em false. Cada regra que você conecta com o operador and deve estar entre parênteses.

O exemplo a seguir usa o operador and para combinar duas regras DQDL.

(IsComplete "id") and (IsUnique "id")

or

O operador lógico or resultará em true se, e somente se, uma ou mais regras que ele conecta forem true. Cada regra que você conecta com o operador or deve estar entre parênteses.

O exemplo a seguir usa o operador or para combinar duas regras DQDL.

(RowCount "id" > 100) or (IsPrimaryKey "id")

Você pode usar o mesmo operador para conectar várias regras, portanto, a combinação de regras a seguir é permitida.

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

Porém, você não pode combinar os operadores lógicos em uma única expressão. Por exemplo, a operação a seguir não é permitida.

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

Como as regras compostas funcionam

Por padrão, as regras compostas são avaliadas como regras individuais em todo o conjunto de dados ou tabela e, em seguida, os resultados são combinados. Em outras palavras, a coluna inteira é avaliada primeiro e, em seguida, o operador é aplicado. Esse comportamento padrão é explicado abaixo com um exemplo:

# Dataset

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

# Overall outcome

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

No exemplo acima, o AWS Glue Data Quality avalia primeiro (ColumnValues "myCol1" > 1), o que resultará em uma falha. Em seguida, ele avaliará (ColumnValues "myCol2" > 2), que também falhará. A combinação de ambos os resultados será anotada como FALHA.

No entanto, se você preferir um comportamento semelhante ao SQL, em que a linha inteira deve ser avaliada, é necessário definir explicitamente o parâmetro ruleEvaluation.scope conforme mostrado em additionalOptions no trecho de código abaixo.

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"
        }
      """
    )
  )
}     
      

No AWS Glue Studio e no AWS Glue Data Catalog, você pode facilmente configurar essa opção na interface do usuário, conforme mostrado abaixo.

Depois de definidas, as regras compostas se comportarão como uma única regra avaliando a linha inteira. O exemplo a seguir ilustra esse 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                     |
+------+------+------------------------------------------------------------+---------------------------+     
      

Algumas regras não podem ser aceitas nesse recurso porque seu resultado geral depende de limites ou proporções. Elas estão listadas abaixo.

Regras baseadas em índices:

• Completeness

• DatasetMatch

• ReferentialIntegrity

• Exclusividade

Regras dependentes de limites:

Quando as regras a seguir incluem limites, elas não são aceitas. No entanto, as regras que não envolvem with threshold permanecem válidas.

• ColumnDataType

• ColumnValues

• CustomSQL

Expressões

Se um tipo de regra não produzir uma resposta booliana, você deverá fornecer uma expressão como parâmetro para criar uma resposta booliana. Por exemplo, a regra a seguir verifica a média de todos os valores em uma coluna em relação a uma expressão para retornar um resultado verdadeiro ou falso.

Mean "colA" between 80 and 100

Alguns tipos de regras, como IsUnique e IsComplete já retornam uma resposta booleana.

A tabela a seguir lista as expressões que você pode usar nas regras DQDL.

Expressões DQDL compatíveis
Expressão	Descrição	Exemplo
= x	Será resolvido como true se a resposta do tipo de regra for igual a x.	Completeness "colA" = "1.0", ColumnValues "colA" = "2022-06-30"
!=x	x será resolvido como verdadeiro se a resposta do tipo de regra for diferente de x.	ColumnValues "colA" != "a", ColumnValues "colA" != "2022-06-30"
> x	Será resolvido como true se a resposta do tipo de regra for maior que x.	ColumnValues "colA" > 10
< x	Será resolvido como true se a resposta do tipo de regra for menor que x.	ColumnValues "colA" < 1000, ColumnValues "colA" < "2022-06-30"
>= x	Será resolvido como true se a resposta do tipo de regra for maior que ou igual a x.	ColumnValues "colA" >= 10
<= x	Será resolvido como true se a resposta do tipo de regra for menor que ou igual a x.	ColumnValues "colA" <= 1000
between x and y	Será resolvido como true se a resposta do tipo de regra estiver em um intervalo especificado (exclusivo). Use esse tipo de expressão apenas para tipos numéricos e de data.	Mean "colA" between 8 and 100, ColumnValues "colA" between "2022-05-31" and "2022-06-30"
not between x and y	Será resolvido como verdadeiro se a resposta do tipo de regra não estiver em um intervalo especificado (inclusive). Você só deve usar esse tipo de expressão para tipos numéricos e dados.	ColumnValues "colA" not between "2022-05-31" and "2022-06-30"
in [a, b, c,... ]	Será resolvido para true se a resposta do tipo de regra está no conjunto especificado.	ColumnValues "colA" in [ 1, 2, 3 ], ColumnValues "colA" in [ "a", "b", "c" ]
not in [a, b, c, ...]	Será resolvido para true se a resposta do tipo de regra não estiver no conjunto especificado.	ColumnValues "colA" not in [ 1, 2, 3 ], ColumnValues "colA" not in [ "a", "b", "c" ]
matches /ab+c/i	Será resolvido como true se a resposta do tipo de regra corresponder a uma expressão regular.	ColumnValues "colA" matches "[a-zA-Z]*"
not matches /ab+c/i	Resolve para true se a resposta do tipo de regra não corresponder a uma expressão regular.	ColumnValues "colA" not matches "[a-zA-Z]*"
now()	Só funciona com o tipo de regra ColumnValues para criar uma expressão de data.	ColumnValues "load_date" > (now() - 3 days)
matches/in […]/not matches/not in [...] with threshold	Especifica a porcentagem de valores que correspondem às condições da regra. Funciona somente com os tipos de regras ColumnValues, ColumnDataType e CustomSQL.	ColumnValues "colA" in ["A", "B"] with threshold > 0.8, ColumnValues "colA" matches "[a-zA-Z]*" with threshold between 0.2 and 0.9 ColumnDataType "colA" = "Timestamp" with threshold > 0.9

Palavras-chave para NULL, EMPTY e WHITESPACES_ONLY

Se desejar validar se uma coluna de string tem uma string nula, vazia ou apenas com espaços em branco, você pode usar as seguintes palavras-chave:

• NULL/null: Essa palavra-chave é resolvida como verdadeira para um valor null em uma coluna de string.

  ColumnValues "colA" != NULL with threshold > 0.5 retornaria verdadeiro se mais de 50% dos seus dados não tivessem valores nulos.

  (ColumnValues "colA" = NULL) or (ColumnLength "colA" > 5) retornaria verdadeiro para todas as linhas que têm um valor nulo ou comprimento > 5. Observe que isso exigirá o uso da opção “compositeRuleEvaluation.method” = “ROW”.

• EMPTY/empty: essa palavra-chave é resolvida como verdadeira para um valor de string vazio ("") em uma coluna de string. Alguns formatos de dados transformam nulos em uma coluna de string para strings vazias. Essa palavra-chave ajuda a filtrar strings vazias em seus dados.

  (ColumnValues "colA" = EMPTY) or (ColumnValues "colA" in ["a", "b"]) retornaria verdadeiro se uma linha estivesse vazia, "a" ou "b". Observe que isso requer o uso da opção “compositeRuleEvaluation.method” = “ROW”.

• WHITESPACES_ONLY/whitespaces_only: essa palavra-chave é resolvida como verdadeira para uma string somente com espaços em branco (" ") em uma coluna de string.

  ColumnValues "colA" not in ["a", "b", WHITESPACES_ONLY] retornaria verdadeiro se uma linha não fosse "a" ou "b" nem apenas espaços em branco.

  Regras compatíveis:

  • ColumnValues

Para uma expressão numérica ou baseada em data, se você quiser validar se uma coluna tem um valor nulo, poderá usar as palavras-chave a seguir.

• NULL/null: Essa palavra-chave é resolvida como verdadeira para um valor nulo em uma coluna de string.

  ColumnValues "colA" in [NULL, "2023-01-01"] retornaria verdadeiro se as datas em sua coluna fossem iguais a 2023-01-01 ou nulas.

  (ColumnValues "colA" = NULL) or (ColumnValues "colA" between 1 and 9) retornaria verdadeiro para todas as linhas que têm um valor nulo ou valores entre 1 e 9. Observe que isso exigirá o uso da opção “compositeRuleEvaluation.method” = “ROW”.

  Regras compatíveis:

  • ColumnValues

Filtrando com a cláusula Where

Você pode filtrar seus dados ao criar regras. Isso é útil quando você deseja aplicar regras condicionais.

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

O filtro deve ser especificado com a where palavra-chave, seguida por uma instrução SparkSQL válida entre aspas. ("")

Se você quiser adicionar a cláusula where a uma regra com um limite, a cláusula where deverá ser especificada antes da condição de limite.

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

Com essa sintaxe, você pode escrever regras como as seguintes.

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)"

Vamos validar se a instrução SparkSQL fornecida é válida. Se for inválida, a avaliação da regra falhará e lançaremos o an IllegalArgumentException com o seguinte formato:

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

Comportamento da cláusula Where quando a identificação do registro de erro em nível de linha está ativada

Com o AWS Glue Data Quality, você pode identificar registros específicos que falharam. Ao aplicar uma cláusula where às regras que oferecem suporte a resultados em nível de linha, rotularemos as linhas que são filtradas pela cláusula where como. Passed

Se você preferir rotular separadamente as linhas filtradas comoSKIPPED, defina o seguinte additionalOptions para a tarefa de 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"
        }
      """
    )
  )
}

Como exemplo, consulte a regra e o quadro de dados a seguir:

IsComplete att2 where "att1 = 'a'"

id	em 1	em 2	Resultados em nível de linha (padrão)	Resultados em nível de linha (opção ignorada)	Comentários
1	a	f	PASSARAM	PASSARAM
2	b	d	PASSARAM	SKIPPED	A linha é filtrada, pois att1 não é "a"
3	a	nulo	COM FALHA	COM FALHA
4	a	f	PASSARAM	PASSARAM
5	b	nulo	PASSARAM	SKIPPED	A linha é filtrada, pois att1 não é "a"
6	a	f	PASSARAM	PASSARAM

Regras dinâmicas

Agora é possível criar regras dinâmicas para comparar as métricas atuais produzidas por suas regras com seus valores históricos. Essas comparações históricas são habilitadas ao usar o operador last() em expressões. Por exemplo, a regra RowCount > last() terá êxito quando o número de linhas na execução atual for maior do que a contagem de linhas anterior mais recente para o mesmo conjunto de dados. last() usa um argumento opcional de número natural que descreve quantas métricas anteriores devem ser consideradas; last(k) em que k >= 1 fará referência às últimas k métricas.

• Se nenhum ponto de dados estiver disponível, last(k) retornará o valor padrão 0,0.

• Se menos de k métricas estiverem disponíveis, last(k) retornará todas as métricas anteriores.

Para formar expressões válidas, use last(k), em que k > 1 requer uma função de agregação para reduzir vários resultados históricos a um único número. Por exemplo, RowCount > avg(last(5)) verificará se a contagem de linhas do conjunto de dados atual é estritamente maior do que a média das últimas cinco contagens de linhas do mesmo conjunto de dados. RowCount > last(5) produzirá um erro porque a contagem de linhas do conjunto de dados atual não pode ser comparada de forma significativa a uma lista.

Funções de agregação compatíveis:

• avg

• median

• max

• min

• sum

• std (desvio padrão)

• abs (valor absoluto)

• index(last(k), i) permitirá selecionar o i valor mais recente entre os últimos k. i é indexado em zero, então index(last(3), 0) retornará o ponto de dados mais recente e index(last(3), 3) resultará em um erro, pois há apenas três pontos de dados e tentamos indexar o 4.º mais recente.

Exemplos de expressões

ColumnCorrelation

• ColumnCorrelation "colA" "colB" < avg(last(10))

DistinctValuesCount

• DistinctValuesCount "colA" between min(last(10))-1 and max(last(10))+1

A maioria dos tipos de regras com condições ou limites numéricos é compatível com as regras dinâmicas. Consulte a tabela fornecida, Analisadores e regras, para determinar se as regras dinâmicas são compatíveis com seu tipo de regra.

Analisadores

nota

Os analisadores não são compatíveis com o AWS Glue Data Catalog.

As regras de DQDL usam funções chamadas analisadores para coletar informações sobre seus dados. Essas informações são empregadas por uma expressão booleana da regra para determinar se a regra terá êxito ou não. Por exemplo, a RowCount regra RowCount > 5 usará um analisador de contagem de linhas para descobrir o número de linhas em seu conjunto de dados e comparar essa contagem com a expressão > 5 para verificar se existem mais de cinco linhas no conjunto de dados atual.

Às vezes, em vez de criar regras, recomendamos criar analisadores e depois fazer com que eles gerem estatísticas que possam ser usadas para detectar anomalias. Para esses casos, será necessário criar analisadores. Os analisadores diferem das regras nas seguintes maneiras:

Característica	Analisadores	Regras
Parte do conjunto de regras	Sim	Sim
Gera estatísticas	Sim	Sim
Gera observações	Sim	Sim
Pode avaliar e afirmar uma condição	Não	Sim
É possível configurar ações, como interromper os trabalhos em caso de falha ou continuar o processamento do trabalho	Não	Sim

Os analisadores podem existir de forma independente, sem a necessidade de regras, permitindo a configuração rápida e a construção progressiva de regras de qualidade de dados.

Alguns tipos de regras podem ser inseridos no bloco de Analyzers do seu conjunto de regras para executar as regras necessárias para os analisadores e coletar informações sem aplicar verificações para nenhuma condição. Alguns analisadores não estão associados a regras e só podem ser inseridos no bloco de Analyzers. A tabela a seguir indica se cada item é compatível como uma regra ou como um analisador independente, junto com detalhes adicionais para cada tipo de regra.

Exemplo de conjunto de regras com o analisador

O seguinte conjunto de regras usa:

• uma regra dinâmica para verificar se um conjunto de dados está crescendo acima da média final nas últimas três execuções de trabalho;

• um analisador de DistinctValuesCount para registrar o número de valores distintos na coluna Name do conjunto de dados;

• um analisador de ColumnLength para rastrear o tamanho mínimo e máximo de Name ao longo do tempo.

Os resultados das métricas do analisador podem ser visualizados na guia Data Quality da execução do trabalho.

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

Comentários

É possível usar o caractere "#" para adicionar um comentário ao seu documento DQDL. Qualquer coisa após o caractere "#" e até o final da linha é ignorada pelo DQDL.

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

Referência de tipos de regra DQDL

Esta seção fornece uma referência para cada tipo de regra compatível com o AWS Glue Data Quality.

nota

• Atualmente, o DQDL não é compatível com dados de colunas aninhadas ou do tipo lista.

• Os valores entre colchetes na tabela abaixo serão substituídos pelas informações fornecidas nos argumentos da regra.

• As regras normalmente exigem um argumento adicional para expressão.

Ruletype	Descrição	Argumentos	Métricas reportadas	Compatível como regra?	Compatível como analisador?	Retorna resultados em nível de linha?	Compatível com regras dinâmicas?	Gera observações	Suporta a sintaxe da cláusula Where?
AggregateMatch	Verifica se há correspondência entre dois conjuntos de dados comparando as métricas resumidas, como o valor total das vendas. Útil para instituições financeiras compararem se todos os dados são ingeridos dos sistemas de origem.	Uma ou mais agregações	Quando os nomes da primeira e da segunda coluna de agregação coincidem: Column.[Column].AggregateMatch Quando os nomes da primeira e da segunda coluna de agregação divergem: Column.[Column1,Column2].AggregateMatch	Sim	Não	Não	Não	Não	Não
AllStatistics	Analisador independente para coletar diversas métricas para a coluna fornecida ou para todas as colunas de um conjunto de dados.	Um único nome de coluna, OU "AllColumns”	Para as colunas de todos os tipos: Dataset.*.RowCount Column.[Column].Completeness Column.[Column].Uniqueness Métricas adicionais para colunas com valor de string: ColumnLength metrics Métricas adicionais para colunas com valor numérico: ColumnValues metrics	Não	Sim	Não	Não	Não	Não
ColumnCorrelation	Verifica em que medida duas colunas estão correlacionadas.	Exatamente dois nomes de coluna	Multicolumn.[Column1],[Column2].ColumnCorrelation	Sim	Sim	Não	Sim	Não	Sim
ColumnCount	Verifica se alguma coluna foi descartada.	Nenhum	Dataset.*.ColumnCount	Sim	Não	Não	Sim	Sim	Não
ColumnDataType	Verifica se uma coluna é compatível com um tipo de dados.	Exatamente um nome de coluna	Column.[Column].ColumnDataType.Compliance	Sim	Não	Não	Sim, na expressão de limite em nível de linha	Não	Sim
ColumnExists	Verifica se existem colunas em um conjunto de dados. Isso permite que os clientes criem plataformas de dados de autoatendimento para garantir que determinadas colunas sejam disponibilizadas.	Exatamente um nome de coluna	N/D	Sim	Não	Não	Não	Não	Não
ColumnLength	Verifica se o comprimento dos dados é consistente.	Exatamente um nome de coluna	Column.[Column].MaximumLength Column.[Column].MinimumLength Métrica adicional quando o limite de nível de linha é fornecido: Column.[Column].ColumnValues.Compliance	Sim	Sim	Sim, quando o limite de nível de linha é fornecido	Não	Sim. Gera apenas observações ao analisar o comprimento mínimo e máximo	Sim
ColumnNamesMatchPattern	Verifica se os nomes das colunas correspondem a padrões definidos. Útil para equipes de governança imporem consistência nos nomes das colunas.	Um regex para nomes de colunas	Dataset.*.ColumnNamesPatternMatchRatio	Sim	Não	Não	Não	Não	Não
ColumnValues	Verifica se os dados são consistentes de acordo com os valores definidos. Essa regra é compatível com expressões regulares.	Exatamente um nome de coluna	Column.[Column].Maximum Column.[Column].Minimum Métrica adicional quando o limite de nível de linha é fornecido: Column.[Column].ColumnValues.Compliance	Sim	Sim	Sim, quando o limite de nível de linha é fornecido	Não	Sim. Gera apenas observações ao analisar valores mínimos e máximos	Sim
Completeness	Verifica se há espaços em branco ou nulos nos dados.	Exatamente um nome de coluna	Column.[Column].Completeness	Sim	Sim	Sim	Sim	Sim	Sim
CustomSql	Os clientes podem implementar praticamente qualquer tipo de verificação de qualidade de dados em SQL.	Uma instrução SQL (Opcional) Um limite em nível de linha	Dataset.*.CustomSQL Métrica adicional quando o limite de nível de linha é fornecido: Dataset.*.CustomSQL.Compliance	Sim	Não	Sim, quando o limite de nível de linha é fornecido	Sim	Não	Não
DataFreshness	Verifica se os dados estão atualizados.	Exatamente um nome de coluna	Column.[Column].DataFreshness.Compliance	Sim	Não	Sim	Não	Não	Sim
DatasetMatch	Compara dois conjuntos de dados e identifica se eles estão sincronizados.	Nome de um conjunto de dados de referência Um mapeamento de colunas (Opcional) Colunas para verificar as correspondências	Dataset.[ReferenceDatasetAlias].DatasetMatch	Sim	Não	Sim	Sim	Não	Não
DistinctValuesCount	Verifica a existência de valores duplicados.	Exatamente um nome de coluna	Column.[Column].DistinctValuesCount	Sim	Sim	Sim	Sim	Sim	Sim
DetectAnomalies	Verifica anomalias nas métricas relatadas de outro tipo de regra.	Um tipo de regra	Métricas relatadas pelo argumento do tipo de regra	Sim	Não	Não	Não	Não	Não
Entropia	Verifica a entropia dos dados.	Exatamente um nome de coluna	Column.[Column].Entropy	Sim	Sim	Não	Sim	Não	Sim
IsComplete	Verifica se 100% dos dados estão completos.	Exatamente um nome de coluna	Column.[Column].Completeness	Sim	Não	Sim	Não	Não	Sim
IsPrimaryKey	Verifica se uma coluna é uma chave primária (não NULA e exclusiva).	Exatamente um nome de coluna	Para colunas únicas: Column.[Column].Uniqueness Para várias colunas: Multicolumn[CommaDelimitedColumns].Uniqueness	Sim	Não	Sim	Não	Não	Sim
IsUnique	Verifica se 100% dos dados estão exclusivos.	Exatamente um nome de coluna	Column.[Column].Uniqueness	Sim	Não	Sim	Não	Não	Sim
Média	Verifica se a média atende ao limite definido.	Exatamente um nome de coluna	Column.[Column].Mean	Sim	Sim	Sim	Sim	Não	Sim
ReferentialIntegrity	Verifica se dois conjuntos de dados têm integridade referencial.	Um ou mais nomes de coluna do conjunto de dados Um ou mais nomes de coluna do conjunto de dados de referência	Column.[ReferenceDatasetAlias].ReferentialIntegrity	Sim	Não	Sim	Sim	Não	Não
RowCount	Verifica se a contagem de registros atende a um limite.	Nenhum	Dataset.*.RowCount	Sim	Sim	Não	Sim	Sim	Sim
RowCountMatch	Verifica se há correspondência nas contagens de registros entre dois conjuntos de dados.	Alias do conjunto de dados de referência	Dataset.[ReferenceDatasetAlias].RowCountMatch	Sim	Não	Não	Sim	Não	Não
StandardDeviation	Verifica se o desvio padrão atende ao limite.	Exatamente um nome de coluna	Column.[Column].StandardDeviation	Sim	Sim	Sim	Sim	Não	Sim
SchemaMatch	Verifica se há correspondência de esquema entre dois conjuntos de dados.	Alias do conjunto de dados de referência	Dataset.[ReferenceDatasetAlias].SchemaMatch	Sim	Não	Não	Sim	Não	Não
Soma	Verifica se a soma atende ao limite definido.	Exatamente um nome de coluna	Column.[Column].Sum	Sim	Sim	Não	Sim	Não	Sim
Exclusividade	Verifica se a exclusividade do conjunto de dados atende ao limite.	Exatamente um nome de coluna	Column.[Column].Uniqueness	Sim	Sim	Sim	Sim	Não	Sim
UniqueValueRatio	Verifica se a razão de valores exclusivos atende ao limite.	Exatamente um nome de coluna	Column.[Column].UniqueValueRatio	Sim	Sim	Sim	Sim	Não	Sim

Tópicos

• AggregateMatch
• ColumnCorrelation
• ColumnCount
• ColumnDataType
• ColumnExists
• ColumnLength
• ColumnNamesMatchPattern
• ColumnValues
• Completeness
• CustomSQL
• DataFreshness
• DatasetMatch
• DistinctValuesCount
• Entropia
• IsComplete
• IsPrimaryKey
• IsUnique
• Média
• ReferentialIntegrity
• RowCount
• RowCountMatch
• StandardDeviation
• Sum
• SchemaMatch
• Exclusividade
• UniqueValueRatio
• DetectAnomalies

AggregateMatch

Verifica a razão de agregações de duas colunas em relação a uma dada expressão. Esse tipo de regra funciona em vários conjuntos de dados. As agregações de duas colunas são avaliadas e uma razão é produzida dividindo o resultado da agregação da primeira coluna pelo resultado da agregação da segunda coluna. A razão é verificada em relação à expressão fornecida para produzir uma resposta booleana.

Sintaxe

Agregação de colunas

ColumnExists <AGG_OPERATION> (<OPTIONAL_REFERENCE_ALIAS>.<COL_NAME>)

• AGG_OPERATION: a operação a ser usada para a agregação. No momento, sum e avg são compatíveis.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• OPTIONAL_REFERENCE_ALIAS: esse parâmetro precisa ser fornecido se a coluna for de um conjunto de dados de referência e não do conjunto de dados primário. <database_name>Se você estiver usando essa regra no AWS Glue Data Catalog, seu alias de referência deverá seguir o formato ". <table_name>. <column_name>

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• COL_NAME: o nome da coluna a ser agregada.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

Exemplo: média

"avg(rating)"

Exemplo: soma

"sum(amount)"

Exemplo: média da coluna no conjunto de dados de referência

"avg(reference.rating)"

Regra

AggregateMatch <AGG_EXP_1> <AGG_EXP_2> <EXPRESSION>

• AGG_EXP_1: a agregação da primeira coluna.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• AGG_EXP_2: a agregação da segunda coluna.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: Aggregate Match usando soma

O exemplo de regra a seguir verifica se a soma dos valores na coluna amount é exatamente igual à soma dos valores na coluna total_amount.

AggregateMatch "sum(amount)" "sum(total_amount)" = 1.0

Exemplo: Aggregate Match usando média

O exemplo de regra a seguir verifica se a média dos valores na coluna ratings é igual a pelo menos 90% da média dos valores na coluna ratings no conjunto de dados reference. O conjunto de dados de referência é fornecido como uma fonte de dados adicional na experiência de ETL ou do catálogo de dados.

No AWS Glue ETL, você pode usar:

AggregateMatch "avg(ratings)" "avg(reference.ratings)" >= 0.9

No AWS Glue Data Catalog, você pode usar:

AggregateMatch "avg(ratings)" "avg(database_name.tablename.ratings)" >= 0.9

Comportamento nulo

A AggregateMatch regra ignorará as linhas com valores NULL no cálculo dos métodos de agregação (soma/média). Por exemplo: .

+---+-----------+
|id |units      |
+---+-----------+
|100|0          | 
|101|null       |
|102|20         |
|103|null       |
|104|40         |
+---+-----------+

A média da coluna units será (0 + 20 + 40)/3 = 20. As linhas 101 e 103 não são consideradas nesse cálculo.

ColumnCorrelation

Verifica a correlação entre duas colunas em relação a uma determinada expressão. AWS O Glue Data Quality usa o coeficiente de correlação de Pearson para medir a correlação linear entre duas colunas. O resultado é um número entre -1 e 1 que mede a força e a direção da relacão.

Sintaxe

ColumnCorrelation <COL_1_NAME> <COL_2_NAME> <EXPRESSION>

• COL_1_NAME: o nome da primeira coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• COL_2_NAME: o nome da segunda coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: correlação de colunas

O exemplo de regra a seguir verifica se o coeficiente de correlação entre as colunas height e weight tem uma correlação positiva forte (um valor de coeficiente maior que 0,8).

ColumnCorrelation "height" "weight" > 0.8

ColumnCorrelation "weightinkgs" "Salary" > 0.8 where "weightinkgs > 40"

Exemplos de regras dinâmicas

• ColumnCorrelation "colA" "colB" between min(last(10)) and max(last(10))

• ColumnCorrelation "colA" "colB" < avg(last(5)) + std(last(5))

Comportamento nulo

A ColumnCorrelation regra ignorará linhas com valores NULL no cálculo da correlação. Por exemplo: .

+---+-----------+
|id |units      |
+---+-----------+
|100|0          | 
|101|null       |
|102|20         |
|103|null       |
|104|40         |
+---+-----------+

As linhas 101 e 103 serão ignoradas e ColumnCorrelation será 1.0.

ColumnCount

Verifica a contagem de colunas de um conjunto de dados primário em relação a uma expressão dada. Na expressão, você pode especificar o número de colunas ou um intervalo de colunas usando operadores como > e <.

Sintaxe

ColumnCount <EXPRESSION>

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: verificação numérica da contagem de colunas

O exemplo de regra a seguir verifica se a contagem de colunas está dentro de um dado intervalo.

ColumnCount between 10 and 20

Exemplos de regras dinâmicas

• ColumnCount >= avg(last(10))

• ColumnCount between min(last(10))-1 and max(last(10))+1

ColumnDataType

Verifica o tipo de dados inerente dos valores em uma dada coluna em relação ao tipo esperado fornecido. Aceita uma expressão with threshold para verificar um subconjunto dos valores da coluna.

Sintaxe

ColumnDataType <COL_NAME> = <EXPECTED_TYPE>
	  ColumnDataType <COL_NAME> = <EXPECTED_TYPE> with threshold <EXPRESSION>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: string

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• EXPECTED_TYPE: o tipo esperado dos valores da coluna.

  Valores compatíveis: booleano, data, timestamp, inteiro, duplo, flutuante, longo

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• EXPRESSION: uma expressão opcional para especificar a porcentagem de valores que devem ser do tipo esperado.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

Exemplo: números inteiros do tipo de dados da coluna como strings

O exemplo de regra a seguir verifica se os valores da coluna da, que é do tipo string, são, na verdade, números inteiros.

ColumnDataType "colA" = "INTEGER"

Exemplo: números inteiros do tipo de dados da coluna como strings verificam um subconjunto dos valores

O exemplo de regra a seguir verifica se mais de 90% dos valores da coluna dada, que é do tipo string, são, na verdade, números inteiros.

ColumnDataType "colA" = "INTEGER" with threshold > 0.9

ColumnExists

Verifica se uma coluna existe.

Sintaxe

ColumnExists <COL_NAME>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: qualquer tipo de coluna

Exemplo: A coluna existe

O exemplo de regra a seguir verifica se a coluna nomeada Middle_Name existe.

ColumnExists "Middle_Name"

ColumnLength

Verifica se o tamanho de cada linha de uma coluna está de acordo com uma determinada expressão.

Sintaxe

ColumnLength <COL_NAME><EXPRESSION>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: string

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: tamanho da linha da coluna

O exemplo de regra a seguir verifica se o valor em cada linha na coluna nomeada Postal_Code contém 5 caracteres.

ColumnLength "Postal_Code" = 5
ColumnLength "weightinkgs" = 2 where "weightinkgs > 10"

Comportamento nulo

A ColumnLength regra trata NULLs como strings de comprimento 0. Para uma linha NULL:

ColumnLength "Postal_Code" > 4 # this will fail

ColumnLength "Postal_Code" < 6 # this will succeed 

O exemplo de regra composta a seguir fornece uma maneira de falhar explicitamente valores NULL:

(ColumnLength "Postal_Code" > 4) AND (ColumnValues != NULL)

ColumnNamesMatchPattern

Verifica se os nomes de todas as colunas no conjunto de dados primário correspondem à expressão regular dada.

Sintaxe

ColumnNamesMatchPattern <PATTERN>

• PATTERN: o padrão em relação ao qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

Exemplo: os nomes das colunas correspondem ao padrão

O exemplo de regra a seguir verifica se todas as colunas começam com o prefixo "aws_"

ColumnNamesMatchPattern "aws_.*"
ColumnNamesMatchPattern "aws_.*" where "weightinkgs > 10"      
     

ColumnValues

Executa uma expressão em relação aos valores em uma coluna.

Sintaxe

ColumnValues <COL_NAME> <EXPRESSION>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: qualquer tipo de coluna

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: valores permitidos

O exemplo de regra a seguir verifica se cada valor na coluna especificada está em um conjunto de valores permitidos (inclusive nulo, vazio e strings somente com espaços em branco).

ColumnValues "Country" in [ "US", "CA", "UK", NULL, EMPTY, WHITESPACES_ONLY ]
ColumnValues "gender" in ["F", "M"] where "weightinkgs < 10"

Exemplo: expressão regular

O exemplo de regra a seguir verifica os valores em uma coluna em relação a uma expressão regular.

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

Exemple: valores de data

O exemplo de regra a seguir verifica os valores em uma coluna de datas em relação a uma expressão regular.

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

Exemplo: valores numéricos

O exemplo de regra a seguir verifica se os valores da coluna correspondem a uma determinada restrição numérica.

ColumnValues "Customer_ID" between 1 and 2000

Comportamento nulo

Para todas as regras ColumnValues (exceto != eNOT IN), as linhas NULL falharão na regra. Se a regra falhar devido a um valor nulo, o motivo da falha exibirá o seguinte:

Value: NULL does not meet the constraint requirement!

O exemplo de regra composta a seguir fornece uma maneira de permitir explicitamente valores NULL:

(ColumnValues "Age" > 21) OR (ColumnValues "Age" = NULL)

ColumnValues As regras negadas usando a != not in sintaxe e serão passadas para NULL as linhas. Por exemplo: .

ColumnValues "Age" != 21

ColumnValues "Age" not in [21, 22, 23]

Os exemplos a seguir fornecem uma maneira de falhar explicitamente valores NULL

(ColumnValues "Age" != 21) AND (ColumnValues "Age" != NULL)

ColumnValues "Age" not in [21, 22, 23, NULL]

Completeness

Verifica a porcentagem de valores completos (não nulos) em uma coluna em relação a uma determinada expressão.

Sintaxe

Completeness <COL_NAME> <EXPRESSION>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: qualquer tipo de coluna

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: porcentagem de valor nulo

O exemplo de regras a seguir verifica se mais de 95 por cento dos valores em uma coluna são completos .

Completeness "First_Name" > 0.95
Completeness "First_Name" > 0.95 where "weightinkgs > 10"

Exemplos de regras dinâmicas

• Completeness "colA" between min(last(5)) - 1 and max(last(5)) + 1

• Completeness "colA" <= avg(last(10))

Comportamento nulo

Observação sobre formatos de dados CSV: linhas em branco em colunas CSV podem apresentar vários comportamentos.

• Se uma coluna for do tipo String, a linha em branco será reconhecida como uma string vazia e não falhará na regra Completeness.

• Se uma coluna for de outro tipo de dados, por exemplo, Int, a linha em branco será reconhecida como NULL e falhará na regra Completeness.

CustomSQL

Esse tipo de regra foi estendido para ser compatível a dois casos de uso:

• Executar uma instrução SQL personalizada em um conjunto de dados e verificar o valor de retorno em relação a uma dada expressão.

• Executar uma instrução SQL personalizada na qual você especifica um nome de coluna na instrução SELECT a qual você compara com alguma condição para obter resultados no nível de linha.

Sintaxe

CustomSql <SQL_STATEMENT> <EXPRESSION>

• SQL_STATEMENT: uma instrução SQL que retorna um único valor numérico entre aspas duplas.

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: SQL personalizado para recuperar o resultado de uma regra geral

Esse exemplo de regra usa uma instrução SQL para recuperar a contagem de registros de um conjunto de dados. A regra então verifica se a contagem de registros está entre 10 e 20.

CustomSql "select count(*) from primary" between 10 and 20

Exemplo: SQL personalizado para recuperar resultados no nível de linha

Esse exemplo de regra usa uma instrução SQL personalizada na qual você especifica um nome de coluna na instrução SELECT que você compara com alguma condição para obter resultados no nível de linha. Uma expressão de condição limite define um limite de quantos registros devem ser reprovados para que toda a regra seja reprovada. Observe que uma regra pode não conter uma condição e uma palavra-chave juntas.

CustomSql "select Name from primary where Age  > 18"

ou

CustomSql "select Name from primary where Age > 18" with threshold  > 3

Importante

O alias primary representa o nome do conjunto de dados que você deseja avaliar. Quando você lida com trabalhos visuais do ETL no console, primary sempre representa o DynamicFrame que está sendo passado para a transformação EvaluateDataQuality.apply(). Quando você usa o AWS Glue Data Catalog para executar tarefas de qualidade de dados em uma tabela, primary representa a tabela.

Se você estiver no catálogo de dados do AWS Glue, também poderá usar os nomes reais das tabelas:

CustomSql "select count(*) from database.table" between 10 and 20

Você também pode unir várias tabelas para comparar diferentes elementos de dados:

CustomSql "select count(*) from database.table inner join database.table2 on id1 = id2" between 10 and 20

No AWS Glue ETL, o CustomSQL pode identificar registros que foram reprovados nas verificações de qualidade dos dados. Para que isso funcione, você precisará retornar registros que fazem parte da tabela primária na qual você está avaliando a qualidade dos dados. Os registros retornados como parte da consulta são considerados bem-sucedidos e os registros que não são retornados são considerados reprovados.

A regra a seguir garantirá que registros com idade < 100 sejam identificados como bem-sucedidos e que os registros acima sejam marcados como reprovados.

CustomSql "select id from primary where age < 100" 

Essa regra CustomSQL será aprovada quando 50% dos registros tiverem mais de 10 anos e também identificará os registros que foram reprovados. Os registros retornados por esse CustomSQL serão considerados aprovados, enquanto os não retornados serão considerados reprovados.

CustomSQL "select ID, CustomerID from primary where age > 10" with threshold > 0.5

Observação: a regra CustomSQL falhará se você retornar registros que não estão disponíveis no conjunto de dados.

DataFreshness

Verifica a atualidade dos dados em uma coluna avaliando a diferença entre a hora atual e os valores de uma coluna de data. Você pode especificar uma expressão baseada em tempo para esse tipo de regra para garantir que os valores das colunas estejam atualizados.

Sintaxe

DataFreshness <COL_NAME> <EXPRESSION>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: data

• EXPRESSION: uma expressão numérica em horas ou dias. Você deve especificar a unidade de tempo na expressão.

Exemplo: atualidade dos dados

O exemplo de regras a seguir verifica a atualidade dos dados.

DataFreshness "Order_Date" <= 24 hours
DataFreshness "Order_Date" between 2 days and 5 days

Comportamento nulo

As regras DataFreshness falharão para linhas com valores NULL. Se a regra falhar devido a um valor nulo, o motivo da falha exibirá o seguinte:

80.00 % of rows passed the threshold

onde 20% das linhas que falharam incluem as linhas com NULL.

O exemplo de regra composta a seguir fornece uma maneira de permitir explicitamente valores NULL:

(DataFreshness "Order_Date" <= 24 hours) OR (ColumnValues "Order_Date" = NULL)

Atualidade dos dados para objetos do Amazon S3

Às vezes, você precisará validar a atualidade dos dados com base na hora de criação do arquivo Amazon S3. Para fazer isso, é possível usar o código a seguir para obter o carimbo de data/hora e adicioná-lo ao seu quadro de dados e, em seguida, aplicar as verificações de atualidade dos dados.

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 os dados do conjunto de dados primário correspondem aos dados de um conjunto de dados de referência. Os dois conjuntos de dados são unidos usando os mapeamentos de colunas de chaves fornecidos. Mapeamentos de colunas adicionais podem ser fornecidos caso você deseje verificar a igualdade dos dados somente nessas colunas. Observe que, DataSetMatchpara funcionar, suas chaves de junção devem ser exclusivas e não devem ser NULL (devem ser uma chave primária). Se você não atender a essas condições, receberá a mensagem de erro “O mapa de teclas fornecido não é adequado para determinados quadros de dados”. Nos casos em que você não pode unir chaves exclusivas, considere usar outros tipos de regras, como AggregateMatcha correspondência em dados resumidos.

Sintaxe

DatasetMatch <REFERENCE_DATASET_ALIAS> <JOIN CONDITION WITH MAPPING> <OPTIONAL_MATCH_COLUMN_MAPPINGS> <EXPRESSION>

• REFERENCE_DATASET_ALIAS: o alias do conjunto de dados de referência com o qual você compara os dados do conjunto de dados primário.

• KEY_COLUMN_MAPPINGS: uma lista separada por vírgulas dos nomes das colunas que formam uma chave nos conjuntos de dados. Se os nomes das colunas não forem iguais nos dois conjuntos de dados, você deverá separá-los com um ->

• OPTIONAL_MATCH_COLUMN_MAPPINGS: você pode fornecer esse parâmetro se quiser verificar se existe correspondência de dados somente em determinadas colunas. É usada a mesma sintaxe dos mapeamentos de colunas de chaves. Se esse parâmetro não for fornecido, compararmos os todas as colunas restantes. As colunas sem chave restantes, devem ter os mesmos nomes nos dois conjuntos de dados.

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: comparar os conjuntos de dados usando a coluna ID

O exemplo de regra a seguir verifica se mais de 90% do conjunto de dados primário corresponde ao conjunto de dados de referência, usando a coluna "ID" para unir os dois conjuntos de dados. Ele compara todas as colunas nesse caso.

DatasetMatch "reference" "ID" >= 0.9

Exemplo: comparar os conjuntos de dados usando várias colunas de chaves

No exemplo a seguir, o conjunto de dados primário e o conjunto de dados de referência têm nomes diferentes para as colunas-chave. ID_1 e ID_2 juntos formam uma chave composta no conjunto de dados primário. ID_ref1 e ID_ref2 juntos formam uma chave composta no conjunto de dados de referência. Nesse cenário, você pode usar a sintaxe especial para fornecer os nomes das colunas.

DatasetMatch "reference" "ID_1->ID_ref1,ID_ref2->ID_ref2" >= 0.9

Exemplo: comparar conjuntos de dados usando várias colunas de chaves e verifique se a coluna específica corresponde

Este exemplo se baseia no exemplo anterior. Queremos verificar se apenas a coluna que contém os valores corresponde. Essa coluna é denominada Amount1 no conjunto de dados primário e Amount2 no conjunto de dados de referência. Você quer uma correspondência exata.

DatasetMatch "reference" "ID_1->ID_ref1,ID_ref2->ID_ref2" "Amount1->Amount2" >= 0.9

DistinctValuesCount

Verifica o número de valores distintos em uma coluna em relação a uma determinada expressão.

Sintaxe

DistinctValuesCount <COL_NAME> <EXPRESSION>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: qualquer tipo de coluna

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: contagem distinta de valores de colunas

O exemplo de regra a seguir verifica se a coluna denominada State contém mais de 3 valores distintos.

DistinctValuesCount "State" > 3
DistinctValuesCount "Customer_ID" < 6  where "Customer_ID < 10"

Exemplos de regras dinâmicas

• DistinctValuesCount "colA" between avg(last(10))-1 and avg(last(10))+1

• DistinctValuesCount "colA" <= index(last(10),2) + std(last(5))

Entropia

Verifica se o valor de entropia de uma coluna corresponde a uma determinada expressão. A entropia mede o nível de informação que está contida em uma mensagem. Dada a distribuição de probabilidade pelos valores em uma coluna, a entropia descreve quantos bits são necessários para identificar um valor.

Sintaxe

Entropy <COL_NAME> <EXPRESSION>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: qualquer tipo de coluna

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: entropia de coluna

O exemplo de regra a seguir verifica se a coluna determinada Feedback tem um valor de entropia maior que um.

Entropy "Star_Rating" > 1
Entropy "First_Name" > 1  where "Customer_ID < 10"

Exemplos de regras dinâmicas

• Entropy "colA" < max(last(10))

• Entropy "colA" between min(last(10)) and max(last(10))

IsComplete

Verifica se todos os valores em uma coluna estão completos (não nulos).

Sintaxe

IsComplete <COL_NAME>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: qualquer tipo de coluna

Exemplo: valores nulos

O exemplo a seguir verifica se todos os valores em uma coluna denominada email não são nulos.

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 nulo

Observação sobre formatos de dados CSV: linhas em branco em colunas CSV podem apresentar vários comportamentos.

• Se uma coluna for do tipo String, a linha em branco será reconhecida como uma string vazia e não falhará na regra Completeness.

• Se uma coluna for de outro tipo de dados, por exemplo, Int, a linha em branco será reconhecida como NULL e falhará na regra Completeness.

IsPrimaryKey

Verifica se uma coluna contém uma chave primária. Uma coluna contém uma chave primária se todos os valores na coluna forem exclusivos e completos (não nulos).

Sintaxe

IsPrimaryKey <COL_NAME>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: qualquer tipo de coluna

Exemplo: chave primária

O exemplo de regra a seguir verifica se a coluna denominada Customer_ID contém uma chave primária.

IsPrimaryKey "Customer_ID"
IsPrimaryKey "Customer_ID" where "Customer_ID < 10"

Exemplo: chave primária com várias colunas. Qualquer um dos exemplos a seguir é válido.

IsPrimaryKey "colA" "colB"
IsPrimaryKey "colA" "colB" "colC"
IsPrimaryKey colA "colB" "colC"
      

IsUnique

Verifica se todos os valores em uma coluna são exclusivos e retorna um valor booliano.

Sintaxe

IsUnique <COL_NAME>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: qualquer tipo de coluna

Exemplo: valores de coluna exclusivos

O exemplo de regra a seguir verifica se todos os valores em uma coluna denominada email são exclusivos.

IsUnique "email"
IsUnique "Customer_ID" where "Customer_ID < 10"]

Média

Verifica se o valor mediano (média) de uma coluna corresponde a uma determinada expressão.

Sintaxe

Mean <COL_NAME> <EXPRESSION>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: valor médio

O exemplo de regra a seguir verifica se a média de todos os valores em uma coluna excede um limite.

Mean "Star_Rating" > 3
Mean "Salary" < 6200 where "Customer_ID < 10"

Exemplos de regras dinâmicas

• Mean "colA" > avg(last(10)) + std(last(2))

• Mean "colA" between min(last(5)) - 1 and max(last(5)) + 1

Comportamento nulo

A regra Mean ignorará linhas com valores NULL no cálculo da média. Por exemplo: .

+---+-----------+
|id |units      |
+---+-----------+
|100|0          |
|101|null       |
|102|20         |
|103|null       |
|104|40         |
+---+-----------+

A média da coluna units será (0 + 20 + 40)/3 = 20. As linhas 101 e 103 não são consideradas nesse cálculo.

ReferentialIntegrity

Verifica até que ponto os valores de um conjunto de colunas no conjunto de dados primário são um subconjunto dos valores de um conjunto de colunas em um conjunto de dados de referência.

Sintaxe

ReferentialIntegrity <PRIMARY_COLS> <REFERENCE_DATASET_COLS> <EXPRESSION>

• PRIMARY_COLS: uma lista de nomes de coluna separados por vírgulas no conjunto de dados primário.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• REFERENCE_DATASET_COLS: esse parâmetro contém duas partes separadas por um ponto. A primeira parte é o alias do conjunto de dados de referência. A segunda parte é a lista separada por vírgulas dos nomes das colunas do conjunto de dados de referência entre colchetes.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: verificar a integridade referencial de uma coluna de códigos postais

O exemplo de regra a seguir verifica se mais de 90% dos valores da coluna zipcode do conjunto de dados primário estão presentes na coluna zipcode do conjunto de dados reference.

ReferentialIntegrity "zipcode" "reference.zipcode" >= 0.9

Exemplo: verificar a integridade referencial das colunas de cidades e estados

No exemplo a seguir, existem colunas contendo informações sobre cidades e estados no conjunto de dados primário e no conjunto de dados de referência. Os nomes das colunas são diferentes nos dois conjuntos de dados. A regra verifica se o conjunto de valores das colunas do conjunto de dados primário é exatamente igual ao conjunto de valores das colunas do conjunto de dados de referência.

ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" = 1.0

Exemplos de regras dinâmicas

• 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 a contagem de linhas de um conjunto de dados em relação a uma determinada expressão. Na expressão, você pode especificar o número de linhas ou um intervalo de linhas usando operadores como > e <.

Sintaxe

RowCount <EXPRESSION>

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: verificação numérica da contagem de linhas

O exemplo de regra a seguir verifica se a contagem de linhas está dentro de um determinado intervalo.

RowCount between 10 and 100
RowCount between 1 and 50 where "Customer_ID < 10"

Exemplos de regras dinâmicas

RowCount > avg(lats(10)) *0.8

RowCountMatch

Verifica a razão entre a contagem de linhas do conjunto de dados primário e a contagem de linhas de um conjunto de dados de referência em relação à expressão dada.

Sintaxe

RowCountMatch <REFERENCE_DATASET_ALIAS> <EXPRESSION>

• REFERENCE_DATASET_ALIAS O alias do conjunto de dados de referência com o qual comparar as contagens de linhas.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: verificação da contagem de linhas em relação a um conjunto de dados de referência

O exemplo de regra a seguir verifica se a contagem de linhas do conjunto de dados primário é pelo menos 90% da contagem de linhas do conjunto de dados de referência.

RowCountMatch "reference" >= 0.9

StandardDeviation

Verifica o desvio padrão de todos os valores em uma coluna em relação a uma determinada expressão.

Sintaxe

StandardDeviation <COL_NAME> <EXPRESSION>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: desvio padrão

O exemplo de regra a seguir verifica se o desvio padrão dos valores em uma coluna denominada colA é menor que um valor especificado.

StandardDeviation "Star_Rating" < 1.5
StandardDeviation "Salary" < 3500 where "Customer_ID < 10"

Exemplos de regras dinâmicas

• StandardDeviation "colA" > avg(last(10) + 0.1

• StandardDeviation "colA" between min(last(10)) - 1 and max(last(10)) + 1

Comportamento nulo

A regra StandardDeviation ignorará linhas com valores NULL no cálculo do desvio padrão. Por exemplo: .

+---+-----------+-----------+
|id |units1     |units2     |
+---+-----------+-----------+
|100|0          |0          |
|101|null       |0          |
|102|20         |20         |
|103|null       |0          |
|104|40         |40         |
+---+-----------+-----------+

O desvio padrão da coluna units1 não considerará as linhas 101 e 103 e resultará em 16,33. O desvio padrão da coluna units2 resultará em 16.

Sum

Verifica a soma de todos os valores em uma coluna em relação a uma determinada expressão.

Sintaxe

Sum <COL_NAME> <EXPRESSION>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: soma

O exemplo de regra a seguir verifica se a soma de todos os valores em uma coluna excede um limite.

Sum "transaction_total" > 500000
Sum "Salary" < 55600 where "Customer_ID < 10"

Exemplos de regras dinâmicas

• Sum "ColA" > avg(last(10))

• Sum "colA" between min(last(10)) - 1 and max(last(10)) + 1

Comportamento nulo

A regra Sum ignorará linhas com valores NULL no cálculo da soma. Por exemplo: .

+---+-----------+
|id |units      |
+---+-----------+
|100|0          |
|101|null       |
|102|20         |
|103|null       |
|104|40         |
+---+-----------+

A soma da coluna units não considerará as linhas 101 e 103 e resultará em (0 + 20 + 40) = 60.

SchemaMatch

Verifica se o esquema do conjunto de dados primário corresponde ao esquema de um conjunto de dados de referência. A verificação de esquema é feita coluna por coluna. O esquema de duas colunas corresponde se os nomes forem idênticos e os tipos forem idênticos. A ordem das colunas não importa.

Sintaxe

SchemaMatch <REFERENCE_DATASET_ALIAS> <EXPRESSION>

• REFERENCE_DATASET_ALIAS: o alias do conjunto de dados de referência com o qual comparar os esquemas.

  Tipos de coluna compatíveis: byte, decimal, duplo, flutuante, inteiro, longo, curto

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: SchemaMatch

A regra de exemplo a seguir verifica se o esquema do conjunto de dados primário corresponde exatamente ao esquema de um conjunto de dados de referência.

SchemaMatch "reference" = 1.0

Exclusividade

Verifica a porcentagem de valores exclusivos em uma coluna em relação a uma determinada expressão. Valores exclusivos ocorrem exatamente uma vez.

Sintaxe

Uniqueness <COL_NAME> <EXPRESSION>

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: qualquer tipo de coluna

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: porcentagem de exclusividade

O exemplo de regra a seguir verifica se a porcentagem de valores exclusivos em uma coluna corresponde a determinados critérios numéricos.

Uniqueness "email" = 1.0
Uniqueness "Customer_ID" != 1.0 where "Customer_ID < 10"

Exemplos de regras dinâmicas

• Uniqueness "colA" between min(last(10)) and max(last(10))

• Uniqueness "colA" >= avg(last(10))

UniqueValueRatio

Verifica a razão de valores exclusivos em uma coluna em relação a uma determinada expressão. Uma razão de valor exclusivo é a fração de valores exclusivos dividida pelo número de todos os valores distintos em uma coluna. Valores exclusivos ocorrem exatamente uma vez, enquanto valores distintos ocorrem pelo menos uma vez.

Por exemplo, o conjunto [a, a, b] contém um valor exclusivo (b) e dois valores distintos (a e b). Portanto, a proporção de valores exclusivos do conjunto é ½ = 0,5.

Sintaxe

UniqueValueRatio <COL_NAME> <EXPRESSION>
      

• COL_NAME: o nome da coluna em relação à qual você deseja avaliar a regra de qualidade de dados.

  Tipos de coluna compatíveis: qualquer tipo de coluna

• EXPRESSION: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para ter mais informações, consulte Expressões.

Exemplo: razão de valores exclusivos

Esse exemplo verifica a proporção de valores exclusivos de uma coluna em relação a um intervalo de valores.

UniqueValueRatio "test_score" between 0 and 0.5
UniqueValueRatio "Customer_ID" between 0 and 0.9 where "Customer_ID < 10"

Exemplos de regras dinâmicas

• UniqueValueRatio "colA" > avg(last(10))

• UniqueValueRatio "colA" <= index(last(10),2) + std(last(5))

DetectAnomalies

Detecta anomalias em uma determinada regra de qualidade de dados. Cada execução de uma DetectAnomalies regra resulta em salvar o valor avaliado para a regra dada. Quando há dados suficientes coletados, o algoritmo de detecção de anomalias pega todos os dados históricos dessa regra e executa a detecção de anomalias. DetectAnomalies a regra falha quando a anomalia é detectada. Para obter mais informações sobre qual anomalia foi detectada, consulte Observações.

Sintaxe

       DetectAnomalies <RULE_NAME> <RULE_PARAMETERS>
     

RULE_NAME: o nome da regra para a qual você quer avaliar e detectar anomalias. Regras compatíveis:

• "RowCount"

• "Completeness"

• "Uniqueness"

• "Mean"

• "Sum"

• "StandardDeviation"

• "Entropy"

• "DistinctValuesCount"

• "UniqueValueRatio"

• "ColumnLength"

• "ColumnValues"

• "ColumnCorrelation"

RULE_PARAMETERS: algumas regras exigem parâmetros adicionais para serem executadas. Consulte a documentação da regra fornecida para ver os parâmetros necessários.

Exemplo: Anomalias para RowCount

Por exemplo, se quisermos detectar RowCount anomalias, fornecemos RowCount como regra o nome.

DetectAnomalies "RowCount"

Exemplo: Anomalias para ColumnLength

Por exemplo, se quisermos detectar ColumnLength anomalias, fornecemos ColumnLength como regra o nome e o nome da coluna.

DetectAnomalies "ColumnLength" "id"