",
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.