",
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 Catálogo de Dados do AWS Glue, é possível configurar facilmente essa opção na interface do usuário, conforme demonstrado abaixo.
![\[A captura de tela mostra uma janela de configurações de regra composta na qual você pode escolher a configuração de avaliação da regra entre linha e coluna. Se você escolher Linha, as regras compostas se comportarão como uma única regra avaliando a linha inteira. Se você escolher Coluna, as regras compostas avaliarão cada regra individualmente em todo o conjunto de dados e combinarão os resultados.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/composite-rule-settings.png)
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"
|
| \$1=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\$1c/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\$1c/i | Será resolvido como 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\$1ONLY
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 exige o uso da opção "compositeRuleEvaluation.method" = "ROW".*
+ WHITESPACES\$1ONLY/whitespaces\$1only: 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](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-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](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
#### Filtragem com a cláusula Where
**nota**
A cláusula Where só é compatível com o AWS Glue 4.0.
Você pode filtrar seus dados ao criar regras. Isso é útil quando você quiser aplicar regras condicionais.
```
where " "
```
É necessário especificar o filtro com a palavra-chave `where`, seguida por uma instrução válida do SparkSQL entre aspas `("")`.
Se você quiser adicionar a cláusula where a uma regra com um limite, será necessário especificar a cláusula where antes da condição de limite.
```
where "valid SparkSQL statement>" with threshold
```
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 do SparkSQL fornecida é válida. Se for inválida, a avaliação da regra falhará e lançaremos o `IllegalArgumentException` com o seguinte formato:
```
Rule where "" has provided an invalid where clause :
```
**Comportamento da cláusula where quando a identificação do registro de erro no nível de linha estiver ativada**
Com o AWS Glue Data Quality, você pode identificar registros específicos que falharam. Ao aplicar uma cláusula where às regras compatíveis com resultados no nível de linha, rotularemos como `Passed` as linhas que forem filtradas pela cláusula where.
Se você preferir rotular separadamente as linhas filtradas como `SKIPPED`, defina o seguinte `additionalOptions` para a tarefa de ETL.
```
object GlueApp {
val datasource = glueContext.getCatalogSource(
database="",
tableName="",
transformationContext="datasource"
).getDynamicFrame()
val ruleset = """
Rules = [
IsComplete "att2" where "att1 = 'a'"
]
"""
val dq_results = EvaluateDataQuality.processRows(
frame=datasource,
ruleset=ruleset,
additionalOptions=JsonOptions("""
{
"rowLevelConfiguration.filteredRowLabel":"SKIPPED"
}
"""
)
)
}
```
Como exemplo, consulte a regra e o quadro de dados a seguir:
```
IsComplete att2 where "att1 = 'a'"
```
| id | att1 | att2 | Resultados no nível de linha (padrão) | Resultados no nível de linha (opção ignorada) | Comentários |
| --- | --- | --- | --- | --- | --- |
| 1 | a | f | PASSED | PASSED | |
| 2 | b | d | PASSED | SKIPPED | A linha é filtrada, pois att1 não é "a" |
| 3 | a | nulo | FAILED | FAILED | |
| 4 | a | f | PASSED | PASSED | |
| 5 | b | nulo | PASSED | SKIPPED | A linha é filtrada, pois att1 não é "a" |
| 6 | a | f | PASSED | PASSED | |
### Constantes
No DQDL, você pode definir valores constantes e referenciá-los em todo o script. Isso ajuda a evitar problemas relacionados aos limites de tamanho da consulta, por exemplo, ao trabalhar com instruções SQL grandes que podem exceder os limites permitidos. Ao atribuir esses valores a constantes, você pode simplificar seu DQDL e evitar atingir esses limites.
O exemplo a seguir mostra como definir e usar uma constante:
```
mySql = "select count(*) from primary"
Rules = [
CustomSql $mySql between 0 and 100
]
```
Neste exemplo, a consulta SQL é atribuída à constante `mySql`, que é então referenciada na regra usando o prefixo `$`.
### Rótulos
Os rótulos fornecem uma maneira eficaz de organizar e analisar os resultados de qualidade dos dados. Você pode consultar os resultados por rótulos específicos para identificar regras com falhas em categorias específicas, contar os resultados das regras por equipe ou domínio e criar relatórios focados para diferentes partes interessadas.
Por exemplo, você pode aplicar todas as regras que dizem respeito à equipe financeira com um rótulo `"team=finance"` e gerar um relatório personalizado para mostrar métricas de qualidade específicas para a equipe financeira. Você pode rotular regras de alta prioridade como `"criticality=high"` para priorizar os esforços de remediação. Os rótulos podem ser criados como parte do DQDL. Você pode consultar os rótulos como parte dos resultados das regras, resultados em nível de linha e respostas da API, facilitando a integração com seus fluxos de trabalho de monitoramento e geração de relatórios existentes.
**nota**
Os rótulos só estão disponíveis no AWS Glue ETL e não estão disponíveis no Data Quality baseado no Catálogo de Dados do AWS Glue.
#### Sintaxe para rótulos DQDL
O DQDL oferece suporte a rótulos padrão e específicos de regras. Os rótulos padrão são definidos no nível do conjunto de regras e se aplicam automaticamente a todas as regras dele. As regras individuais também podem ter seus próprios rótulos e, como os rótulos são implementados como pares de chave-valor, os rótulos específicos da regra podem substituir os rótulos padrão ao usar a mesma chave.
O exemplo a seguir mostra como usar rótulos padrão e específicos para regras:
```
DefaultLabels=["frequency"="monthly"]
Rules = [
// Auto includes the default label ["frequency"="monthly"]
ColumnValues "col" > 21,
// Add ["foo"="bar"] to default label. Labels for this rule would be ["frequency"="monthly", "foo"="bar"]
Rule 1 with threshold > 0.8 labels=["foo"="bar"],
// Override default label. Labels for this rule would be ["frequency"="daily", "foo"="bar"]
Rule 2 with threshold > 0.8 labels=["foo"="bar", "frequency"="daily"]
// Labels must be applied to the entire composite rule (parentheses required)
(Rule 1 AND Rule 2) labels=["foo"="bar]
]
```
##### Restrições do rótulo
Os rótulos têm as seguintes restrições:
+ No máximo 10 rótulos por regra DQDL.
+ Os rótulos são especificados como uma lista de pares de chave-valor.
+ A chave e o valor do rótulo diferenciam maiúsculas de minúsculas.
+ O comprimento máximo da chave do rótulo é de 128 caracteres. A chave do rótulo não pode estar vazia nem ser nula.
+ O comprimento máximo do valor do rótulo é de 256 caracteres. O valor do rótulo pode estar vazio ou ser nulo.
#### Recuperar rótulos DQDL
Você pode recuperar rótulos DQDL de resultados de regras, resultados em nível de linha e respostas de API.
##### Resultados da regra
Os rótulos DQDL estão sempre visíveis nos resultados das regras. Nenhuma configuração adicional é necessária para habilitá-los.
##### Resultados por linha
Os rótulos DQDL são desabilitados por padrão nos resultados em nível de linha, mas podem ser habilitados usando as `AdditionalOptions` no `EvaluateDataQuality`.
O exemplo a seguir mostra como habilitar rótulos em resultados por linha:
```
val evaluateResult = EvaluateDataQuality.processRows(
frame=AmazonS3_node1754591511068,
ruleset=example_ruleset,
publishingOptions=JsonOptions("""{
"dataQualityEvaluationContext": "evaluateResult",
"enableDataQualityCloudWatchMetrics": "true",
"enableDataQualityResultsPublishing": "true"
}"""),
additionalOptions=JsonOptions("""{
"performanceTuning.caching":"CACHE_NOTHING",
"observations.scope":"ALL",
"rowLevelConfiguration.ruleWithLabels":"ENABLED"
}""")
)
```
Quando habilitado, o quadro de dados de resultados em nível de linha inclui rótulos para cada regra nas colunas `DataQualityRulesPass`, `DataQualityRulesFail` e `DataQualityRulesSkip`.
##### Resposta da API
Os rótulos DQDL estão sempre visíveis nas respostas da API em um novo campo `Labels` no objeto `RuleResults`.
O exemplo a seguir mostra os rótulos em uma resposta da API:
```
{
"ResultId": "dqresult-example",
"ProfileId": "dqprofile-example",
"Score": 0.6666666666666666,
"RulesetName": "EvaluateDataQuality_node1754591514205",
"EvaluationContext": "EvaluateDataQuality_node1754591514205",
"StartedOn": "2025-08-22T19:36:10.448000+00:00",
"CompletedOn": "2025-08-22T19:36:16.368000+00:00",
"JobName": "anniezc-test-labels",
"JobRunId": "jr_068f6d7a45074d9105d14e4dee09db12c3b95664b45f6ee44fa29ed7e5619ba8",
"RuleResults": [
{
"Name": "Rule_0",
"Description": "IsComplete colA",
"EvaluationMessage": "Input data does not include column colA!",
"Result": "FAIL",
"EvaluatedMetrics": {},
"EvaluatedRule": "IsComplete colA",
"Labels": {
"frequency": "monthly"
}
},
{
"Name": "Rule_1",
"Description": "Rule 1 with threshold > 0.8",
"Result": "PASS",
"EvaluatedMetrics": {},
"EvaluatedRule": "Rule 1 with threshold > 0.8",
"Labels": {
"frequency": "monthly",
"foo": "bar"
}
},
{
"Name": "Rule_3",
"Description": "Rule 2 with threshold > 0.8",
"Result": "PASS",
"EvaluatedMetrics": {},
"EvaluatedRule": "Rule 2 with threshold > 0.8",
"Labels": {
"frequency": "daily",
"foo": "bar"
}
}
]
}
```
### Regras dinâmicas
**nota**
As regras dinâmicas são compatíveis somente no ETL do AWS Glue e não são compatíveis no Catálogo de Dados do AWS Glue.
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](#dqdl-analyzers-table), para determinar se as regras dinâmicas são compatíveis com seu tipo de regra.
**Exclusão de estatísticas das regras dinâmicas**
Às vezes, você precisará excluir estatísticas de dados dos cálculos das regras dinâmicas. Digamos que você tenha feito um carregamento de dados históricos e não queira que isso afete as médias. Para fazer isso, abra o trabalho no ETL do AWS Glue e escolha a guia **Qualidade de dados**, em seguida escolha **Estatísticas** e selecione as estatísticas que você deseja excluir. Você poderá ver um gráfico de tendências com uma tabela de estatísticas. Selecione os valores que você deseja excluir e escolha **Excluir estatísticas**. Agora, as estatísticas excluídas não serão consideradas nos cálculos dinâmicos das regras.
![\[A captura de tela mostra a opção de excluir ou incluir estatísticas no menu suspenso após a seleção de uma estatística.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/data-quality-excluding-statistics-from-dynamic-rules.png)
### Analisadores
**nota**
Não há suporte a analisadores no Catálogo de Dados do AWS Glue.
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 regra RowCount `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"
]
```
O AWS Glue Data Quality é compatível com os seguintes analisadores.
| Nome do analisador | Funcionalidade |
| --- | --- |
| RowCount | Calcula as quantidades de linhas para um conjunto de dados |
| Completeness | Calcula a porcentagem de completude de uma coluna |
| Uniqueness | Calcula a porcentagem de exclusividade de uma coluna |
| Mean | Calcula a média de uma coluna numérica |
| Sum | Calcula a soma de uma coluna numérica |
| StandardDeviation | Calcula o desvio padrão de uma coluna numérica |
| Entropy | Calcula a entropia de uma coluna numérica |
| DistinctValuesCount | Calcular o número de valores distintos em uma coluna |
| UniqueValueRatio | Calcula a proporção de valores exclusivos em uma coluna |
| ColumnCount | Calcula o número de colunas em um conjunto de dados |
| ColumnLength | Calcula o comprimento de uma coluna |
| ColumnValues | Calcula o mínimo e o máximo para colunas numéricas Calcula o mínimo e o máximo de ColumnLength para colunas não numéricas |
| ColumnCorrelation | Calcula as correlações de colunas para colunas específicas |
| CustomSql | Calcula as estatísticas retornadas pelo CustomSQL |
| AllStatistics | Calcula as seguintes estatísticas: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/dqdl.html) |
### Comentários
É possível usar o caractere "\$1" para adicionar um comentário ao seu documento DQDL. Qualquer coisa após o caractere "\$1" 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 | Compatível com 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 em um conjunto de dados. | Um único nome de coluna | 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.\$1.ColumnCount | Sim | Sim | 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.\$1.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.\$1.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 |
| FileFreshness | Verifica se arquivos no Amazon S3 estão atualizados. | Caminho e um limite de arquivo ou pasta. | `Dataset.*.FileFreshness.Compliance` `Dataset.*.FileCount` | Sim | Não | Não | Não | Não | Não |
| FileMatch | Verifica se o conteúdo do arquivo corresponde a uma soma de verificação ou a outro arquivo. Essa regra usa somas de verificação para validar se dois arquivos são iguais. | Caminho do arquivo ou pasta de origem e caminho do arquivo ou pasta de destino. | Nenhuma estatística é gerada. | Sim | Não | Não | Não | Não | Não |
| FileSize | Verifica se o tamanho de um arquivo corresponde a uma condição especificada. | Caminho e limite de arquivo ou pasta. | `Dataset.*.FileSize.Compliance` `Dataset.*.FileCount` `Dataset.*.MaximumFileSize` `Dataset.*.MinimumFileSize` | Sim | Não | Não | Não | Não | Não |
| FileUniqueness | Verifica se os arquivos são exclusivos usando somas de verificação. | Caminho e limite de arquivo ou pasta. | `Dataset.*.FileUniquenessRatio` `Dataset.*.FileCount` | Sim | Não | Não | Não | Não | Não |
**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)
+ [Completeness](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)
+ [Média](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)
+ [Sum](dqdl-rule-types-Sum.md)
+ [SchemaMatch](dqdl-rule-types-SchemaMatch.md)
+ [Exclusividade](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 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**
```
AggregateMatch (.)
```
+ **AGG\$1OPERATION**: 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\$1REFERENCE\$1ALIAS**: 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. Se você estiver usando essa regra no catálogo de dados do AWS Glue, o alias de referência deverá seguir o formato "..
**Tipos de coluna compatíveis**: byte, decimal, duplo, flutuante, inteiro, longo, curto
+ **COL\$1NAME**: 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\$1EXP\$11**: 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\$1EXP\$12**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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 catálogo de dados do AWS Glue, 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 \$1 20 \$1 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\$11\$1NAME**: 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\$12\$1NAME**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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**: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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 se os valores em uma determinada coluna podem ser convertidos no Apache Spark para o tipo fornecido. Aceita uma expressão `with threshold` para verificar um subconjunto dos valores da coluna.
**Sintaxe**
```
ColumnDataType =
```
+ **COL\$1NAME**: 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\$1TYPE**: 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 na coluna indicada, que é do tipo string, podem ser 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 na coluna indicada, que é do tipo string, podem ser números inteiros.
```
ColumnDataType "colA" = "INTEGER" with threshold > 0.9
```
# ColumnExists
Verifica se uma coluna existe.
**Sintaxe**
```
ColumnExists
```
+ **COL\$1NAME**: 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\$1NAME**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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 `NULL`s 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 "Postal_Code" != NULL)
```
# ColumnNamesMatchPattern
Verifica se os nomes de todas as colunas no conjunto de dados primário correspondem à expressão regular dada.
**Sintaxe**
```
ColumnNamesMatchPattern
```
+ **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\$1"
```
ColumnNamesMatchPattern "aws_.*"
ColumnNamesMatchPattern "aws_.*" where "weightinkgs > 10"
```
# ColumnValues
Executa uma expressão em relação aos valores em uma coluna.
**Sintaxe**
```
ColumnValues
```
+ **COL\$1NAME**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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 `!=` e`NOT 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)
```
As regras de ColumnValues negadas usando a sintaxe `!=` e `not in` serão transmitidas para as linhas `NULL`. 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\$1NAME**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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\$1STATEMENT**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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"
```
or
```
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 sejam parte da tabela primária para cuja qualidade de dados você está avaliando. 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. Isso funciona unindo o resultado da sua consulta em CustomSQL com o conjunto de dados original. Pode haver implicações para a performance dependendo da complexidade da consulta em SQL.
Para fazer isso:
+ Você precisa selecionar pelo menos uma coluna na tabela primária.
+ `select count(*) from primary` é uma consulta válida para a regra de DQ em CustomSQL OVERALL, mas não para CustomSQL no nível de linha.
+ Essa regra gerará um erro durante a avaliação: `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.`
+ Em sua consulta em SQL, selecione uma "chave primária" na tabela ou selecione um conjunto de colunas que formam uma chave composta. Não fazer isso pode gerar resultados inconsistentes devido à correspondência de linhas duplicadas e degradação do performance.
+ Selecione chaves SOMENTE na tabela primária e não nas tabelas de referência.
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\$1NAME**: 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. Para que **DataSetMatch** funcione, suas chaves de união deverão ser exclusivas e não deverão ser NULL (deverão 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 puder ter chaves de união exclusivas, considere usar outros tipos de regras, como **AggregateMatch**, para comparar com base nos dados resumidos.
**Sintaxe**
```
DatasetMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS**: o alias do conjunto de dados de referência com o qual você compara os dados do conjunto de dados primário.
+ **KEY\$1COLUMN\$1MAPPINGS**: 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\$1MATCH\$1COLUMN\$1MAPPINGS**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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_2->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_2->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\$1NAME**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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\$1NAME**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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\$1NAME**: 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). Também é possível verificar as chaves primárias com várias colunas.
**Sintaxe**
```
IsPrimaryKey
```
+ **COL\$1NAME**: 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\$1NAME**: 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
**Exemplos**
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"]
```
O exemplo de regra a seguir verifica várias colunas.
```
IsUnique "vendorid" "tpep_pickup_datetime"
```
# Média
Verifica se o valor mediano (média) de uma coluna corresponde a uma determinada expressão.
**Sintaxe**
```
Mean
```
+ **COL\$1NAME**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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 \$1 20 \$1 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\$1COLS**: 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\$1DATASET\$1COLS**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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**: uma expressão a ser executada na resposta do tipo de regra para produzir um valor booliano. Para obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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(last(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\$1DATASET\$1ALIAS** 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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\$1NAME**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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\$1NAME**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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 \$1 20 \$1 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\$1DATASET\$1ALIAS**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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\$1NAME**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**Exemplo**
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"
```
O exemplo de regra a seguir verifica várias colunas.
```
Uniqueness "vendorid" "tpep_pickup_datetime" = 1
```
**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\$1NAME**: 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 obter mais informações, consulte [Expressões](dqdl.md#dqdl-syntax-rule-expressions).
**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 da regra DetectAnomalies resulta em salvar o valor avaliado para a regra fornecida. 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. A regra DetectAnomalies falha quando uma anomalia é detectada. Para obter mais informações sobre qual anomalia foi detectada, consulte Observações.
**Sintaxe**
```
DetectAnomalies
```
`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"
+ "CustomSQL"
+ "ColumnCount"
`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 anomalias de RowCount, fornecemos RowCount como nome de regra.
```
DetectAnomalies "RowCount"
```
**Exemplo: anomalias para ColumnLength**
Por exemplo, se quisermos detectar anomalias de ColumnLength, fornecemos ColumnLength como nome de regra e nome de coluna.
```
DetectAnomalies "ColumnLength" "id"
```
# FileFreshness
O FileFreshness garante que os arquivos de dados estejam atualizados com base nas condições que você fornece. Ele usa a hora da última modificação dos arquivos para garantir que os arquivos de dados ou a pasta inteira esteja atualizada.
Essa regra reúne duas métricas:
+ Conformidade com o FileFreshness com base na regra que você configurou
+ O número de arquivos que foram verificados pela regra
```
{"Dataset.*.FileFreshness.Compliance":1,"Dataset.*.FileCount":1}
```
A detecção de anomalias não considera essas métricas.
**Verificação da atualização do arquivo**
A regra a seguir garante que o tickets.parquet tenha sido criado nas últimas 24 horas.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/tickets.parquet" > (now() - 24 hours)
```
**Verificação da atualização da pasta**
A regra a seguir será válida se todos os arquivos da pasta tiverem sido criados ou modificados nas últimas 24 horas.
```
FileFreshness "s3://bucket/" >= (now() -1 days)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" >= (now() - 24 hours)
```
**Verificação da atualização da pasta ou do arquivo com limite**
A regra a seguir é válida se 10% dos arquivos da pasta “tiquetes” tiverem sido criados ou modificados nos últimos 10 dias.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" < (now() - 10 days) with threshold > 0.1
```
**Verificação de arquivos ou pastas com datas específicas**
Você pode verificar a atualização de arquivos em dias específicos.
```
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"
```
**Verificação de arquivos ou pastas com hora**
É possível usar FileFreshness para garantir que os arquivos chegaram com base em determinadas horas.
```
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"
```
Considerações importantes:
+ O FileFreshness pode avaliar arquivos usando unidades de dias, horas e minutos
+ Para horários, ele oferece suporte aos formatos AM/PM e de 24 horas
+ Os horários são calculados em UTC, a menos que algo diferente seja especificado
+ As datas são calculadas em UTC no horário 00:00
O FileFreshness baseado em hora funciona da seguinte forma:
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45"
```
+ Primeiro, o horário "21h45" é combinado com a data de hoje no formato UTC para criar um campo de data e hora
+ Em seguida, a data e hora são convertidas para um fuso horário que você especificou
+ Finalmente, a regra é avaliada
**Tags de regras opcionais baseadas em arquivos:**
As tags permitem controlar o comportamento da regra.
**recentFiles**
Essa tag limita o número de arquivos processados ao manter primeiro o arquivo mais recente.
```
FileFreshness "s3://amzn-s3-demo-bucket/" between (now() - 100 minutes) and (now() + 10 minutes) with recentFiles = 1
```
**uriRegex**
**nota**
A tag `uriRegex` está disponível no AWS Glue 5.0 e em versões posteriores.
Essa tag filtra os arquivos aplicando um padrão regex ao caminho do arquivo. Somente são processados os arquivos cujos caminhos correspondam ao padrão. Você também pode usar um lookahead negativo para excluir os arquivos que correspondam a um padrão.
```
# 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$).*"
```
**filterOrder**
**nota**
A tag `filterOrder` está disponível no AWS Glue 5.0 e em versões posteriores.
Quando você usa várias tags de filtro juntas, como `recentFiles` e `uriRegex`, a tag `filterOrder` controla a ordem na qual elas são aplicadas. A ordem padronizada é primeiro `recentFiles` e depois `uriRegex`.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with recentFiles = 1 with uriRegex = "inventory_" with filterOrder = ["uriRegex","recentFiles"]
```
No exemplo acima, primeiramente é aplicado o filtro `uriRegex` para selecionar somente os arquivos que correspondam a “inventory\$1” e, em seguida, `recentFiles = 1` obtém o arquivo mais recente desse conjunto filtrado. Sem `filterOrder`, o comportamento padrão seria selecionar primeiro o arquivo mais recente e depois aplicar o regex, o que poderia resultar na ausência de correspondência de arquivos se o arquivo mais recente não correspondesse ao padrão.
**nota**
Todos os valores na lista `filterOrder` devem fazer referência a outras tags do filtro (`recentFiles` ou `uriRegex`) que também estejam presentes na mesma regra. Tags que não fazem parte do filtro, como `timeZone` ou `failFast`, não são válidas em `filterOrder`.
**failFast**
Quando definida como `"true"`, a regra informa a falha imediatamente no primeiro arquivo que falhar na condição de atualização, em vez de avaliar todos os arquivos e calcular uma taxa de conformidade.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with failFast = "true"
```
**timeZone**
Substituições de fuso horário aceitas, consulte [Fusos horários permitidos](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html) para ver os fusos horários compatíveis.
```
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"
```
**Dedução de nomes de arquivos diretamente de quadros de dados**
Você nem sempre precisa fornecer um caminho de arquivo. Por exemplo, quando você está criando a regra no Catálogo de Dados do AWS Glue, pode ser difícil descobrir quais pastas as tabelas do catálogo estão usando. O AWS Glue Data Quality pode encontrar as pastas ou arquivos específicos usados para o preenchimento do quadro de dados e detectar se eles estão atualizados.
**nota**
Esse recurso só funcionará quando os arquivos forem lidos com sucesso no DynamicFrame ou no DataFrame.
```
FileFreshness > (now() - 24 hours)
```
Essa regra descobrirá o caminho da pasta ou os arquivos usados para preencher o quadro dinâmico ou o quadro de dados. Isso funciona para caminhos do Amazon S3 ou para tabelas do Catálogo de Dados do AWS Glue baseadas no Amazon S3. Existem algumas considerações:
1. No ETL do AWS Glue, você deve ter a transformação **EvaluateDataQuality** imediatamente após uma transformação do Amazon S3 ou do Catálogo de Dados do AWS Glue.
![\[A captura de tela mostra um nó de avaliação da qualidade dos dados conectado a um nó do Amazon S3.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/data-quality-file-freshness.png)
1. Essa regra não funcionará nas sessões interativas do AWS Glue.
Se você tentar isso em ambos os casos, ou quando o AWS Glue não conseguir encontrar os arquivos, o AWS Glue irá gerar o seguinte erro: `“Unable to parse file path from DataFrame”`
# FileMatch
A regra FileMatch permite que você compare arquivos com outros arquivos ou somas de verificação. Isso pode ser útil em algumas situações:
1. Validação de arquivos recebidos de fontes externas: você pode usar o FileMatch para garantir que recebeu os arquivos corretos de fontes externas ao compará-los com somas de verificação. Isso ajuda a validar a integridade dos dados que você está ingerindo.
1. Comparação de dados em duas pastas diferentes: o FileMatch pode ser usado para comparar arquivos entre duas pastas.
Essa regra reúne uma métrica: o número de arquivos que foram examinados pela regra.
```
{"Dataset.*.FileCount":1}
```
**Validar arquivos com uma soma de verificação:**
O FileMatch aceita um arquivo e um conjunto de somas de verificação para garantir que pelo menos uma delas corresponda ao arquivo.
```
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"]
```
Os seguintes algoritmos padrão são compatíveis:
+ MD5
+ SHA-1
+ SHA-256
Se você não fornecer um algoritmo, o padrão será SHA-256.
**Validar todos os arquivos de uma pasta com um conjunto de somas de verificação:**
```
FileMatch "s3://amzn-s3-demo-bucket /" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch "s3://amzn-s3-demo-bucket /internal-folder/" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"]
```
**Comparar arquivos em pastas diferentes**
```
# 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"]
```
O FileMatch verificará o conteúdo dos arquivos do `original_bucket` e garantirá que eles correspondam ao conteúdo do `archive_bucket`. A regra falhará se eles não corresponderem exatamente. Ele também pode verificar o conteúdo de pastas internas ou arquivos individuais.
O FileMatch também pode comparar arquivos individuais uns com os outros.
```
FileMatch "s3://amzn-s3-demo-bucket /file_old.json" "s3://amzn-s3-demo-bucket /file_new.json"
```
**Dedução de nomes de arquivos diretamente de quadros de dados**
Você nem sempre precisa fornecer um caminho de arquivo. Por exemplo, quando você está criando a regra no Catálogo de Dados do AWS Glue (com o suporte do Amazon S3), pode ser difícil descobrir quais pastas as tabelas do catálogo estão usando. O AWS Glue Data Quality pode encontrar as pastas ou arquivos específicos usados para o preenchimento do quadro de dados.
**nota**
Esse recurso só funcionará quando os arquivos forem lidos com sucesso no DynamicFrame ou no 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 a soma de verificação fornecida for diferente da calculada, o FileMatch alertará você sobre a diferença.
![\[A captura de tela mostra uma regra com o status DQ de Falha na regra. O FileMatch explica a falha.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/data-quality-file-match.png)
**Tags de regras opcionais baseadas em arquivos:**
As tags permitem controlar o comportamento da regra.
**recentFiles**
Essa tag limita o número de arquivos processados ao manter primeiro o arquivo mais recente.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1
```
**uriRegex**
**nota**
A tag `uriRegex` está disponível no AWS Glue 5.0 e em versões posteriores.
Essa tag filtra os arquivos aplicando um padrão regex ao caminho do arquivo. Somente são processados os arquivos cujos caminhos correspondam ao padrão. Você também pode usar um lookahead negativo para excluir os arquivos que correspondam a um padrão.
```
# 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$).*"
```
**filterOrder**
**nota**
A tag `filterOrder` está disponível no AWS Glue 5.0 e em versões posteriores.
Quando você usa várias tags de filtro juntas, como `recentFiles` e `uriRegex`, a tag `filterOrder` controla a ordem na qual elas são aplicadas. A ordem padronizada é primeiro `recentFiles` e depois `uriRegex`.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1 with uriRegex = "\.json$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
Essa tag garante que os arquivos não tenham nomes duplicados. O comportamento padrão é falso.
```
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac04179sam4713e5ef8f319"] with matchFileName = "true"
```
Existem algumas considerações:
1. No ETL do AWS Glue, você deve ter a transformação **EvaluateDataQuality** imediatamente após uma transformação do Amazon S3 ou do Catálogo de Dados do AWS Glue.
![\[A captura de tela mostra uma regra com o status DQ de Falha na regra. O FileMatch explica a falha.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/data-quality-file-match-transform.png)
1. Essa regra não funcionará nas sessões interativas do AWS Glue.
# FileUniqueness
O FileUniqueness permite que você garanta que não haja arquivos duplicados nos dados que você recebeu dos produtores de dados.
A regra reúne as seguintes estatísticas de dados:
1. O número de arquivos que foram verificados pela regra
1. A taxa de exclusividade dos arquivos
```
Dataset.*.FileUniquenessRatio: 1.00, Dataset.*.FileCount: 8.00
```
**Encontrar arquivos duplicados em uma pasta:**
```
FileUniqueness "s3://bucket/" > 0.5
FileUniqueness "s3://bucket/folder/" = 1
```
**Inferir nomes de pastas diretamente dos quadros de dados para detectar duplicatas:**
Você nem sempre precisa fornecer um caminho de arquivo. Por exemplo, quando você está criando a regra no Catálogo de Dados do AWS Glue, pode ser difícil descobrir quais pastas as tabelas do catálogo estão usando. O AWS Glue Data Quality pode encontrar as pastas ou arquivos específicos usados para o preenchimento do quadro de dados.
**nota**
Quando a inferência é usada, as regras baseadas em arquivos só podem detectar arquivos lidos com sucesso no DynamicFrame ou no DataFrame.
```
FileUniqueness > 0.5
```
**Tags de regras opcionais baseadas em arquivos:**
As tags permitem controlar o comportamento da regra.
**recentFiles**
Essa tag limita o número de arquivos processados ao manter primeiro o arquivo mais recente.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with recentFiles = 1
```
**uriRegex**
**nota**
A tag `uriRegex` está disponível no AWS Glue 5.0 e em versões posteriores.
Essa tag filtra os arquivos aplicando um padrão regex ao caminho do arquivo. Somente são processados os arquivos cujos caminhos correspondam ao padrão. Você também pode usar um lookahead negativo para excluir os arquivos que correspondam a um padrão.
```
# 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$).*"
```
**filterOrder**
**nota**
A tag `filterOrder` está disponível no AWS Glue 5.0 e em versões posteriores.
Quando você usa várias tags de filtro juntas, como `recentFiles` e `uriRegex`, a tag `filterOrder` controla a ordem na qual elas são aplicadas. A ordem padronizada é primeiro `recentFiles` e depois `uriRegex`.
```
FileUniqueness "s3://bucket/" > 0.5 with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
Essa tag garante que os arquivos não tenham nomes duplicados. O comportamento padrão é falso.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with matchFileName = "true"
```
Existem algumas considerações:
1. No ETL do AWS Glue, você deve ter a transformação **EvaluateDataQuality** imediatamente após uma transformação do Amazon S3 ou do Catálogo de Dados do AWS Glue.
1. Essa regra não funcionará nas sessões interativas do AWS Glue.
# FileSize
A regra FileSize permite que você garanta que os arquivos atendam a determinados critérios de tamanho. Isso é útil para os seguintes casos de uso:
1. Certificar-se de que os produtores não estejam enviando arquivos vazios ou substancialmente menores para processamento.
1. Certificar-se de que os buckets de destino não tenham arquivos menores, o que pode causar problemas de desempenho.
O FileSize reúne as seguintes métricas:
1. Conformidade: retorna a porcentagem de arquivos que atendem ao limite da regra que você estabeleceu
1. Contagem de arquivos: o número de arquivos que foram verificados pela regra
1. Tamanho mínimo do arquivo em bytes
1. Tamanho máximo do arquivo em bytes
```
Dataset.*.FileSize.Compliance: 1.00,
Dataset.*.FileCount: 8.00,
Dataset.*.MaximumFileSize: 327413121.00,
Dataset.*.MinimumFileSize: 204558920.00
```
A detecção de anomalias não é compatível com essas métricas.
**Validar o tamanho dos arquivos**
Essa regra será válida quando file.dat for maior do que 2 MB.
```
FileSize "s3://amzn-s3-demo-bucket/file.dat" > 2 MB
```
As unidades compatíveis incluem B (bytes), MB (megabytes), GB (gigabytes) e TB (terabytes).
**Validar o tamanho dos arquivos nas pastas**
```
FileSize "s3://bucket/" > 5 B
FileSize "s3://bucket/" < 2 GB
```
Essa regra será válida se 70% dos arquivos em s3://amzn-s3-demo-bucket tiverem entre 2 GB e 1 TB.
```
FileSize "s3://amzn-s3-demo-bucket/" between 2 GB and 1 TB with threshold > 0.7
```
**Dedução de nomes de arquivos diretamente de quadros de dados**
Você nem sempre precisa fornecer um caminho de arquivo. Por exemplo, quando você está criando a regra no Catálogo de Dados, pode ser difícil descobrir quais pastas as tabelas do catálogo estão usando. O AWS Glue Data Quality pode encontrar as pastas ou arquivos específicos usados para o preenchimento do quadro de dados.
**nota**
Esse recurso só funcionará quando os arquivos forem lidos com sucesso no DynamicFrame ou no DataFrame.
```
FileSize < 10 MB with threshold > 0.7
```
**Tags de regras opcionais baseadas em arquivos:**
As tags permitem controlar o comportamento da regra.
**recentFiles**
Essa tag limita o número de arquivos processados ao manter primeiro o arquivo mais recente.
```
FileSize "s3://amzn-s3-demo-bucket/" > 5 B with recentFiles = 1
```
**uriRegex**
**nota**
A tag `uriRegex` está disponível no AWS Glue 5.0 e em versões posteriores.
Essa tag filtra os arquivos aplicando um padrão regex ao caminho do arquivo. Somente são processados os arquivos cujos caminhos correspondam ao padrão. Você também pode usar um lookahead negativo para excluir os arquivos que correspondam a um padrão.
```
# 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$).*"
```
**filterOrder**
**nota**
A tag `filterOrder` está disponível no AWS Glue 5.0 e em versões posteriores.
Quando você usa várias tags de filtro juntas, como `recentFiles` e `uriRegex`, a tag `filterOrder` controla a ordem na qual elas são aplicadas. A ordem padronizada é primeiro `recentFiles` e depois `uriRegex`.
```
FileSize "s3://bucket/" > 5 B with recentFiles = 5 with uriRegex = "\.dat$" with filterOrder = ["uriRegex","recentFiles"]
```
**failFast**
Quando definida como `"true"`, a regra informa a falha imediatamente no primeiro arquivo que falhar na condição de tamanho, em vez de avaliar todos os arquivos e calcular uma taxa de conformidade.
```
FileSize "s3://bucket/" > 2 MB with failFast = "true"
```
Existem algumas considerações:
1. No ETL do AWS Glue, você deve ter a transformação EvaluateDataQuality imediatamente após uma transformação do Amazon S3 ou do Catálogo de Dados.
1. Essa regra não funcionará nas sessões interativas do AWS Glue.
# Usar APIs para medir e gerenciar a qualidade dos dados
Este tópico descreve como usar as APIs para medir e gerenciar a qualidade dos dados.
**Contents**
+ [Pré-requisitos](#using-apis-prerequisites)
+ [Trabalhar com as recomendações do AWS Glue Data Quality](#using-apis-recommendations)
+ [Trabalhar com conjuntos de regras do AWS Glue Data Quality](#using-apis-rulesets)
+ [Trabalhar com execuções do AWS Glue Data Quality](#using-apis-runs)
+ [Trabalhar com resultados do AWS Glue Data Quality](#using-apis-results)
## Pré-requisitos
+ Certifique-se de que sua versão do boto3 esteja atualizada para incluir a API do AWS Glue Data Quality mais recente.
+ Certifique-se de que sua versão da AWS CLI esteja atualizada, para incluir a CLI mais recente.
Se você estiver usando um trabalho do AWS Glue para executar essas APIs, poderá usar a opção a seguir para atualizar a biblioteca do boto3 para a versão mais recente:
```
—additional-python-modules boto3==
```
## Trabalhar com as recomendações do AWS Glue Data Quality
**Para iniciar uma recomendação do AWS Glue Data Quality, execute:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def start_data_quality_rule_recommendation_run(self, database_name, table_name, role_arn):
"""
Starts a recommendation run that is used to generate rules when you don't know what rules to write. AWS Glue Data Quality
analyzes the data and comes up with recommendations for a potential ruleset. You can then triage the ruleset
and modify the generated ruleset to your liking.
:param database_name: The name of the AWS Glue database which contains the dataset.
:param table_name: The name of the AWS Glue table against which we want a recommendation
:param role_arn: The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM) role that grants permission to let AWS Glue access the resources it needs.
"""
try:
response = self.client.start_data_quality_rule_recommendation_run(
DataSource={
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name
}
},
Role=role_arn
)
except ClientError as err:
logger.error(
"Couldn't start data quality recommendation run %s. Here's why: %s: %s", name,
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response['RunId']
```
Para uma execução de recomendação, você pode usar `pushDownPredicates` ou `catalogPartitionPredicates` para melhorar a performance e executar recomendações somente em partições específicas das fontes do catálogo.
```
client.start_data_quality_rule_recommendation_run(
DataSource={
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name,
'AdditionalOptions': {
'pushDownPredicate': "year=2022"
}
}
},
Role=role_arn,
NumberOfWorkers=2,
CreatedRulesetName=''
)
```
**Para obter os resultados de uma recomendação do AWS Glue Data Quality, execute:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_data_quality_rule_recommendation_run(self, run_id):
"""
Gets the specified recommendation run that was used to generate rules.
:param run_id: The id of the data quality recommendation run
"""
try:
response = self.client.get_data_quality_rule_recommendation_run(RunId=run_id)
except ClientError as err:
logger.error(
"Couldn't get data quality recommendation run %. Here's why: %s: %s", run_id,
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
Do objeto de resposta acima, você pode extrair o conjunto de regras recomendado pela execução, para usar em outras etapas:
```
print(response['RecommendedRuleset'])
Rules = [
RowCount between 2000 and 8000,
IsComplete "col1",
IsComplete "col2",
StandardDeviation "col3" between 58138330.8 and 64258155.09,
ColumnValues "col4" between 1000042965 and 1214474826,
IsComplete "col5"
]
```
**Para obter uma lista de todas as suas execuções de recomendação que podem ser filtradas e listadas:**
```
response = client.list_data_quality_rule_recommendation_runs(
Filter={
'DataSource': {
'GlueTable': {
'DatabaseName': '',
'TableName': ''
}
}
)
```
**Para cancelar as tarefas existentes de recomendação do AWS Glue Data Quality:**
```
response = client.cancel_data_quality_rule_recommendation_run(
RunId='dqrun-d4b6b01957fdd79e59866365bf9cb0e40fxxxxxxx'
)
```
## Trabalhar com conjuntos de regras do AWS Glue Data Quality
**Para criar um conjunto de regras do AWS Glue Data Quality:**
```
response = client.create_data_quality_ruleset(
Name='',
Ruleset='Rules = [IsComplete "col1", IsPrimaryKey "col2", RowCount between 2000 and 8000]',
TargetTable={
'TableName': '',
'DatabaseName': ''
}
)
```
**Para criar um conjunto de regras de qualidade de dados:**
```
response = client.get_data_quality_ruleset(
Name=''
)
print(response)
```
Você pode usar essa API para extrair o conjunto de regras:
```
print(response['Ruleset'])
```
**Para listar todos os conjuntos de regras de qualidade de dados para uma tabela:**
```
response = client.list_data_quality_rulesets()
```
Você pode usar a condição de filtro na API para filtrar todos os conjuntos de regras anexados a um banco de dados ou a uma tabela específica:
```
response = client.list_data_quality_rulesets(
Filter={
'TargetTable': {
'TableName': '',
'DatabaseName': ''
}
},
)
```
**Para atualizar um conjunto de regras de qualidade de dados:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def update_data_quality_ruleset(self, ruleset_name, ruleset_string):
"""
Update an AWS Glue Data Quality Ruleset
:param ruleset_name: The name of the AWS Glue Data Quality ruleset to update
:param ruleset_string: The DQDL ruleset string to update the ruleset with
"""
try:
response = self.client.update_data_quality_ruleset(
Name=ruleset_name,
Ruleset=ruleset_string
)
except ClientError as err:
logger.error(
"Couldn't update the AWS Glue Data Quality ruleset. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
**Para excluir um conjunto de regras de qualidade de dados:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def delete_data_quality_ruleset(self, ruleset_name):
"""
Delete a AWS Glue Data Quality Ruleset
:param ruleset_name: The name of the AWS Glue Data Quality ruleset to delete
"""
try:
response = self.client.delete_data_quality_ruleset(
Name=ruleset_name
)
except ClientError as err:
logger.error(
"Couldn't delete the AWS Glue Data Quality ruleset. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
## Trabalhar com execuções do AWS Glue Data Quality
**Para iniciar uma execução do AWS Glue Data Quality:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def start_data_quality_ruleset_evaluation_run(self, database_name, table_name, role_name, ruleset_list):
"""
Start an AWS Glue Data Quality evaluation run
:param database_name: The name of the AWS Glue database which contains the dataset.
:param table_name: The name of the AWS Glue table against which we want to evaluate.
:param role_arn: The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM) role that grants permission to let AWS Glue access the resources it needs.
:param ruleset_list: The list of AWS Glue Data Quality ruleset names to evaluate.
"""
try:
response = client.start_data_quality_ruleset_evaluation_run(
DataSource={
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name
}
},
Role=role_name,
RulesetNames=ruleset_list
)
except ClientError as err:
logger.error(
"Couldn't start the AWS Glue Data Quality Run. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response['RunId']
```
Lembre-se de que você pode passar um parâmetro `pushDownPredicate` ou `catalogPartitionPredicate` para garantir que sua execução de qualidade de dados só tenha como objetivo um conjunto específico de partições na tabela do catálogo. Por exemplo:
```
response = client.start_data_quality_ruleset_evaluation_run(
DataSource={
'GlueTable': {
'DatabaseName': '',
'TableName': '',
'AdditionalOptions': {
'pushDownPredicate': 'year=2023'
}
}
},
Role='',
NumberOfWorkers=5,
Timeout=123,
AdditionalRunOptions={
'CloudWatchMetricsEnabled': False
},
RulesetNames=[
'',
]
)
```
Você também pode configurar como as regras compostas em seu conjunto de regras são avaliadas, no nível ROW ou COLUMN. Para obter mais informações sobre o funcionamento das regras compostas, consulte [How composite rules work](dqdl.md#dqdl-syntax-composite-rules) na documentação.
Exemplo de como definir o método de avaliação de regra composta em sua solicitação:
```
response = client.start_data_quality_ruleset_evaluation_run(
DataSource={
'GlueTable': {
'DatabaseName': '',
'TableName': '',
'AdditionalOptions': {
'pushDownPredicate': 'year=2023'
}
}
},
Role='',
NumberOfWorkers=5,
Timeout=123,
AdditionalRunOptions={
'CompositeRuleEvaluationMethod':ROW
},
RulesetNames=[
'',
]
)
```
**Para obter informações sobre uma execução do AWS Glue Data Quality:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_data_quality_ruleset_evaluation_run(self, run_id):
"""
Get details about an AWS Glue Data Quality Run
:param run_id: The AWS Glue Data Quality run ID to look up
"""
try:
response = self.client.get_data_quality_ruleset_evaluation_run(
RunId=run_id
)
except ClientError as err:
logger.error(
"Couldn't look up the AWS Glue Data Quality run ID. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
**Para obter os resultados de uma execução do AWS Glue Data Quality:**
Para uma determinada execução do AWS Glue Data Quality, você pode extrair os resultados da avaliação da execução usando o seguinte método:
```
response = client.get_data_quality_ruleset_evaluation_run(
RunId='d4b6b01957fdd79e59866365bf9cb0e40fxxxxxxx'
)
resultID = response['ResultIds'][0]
response = client.get_data_quality_result(
ResultId=resultID
)
print(response['RuleResults'])
```
**Para listar todas as suas execuções do AWS Glue Data Quality:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def list_data_quality_ruleset_evaluation_runs(self, database_name, table_name):
"""
Lists all the AWS Glue Data Quality runs against a given table
:param database_name: The name of the database where the data quality runs
:param table_name: The name of the table against which the data quality runs were created
"""
try:
response = self.client.list_data_quality_ruleset_evaluation_runs(
Filter={
'DataSource': {
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name
}
}
}
)
except ClientError as err:
logger.error(
"Couldn't list the AWS Glue Quality runs. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
Você pode modificar a cláusula de filtro para só mostrar os resultados entre determinadas horas ou os resultados de execuções em tabelas específicas.
**Para interromper uma execução contínua do AWS Glue Data Quality:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def cancel_data_quality_ruleset_evaluation_run(self, result_id):
"""
Cancels a given AWS Glue Data Quality run
:param result_id: The result id of a AWS Glue Data Quality run to cancel
"""
try:
response = self.client.cancel_data_quality_ruleset_evaluation_run(
ResultId=result_id
)
except ClientError as err:
logger.error(
"Couldn't cancel the AWS Glue Data Quality run. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
## Trabalhar com resultados do AWS Glue Data Quality
**Para obter os resultados de uma execução do AWS Glue Data Quality:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_data_quality_result(self, result_id):
"""
Outputs the result of an AWS Glue Data Quality Result
:param result_id: The result id of an AWS Glue Data Quality run
"""
try:
response = self.client.get_data_quality_result(
ResultId=result_id
)
except ClientError as err:
logger.error(
"Couldn't get the AWS Glue Data Quality result. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
**Para ver as estatísticas coletadas para um determinado resultado de qualidade de dados:**
```
import boto3
from botocore.exceptions import ClientError
import logging
logger = logging.getLogger(__name__)
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_profile_for_data_quality_result(self, result_id):
"""
Outputs the statistic profile for a AWS Glue Data Quality Result
:param result_id: The result id of a AWS Glue Data Quality run
"""
try:
response = self.glue_client.get_data_quality_result(
ResultId=result_id
)
# the profile contains all statistics gathered for the result
profile_id = response['ProfileId']
profile = self.glue_client.list_data_quality_statistics(
ProfileId = profile_id
)
return profile
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality profile. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Para visualizar a série temporal de uma estatística coletada em várias execuções de qualidade de dados:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_statistics_for_data_quality_result(self, profile_id):
"""
Outputs an array of datapoints for each statistic in the input result.
:param result_id: The profile id of a AWS Glue Data Quality run
"""
try:
profile = self.glue_client.list_data_quality_statistics(
ProfileId = profile_id
)
statistics = [self.glue_client.list_data_quality_statistics(
StatisticId = s['StatisticId']
) for s in profile['Statistics']]
return statistics
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality statistics. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Para visualizar o modelo de detecção de anomalias para uma estatística específica:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_model_training_result_for_statistic(self, statistic_id, profile_id):
"""
Outputs the details (bounds) of anomaly detection training for the given statistic at the given profile.
:param statistic_id the model's statistic (the timeseries it is tracking)
:param profile_id the profile associated with the model (a point in the timeseries)
"""
try:
model = self.glue_client.get_data_quality_model_result(
ProfileId = profile_id, StatisticId = statistic_id
)
return model
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality model results. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Para excluir um ponto de dados da linha de base de detecção de anomalias de seu modelo estatístico:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def apply_exclusions_to_statistic(self, statistic_id, profile_ids):
"""
Annotate some points along a given statistic timeseries.
This example excludes the provided values; INCLUDE can also be used to undo this action.
:param statistic_id the statistic timeseries to annotate
:param profile_id the profiles we want to exclude (points in the timeseries)
"""
try:
response = self.glue_client.batch_put_data_quality_statistic_annotation(
InclusionAnnotations = [
{'ProfileId': prof_id,
'StatisticId': statistic_id,
'InclusionAnnotation': 'EXCLUDE'} for prof_id in profile_ids
]
)
return response['FailedInclusionAnnotations']
except ClientError as err:
logger.error(
"Couldn't store Data Quality annotations. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Para visualizar o status do treinamento do modelo de detecção de anomalias para uma estatística específica:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_model_training_status_for_statistic(self, statistic_id, profile_id):
"""
Outputs the status of anomaly detection training for the given statistic at the given profile.
:param statistic_id the model's statistic (the timeseries it is tracking)
:param profile_id the profile associated with the model (a point in the timeseries)
"""
try:
model = self.glue_client.get_data_quality_model(
ProfileId = profile_id, StatisticId = statistic_id
)
return model
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality statistics. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Para excluir todos os resultados de uma rodada específica de qualidade de dados das linhas de base de detecção de anomalias:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def apply_exclusions_to_profile(self, profile_id):
"""
Exclude datapoints produced by a run across statistic timeseries.
This example excludes the provided values; INCLUDE can also be used to undo this action.
:param profile_id the profiles we want to exclude (points in the timeseries)
"""
try:
response = self.glue_client.put_data_quality_profile_annotation(
ProfileId = profile_id,
InclusionAnnotation = "EXCLUDE"
)
return response
except ClientError as err:
logger.error(
"Couldn't store Data Quality annotations. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Para obter os resultados de uma determinada rodada qualidade de dados e exibir os resultados:**
Com um `runID` do AWS Glue Data Quality, você pode extrair o `resultID` para obter os resultados reais, conforme apresentado abaixo:
```
response = client.get_data_quality_ruleset_evaluation_run(
RunId='dqrun-abca77ee126abe1378c1da1ae0750d7dxxxx'
)
resultID = response['ResultIds'][0]
response = client.get_data_quality_result(
ResultId=resultID
)
print(resp['RuleResults'])
```
# Configurar alertas, implantações e agendamentos
Este tópico descreve como configurar alertas, implantações e agendamentos para o AWS Glue Data Quality.
**Contents**
+ [Configurar alertas e notificações na integração com o Amazon EventBridge](#data-quality-alerts-eventbridge)
+ [Opções de configuração adicionais para o padrão de eventos](#data-quality-alerts-eventbridge-config-options)
+ [Formatar notificações como e-mails](#data-quality-alerts-eventbridge-format-notifications)
+ [Configurar alertas e notificações na integração com o CloudWatch](#data-quality-alerts-cloudwatch)
+ [Consultar resultados de qualidade de dados para criar painéis](#data-quality-alerts-querying-results)
+ [Implantar regras de qualidade de dados usando o AWS CloudFormation](#data-quality-deploy-cfn)
+ [Agendar regras de qualidade de dados](#data-quality-scheduling-rules)
## Configurar alertas e notificações na integração com o Amazon EventBridge
O AWS Glue Data Quality é compatível com a publicação de eventos do EventBridge, que são emitidos após a conclusão de uma execução de avaliação do conjunto de regras de qualidade de dados. Com isso, você pode facilmente configurar alertas quando as regras de qualidade de dados não forem atendidas.
Aqui está um exemplo de evento quando você avalia os conjuntos de regras de qualidade de dados no catálogo de dados. Com essas informações, você pode revisar os dados disponibilizados com o Amazon EventBridge. Você pode emitir chamadas de API adicionais para obter mais detalhes. Por exemplo, chame a API `get_data_quality_result` com o ID do resultado para obter os detalhes de uma execução específica.
```
{
"version":"0",
"id":"abcdef00-1234-5678-9abc-def012345678",
"detail-type":"Data Quality Evaluation Results Available",
"source":"aws.glue-dataquality",
"account":"123456789012",
"time":"2017-09-07T18:57:21Z",
"region":"us-west-2",
"resources":[],
"detail":{
"context": {
"contextType": "GLUE_DATA_CATALOG",
"runId":"dqrun-12334567890",
"databaseName": "db-123",
"tableName": "table-123",
"catalogId": "123456789012"
},
"resultID": "dqresult-12334567890",
"rulesetNames": ["rulset1"],
"state":"SUCCEEDED",
"score": 1.00,
"rulesSucceeded": 100,
"rulesFailed": 0,
"rulesSkipped": 0
}
}
```
Este é um exemplo de evento que é publicado quando você avalia conjuntos de regras de qualidade de dados nos cadernos do AWS Glue ETL ou do AWS Glue Studio.
```
{
"version":"0",
"id":"abcdef00-1234-5678-9abc-def012345678",
"detail-type":"Data Quality Evaluation Results Available",
"source":"aws.glue-dataquality",
"account":"123456789012",
"time":"2017-09-07T18:57:21Z",
"region":"us-west-2",
"resources":[],
"detail":{
"context": {
"contextType": "GLUE_JOB",
"jobId": "jr-12334567890",
"jobName": "dq-eval-job-1234",
"evaluationContext": "",
}
"resultID": "dqresult-12334567890",
"rulesetNames": ["rulset1"],
"state":"SUCCEEDED",
"score": 1.00
"rulesSucceeded": 100,
"rulesFailed": 0,
"rulesSkipped": 0
}
}
```
Para execuções de avaliação de qualidade de dados no catálogo de dados e em trabalhos de ETL, a opção **Publicar métricas no Amazon CloudWatch**, selecionada por padrão, deve permanecer selecionada para que a publicação do EventBridge funcione.
**Configurar eventos e notificações**
![\[Propriedades de qualidade de dados no AWS CloudFormation\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/data-quality-properties-cfn.png)
Para receber os eventos emitidos e definir destinos, você deve configurar as regras do Amazon EventBridge. Para criar regras:
1. Abra o console do Amazon EventBridge.
1. Escolha **Regras** na seção **Barramentos** da barra de navegação.
1. Selecione **Create Rule**.
1. Em **Definir detalhes da regra**:
1. Em Nome, insira `myDQRule`.
1. Insira uma descrição (opcional).
1. Para barramento de eventos, selecione seu barramento de eventos. Se você não tiver um, deixe o padrão.
1. Em **Tipo de regra**, escolha **Regra com um padrão de eventos**.
1. Em **Criar padrão de eventos**:
1. Como a origem dos eventos, selecione **Eventos da AWS ou eventos de parceiros do EventBridge**.
1. Pule a seção de exemplo de evento.
1. Como método de criação, selecione **Usar formulário de padrão**.
1. Para padrão de eventos:
1. Selecione **Serviços da AWS** para Fonte do evento.
1. Selecione **Glue Data Quality** para serviço da AWS.
1. Selecione **Resultados da avaliação de qualidade de dados disponíveis** para Tipo de evento.
1. Selecione **FALHA** para Estados específicos. Em seguida, você verá um padrão de evento como este:
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"state": ["FAILED"]
}
}
```
1. Para obter mais opções de conexão, consulte [Opções de configuração adicionais para o padrão de eventos](#data-quality-alerts-eventbridge-config-options).
1. Em **Selecionar alvos**:
1. Em **Tipos de destino**, selecione **Serviço da AWS**.
1. **Use o menu suspenso **Selecionar um destino** para escolher o AWS serviço ao qual você deseja se conectar (SNS, Lambda, SQS etc.) e escolha Avançar.**
1. Em **Configurar tag(s)**, clique em **Adicionar novas tags** para adicionar tags opcionais e escolha **Avançar**.
1. Você verá uma página de resumo de todas as seleções. Escolha **Criar regra** na parte inferior.
### Opções de configuração adicionais para o padrão de eventos
Além de filtrar o evento baseado em sucesso ou fracasso, talvez você queira filtrar ainda mais os eventos com base em outros parâmetros.
Para fazer isso, vá para a seção Padrão de eventos e selecione **Editar padrão** para especificar parâmetros adicionais. Observe que os campos no padrão de eventos diferenciam maiúsculas de minúsculas. Estes são exemplos de configuração do padrão de eventos.
Para capturar eventos de uma tabela específica avaliando conjuntos de regras específicos, use esse tipo de padrão:
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"context": {
"contextType": ["GLUE_DATA_CATALOG"],
"databaseName": "db-123",
"tableName": "table-123",
},
"rulesetNames": ["ruleset1", "ruleset2"]
"state": ["FAILED"]
}
}
```
Para capturar eventos de trabalhos específicos na experiência de ETL, use esse tipo de padrão:
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"context": {
"contextType": ["GLUE_JOB"],
"jobName": ["dq_evaluation_job1", "dq_evaluation_job2"]
},
"state": ["FAILED"]
}
}
```
Para capturar eventos com uma pontuação abaixo de um limite específico (por exemplo, 70%):
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"score": [{
"numeric": ["<=", 0.7]
}]
}
}
```
### Formatar notificações como e-mails
Às vezes, você precisa enviar uma notificação por e-mail bem formatada para as equipes da sua empresa. Você pode usar o Amazon EventBridge e o AWS Lambda para fazer isso.
![\[Notificação de qualidade de dados formatada como um e-mail\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/data_quality_sample_email.png)
O exemplo de código a seguir pode ser usado para formatar as notificações de qualidade de dados para gerar e-mails.
```
import boto3
import json
from datetime import datetime
sns_client = boto3.client('sns')
glue_client = boto3.client('glue')
sns_topic_arn = 'arn:aws:sns:::'
def lambda_handler(event, context):
log_metadata = {}
message_text = ""
subject_text = ""
if event['detail']['context']['contextType'] == 'GLUE_DATA_CATALOG':
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['tableName'] = str(event['detail']['context']['tableName'])
log_metadata['databaseName'] = str(event['detail']['context']['databaseName'])
log_metadata['runId'] = str(event['detail']['context']['runId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_table_name: {}\n".format(log_metadata['tableName'])
message_text += "glue_database_name: {}\n".format(log_metadata['databaseName'])
message_text += "run_id: {}\n".format(log_metadata['runId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
else:
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['jobName'] = str(event['detail']['context']['jobName'])
log_metadata['jobId'] = str(event['detail']['context']['jobId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_job_name: {}\n".format(log_metadata['jobName'])
message_text += "job_id: {}\n".format(log_metadata['jobId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
resultID = str(event['detail']['resultId'])
response = glue_client.get_data_quality_result(ResultId=resultID)
RuleResults = response['RuleResults']
message_text += "\n\nruleset details evaluation steps results:\n\n"
subresult_info = []
for dic in RuleResults:
subresult = "Name: {}\t\tResult: {}\t\tDescription: \t{}".format(dic['Name'], dic['Result'], dic['Description'])
if 'EvaluationMessage' in dic:
subresult += "\t\tEvaluationMessage: {}".format(dic['EvaluationMessage'])
subresult_info.append({
'Name': dic['Name'],
'Result': dic['Result'],
'Description': dic['Description'],
'EvaluationMessage': dic.get('EvaluationMessage', '')
})
message_text += "\n" + subresult
log_metadata['resultrun'] = subresult_info
sns_client.publish(
TopicArn=sns_topic_arn,
Message=message_text,
Subject=subject_text
)
return {
'statusCode': 200,
'body': json.dumps('Message published to SNS topic')
}
```
## Configurar alertas e notificações na integração com o CloudWatch
Nossa abordagem recomendada é configurar alertas de qualidade de dados usando o Amazon EventBridge, porque o Amazon EventBridge só precisa ser configurado uma única vez para alertar os clientes. Porém, alguns clientes preferem o Amazon CloudWatch por sua familiaridade. Para esses clientes, oferecemos a integração com o Amazon CloudWatch.
Cada avaliação do AWS Glue Data Quality emite um par de métricas denominadas `glue.data.quality.rules.passed` (indicando o número de regras aprovadas) e `glue.data.quality.rules.failed` (indicando o número de regras que falharam) por execução de qualidade de dados. Você pode usar essa métrica emitida para criar alarmes para avisar os usuários se uma determinada execução de qualidade de dados ficar abaixo de um limite. Para começar a configurar um alarme que enviaria um e-mail por meio de uma notificação do Amazon SNS, siga as etapas abaixo:
Para começar a configurar um alarme que enviaria um e-mail por meio de uma notificação do Amazon SNS, siga as etapas abaixo:
1. Abra o console do Amazon CloudWatch.
1. Escolha **Todas as métricas** em **Métricas**. Você verá um namespace adicional em Namespaces personalizados intitulado Glue Data Quality.
**nota**
Ao iniciar uma execução do AWS Glue Data Quality, certifique-se de que a caixa de seleção **Publicar métricas no Amazon CloudWatch** esteja marcada. Caso contrário, as métricas dessa execução específica não serão publicadas no Amazon CloudWatch.
No namespace `Glue Data Quality`, você pode ver as métricas que estão sendo emitidas por tabela, por conjunto de regras. Para a finalidade deste tópico, usaremos a regra `glue.data.quality.rules.failed` e o alarme se esse valor ultrapassar 1 (indicando que, se observarmos um número de avaliações de regras com falha maior do que 1, queremos ser notificados).
1. Para criar o alarme, escolha **Todos os alarmes** em **Alarmes**.
1. Selecione **Criar alarme**.
1. Escolha **Selecionar métrica**.
1. Selecione a métrica `glue.data.quality.rules.failed` correspondente à tabela que você criou e depois escolha **Selecionar métrica**.
1. Na guia **Especificar métricas e condições**, na seção **Métricas**:
1. Em **Estatística**, selecione **Soma**.
1. Em **Período**, escolha **1 minuto**.
1. Na seção **Condições**:
1. Em **Tipo de limite**, escolha **Estático**.
1. para **Sempre que glue.data.quality.rules.failed for...**, selecione **Maior/Igual**.
1. Por **do que...** , insira **1** como o valor limite.
Essas seleções implicam que, se a métrica `glue.data.quality.rules.failed` emitir um valor maior ou igual a 1, acionaremos um alarme. Porém, se não houver dados, nós a trataremos como aceitável.
1. Escolha **Próximo**.
1. Em **Configurar ações**:
1. Em **Gatilho de estado do alarme**, escolha **Em alarme**.
1. Em **Enviar uma notificação para o seguinte tópico do SNS**, escolha **Criar um novo tópico para enviar uma notificação por um novo tópico do SNS**.
1. Em **Endpoints de e-mail que receberão a notificação**, insira o endereço de e-mail. Depois clique em **Criar tópico**.
1. Escolha **Avançar**.
1. Em **Nome secreto**, insira `myFirstDQAlarm` e escolha **Avançar**.
1. Você verá uma página de resumo de todas as seleções. Escolha **Criar alarme** na parte inferior.
Agora você pode ver o alarme sendo criado no painel de alarmes do Amazon CloudWatch.
## Consultar resultados de qualidade de dados para criar painéis
Talvez você queira criar um painel para exibir seus resultados de qualidade de dados. Há duas maneiras de fazer isso:
**Configure o Amazon EventBridge com o seguinte códigopara gravar os dados no Amazon S3:**
```
import boto3
import json
from datetime import datetime
s3_client = boto3.client('s3')
glue_client = boto3.client('glue')
s3_bucket = 's3-bucket-name'
def write_logs(log_metadata):
try:
filename = datetime.now().strftime("%m%d%Y%H%M%S") + ".json"
key_opts = {
'year': datetime.now().year,
'month': "{:02d}".format(datetime.now().month),
'day': "{:02d}".format(datetime.now().day),
'filename': filename
}
s3key = "gluedataqualitylogs/year={year}/month={month}/day={day}/{filename}".format(**key_opts)
s3_client.put_object(Bucket=s3_bucket, Key=s3key, Body=json.dumps(log_metadata))
except Exception as e:
print(f'Error writing logs to S3: {e}')
def lambda_handler(event, context):
log_metadata = {}
message_text = ""
subject_text = ""
if event['detail']['context']['contextType'] == 'GLUE_DATA_CATALOG':
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['tableName'] = str(event['detail']['context']['tableName'])
log_metadata['databaseName'] = str(event['detail']['context']['databaseName'])
log_metadata['runId'] = str(event['detail']['context']['runId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_table_name: {}\n".format(log_metadata['tableName'])
message_text += "glue_database_name: {}\n".format(log_metadata['databaseName'])
message_text += "run_id: {}\n".format(log_metadata['runId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
else:
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['jobName'] = str(event['detail']['context']['jobName'])
log_metadata['jobId'] = str(event['detail']['context']['jobId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_job_name: {}\n".format(log_metadata['jobName'])
message_text += "job_id: {}\n".format(log_metadata['jobId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
resultID = str(event['detail']['resultId'])
response = glue_client.get_data_quality_result(ResultId=resultID)
RuleResults = response['RuleResults']
message_text += "\n\nruleset details evaluation steps results:\n\n"
subresult_info = []
for dic in RuleResults:
subresult = "Name: {}\t\tResult: {}\t\tDescription: \t{}".format(dic['Name'], dic['Result'], dic['Description'])
if 'EvaluationMessage' in dic:
subresult += "\t\tEvaluationMessage: {}".format(dic['EvaluationMessage'])
subresult_info.append({
'Name': dic['Name'],
'Result': dic['Result'],
'Description': dic['Description'],
'EvaluationMessage': dic.get('EvaluationMessage', '')
})
message_text += "\n" + subresult
log_metadata['resultrun'] = subresult_info
write_logs(log_metadata)
return {
'statusCode': 200,
'body': json.dumps('Message published to SNS topic')
}
```
Depois de gravar no Amazon S3, você pode usar os crawlers do AWS Glue para se registrar no Athena e consultar as tabelas.
**Configure um local no Amazon S3 durante uma avaliação de qualidade de dados:**
Ao executar tarefas de qualidade de dados no catálogo de dados do AWS Glue ou no AWS Glue ETL, você pode fornecer um local no Amazon S3 para gravar os resultados de qualidade de dados. Você pode usar a sintaxe abaixo para criar uma tabela referenciando o destino para o qual ler os resultados de qualidade dos dados.
Observe que você deve executar as consultas `CREATE EXTERNAL TABLE` e `MSCK REPAIR TABLE` separadamente.
```
CREATE EXTERNAL TABLE (
catalogid string,
databasename string,
tablename string,
dqrunid string,
evaluationstartedon timestamp,
evaluationcompletedon timestamp,
rule string,
outcome string,
failurereason string,
evaluatedmetrics string)
PARTITIONED BY (
`year` string,
`month` string,
`day` string)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES (
'paths'='catalogId,databaseName,dqRunId,evaluatedMetrics,evaluationCompletedOn,evaluationStartedOn,failureReason,outcome,rule,tableName')
STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://glue-s3-dq-bucket-us-east-2-results/'
TBLPROPERTIES (
'classification'='json',
'compressionType'='none',
'typeOfData'='file');
```
```
MSCK REPAIR TABLE ;
```
Depois de criar a tabela acima, você poderá executar consultas analíticas usando o Amazon Athena.
## Implantar regras de qualidade de dados usando o AWS CloudFormation
Você pode usar o AWS CloudFormation para criar regras de qualidade de dados. Para obter mais informações, consulte [AWS CloudFormation para o AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/populate-with-cloudformation-templates.html).
## Agendar regras de qualidade de dados
Você pode agendar as regras de qualidade de dados usando os seguintes métodos:
+ Agende as regras de qualidade no dados do catálogo de dados: nenhum usuário de código pode usar essa opção para agendar facilmente suas verificações de qualidade de dados. O AWS O Glue Data Quality criará a agenda no Amazon EventBridge. Para agendar regras de qualidade de dados:
+ Navegue até o conjunto de regras e clique em **Executar**.
+ Na **Frequência de execução**, selecione a agenda desejada e forneça um **Nome de tarefa**. Esse nome de tarefa será o nome da sua agenda no EventBridge.
+ Use o Amazon EventBridge e o AWS Step Functions para orquestrar avaliações e recomendações para regras de qualidade de dados.
# Criptografia de dados em repouso no AWS Glue Data Quality
O AWS Glue Data Quality fornece criptografia por padrão para proteger dados sensíveis do cliente em repouso usando chaves de criptografia de propriedade da AWS.
## chaves de propriedade da AWS
O AWS Glue Data Quality usa essas chaves para criptografar automaticamente os ativos do Data Quality dos clientes. Você não pode visualizar, gerenciar nem usar chaves de propriedade da AWS, tampouco auditar o uso delas. No entanto, você não precisa realizar nenhuma ação nem alterar nenhum programa para proteger as chaves que criptografam seus dados. Para obter mais informações, consulte [AWS owned keys](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk) no Guia do desenvolvedor do AWS KMS.
A criptografia de dados em repouso por padrão reduz a sobrecarga operacional e a complexidade envolvidas na proteção de dados confidenciais. Ao mesmo tempo, ela permite que você crie aplicações seguras que atendam aos rigorosos requisitos regulatórios e de conformidade de criptografia.
Embora você não possa desabilitar essa camada de criptografia nem selecionar um tipo alternativo de criptografia, é possível adicionar uma segunda camada de criptografia sobre as chaves de criptografia existentes pertencentes à AWS mediante a escolha de uma chave gerenciada pelo cliente ao criar seus recursos do Data Quality.
## Chaves gerenciadas pelo cliente
**Chaves gerenciadas pelo cliente**: o AWS Glue Data Quality é compatível com o uso de uma chave simétrica gerenciada pelo cliente que você cria, assume e gerencia. Isso adiciona uma segunda camada de criptografia sobre a criptografia existente pertencente à AWS. Como você tem controle total dessa camada de criptografia, é possível realizar tarefas como:
+ Estabelecer e manter as políticas de chave
+ Estabelecer e manter políticas do IAM
+ Ativar e desativar políticas de chaves
+ Alternar os materiais de criptografia de chave
+ Adicionar etiquetas
+ Criar réplicas de chaves
+ Chaves de agendamento para exclusão
Para obter mais informações, consulte [Chaves gerenciadas pelo cliente](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) no Guia do desenvolvedor do AWS KMS.
A tabela a seguir resume como o AWS Glue Data Quality criptografa diferentes ativos do Data Quality.
| Tipo de dados | Criptografia de chave de propriedade da AWS | Criptografia de chave gerenciada pelo cliente |
| --- | --- | --- |
| **Conjunto de regras do Data Quality** Cadeia de caracteres do conjunto de regras da DQDL que é indicada pelo conjunto persistente de regras do DQ. Por enquanto, esses conjuntos persistentes de regras são usados apenas na experiência do Catálogo de Dados do AWS Glue. | Habilitado | Habilitado |
| **Resultados de regra/analisador do Data Quality** Artefatos de resultado que contêm o status de aprovação/reprovação de cada regra em um conjunto de regras, bem como as métricas coletadas pelas regras e pelos analisadores. | Habilitado | Habilitado |
| **Observações** As observações são geradas quando há a detecção de uma anomalia nos dados. Elas contêm informações sobre os limites superior e inferior esperados, além de uma regra sugerida com base nesses limites. Se geradas, elas serão exibidas com os resultados do Data Quality. | Habilitado | Habilitado |
| **Statistics** Essa opção contém informações sobre métricas coletadas após avaliar os dados fornecidos por um conjunto de regras específico, como o valor da métrica (p. ex., RowCount, completude), nomes de colunas e outros metadados. | Habilitado | Habilitado |
| **Modelos estatísticos de detecção de anomalias** Os modelos estatísticos contêm a série temporal dos limites superior e inferior de uma determinada métrica gerada com base em avaliações anteriores dos dados do cliente. | Habilitado | Habilitado |
**nota**
O AWS Data Quality habilita automaticamente a criptografia em repouso usando chaves pertencentes à AWS para proteger dados de identificação pessoal sem nenhum custo. No entanto, AWS KMS há cobrança aplicável pelo uso de uma chave gerenciada pelo cliente. Para obter mais informações sobre precificação, consulte [Precificação do AWS KMS](https://aws.amazon.com/kms/pricing/).
Para obter mais informações sobre o AWS KMS, consulte [AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
## Criar uma chave gerenciada pelo cliente
Você pode criar uma chave simétrica gerenciada pelo cliente usando o Console de gerenciamento da AWS ou as APIs do AWS KMS.
**Para criar uma chave gerenciada pelo cliente:**
+ Siga as etapas em [Creating symmetric encryption AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) no Guia do desenvolvedor do AWS Key Management Service.
### Política de chave
As políticas de chaves controlam o acesso à chave gerenciada pelo seu cliente. Cada chave gerenciada pelo cliente deve ter exatamente uma política de chaves, que contém declarações que determinam quem pode usar a chave e como pode usá-la. Ao criar a chave gerenciada pelo cliente, é possível especificar uma política de chave. Para obter mais informações, consulte [Key policies in AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) no Guia do desenvolvedor do AWS Key Management Service.
Para usar sua chave gerenciada pelo cliente com seus recursos do Data Quality, é necessário permitir as seguintes operações de API na política de chave:
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html): descriptografa o texto cifrado que foi criptografado por uma chave do AWS KMS usando `GenerateDataKeyWithoutPlaintext`.
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html) – Fornecer os principais detalhes gerenciados pelo cliente para permitir que o Amazon Location valide a chave.
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html): retorna uma chave de dados simétrica exclusiva para uso fora do AWS KMS. Essa operação retorna uma chave de dados criptografada com a chave do KMS de criptografia simétrica que você especifica. Os bytes na chave são aleatórios e não estão relacionados ao chamador ou à chave do KMS. Isso é usado para reduzir as chamadas do KMS que o cliente precisa fazer.
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html): descriptografa o texto cifrado e, em seguida, o recriptografa inteiramente no AWS KMS. Você pode usar essa operação para alterar a chave do KMS sob a qual os dados são criptografados, como quando você [alterna manualmente](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html#rotate-keys-manually) uma chave do KMS ou altera a chave do KMS que protege um texto cifrado. Você também pode usá-la para recriptografar o texto cifrado com a mesma chave do KMS, assim como para alterar o [contexto de criptografia](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) de um texto cifrado.
A seguir estão exemplos de declarações de política que você pode adicionar ao Amazon Location:
```
"Statement" : [
{
"Sid" : "Allow access to principals authorized to use AWS Glue Data Quality",
"Effect" : "Allow",
"Principal" : {
"AWS": "arn:aws:iam:::role/ExampleRole"
},
"Action" : [
"kms:Decrypt",
"kms:DescribeKey",
"kms:GenerateDataKeyWithoutPlaintext",
"kms:ReEncrypt*"
],
"Resource" : "*",
"Condition" : {
"StringEquals" : {
"kms:ViaService" : "glue.amazonaws.com",
"kms:CallerAccount" : "111122223333"
}
},
{
"Sid": "Allow access for key administrators",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action" : [
"kms:*"
],
"Resource": "arn:aws:kms:region:111122223333:key/key_ID"
},
{
"Sid" : "Allow read-only access to key metadata to the account",
"Effect" : "Allow",
"Principal" : {
"AWS" : "arn:aws:iam::111122223333:root"
},
"Action" : [
"kms:Describe*",
"kms:Get*",
"kms:List*",
],
"Resource" : "*"
}
]
```
### Observações sobre o uso de chaves do KMS no AWS Glue Data Quality
O AWS Glue Data Quality não é compatível com transições de chave. Isso significa que se você criptografar seus ativos do Data Quality com a chave A e decidir mudar para a chave B, não vamos criptografar novamente os dados que foram criptografados com a chave A para usar a chave B. Você ainda poderá mudar para a chave B, mas precisará manter o acesso à chave A para acessar dados previamente criptografados com a chave A.
Para obter mais informações sobre como especificar permissões em uma política, consulte [Permissions for AWS services in key policies](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-services.html) no Guia do desenvolvedor do AWS Key Management Service.
Para obter mais informações sobre solução de problemas de acesso a chaves, consulte [Troubleshooting key access](https://docs.aws.amazon.com/kms/latest/developerguide/policy-evaluation.html) no Guia do desenvolvedor do AWS Key Management Service.
## Criar uma configuração de segurança
No AWS Glue, o [recurso configurações de segurança](encryption-security-configuration.md) contém as propriedades que são necessárias quando você grava dados criptografados.
**Para criptografar seus ativos de qualidade de dados:**
1. Em **Configurações de criptografia**, em **Configurações avançadas**, escolha **Habilitar criptografia do Data Quality**.
1. Selecione sua chave do KMS ou escolha **Criar uma chave do AWS KMS**.
![\[A captura de tela mostra a página Adicionar configuração de segurança. A opção Habilitar criptografia do Data Quality está selecionada.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/data-quality-add-security-configuration.png)
## Contexto de criptografia do AWS Glue Data Quality
Um [contexto de criptografia](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) é um conjunto opcional de pares de chave/valor que pode conter informações contextuais adicionais sobre os dados.
O AWS KMS usa o contexto de criptografia como [dados autenticados adicionais](https://docs.aws.amazon.com/crypto/latest/userguide/cryptography-concepts.html#term-aad) para viabilizar a [criptografia autenticada](https://docs.aws.amazon.com/crypto/latest/userguide/cryptography-concepts.html#term-aad). Quando você inclui um contexto de criptografia em uma solicitação para criptografar dados, o AWS KMS vincula de forma criptográfica o contexto da criptografia aos dados criptografados. Para descriptografar os dados, você inclui o mesmo contexto de criptografia na solicitação.
### Exemplo de contexto de criptografia do AWS Glue Data Quality
```
"encryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "beacon:ACTIVE"
}
```
### Uso do contexto de criptografia para monitoramento
Ao usar uma chave simétrica gerenciada pelo cliente para criptografar seu rastreador ou sua coleção de geocercas, você também pode usar o contexto de criptografia nos registros e logs de auditoria para identificar como a chave gerenciada pelo cliente está sendo usada. O contexto de criptografia também aparece nos logs gerados pelo AWS CloudTrail ou Amazon CloudWatch Logs.
## Monitoramento das suas chaves de criptografia para o AWS Glue Data Quality
Ao usar uma chave do AWS KMS gerenciada pelo cliente com seus recursos do AWS Glue Data Quality, você pode usar o AWS CloudTrail ou o Amazon CloudWatch Logs para rastrear as solicitações que o AWS Glue Data Quality envia para o AWS KMS.
Os exemplos a seguir são eventos do AWS CloudTrail para `GenerateDataKeyWithoutPlainText` e `Decrypt` para monitorar as operações do KMS chamadas pelo AWS Glue Data Quality para acessar dados criptografados por sua chave gerenciada pelo cliente.
**Decrypt**
```
{
"eventVersion": "1.09",
"userIdentity": {
"type": "AssumedRole",
"arn": "arn:aws:sts::111122223333:role/CustomerRole",
"accountId": "111122223333",
"invokedBy": "glue.amazonaws.com"
},
"eventTime": "2024-07-02T20:03:10Z",
"eventSource": "kms.amazonaws.com",
"eventName": "Decrypt",
"awsRegion": "us-east-1",
"sourceIPAddress": "glue.amazonaws.com",
"userAgent": "glue.amazonaws.com",
"requestParameters": {
"keyId": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"encryptionAlgorithm": "SYMMETRIC_DEFAULT",
"encryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:ACTIVE",
"version": "branch:version:ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE"
}
},
"responseElements": null,
"requestID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"eventID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"readOnly": true,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
}
],
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "111122223333",
"eventCategory": "Management"
}
```
**GenerateDataKeyWithoutPlaintext**
```
{
"eventVersion": "1.09",
"userIdentity": {
"type": "AssumedRole",
"arn": "arn:aws:sts::111122223333:role/CustomerRole",
"accountId": "111122223333",
"invokedBy": "glue.amazonaws.com"
},
"eventTime": "2024-07-02T20:03:10Z",
"eventSource": "kms.amazonaws.com",
"eventName": "GenerateDataKeyWithoutPlaintext",
"awsRegion": "us-east-1",
"sourceIPAddress": "glue.amazonaws.com",
"userAgent": "glue.amazonaws.com",
"requestParameters": {
"keyId": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"encryptionAlgorithm": "SYMMETRIC_DEFAULT",
"encryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:version:ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE"
}
},
"responseElements": null,
"requestID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"eventID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"readOnly": true,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
}
],
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "111122223333",
"eventCategory": "Management"
}
```
**ReEncyrpt**
```
{
"eventVersion": "1.09",
"userIdentity": {
"type": "AssumedRole",
"arn": "arn:aws:sts::111122223333:role/CustomerRole",
"accountId": "111122223333",
"invokedBy": "glue.amazonaws.com"
},
"eventTime": "2024-07-17T21:34:41Z",
"eventSource": "kms.amazonaws.com",
"eventName": "ReEncrypt",
"awsRegion": "us-east-1",
"sourceIPAddress": "glue.amazonaws.com",
"userAgent": "glue.amazonaws.com",
"requestParameters": {
"destinationEncryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:ACTIVE"
"version": "branch:version:12345678-SAMPLE"
},
"destinationKeyId": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"sourceAAD": "1234567890-SAMPLE+Z+lqoYOHj7VtWxJLrvh+biUFbliYDAQkobM=",
"sourceKeyId": "arn:aws:kms:ap-southeast-2:585824196334:key/17ca05ca-a8c1-40d7-b7fd-30abb569a53a",
"destinationEncryptionAlgorithm": "SYMMETRIC_DEFAULT",
"sourceEncryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:version:ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE"
},
"destinationAAD": "1234567890-SAMPLE",
"sourceEncryptionAlgorithm": "SYMMETRIC_DEFAULT"
},
"responseElements": null,
"requestID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"eventID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"readOnly": true,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
},
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
}
],
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "111122223333",
"eventCategory": "Management"
}
```
## Saiba mais
Os recursos a seguir fornecem mais informações sobre a criptografia de dados em repouso.
+ Para obter mais informações sobre [AWS Key Management Service basic concepts](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html), consulte o Guia do desenvolvedor do AWS Key Management Service.
+ Para obter mais informações sobre [Security best practices for AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/best-practices.html) consulte o Guia do desenvolvedor do AWS Key Management Service.
# Solução de problemas de erros do AWS Glue Data Quality
Se você encontrar erros no AWS Glue Data Quality, use as seguintes soluções para ajudar você a encontrar a fonte dos problemas e corrigi-los.
**Contents**
+ [Erro: módulo AWS Glue Data Quality ausente](#data-quality-trouble-error-1)
+ [Erro: permissões insuficientes do AWS Lake Formation](#data-quality-trouble-error-2)
+ [Erro: os conjuntos de regras não têm nomes exclusivos](#data-quality-trouble-error-3)
+ [Erro: tabelas com caracteres especiais](#data-quality-trouble-error-4)
+ [Erro: erro de estouro com um conjunto de regras grande](#data-quality-trouble-error-5)
+ [Erro: o status geral da regras é com falha](#data-quality-trouble-error-6)
+ [AnalysisException: não é possível verificar a existência de banco de dados padrão](#data-quality-trouble-error-7)
+ [Mensagem de erro: o mapa de chaves fornecido não é adequado para os quadros de dados fornecidos](#data-quality-trouble-error-8)
+ [Exceção na classe de usuário: java.lang.RuntimeException: falha ao buscar dados. Verificar os logs do CloudWatch para obter mais detalhes](#data-quality-trouble-error-9)
+ [ERRO DE INICIALIZAÇÃO: erro ao baixar o S3 para o bucket](#data-quality-trouble-error-10)
+ [InvalidInputException (status: 400): as regras DataQuality não podem ser analisadas](#data-quality-trouble-error-11)
+ [Erro: o Eventbridge não está acionando trabalhos do Glue DQ com base na agenda que eu configurei](#data-quality-trouble-error-12)
+ [Erros de CustomSQL](#data-quality-trouble-error-13)
+ [Regras dinâmicas](#data-quality-trouble-error-14)
+ [Exceção na classe de usuário: org.apache.spark.sql.AnalysisException: org.apache.hadoop.hive.ql.metadata.HiveException](#data-quality-trouble-error-15)
+ [UNCLASSIFIED\$1ERROR; IllegalArgumentException: erro de análise: nenhuma regra ou analisador fornecido, nenhuma alternativa viável na entrada](#data-quality-trouble-error-16)
## Erro: módulo AWS Glue Data Quality ausente
**Mensagem de erro**: nenhum módulo denominado 'awsgluedq'.
**Resolução**: esse erro ocorre quando você executa o AWS Glue Data Quality em uma versão não compatível. O AWS Glue Data Quality é compatível com o Glue versão 3.0 ou posterior.
## Erro: permissões insuficientes do AWS Lake Formation
**Mensagem de erro**: exceção na classe de usuário `com.amazonaws.services.glue.model.AccessDeniedException`: Permissões insuficientes do Lake Formation em impact\$1sdg\$1involvement (Serviço: AWS Glue; Código de status: 400; Código de erro: AccessDeniedException; ID da solicitação: 465ae693-b7ba-4df0-a4e4-6b17xxxxxxxx; Proxy: nulo).
**Resolução**: você precisa fornecer permissões suficientes no AWS Lake Formation.
## Erro: os conjuntos de regras não têm nomes exclusivos
**Mensagem de erro**: exceção na classe de usuário:... services.glue.model.AlreadyExistsException: já existe outro conjunto de regras com o mesmo nome.
**Resolução**: os conjuntos de regras precisam ser exclusivos.
## Erro: tabelas com caracteres especiais
**Mensagem de erro**: exceção na classe de usuário: org.apache.spark.sql.AnalysisException: não é possível resolver colunas de entrada dadas de ''C'': [primary.data\$1end\$1time, primary.data\$1start\$1time, primary.end\$1time, primary.last\$1updated, primary.message, primary.process\$1date, primary.rowhash, primary.run\$1by, primary.run\$1id, primary.start\$1time, primary.status]; Linha 1 posição 44;.
**Resolução**: existe uma limitação atual de que o AWS Glue Data Quality não pode ser executado em tabelas com caracteres especiais, como ".".
## Erro: erro de estouro com um conjunto de regras grande
**Mensagem de erro**: exceção na classe de usuário: java.lang.StackOverflowError.
**Resolução**: se você tiver um conjunto de regras grande com mais de 2 mil regras, poderá encontrar esse problema. Divida as regras em vários conjuntos de regras.
## Erro: o status geral da regras é com falha
**Condição de erro**: meu conjunto de regras teve sucesso, mas o status geral de regras é com falha.
**Resolução**: esse erro provavelmente ocorreu porque você escolheu a opção de publicar métricas no Amazon CloudWatch durante a publicação. Se o conjunto de dados estiver em uma VPC, ela talvez não permita que o AWS Glue publique métricas no Amazon CloudWatch. Nesse caso, você >precisa configurar um endpoint para a VPC acessar o Amazon CloudWatch.
## AnalysisException: não é possível verificar a existência de banco de dados padrão
**Condição de erro**: AnalysisException: não foi possível verificar a existência de um banco de dados padrão: com.amazonaws.services.glue.model.AccessDeniedException: permissões insuficientes do Lake Formation no padrão (Serviço: AWS Glue; Código de status: 400; Código de erro: AccessDeniedException; ID da solicitação: XXXXXXXX-XXXX-XXXXXXXXXXXX; Proxy: nulo)
**Resolução**: na integração do catálogo do trabalho do AWS Glue, o AWS Glue sempre tenta verificar se o banco de dados padrão existe ou não está usando a `GetDatabase API` do AWS Glue. Quando a permissão do `DESCRIBE` Lake Formation não é concedida, ou a permissão `GetDatabase IAM` é concedida e depois o trabalho falha ao verificar a existência do banco de dados padrão.
Para resolver:
1. Adicione a permissão `DESCRIBE` no Lake Formation para o banco de dados padrão.
1. Configure o perfil do IAM anexado ao trabalho do AWS Glue como criador de banco de dados no Lake Formation. Isso criará automaticamente um banco de dados padrão e concederá ao perfil as permissões necessárias do Lake Formation.
1. Desabilite a opção `--enable-data-catalog`. (É mostrado como **Usar o Data Catalog como metastore do Hive** no AWS Glue Studio).
Se você não precisar da integração do Data Catalog com o Spark SQL no trabalho, poderá desabilitá-la.
## Mensagem de erro: o mapa de chaves fornecido não é adequado para os quadros de dados fornecidos
**Condição de erro**: o mapa de chaves fornecido não é adequado para os quadros de dados fornecidos.
**Resolução**: você está usando o tipo de regra **DatasetMatch** e o tipo de regra e as chaves de união têm duplicatas. Suas chaves de união devem ser exclusivas e não devem ser NULL. Nos casos em que você não puder ter chaves de união exclusivas, considere usar outros tipos de regras, como **AggregateMatch**, para fazer a correspondência com os dados resumidos.
## Exceção na classe de usuário: java.lang.RuntimeException: falha ao buscar dados. Verificar os logs do CloudWatch para obter mais detalhes
**Condição de erro**: exceção na classe de usuário: java.lang.RuntimeException: falha ao buscar dados. Verifique os logs do CloudWatch para obter mais detalhes.
**Resolução**: isso acontece quando você cria regras de DQ em uma tabela baseada no Amazon S3 que é comparada com o Amazon RDS ou o Amazon Redshift. Nesses casos, o AWS Glue não consegue carregar a conexão. Em vez disso, tente configurar a regra do DQ no Amazon Redshift ou no conjunto de dados do Amazon RDS. Esse é um erro conhecido.
## ERRO DE INICIALIZAÇÃO: erro ao baixar o S3 para o bucket
**Condição de erro**: ERRO DE INICIALIZAÇÃO: erro ao baixar o S3 para o bucket: `aws-glue-ml-data-quality-assets-us-east-1, key: jars/aws-glue-ml-data-quality-etl.jar.Access Denied (Service: Amazon S3; Status Code: 403; Please refer logs for details) `.
**Resolução**: as permissões no perfil passadas para o AWS Glue Data Quality precisam permitir a leitura do local anterior do Amazon S3. Essa política do IAM deve ser anexada ao perfil:
```
{
"Sid": "allowS3",
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::aws-glue-ml-data-quality-assets-/*"
}
```
Consulte a [Autorização de qualidade de dados](https://docs.aws.amazon.com/glue/latest/dg/data-quality-authorization.html) para ver as permissões detalhadas. Essas bibliotecas são necessárias para avaliar a qualidade dos dados de seus conjuntos de dados.
## InvalidInputException (status: 400): as regras DataQuality não podem ser analisadas
**Condição de erro**: InvalidInputException (status: 400): as regras DataQuality não podem ser analisadas.
**Resolução**: existem muitas possibilidades para esse erro. Uma possibilidade é que suas regras tenham aspas simples. Verifique se elas estão entre aspas duplas. Por exemplo:
```
Rules = [
ColumnValues "tipo_vinculo" in ["CODO", "DOCO", "COCO", "DODO"] AND "categoria" = 'ES"
AND "cod_bandera" = 'CEP'
```
Altere isso para:
```
Rules = [
(ColumnValues "tipovinculo" in [ "CODO", "DOCO", "COCO", "DODO"]) AND (ColumnValues "categoria" = "ES")
AND (ColumnValues "codbandera" = "CEP")
]
```
## Erro: o Eventbridge não está acionando trabalhos do Glue DQ com base na agenda que eu configurei
**Condição de erro**: o Eventbridge não está acionando trabalhos do AWS Glue Data Quality com base na agenda que eu configurei.
**Resolução**: o perfil que aciona o trabalho pode não ter as permissões certas. Verifique se o perfil que você está usando para iniciar os trabalhos tem as permissões mencionadas em [Configuração do IAM requerida para programar execuções de avaliação](https://docs.aws.amazon.com/glue/latest/dg/data-quality-authorization.html#data-quality-iam-setup-evaluation-runs).
## Erros de CustomSQL
**Condição de erro**:` 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 no columns from the SQL result are present in the Input Dataset. Ensure that matching columns are returned from the SQL`.
**Resolução**: a consulta SQL é válida, mas verifique se as colunas selecionadas pertencem apenas à tabela primária. Selecionar funções agregadas como sum, count on the columns from the primary pode resultar nesse erro.
**Condição de erro**: ` There was a problem when executing your SQL statement: cannot resolve "Col"`.
**Resolução**: essa coluna não está presente na tabela primária.
**Condição de erro**:` The columns that are returned from the SQL statement should only belong to the primary table. "In this case, some columns ( Col ) belong to reference table"`.
**Resolução**: em consultas SQL, ao unir a tabela primária com outras tabelas de referência, verifique se a instrução de selecionar tem apenas nomes de colunas da tabela primária para gerar resultados em nível de linha para a tabela primária.
## Regras dinâmicas
**Condição de erro**`: Dynamic rules require job context, and cannot be evaluated in interactive session or data preview.`.
**Causa:** essa mensagem de erro pode aparecer nos resultados da visualização de dados ou em outras sessões interativas quando as regras dinâmicas do DQ estiverem presentes no conjunto de regras. As regras dinâmicas fazem referência a métricas históricas associadas a um determinado nome de trabalho e contexto de avaliação. Portanto, não podem ser avaliadas em sessões interativas.
**Resolução**: a execução de trabalho do AWS Glue produzirá métricas históricas, que podem ser referenciadas em execuções posteriores do mesmo trabalho.
**Condição de erro**:
+ ` [RuleType] rule only supports simple atomic operands in thresholds.`.
+ `Function last not yet implemented for [RuleType] rule.`
**Resolução**: as regras dinâmicas geralmente são compatíveis com todos os tipos de regras de DQDL em expressões numéricas (consulte [Referência de DQDL](dqdl.md)). No entanto, algumas regras que produzem várias métricas, ColumnValues e ColumnLength, ainda não são compatíveis.
**Condição de erro**:` Binary expression operands must resolve to a single number.`.
**Causa**: as regras dinâmicas são compatíveis com expressões binárias, como `RowCount > avg(last(5)) * 0.9`. Nesse caso, a expressão binária é `avg(last(5)) * 0.9`. Essa regra é válida porque os dois operandos `avg(last(5))` e `0.9` se resolvem para um único número. `RowCount > last(5) * 0.9` é um exemplo incorreto, pois `last(5)` produzirá uma lista que não poderá ser comparada de forma significativa com a contagem de linhas atual.
**Resolução**: use funções de agregação para reduzir um operando com valores de lista para um único número.
**Condição de erro**:
+ `Rule threshold results in list, and a single value is expected. Use aggregation functions to produce a single value. Valid example: sum(last(10)), avg(last(10)).`
+ `Rule threshold results in empty list, and a single value is expected.`
**Causa**: as regras dinâmicas podem ser usadas para comparar alguns atributos do conjunto de dados com os valores históricos. A última função permite a recuperação de vários valores históricos, se um argumento inteiro positivo for fornecido. Por exemplo, `last(5)` recuperará os últimos cinco valores mais recentes observados nas execuções de trabalho da sua regra.
**Resolução**: uma função de agregação precisa ser usada para reduzir esses valores a um único número para fazer uma comparação significativa com o valor observado na execução do trabalho atual.
Exemplos válidos:
+ `RowCount >= avg(last(5))`
+ `RowCount > last(1)`
+ `RowCount < last()`
Exemplo inválido: `RowCount > last(5)`.
**Condição de erro**:
+ `Function index used in threshold requires positive integer argument.`
+ `Index argument must be an integer. Valid syntax example: RowCount > index(last(10, 2)), which means RowCount must be greater than third most recent execution from last 10 job runs.`
**Resolução**: ao criar regras dinâmicas, você poderá usar a função de agregação `index` para selecionar um valor histórico em uma lista. Por exemplo, `RowCount > index(last(5)`, 1) verificará se a contagem de linhas observada no trabalho atual é estritamente maior do que a segunda contagem de linhas mais recente observada no trabalho. `index` é indexado em zero.
**Condição de erro**:` IllegalArgumentException: Parsing Error: Rule Type: DetectAnomalies is not valid`.
**Resolução**: a detecção de anomalias só está disponível na versão 4.0 do AWS Glue.
**Condição de erro**:` IllegalArgumentException: Parsing Error: Unexpected condition for rule of type ... no viable alternative at input ...`.
Observação: `...` é dinâmico. Exemplo: `IllegalArgumentException: Parsing Error: Unexpected condition for rule of type RowCount with number return type, line 4:19 no viable alternative at input '>last'`.
**Resolução**: a detecção de anomalias só está disponível na versão 4.0 do AWS Glue.
## Exceção na classe de usuário: org.apache.spark.sql.AnalysisException: org.apache.hadoop.hive.ql.metadata.HiveException
**Condição de erro**`: Exception in User Class: org.apache.spark.sql.AnalysisException: org.apache.hadoop.hive.ql.metadata.HiveException: Unable to fetch table mailpiece_submitted. StorageDescriptor#InputFormat cannot be null for table: mailpiece_submitted (Service: null; Status Code: 0; Error Code: null; Request ID: null; Proxy: null)`
**Causa:** você está usando o Apache Iceberg no Catálogo de Dados do AWS Glue e o atributo Input Format no Catálogo de Dados do AWS Glue está vazio.
**Resolução**: esse problema ocorre quando o tipo de regra CustomSQL é usado em sua regra de DQ. Uma maneira de corrigir isso é usar "primary" ou adicionar o nome do catálogo `glue_catalog.` a `. in Custom ruletype`.
## UNCLASSIFIED\$1ERROR; IllegalArgumentException: erro de análise: nenhuma regra ou analisador fornecido, nenhuma alternativa viável na entrada
**Condição de erro**`: UNCLASSIFIED_ERROR; IllegalArgumentException: Parsing Error: No rules or analyzers provided., no viable alternative at input`
**Resolução**: o DQDL não é analisável. Existem alguns casos em que isso pode ocorrer. Se você estiver usando regras compostas, verifique se elas têm parênteses corretos.
```
(RowCount >= avg(last(10)) * 0.6) and (RowCount <= avg(last(10)) * 1.4) instead of
RowCount >= avg(last(10)) * 0.6 and RowCount <= avg(last(10)) * 1.4
```