",
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"
}
"""
)
)
}
```
En Catálogo de datos de AWS Glue, puede configurar fácilmente esta opción en la interfaz de usuario, como se muestra a continuación.
![\[En la captura de pantalla se muestra una ventana de configuración de reglas compuesta en la que puede elegir entre filas y columnas para la configuración de evaluación de reglas. Si elige Fila, las reglas compuestas se comportarán como una regla única que evalúa la fila en su totalidad. Si elige Columna, las reglas compuestas evaluarán las reglas individuales en todo el conjunto de datos y combinarán los resultados.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/composite-rule-settings.png)
Una vez establecidas, las reglas compuestas se comportarán como una regla única que evalúa la fila en su totalidad. En el ejemplo a continuación se muestra este comportamiento.
```
# 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 |
+------+------+------------------------------------------------------------+---------------------------+
```
Algunas reglas no son compatibles con esta característica debido a que los resultados generales se basan en umbrales o proporciones. Estas regulas se enumeran a continuación.
Reglas que se basan en las proporciones:
+ Integridad
+ DataSetMatch
+ ReferentialIntegrity
+ Singularidad
Reglas que se basan en los umbrales:
Cuando las reglas que se mencionan a continuación incluyen con un umbral, no son compatibles. Sin embargo, las reglas que no incluyen `with threshold` sí mantienen la compatibilidad.
+ ColumnDataType
+ ColumnValues
+ CustomSQL
### Expresiones
Si un tipo de regla no produce una respuesta booleana, debe proporcionar una expresión como parámetro para crear una respuesta booleana. Por ejemplo, la siguiente regla compara la media (promedio) de todos los valores de una columna con una expresión para obtener un resultado true (verdadero) o false (falso).
```
Mean "colA" between 80 and 100
```
Algunos tipos de reglas, como `IsUnique` y `IsComplete` ya producen una respuesta booleana.
En la tabla siguiente, se enumeran las expresiones que puede utilizar en las reglas de DQDL.
**Expresiones de DQDL admitidas**
| Expresión | Descripción | Ejemplo |
| --- | --- | --- |
| =x | Se resuelve en true si la respuesta del tipo de regla es igual que x. | Completeness "colA" = "1.0",
ColumnValues "colA" = "2022-06-30"
|
| \$1=x | Se resuelve en verdadero si la respuesta del tipo de regla es igual a x. | ColumnValues "colA" != "a",
ColumnValues "colA" != "2022-06-30"
|
| > x | Se resuelve en true si la respuesta del tipo de regla es mayor que x. | ColumnValues "colA" > 10
|
| < x | Se resuelve en true si la respuesta del tipo de regla es menor que x. | ColumnValues "colA" < 1000,
ColumnValues "colA" < "2022-06-30"
|
| >= x | Se resuelve en true si la respuesta del tipo de regla es mayor o igual que x. | ColumnValues "colA" >= 10
|
| <= x | Se resuelve en true si la respuesta del tipo de regla es menor o igual que x. | ColumnValues "colA" <= 1000
|
| entre x e y | Se resuelve en true si la respuesta del tipo de regla se encuentra en un rango especificado (exclusivo). Solo debe utilizar este tipo de expresión para los tipos numéricos y de datos. | Mean "colA" between 8 and 100,
ColumnValues "colA" between "2022-05-31" and "2022-06-30"
|
| no está entre x e y | Se resuelve en verdadero si la respuesta del tipo de regla no se encuentra en un rango especificado (inclusivo). Solo debe utilizar este tipo de expresión para los tipos numéricos y de fecha. | ColumnValues "colA" not between "2022-05-31" and "2022-06-30"
|
| en [a, b, c, ...] | Se resuelve en true si la respuesta del tipo de regla se encuentra en el conjunto especificado. | ColumnValues "colA" in [ 1, 2, 3 ],
ColumnValues "colA" in [ "a", "b", "c" ]
|
| no está en [a, b, c,... ] | Se resuelve en true si la respuesta del tipo de regla no se encuentra en el conjunto especificado. | ColumnValues "colA" not in [ 1, 2, 3 ],
ColumnValues "colA" not in [ "a", "b", "c" ]
|
| coincide con /ab\$1c/i | Se resuelve en true si la respuesta del tipo de regla coincide con una expresión regular. | ColumnValues "colA" matches "[a-zA-Z]*"
|
| no coincide con /ab\$1c/i | Se resuelve en true si la respuesta del tipo de regla no coincide con una expresión regular. | ColumnValues "colA" not matches "[a-zA-Z]*"
|
| now() | Solo funciona con el tipo de regla ColumnValues para crear una expresión de fecha. | ColumnValues "load_date" > (now() - 3 days)
|
| en/coincide con [...] / no está en/no coincide con [...] with threshold | Indica el porcentaje de valores que coinciden con las condiciones de la regla. Solo funciona con los tipos de regla ColumnValues, ColumnDataType y 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
|
#### Palabras clave para NULL, EMPTY y WHITESPACES\$1ONLY
Para validar si una columna de cadenas contiene una cadena nula, vacía o solo con espacios en blanco, puede utilizar las palabras clave a continuación:
+ NULL/null: esta palabra clave se resuelve como verdadera para un valor `null` en una columna de cadenas.
`ColumnValues "colA" != NULL with threshold > 0.5` devolvería el valor verdadero si más del 50 % de los datos no tienen valores nulos.
`(ColumnValues "colA" = NULL) or (ColumnLength "colA" > 5)` devolvería el valor verdadero para todas las filas que tengan un valor nulo o una longitud superior a 5. *Tenga en cuenta que esto requiere que se utilice la opción “compositeRuleEvaluation.method” = “ROW”.*
+ EMPTY/empty: esta palabra clave se resuelve como verdadera para un valor de cadena vacío (“”) en una columna de cadenas. Algunos formatos de datos transforman los valores nulos de una columna de cadenas en cadenas vacías. Esta palabra clave ayuda a remover las cadenas vacías en los datos.
`(ColumnValues "colA" = EMPTY) or (ColumnValues "colA" in ["a", "b"])` devolvería el valor verdadero si una fila está vacía, “a” o “b”. *Tenga en cuenta que esto requiere que se utilice la opción “compositeRuleEvaluation.method” = “ROW”.*
+ WHITESPACES\$1ONLY/whitespaces\$1only: esta palabra clave se resuelve como verdadera para una cadena que solo tiene un valor de espacios en blanco (“ ”) en una columna de cadenas.
`ColumnValues "colA" not in ["a", "b", WHITESPACES_ONLY]` devolvería el valor verdadero si una fila no es ni “a” ni “b” ni solo contiene espacios en blanco.
Reglas admitidas:
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
Puede utilizar las palabras clave a continuación para validar si una columna contiene un valor nulo al trabajar con expresiones numéricas o basadas en fechas.
+ NULL/null: esta palabra clave se resuelve como verdadera para un valor nulo en una columna de cadenas.
`ColumnValues "colA" in [NULL, "2023-01-01"]` devolvería el valor verdadero si una fecha de la columna es `2023-01-01` o nula.
`(ColumnValues "colA" = NULL) or (ColumnValues "colA" between 1 and 9)` devolvería el valor verdadero para todas las filas que tengan un valor nulo o cuyos valores sean entre 1 y 9. *Tenga en cuenta que esto requiere que se utilice la opción “compositeRuleEvaluation.method” = “ROW”.*
Reglas admitidas:
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
#### Filtrado con la cláusula Where
**nota**
La cláusula Where solo es compatible con AWS Glue 4.0.
Puede filtrar sus datos durante la creación de reglas. Esto resulta útil cuando se quieren aplicar reglas condicionales.
```
where " "
```
El filtro debe especificarse con la palabra clave `where`, seguida de una instrucción de SparkSQL válida entre comillas `("")`.
Si desea agregar la cláusula Where a una regla que tiene un umbral, la cláusula Where debe especificarse antes de la condición de umbral.
```
where "valid SparkSQL statement>" with threshold
```
Con esta sintaxis, puede escribir reglas como las siguientes.
```
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)"
```
Comprobaremos si la instrucción de SparkSQL proporcionada es válida. Si no es válida, la evaluación de la regla fallará y mostrará el error `IllegalArgumentException` con el siguiente formato:
```
Rule where "" has provided an invalid where clause :
```
**Comportamiento de la cláusula Where cuando la identificación del registro de errores a nivel de la fila está activada**
Con Calidad de datos de AWS Glue, puede identificar registros específicos que fallaron. Al aplicar una cláusula Where a las reglas que admiten resultados a nivel de la fila, etiquetaremos las filas filtradas por la cláusula Where como `Passed`.
Si prefiere etiquetar por separado las filas filtradas como `SKIPPED`, puede configurar las siguientes `additionalOptions` para el trabajo 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 ejemplo, consulte la siguiente regla y el marco de datos:
```
IsComplete att2 where "att1 = 'a'"
```
| id | att1 | att2 | Resultados a nivel de la fila (predeterminado) | Resultados a nivel de la fila (opción omitida) | Comentarios |
| --- | --- | --- | --- | --- | --- |
| 1 | a | f | PASSED | PASSED | |
| 2 | b | d | PASSED | SKIPPED | La fila está filtrada, ya que att1 no es "a" |
| 3 | a | null | ERROR | ERROR | |
| 4 | a | f | PASSED | PASSED | |
| 5 | b | null | PASSED | SKIPPED | La fila está filtrada, ya que att1 no es "a" |
| 6 | a | f | PASSED | PASSED | |
### Constantes
En DQDL, puede definir valores constantes y hacer referencia a ellos a lo largo de todo el script. Esto ayuda a evitar problemas relacionados con los límites de tamaño de las consultas, por ejemplo, al trabajar con instrucciones SQL de gran tamaño que podrían superar los límites permitidos. Al asignar estos valores a las constantes, puede simplificar el DQDL y evitar sobrepasar esos límites.
En el siguiente ejemplo, se muestra cómo definir y utilizar una constante:
```
mySql = "select count(*) from primary"
Rules = [
CustomSql $mySql between 0 and 100
]
```
En este ejemplo, la consulta SQL se asigna a la constante `mySql`, que luego se referencia en la regla mediante el prefijo `$`.
### Etiquetas
Las etiquetas ofrecen una forma eficaz de organizar y analizar los resultados de calidad de los datos. Puede consultar los resultados por etiquetas específicas para identificar reglas fallidas dentro de categorías concretas, contar los resultados de las reglas por equipo o dominio y crear informes específicos para distintas partes interesadas.
Por ejemplo, puede aplicar a todas las reglas relacionadas con el equipo de finanzas una etiqueta `"team=finance"` y generar un informe personalizado para mostrar métricas de calidad específicas del equipo de finanzas. Puede etiquetar las reglas de alta prioridad con `"criticality=high"` para priorizar las tareas de remediación. Las etiquetas se pueden crear como parte del DQDL. Puede consultar las etiquetas como parte de los resultados de las reglas, los resultados a nivel de fila y las respuestas de la API, lo que facilita la integración con sus flujos de trabajo existentes de supervisión y generación de informes.
**nota**
Las etiquetas solo están disponibles en ETL de AWS Glue y no están disponibles en la calidad de datos basada en el catálogo de datos de AWS Glue.
#### Sintaxis de las etiquetas de DQDL
DQDL admite tanto etiquetas predeterminadas como etiquetas específicas de las reglas. Las etiquetas predeterminadas se definen a nivel del conjunto de reglas y se aplican automáticamente a todas las reglas incluidas en ese conjunto. Las reglas individuales también pueden tener sus propias etiquetas y, dado que las etiquetas se implementan como pares clave-valor, las etiquetas específicas de una regla pueden sustituir a las etiquetas predeterminadas cuando se utiliza la misma clave.
En el siguiente ejemplo, se muestra cómo utilizar etiquetas predeterminadas y específicas de una regla:
```
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]
]
```
##### Restricciones del etiquetado
Las etiquetas tienen las siguientes restricciones:
+ Un máximo de 10 etiquetas por regla de DQDL.
+ Las etiquetas se especifican como una lista de pares clave-valor.
+ La clave de la etiqueta y el valor de la etiqueta distinguen entre mayúsculas y minúsculas.
+ La longitud máxima de la clave de la etiqueta es de 128 caracteres. La clave de la etiqueta no debe estar vacía ni ser nula.
+ La longitud máxima del valor de la etiqueta es de 256 caracteres. El valor de la etiqueta puede estar vacío o ser nulo.
#### Recuperación de etiquetas de DQDL
Puede recuperar las etiquetas de DQDL a partir de los resultados de las reglas, los resultados a nivel de fila y las respuestas de la API.
##### Resultados de la regla
Las etiquetas de DQDL siempre son visibles en los resultados de las reglas. No se necesita ninguna configuración adicional para habilitarlas.
##### Resultados a nivel de fila
Las etiquetas de DQDL están desactivadas de forma predeterminada en los resultados a nivel de fila, pero pueden habilitarse mediante `AdditionalOptions` en `EvaluateDataQuality`.
En el siguiente ejemplo, se muestra cómo habilitar etiquetas en resultados a nivel de fila:
```
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"
}""")
)
```
Cuando están habilitadas, el marco de datos de resultados a nivel de fila incluye las etiquetas de cada regla en las columnas `DataQualityRulesPass`, `DataQualityRulesFail` y `DataQualityRulesSkip`.
##### Respuesta de la API
Las etiquetas de DQDL siempre son visibles en las respuestas de la API, en un nuevo campo `Labels` dentro del objeto `RuleResults`.
En el siguiente ejemplo, se muestran las etiquetas en una respuesta de la 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"
}
}
]
}
```
### Reglas dinámicas
**nota**
Las reglas dinámicas solo se admiten en la ETL de AWS Glue y no en el Catálogo de datos de AWS Glue.
Ahora puede crear reglas dinámicas para comparar las métricas actuales generadas por sus reglas con sus valores históricos. Estas comparaciones históricas se habilitan usando el operador `last()` en las expresiones. Por ejemplo, la regla `RowCount > last()` se aplicará correctamente cuando el número de filas de la ejecución actual sea superior al recuento de filas anterior más reciente del mismo conjunto de datos. `last()` utiliza un argumento numérico natural opcional que describe cuántas métricas anteriores se deben tener en cuenta; `last(k)` donde `k >= 1` hará referencia a las últimas métricas `k`.
+ Si no hay puntos de datos disponibles, `last(k)` devolverá el valor predeterminado, 0,0.
+ Si hay menos de las métricas `k` disponibles, `last(k)` devolverá todas las métricas anteriores.
Para formar expresiones válidas utilice `last(k)`, donde `k > 1` requiera una función de agregación para reducir varios resultados históricos a un solo número. Por ejemplo, `RowCount > avg(last(5))` comprobará si el recuento de filas del conjunto de datos actual es estrictamente mayor que el promedio de los últimos cinco recuentos de filas del mismo conjunto de datos. `RowCount > last(5)` producirá un error, porque el recuento de filas del conjunto de datos actual no se puede comparar de forma significativa con una lista.
Funciones de agregación admitidas:
+ `avg`
+ `median`
+ `max`
+ `min`
+ `sum`
+ `std` (desviación estándar)
+ `abs` (valor absoluto)
+ `index(last(k), i)` permitirá seleccionar el valor en la posición `i` de los más recientes del último `k`. `i` está indexado a cero, por lo que `index(last(3), 0)` devolverá el punto de datos más reciente y `index(last(3), 3)` generará un error, ya que solo hay tres puntos de datos e intentaremos indexar el cuarto más reciente.
**Ejemplos de expresiones**
**ColumnCorrelation**
+ `ColumnCorrelation "colA" "colB" < avg(last(10))`
**DistinctValuesCount**
+ `DistinctValuesCount "colA" between min(last(10))-1 and max(last(10))+1`
La mayoría de los tipos de reglas con condiciones o umbrales numéricos admiten reglas dinámicas; consulte la tabla dada, [Analizadores y reglas](#dqdl-analyzers-table), para determinar si las reglas dinámicas son compatibles con su tipo de regla.
**Exclusión de las estadísticas de las reglas dinámicas**
En ocasiones, tendrá que excluir las estadísticas de datos de los cálculos de las reglas dinámicas. Supongamos que ha efectuado una carga de datos históricos y no quiere que eso afecte a sus promedios. Para ello, abra el trabajo en la ETL de AWS Glue y seleccione la pestaña **Calidad de los datos**; a continuación, seleccione **Estadísticas** y seleccione las estadísticas que desee excluir. Podrá ver un gráfico de tendencias junto con una tabla de estadísticas. Seleccione los valores que desee excluir y elija **Excluir estadísticas**. Ahora las estadísticas que estén excluidas no se incluirán en los cálculos de las reglas dinámicas.
![\[La captura de pantalla muestra la opción de excluir o incluir estadísticas del menú desplegable después de seleccionar una estadística.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/data-quality-excluding-statistics-from-dynamic-rules.png)
### Analizadores
**nota**
El Catálogo de datos de AWS Glue no es compatible con los analizadores.
Las reglas de DQDL usan funciones denominadas *analizadores* para recopilar información sobre los datos. La expresión booleana de una regla hace uso de esta información para determinar si la regla debe funcionar correctamente o no. Por ejemplo, la regla RowCount `RowCount > 5 ` usará un analizador de recuento de filas para descubrir el número de filas del conjunto de datos y compararlo con la expresión `> 5`, para comprobar si existen más de cinco filas en el conjunto de datos actual.
A veces, en lugar de crear reglas, recomendamos crear analizadores y luego hacer que generen estadísticas que puedan usarse para detectar anomalías. Para estos casos, puede crear analizadores. Los analizadores se diferencian de las reglas en estas formas.
| Característica | Analizadores | Reglas |
| --- | --- | --- |
| Parte del conjunto de reglas | Sí | Sí |
| Genera estadísticas | Sí | Sí |
| Genera observaciones | Sí | Sí |
| Puede evaluar y hacer valer una condición | No | Sí |
| Puede configurar acciones como detener los trabajos por fallas o continuar procesando el trabajo | No | Sí |
Los analizadores pueden existir de forma independiente sin reglas, por lo que es posible configurarlos rápidamente y crear progresivamente reglas de calidad de datos.
Algunos tipos de reglas se pueden introducir en el bloque `Analyzers` del conjunto de reglas para ejecutar las reglas necesarias para los analizadores y recopilar información sin comprobar ninguna condición. Algunos analizadores no están asociados a las reglas y solo se pueden introducir en el bloque `Analyzers`. La siguiente tabla indica si cada elemento se admite como regla o como analizador independiente, junto con información adicional para cada tipo de regla.
**Ejemplos de conjunto de reglas con el analizador**
El siguiente conjunto de reglas usa:
+ una regla dinámica para comprobar si un conjunto de datos está creciendo por arriba de su media final en las últimas tres ejecuciones de tareas,
+ un analizador `DistinctValuesCount` para registrar la cantidad de valores distintos de la columna del conjunto de datos de `Name`,
+ un analizador `ColumnLength` para rastrear el tamaño mínimo y máximo de `Name` a lo largo del tiempo.
Los resultados de las métricas del analizador pueden verse en la pestaña Calidad de los datos durante la ejecución del trabajo.
```
Rules = [
RowCount > avg(last(3))
]
Analyzers = [
DistinctValuesCount "Name",
ColumnLength "Name"
]
```
Calidad de datos de AWS Glue es compatible con los siguientes analizadores.
| Nombre del analizador | Funcionalidad |
| --- | --- |
| RowCount | Calcula los recuentos de filas de un conjunto de datos |
| Completeness | Calcula el porcentaje de integridad de una columna |
| Uniqueness | Calcula el porcentaje de exclusividad de una columna |
| Mean | Calcula la media de una columna numérica |
| Sum | Calcula la suma de una columna numérica |
| StandardDeviation | Calcula la desviación estándar de una columna numérica |
| Entropy | Calcula la entropía de una columna numérica |
| DistinctValuesCount | Calcula el número de valores distintos de una columna |
| UniqueValueRatio | Calcula la relación de valores únicos de una columna |
| ColumnCount | Calcula el número de columnas de un conjunto de datos |
| ColumnLength | Calcula la longitud de una columna |
| ColumnValues | Calcula el mínimo y el máximo para las columnas numéricas Calcula la longitud mínima de la columna y la longitud máxima de la columna para las columnas no numéricas |
| ColumnCorrelation | Calcula las correlaciones de columnas para las columnas dadas |
| CustomSql | Calcula las estadísticas que devuelve CustomSQL |
| AllStatistics | Calcula las siguientes estadísticas: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/dqdl.html) |
### Comentarios
Puede utilizar el carácter “\$1” para agregar un comentario al documento DQDL. DQDL ignorará todo lo que figure a continuación del “\$1” hasta el final de la línea.
```
Rules = [
# More items should generally mean a higher price, so correlation should be positive
ColumnCorrelation "price" "num_items" > 0
]
```
# Referencia de tipo de regla de DQDL
En esta sección, se proporciona una referencia para cada tipo de regla que admite Calidad de datos de AWS Glue.
**nota**
En la actualidad, DQDL no admite datos de columnas anidadas o de tipo lista.
Los valores entre corchetes de la siguiente tabla se sustituirán por la información dada en los argumentos de la regla.
Por lo general, las reglas requieren un argumento adicional para la expresión.
| RuleType | Descripción | Argumentos | Métricas informadas | ¿Se admite como regla? | ¿Se admite como analizador? | ¿Devuelve los resultados de nivel de fila? | ¿Soporte para reglas dinámicas? | Genera observaciones | ¿Admite la cláusula Where? |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| AggregateMatch | Comprueba si dos conjuntos de datos coinciden mediante la comparación de métricas resumidas, como el importe total de ventas. Es útil para que las instituciones financieras comparen si todos los datos provienen de los sistemas de origen. | Una o más agregaciones | Cuando los nombres de la primera y la segunda columna de agregación son los mismos: `Column.[Column].AggregateMatch` Cuando los nombres de la primera y la segunda columna de agregación son distintos: `Column.[Column1,Column2].AggregateMatch` | Sí | No | No | No | No | No |
| AllStatistics | Analizador independiente que recopila varias métricas para la columna dada de un conjunto de datos. | El nombre de una sola columna | Para las columnas de todos los tipos: `Dataset.*.RowCount` `Column.[Column].Completeness` `Column.[Column].Uniqueness` Métricas adicionales para columnas con valores de cadena: `ColumnLength metrics` Métricas adicionales para columnas con valores numéricos: `ColumnValues metrics` | No | Sí | No | No | No | No |
| ColumnCorrelation | Compruebe lo bien que se correlacionan dos columnas. | Exactamente dos columnas de nombres | Multicolumn.[Column1,Column2].ColumnCorrelation | Sí | Sí | No | Sí | No | Sí |
| ColumnCount | Comprueba si se ha eliminado alguna columna. | Ninguno | Dataset.\$1.ColumnCount | Sí | Sí | No | Sí | Sí | No |
| ColumnDataType | Comprueba si una columna es compatible con un tipo de datos. | Exactamente un nombre de columna | Column.[Column].ColumnDataType.Compliance | Sí | No | No | Sí, en la expresión de umbral a nivel de fila | No | Sí |
| ColumnExists | Comprueba si existen columnas en un conjunto de datos. Esto les permite a los clientes crear plataformas de datos de autoservicio para garantizar que determinadas columnas estén disponibles. | Exactamente un nombre de columna | N/A | Sí | No | No | No | No | No |
| ColumnLength | Comprueba si la longitud de los datos es coherente. | Exactamente un nombre de columna | `Column.[Column].MaximumLength` `Column.[Column].MinimumLength` Métrica adicional cuando se da un umbral a nivel de fila: `Column.[Column].ColumnValues.Compliance` | Sí | Sí | Sí, cuando se da un umbral a nivel de fila | No | Sí. Solo genera observaciones analizando la longitud mínima y máxima | Sí |
| ColumnNamesMatchPattern | Comprueba si los nombres de las columnas coinciden con patrones definidos. Es útil para que los equipos de gobierno refuercen la coherencia de los nombres de las columnas. | Una expresión regular para los nombres de las columnas | Dataset.\$1.ColumnNamesPatternMatchRatio | Sí | No | No | No | No | No |
| ColumnValues | Comprueba si los datos son coherentes según los valores definidos. Esta regla admite expresiones regulares. | Exactamente un nombre de columna | `Column.[Column].Maximum` `Column.[Column].Minimum` Métrica adicional cuando se da un umbral a nivel de fila: `Column.[Column].ColumnValues.Compliance` | Sí | Sí | Sí, cuando se da un umbral a nivel de fila | No | Sí. Solo genera observaciones analizando los valores mínimo y máximo | Sí |
| Integridad | Comprueba si hay espacios en blanco o CEROS en los datos. | Exactamente un nombre de columna | `Column.[Column].Completeness` | Sí | Sí | Sí | Sí | Sí | Sí |
| CustomSql | Los clientes pueden implementar prácticamente cualquier tipo de control de calidad de datos en SQL. | Una instrucción SQL (Opcional) Un umbral a nivel de fila | `Dataset.*.CustomSQL` Métrica adicional cuando se da un umbral a nivel de fila: `Dataset.*.CustomSQL.Compliance` | Sí | No | Sí, cuando se da un umbral a nivel de fila | Sí | No | No |
| DataFreshness | Comprueba si los datos están actualizados. | Exactamente un nombre de columna | Column.[Column].DataFreshness.Compliance | Sí | No | Sí | No | No | Sí |
| DataSetMatch | Compara dos conjuntos de datos e identifica si están sincronizados. | Nombre de un conjunto de datos de referencia Un mapeo de columnas (Opcional) Columnas para comprobar si hay coincidencias | Dataset.[ReferenceDatasetAlias].DatasetMatch | Sí | No | Sí | Sí | No | No |
| DistinctValuesCount | Comprueba si hay valores duplicados. | Exactamente un nombre de columna | Column.[Column].DistinctValuesCount | Sí | Sí | Sí | Sí | Sí | Sí |
| DetectAnomalies | Comprueba la presencia de anomalías en las métricas notificadas por otro tipo de regla. | Un tipo de regla | Métricas informadas por el argumento del tipo de regla | Sí | No | No | No | No | No |
| Entropía | Comprueba la entropía de los datos. | Exactamente un nombre de columna | Column.[Column].Entropy | Sí | Sí | No | Sí | No | Sí |
| IsComplete | Comprueba si el 100 % de los datos está completos. | Exactamente un nombre de columna | Column.[Column].Completeness | Sí | No | Sí | No | No | Sí |
| IsPrimaryKey | Comprueba si una columna es una clave principal (no NULA y única). | Exactamente un nombre de columna | Para una sola columna: `Column.[Column].Uniqueness` Para múltiples columnas: `Multicolumn.[CommaDelimitedColumns].Uniqueness` | Sí | No | Sí | No | No | Sí |
| IsUnique | Comprueba si el 100 % de los datos es único. | Exactamente un nombre de columna | Column.[Column].Uniqueness | Sí | No | Sí | No | No | Sí |
| Media | Comprueba si la media coincide con el umbral establecido. | Exactamente un nombre de columna | Column.[Column].Mean | Sí | Sí | Sí | Sí | No | Sí |
| ReferentialIntegrity | Comprueba si dos conjuntos de datos tienen integridad referencial. | Una o más columnas del conjunto de datos Uno o más nombres de columnas del conjunto de datos de referencia | Column.[ReferenceDatasetAlias].ReferentialIntegrity | Sí | No | Sí | Sí | No | No |
| RowCount | Comprueba si los recuentos de registros coinciden con un umbral. | Ninguno | Dataset.\$1.RowCount | Sí | Sí | No | Sí | Sí | Sí |
| RowCountMatch | Comprueba si los recuentos de registros entre dos conjuntos de datos coinciden. | Alias del conjunto de datos de referencia | Dataset.[ReferenceDatasetAlias].RowCountMatch | Sí | No | No | Sí | No | No |
| StandardDeviation | Comprueba si la desviación estándar coincide con el umbral. | Exactamente un nombre de columna | Column.[Column].StandardDeviation | Sí | Sí | Sí | Sí | No | Sí |
| SchemaMatch | Comprueba si el esquema entre dos conjuntos de datos coincide. | Alias del conjunto de datos de referencia | Dataset.[ReferenceDatasetAlias].SchemaMatch | Sí | No | No | Sí | No | No |
| Sum | Comprueba si la suma coincide con un umbral establecido. | Exactamente un nombre de columna | Column.[Column].Sum | Sí | Sí | No | Sí | No | Sí |
| Singularidad | Comprueba si la unicidad del conjunto de datos coincide con el umbral. | Exactamente un nombre de columna | Column.[Column].Uniqueness | Sí | Sí | Sí | Sí | No | Sí |
| UniqueValueRatio | Comprueba si la relación de valores únicos coincide con el umbral. | Exactamente un nombre de columna | Column.[Column].UniqueValueRatio | Sí | Sí | Sí | Sí | No | Sí |
| FileFreshness | Comprueba si los archivos de Amazon S3 están actualizados. | Ruta del archivo o carpeta y un umbral. | `Dataset.*.FileFreshness.Compliance` `Dataset.*.FileCount` | Sí | No | No | No | No | No |
| FileMatch | Comprueba si el contenido del archivo coincide con una suma de comprobación o con otro archivo. Esta regla usa sumas de comprobación para validar si dos archivos son iguales. | Ruta del archivo o carpeta de origen y ruta del archivo o carpeta de destino. | No se genera ninguna estadística. | Sí | No | No | No | No | No |
| FileSize | Comprueba si el tamaño de un archivo coincide con una condición especificada. | Ruta del archivo o carpeta y umbral. | `Dataset.*.FileSize.Compliance` `Dataset.*.FileCount` `Dataset.*.MaximumFileSize` `Dataset.*.MinimumFileSize` | Sí | No | No | No | No | No |
| FileUniqueness | Comprueba si los archivos son únicos mediante sumas de comprobación. | Ruta del archivo o carpeta y umbral. | `Dataset.*.FileUniquenessRatio` `Dataset.*.FileCount` | Sí | No | No | No | No | No |
**Topics**
+ [AggregateMatch](dqdl-rule-types-AggregateMatch.md)
+ [ColumnCorrelation](dqdl-rule-types-ColumnCorrelation.md)
+ [ColumnCount](dqdl-rule-types-ColumnCount.md)
+ [ColumnDataType](dqdl-rule-types-ColumnDataType.md)
+ [ColumnExists](dqdl-rule-types-ColumnExists.md)
+ [ColumnLength](dqdl-rule-types-ColumnLength.md)
+ [ColumnNamesMatchPattern](dqdl-rule-types-ColumnNamesMatchPattern.md)
+ [ColumnValues](dqdl-rule-types-ColumnValues.md)
+ [Integridad](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)
+ [Entropía](dqdl-rule-types-Entropy.md)
+ [IsComplete](dqdl-rule-types-IsComplete.md)
+ [IsPrimaryKey](dqdl-rule-types-IsPrimaryKey.md)
+ [IsUnique](dqdl-rule-types-IsUnique.md)
+ [Media](dqdl-rule-types-Mean.md)
+ [ReferentialIntegrity](dqdl-rule-types-ReferentialIntegrity.md)
+ [RowCount](dqdl-rule-types-RowCount.md)
+ [RowCountMatch](dqdl-rule-types-RowCountMatch.md)
+ [StandardDeviation](dqdl-rule-types-StandardDeviation.md)
+ [Sum](dqdl-rule-types-Sum.md)
+ [SchemaMatch](dqdl-rule-types-SchemaMatch.md)
+ [Singularidad](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
Comprueba la relación de dos agregaciones de columnas con respecto a una expresión determinada. Este tipo de regla funciona en varios conjuntos de datos. Se evalúan las agregaciones de dos columnas y se obtiene una relación al dividir el resultado de la agregación de la primera columna por el resultado de la agregación de la segunda columna. La relación se comprueba con la expresión proporcionada para producir una respuesta booleana.
**Sintaxis**
**Agregación de columnas**
```
AggregateMatch (.)
```
+ **AGG\$1OPERATION**: la operación que se debe utilizar para la agregación. `sum` y `avg` se admiten en la actualidad.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **OPTIONAL\$1REFERENCE\$1ALIAS**: este parámetro debe proporcionarse si la columna proviene de un conjunto de datos de referencia y no del conjunto de datos principal. Si utiliza esta regla en el Catálogo de datos de AWS Glue, su alias de referencia debe tener el formato "..
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **COL\$1NAME**: el nombre de la columna que se va a agregar.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
**Ejemplo: promedio**
```
"avg(rating)"
```
**Ejemplo: suma**
```
"sum(amount)"
```
**Ejemplo: promedio de la columna en el conjunto de datos de referencia**
```
"avg(reference.rating)"
```
**Regla**
```
AggregateMatch
```
+ **AGG\$1EXP\$11**: la agregación de la primera columna.
Tipos de columnas compatibles: byte, decimal, doble, flotante, entero, largo, corto
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **AGG\$1EXP\$12**: la agregación de la segunda columna.
Tipos de columnas compatibles: byte, decimal, doble, flotante, entero, largo, corto
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: coincidencia agregada mediante suma**
La siguiente regla de ejemplo comprueba si la suma de los valores en la columna `amount` es exactamente igual a la suma de los valores en la columna `total_amount`.
```
AggregateMatch "sum(amount)" "sum(total_amount)" = 1.0
```
**Ejemplo: coincidencia agregada mediante promedio**
La siguiente regla de ejemplo comprueba si el promedio de los valores en la columna `ratings` es igual al 90 %, como mínimo, del promedio de los valores en la columna `ratings` en el conjunto de datos `reference`. El conjunto de datos de referencia se proporciona como origen de datos adicional en la experiencia ETL o el Catálogo de datos.
En AWS Glue ETL, puede usar:
```
AggregateMatch "avg(ratings)" "avg(reference.ratings)" >= 0.9
```
En el Catálogo de datos de AWS Glue, puede usar:
```
AggregateMatch "avg(ratings)" "avg(database_name.tablename.ratings)" >= 0.9
```
**Comportamiento nulo**
La regla `AggregateMatch` ignorará las filas con valores nulos al momento de calcular los métodos de agregación (suma/media). Por ejemplo:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
La media de la columna `units` será (0 \$1 20 \$1 40) / 3 = 20. Las filas 101 y 103 no se tienen en cuenta para este cálculo.
# ColumnCorrelation
Comprueba la *correlación* entre dos columnas con una expresión dada. AWS Calidad de datos de Glue utiliza el coeficiente de correlación de Pearson para medir la correlación lineal entre dos columnas. El resultado es un número entre -1 y 1 que mide la fuerza y la dirección de la relación.
**Sintaxis**
```
ColumnCorrelation
```
+ **COL\$11\$1NAME**: el nombre de la primera columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **COL\$12\$1NAME**: el nombre de la segunda columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: correlación de columnas**
La siguiente regla de ejemplo comprueba si el coeficiente de correlación entre las columnas `height` y `weight` tiene una correlación positiva fuerte (un valor de coeficiente superior a 0,8).
```
ColumnCorrelation "height" "weight" > 0.8
```
```
ColumnCorrelation "weightinkgs" "Salary" > 0.8 where "weightinkgs > 40"
```
**Muestra de reglas dinámicas**
+ `ColumnCorrelation "colA" "colB" between min(last(10)) and max(last(10))`
+ `ColumnCorrelation "colA" "colB" < avg(last(5)) + std(last(5))`
**Comportamiento nulo**
La regla `ColumnCorrelation` ignorará las filas con los valores `NULL` al momento de calcular la correlación. Por ejemplo:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
Las filas 101 y 103 se ignorarán y la `ColumnCorrelation` será 1.0.
# ColumnCount
Comprueba el recuento de columnas del conjunto de datos principal con respecto a una expresión determinada. En la expresión, puede indicar el número de columnas o un rango de columnas mediante operadores como `>` y `<`.
**Sintaxis**
```
ColumnCount
```
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: comprobación numérica del recuento de columnas**
La siguiente regla de ejemplo comprueba si el recuento de columnas se encuentra dentro de un rango determinado.
```
ColumnCount between 10 and 20
```
**Muestra de reglas dinámicas**
+ `ColumnCount >= avg(last(10))`
+ `ColumnCount between min(last(10))-1 and max(last(10))+1`
# ColumnDataType
Comprueba si los valores de una columna determinada se pueden convertir en Apache Spark al tipo proporcionado. Acepta una expresión `with threshold` para comprobar si hay un subconjunto de los valores en la columna.
**Sintaxis**
```
ColumnDataType =
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
Tipos de columnas compatibles: tipo cadena
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPECTED\$1TYPE**: el tipo esperado de los valores en la columna.
Valores admitidos: booleano, fecha, marca de tiempo, entero, doble, flotante, largo
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESIÓN**: una expresión opcional para especificar el porcentaje de valores que deben ser del tipo esperado.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
**Ejemplo: números enteros del tipo de datos de columna como cadenas**
La siguiente regla de ejemplo comprueba si los valores de la columna dada, que es de tipo cadena, pueden convertirse a enteros.
```
ColumnDataType "colA" = "INTEGER"
```
**Ejemplo: los números enteros del tipo de datos de las columnas como cadenas comprueban un subconjunto de los valores**
La siguiente regla de ejemplo comprueba si más del 90 % de los valores de la columna dada, que es de tipo cadena, pueden convertirse a enteros.
```
ColumnDataType "colA" = "INTEGER" with threshold > 0.9
```
# ColumnExists
Comprueba si existe una columna.
**Sintaxis**
```
ColumnExists
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
**Ejemplo: la columna existe**
La siguiente regla de ejemplo comprueba si existe la columna denominada `Middle_Name`.
```
ColumnExists "Middle_Name"
```
# ColumnLength
Comprueba si la longitud de cada fila de una columna se ajusta a una expresión dada.
**Sintaxis**
```
ColumnLength
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cadena
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: longitud de la fila de la columna**
La siguiente regla de ejemplo comprueba si el valor de cada fila de la columna denominada `Postal_Code` tiene 5 caracteres.
```
ColumnLength "Postal_Code" = 5
ColumnLength "weightinkgs" = 2 where "weightinkgs > 10"
```
**Comportamiento nulo**
La regla `ColumnLength` considera a los valores `NULL` como cadenas con una longitud de 0. Para una fila `NULL`:
```
ColumnLength "Postal_Code" > 4 # this will fail
```
```
ColumnLength "Postal_Code" < 6 # this will succeed
```
El ejemplo de regla compuesta a continuación presenta una manera de fallar de manera explícita un valor `NULL`:
```
(ColumnLength "Postal_Code" > 4) AND (ColumnValues "Postal_Code" != NULL)
```
# ColumnNamesMatchPattern
Comprueba si los nombres de todas las columnas del conjunto de datos principal coinciden con la expresión regular dada.
**Sintaxis**
```
ColumnNamesMatchPattern
```
+ **PATRÓN**: el patrón contra el que desea evaluar la regla de calidad de los datos.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
**Ejemplo: los nombres de las columnas coinciden con el patrón**
La siguiente regla de ejemplo comprueba si todas las columnas comienzan con el prefijo “aws\$1”
```
ColumnNamesMatchPattern "aws_.*"
ColumnNamesMatchPattern "aws_.*" where "weightinkgs > 10"
```
# ColumnValues
Ejecuta una expresión con los valores de una columna.
**Sintaxis**
```
ColumnValues
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: valores permitidos**
El ejemplo de regla a continuación controla que cada valor en la columna específica se encuentre en un conjunto de valores permitidos (incluidos los valores nulos y las cadenas que solo contienen espacios en blanco).
```
ColumnValues "Country" in [ "US", "CA", "UK", NULL, EMPTY, WHITESPACES_ONLY ]
ColumnValues "gender" in ["F", "M"] where "weightinkgs < 10"
```
**Ejemplo: expresión regular**
La siguiente regla de ejemplo compara los valores de una columna con una expresión regular.
```
ColumnValues "First_Name" matches "[a-zA-Z]*"
```
**Ejemplo: valores de fecha**
La siguiente regla de ejemplo compara los valores de una columna de fecha con una expresión de fecha.
```
ColumnValues "Load_Date" > (now() - 3 days)
```
**Ejemplo: valores numéricos**
La siguiente regla de ejemplo comprueba si los valores de las columnas coinciden con una restricción numérica determinada.
```
ColumnValues "Customer_ID" between 1 and 2000
```
**Comportamiento nulo**
Para todas las reglas `ColumnValues` (además de `!=` y `NOT IN`), las filas `NULL` fallarán la regla. Si la regla falla debido a un valor nulo, la razón de la falla se mostrará de la siguiente manera:
```
Value: NULL does not meet the constraint requirement!
```
El ejemplo de regla compuesta a continuación presenta una manera de permitir de manera explícita los valores `NULL`:
```
(ColumnValues "Age" > 21) OR (ColumnValues "Age" = NULL)
```
Las reglas ColumnValues negadas que utilicen la sintaxis `!=` y `not in` se considerarán filas `NULL`. Por ejemplo:
```
ColumnValues "Age" != 21
```
```
ColumnValues "Age" not in [21, 22, 23]
```
Los ejemplos a continuación presentan una manera de fallar de manera explícita los valores `NULL`
```
(ColumnValues "Age" != 21) AND (ColumnValues "Age" != NULL)
```
```
ColumnValues "Age" not in [21, 22, 23, NULL]
```
# Integridad
Comprueba el porcentaje de valores completos (no nulos) de una columna con respecto a una expresión determinada.
**Sintaxis**
```
Completeness
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: porcentaje de valor nulo**
Las siguientes reglas de ejemplo comprueban si más del 95 % de los valores de una columna están completos.
```
Completeness "First_Name" > 0.95
Completeness "First_Name" > 0.95 where "weightinkgs > 10"
```
**Muestra de reglas dinámicas**
+ `Completeness "colA" between min(last(5)) - 1 and max(last(5)) + 1`
+ `Completeness "colA" <= avg(last(10))`
**Comportamiento nulo**
Nota sobre los formatos de datos CSV: las filas en blanco en las columnas de CSV pueden demostrar distintos comportamientos.
+ Si una columna es del tipo `String`, la fila en blanco se reconocerá como una cadena vacía y no fallará la regla `Completeness`.
+ Si una columna es de otro tipo de dato, como `Int`, la fila en blanco se reconocerá como `NULL` y fallará la regla `Completeness`.
# CustomSQL
Este tipo de regla se ha ampliado para admitir dos casos de uso:
+ Ejecutar una instrucción SQL personalizada contra un conjunto de datos y comprobar el valor que se produce con respecto a una expresión dada.
+ Ejecutar una instrucción SQL personalizada en la que especifique un nombre de columna en la instrucción SELECT contra el que compararlo con alguna condición para obtener resultados a nivel de fila.
**Sintaxis**
```
CustomSql
```
+ **SQL\$1STATEMENT**: una instrucción SQL que devuelve un solo valor numérico, entre comillas dobles.
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: SQL personalizado para recuperar el resultado general de una regla**
Esta regla de ejemplo usa una instrucción SQL para recuperar el recuento de registros de un conjunto de datos. A continuación, la regla comprueba que el recuento de registros esté comprendido entre 10 y 20.
```
CustomSql "select count(*) from primary" between 10 and 20
```
**Ejemplo: SQL personalizado para recuperar los resultados a nivel de fila**
Esta regla de ejemplo utiliza una instrucción SQL en la que se especifica un nombre de columna en la instrucción SELECT con el que se compara con alguna condición para obtener resultados a nivel de fila. Una expresión de condición de umbral define un umbral del número de registros que deben fallar para que falle toda la regla. Tenga en cuenta que una regla no puede contener una condición y una palabra clave juntas.
```
CustomSql "select Name from primary where Age > 18"
```
o
```
CustomSql "select Name from primary where Age > 18" with threshold > 3
```
**importante**
El alias `primary` representa el nombre del conjunto de datos que quiere evaluar. Al trabajar con trabajos de ETL visuales en la consola, `primary` siempre representa el elemento `DynamicFrame` que se pasa a la transformación de `EvaluateDataQuality.apply()`. Cuando se utiliza el Catálogo de datos de AWS Glue para ejecutar tareas de calidad de datos en una tabla, `primary` representa la tabla.
Si está en el Catálogo de datos de AWS Glue, también puede usar los nombres reales de las tablas:
```
CustomSql "select count(*) from database.table" between 10 and 20
```
También puede combinar varias tablas para comparar diferentes elementos de datos:
```
CustomSql "select count(*) from database.table inner join database.table2 on id1 = id2" between 10 and 20
```
En ETL de AWS Glue, CustomSQL puede identificar los registros que no superaron las comprobaciones de calidad de datos. Para que esto funcione, debe devolver los registros que forman parte de la tabla principal para la que evalúa la calidad de los datos. Los registros que se producen como parte de la consulta se consideran correctos y aquellos que no se producen se consideran fallidos. Esto funciona uniendo el resultado de la consulta CustomSQL con el conjunto de datos original. Puede haber implicaciones de rendimiento en función de la complejidad de su consulta SQL.
Para ello:
+ Debe seleccionar al menos una columna de la tabla principal.
+ `select count(*) from primary` es una consulta válida para la regla OVERALL de CustomSQL DQ, pero no para el SQL personalizado a nivel de fila.
+ Esta regla generará un error durante la evaluación: `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.`
+ En su consulta SQL, seleccione una `Clave principal` de su tabla o seleccione un conjunto de columnas que formen una clave compuesta. No hacerlo puede generar resultados inconsistentes debido a la coincidencia de filas duplicadas y en un rendimiento degradado.
+ Seleccione claves SOLO de su tabla principal y no de sus tablas de referencia.
La siguiente regla garantizará que los registros con una antigüedad inferior a 100 años se identifiquen como correctos y que aquellos anteriores se marquen como fallidos.
```
CustomSql "select id from primary where age < 100"
```
Esta regla CustomSQL se aprobará cuando el 50 % de los registros tengan más 10 años de antigüedad y también identificará los registros que fallaron. Los registros que este CustomSQL produce se considerarán aprobados, mientras que los que no se producen se considerarán fallidos.
```
CustomSQL "select ID, CustomerID from primary where age > 10" with threshold > 0.5
```
Nota: La regla CustomSQL fallará si usted produce registros que no están disponibles en el conjunto de datos.
# DataFreshness
Comprueba la actualización de los datos de una columna mediante la evaluación de la diferencia entre la hora actual y los valores de una columna de fecha. Puede indicar una expresión basada en el tiempo para este tipo de regla para asegurarse de que los valores de las columnas estén actualizados.
**Sintaxis**
```
DataFreshness
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: fecha
+ **EXPRESSION**: una expresión numérica en horas o días. Debe indicar la unidad de tiempo en la expresión.
**Ejemplo: actualización de los datos**
Las siguientes reglas de ejemplo comprueban la actualización de los datos.
```
DataFreshness "Order_Date" <= 24 hours
DataFreshness "Order_Date" between 2 days and 5 days
```
**Comportamiento nulo**
Las reglas `DataFreshness` fallarán para las filas con valores `NULL`. Si la regla falla debido a un valor nulo, la razón de la falla se mostrará de la siguiente manera:
```
80.00 % of rows passed the threshold
```
donde el 20 % de las filas que fallaron incluyen las filas con valores `NULL`.
El ejemplo de regla compuesta a continuación presenta una manera de permitir de manera explícita los valores `NULL`:
```
(DataFreshness "Order_Date" <= 24 hours) OR (ColumnValues "Order_Date" = NULL)
```
**Actualización de datos para objetos de Amazon S3**
En ocasiones, tendrá que validar la actualización de los datos en función del tiempo de creación del archivo de Amazon S3. Para ello, puede usar el siguiente código para obtener la marca temporal y añadirla a su marco de datos y, a continuación, aplicar las comprobaciones de actualización de los datos.
```
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
Compruebe si los datos del conjunto de datos principal coinciden con los datos de un conjunto de datos de referencia. Los dos conjuntos de datos se combinan mediante las asignaciones de columnas clave proporcionadas. Se pueden proporcionar asignaciones de columnas adicionales si desea comprobar la igualdad de los datos solo en esas columnas. Tenga en cuenta que para que **DataSetMatch** funcione, sus claves de unión deben ser únicas y no NULA (debe ser una clave principal). Si no cumple estas condiciones, recibirá el siguiente mensaje de error: “La asignación de teclas proporcionada no es adecuada para determinados marcos de datos”. En los casos en los que no pueda contar con claves combinadas que sean únicas, considere usar otros tipos de reglas, como **AggregateMatch**, para que coincidan en los datos resumidos.
**Sintaxis**
```
DatasetMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS**: el alias del conjunto de datos de referencia con el que se comparan los datos del conjunto de datos principal.
+ **KEY\$1COLUMN\$1MAPPINGS**: una lista de nombres de columnas separados por comas que forman una clave en los conjuntos de datos. Si los nombres de las columnas no son los mismos en ambos conjuntos de datos, debe separarlos con un `->`
+ **OPTIONAL\$1MATCH\$1COLUMN\$1MAPPINGS**: puede proporcionar este parámetro si desea comprobar si hay datos coincidentes solo en determinadas columnas. Utiliza la misma sintaxis que las asignaciones de columnas clave. Si no se proporciona este parámetro, haremos coincidir los datos en todas las columnas restantes. Las columnas restantes, que no son clave, deben tener los mismos nombres en ambos conjuntos de datos.
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: haga coincidir los conjuntos de datos mediante la columna de ID**
La siguiente regla de ejemplo comprueba que más del 90 % del conjunto de datos principal coincide con el conjunto de datos de referencia, mediante el uso de la columna “ID” para unir los dos conjuntos de datos. En este caso, compara todas las columnas.
```
DatasetMatch "reference" "ID" >= 0.9
```
**Ejemplo: haga coincidir conjuntos de datos mediante varias columnas clave**
En el siguiente ejemplo, el conjunto de datos principal y el conjunto de datos de referencia tienen nombres diferentes para las columnas clave. `ID_1` y `ID_2` juntos forman una clave compuesta en el conjunto de datos principal. `ID_ref1` y `ID_ref2` juntos forman una clave compuesta en el conjunto de datos de referencia. En este escenario, puede usar la sintaxis especial para proporcionar los nombres de las columnas.
```
DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" >= 0.9
```
**Ejemplo: haga coincidir conjuntos de datos mediante varias columnas clave y compruebe que una columna específica coincida**
Este ejemplo se basa en el ejemplo anterior. Queremos comprobar que solo coincide la columna que contiene los importes. Esta columna se denomina `Amount1` en el conjunto de datos principal y `Amount2` en el conjunto de datos de referencia. Quiere una coincidencia exacta.
```
DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" "Amount1->Amount2" >= 0.9
```
# DistinctValuesCount
Compara la cantidad de valores distintos de una columna con una expresión dada.
**Sintaxis**
```
DistinctValuesCount
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: recuento de valores distintos de columnas**
La siguiente regla de ejemplo comprueba que la columna denominada `State` contenga más de 3 valores distintos.
```
DistinctValuesCount "State" > 3
DistinctValuesCount "Customer_ID" < 6 where "Customer_ID < 10"
```
**Muestra de reglas dinámicas**
+ `DistinctValuesCount "colA" between avg(last(10))-1 and avg(last(10))+1`
+ `DistinctValuesCount "colA" <= index(last(10),2) + std(last(5))`
# Entropía
Comprueba si el valor de *entropía* de una columna coincide con una expresión dada. La entropía mide el nivel de información que contiene un mensaje. Dada la distribución de probabilidad entre los valores de una columna, la entropía describe cuántos bits se necesitan para identificar un valor.
**Sintaxis**
```
Entropy
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: entropía de columna**
La siguiente regla de ejemplo comprueba que la columna denominada `Feedback` tiene un valor de entropía superior a uno.
```
Entropy "Star_Rating" > 1
Entropy "First_Name" > 1 where "Customer_ID < 10"
```
**Muestra de reglas dinámicas**
+ `Entropy "colA" < max(last(10))`
+ `Entropy "colA" between min(last(10)) and max(last(10))`
# IsComplete
Comprueba si todos los valores de una columna están completos (no nulos).
**Sintaxis**
```
IsComplete
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
**Ejemplo: valores nulos**
El siguiente ejemplo comprueba si todos los valores de una columna denominada `email` no son 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"
```
**Comportamiento nulo**
Nota sobre los formatos de datos CSV: las filas en blanco en las columnas de CSV pueden demostrar distintos comportamientos.
+ Si una columna es del tipo `String`, la fila en blanco se reconocerá como una cadena vacía y no fallará la regla `Completeness`.
+ Si una columna es de otro tipo de dato, como `Int`, la fila en blanco se reconocerá como `NULL` y fallará la regla `Completeness`.
# IsPrimaryKey
Comprueba si una columna contiene una clave principal. Una columna contiene una clave principal si todos los valores de la columna son únicos y completos (no nulos). También puede comprobar las claves principales con varias columnas.
**Sintaxis**
```
IsPrimaryKey
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
**Ejemplo: clave principal**
La siguiente regla de ejemplo comprueba si la columna denominada `Customer_ID` contiene una clave principal.
```
IsPrimaryKey "Customer_ID"
IsPrimaryKey "Customer_ID" where "Customer_ID < 10"
```
**Ejemplo: clave principal con múltiples columnas. Cualquiera de los ejemplos siguientes son válidos.**
```
IsPrimaryKey "colA" "colB"
IsPrimaryKey "colA" "colB" "colC"
IsPrimaryKey colA "colB" "colC"
```
# IsUnique
Comprueba si todos los valores de una columna son únicos y devuelve un valor booleano.
**Sintaxis**
```
IsUnique
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
**Ejemplos**
La siguiente regla de ejemplo comprueba si todos los valores de una columna denominada `email` son únicos.
```
IsUnique "email"
IsUnique "Customer_ID" where "Customer_ID < 10"]
```
La siguiente regla de ejemplo verifica varias columnas.
```
IsUnique "vendorid" "tpep_pickup_datetime"
```
# Media
Comprueba si la media (promedio) de todos los valores de una columna coincide con una expresión dada.
**Sintaxis**
```
Mean
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: valor promedio**
La siguiente regla de ejemplo comprueba si el promedio de todos los valores de una columna supera un umbral.
```
Mean "Star_Rating" > 3
Mean "Salary" < 6200 where "Customer_ID < 10"
```
**Muestra de reglas dinámicas**
+ `Mean "colA" > avg(last(10)) + std(last(2))`
+ `Mean "colA" between min(last(5)) - 1 and max(last(5)) + 1`
**Comportamiento nulo**
La regla `Mean` ignorará las filas con valores `NULL` al momento de calcular la media. Por ejemplo:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
La media de la columna `units` será (0 \$1 20 \$1 40) / 3 = 20. Las filas 101 y 103 no se tienen en cuenta para este cálculo.
# ReferentialIntegrity
Comprueba en qué medida los valores de un conjunto de columnas en el conjunto de datos principal son un subconjunto de los valores de un conjunto de columnas en un conjunto de datos de referencia.
**Sintaxis**
```
ReferentialIntegrity
```
+ **PRIMARY\$1COLS**: una lista de nombres de columnas separados por comas en el conjunto de datos principal.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **REFERENCE\$1DATASET\$1COLS**: este parámetro contiene dos partes separadas por un punto. La primera parte es el alias del conjunto de datos de referencia. La segunda parte es la lista de nombres de columnas separados por comas en el conjunto de datos de referencia entre corchetes.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: compruebe la integridad referencial de una columna de código postal**
La siguiente regla de ejemplo comprueba que más del 90 % de los valores en la columna `zipcode` en el conjunto de datos principal estén presentes en la columna `zipcode` en el conjunto de datos de `reference`.
```
ReferentialIntegrity "zipcode" "reference.zipcode" >= 0.9
```
**Ejemplo: compruebe la integridad referencial de las columnas de ciudad y estado**
En el siguiente ejemplo, las columnas que contienen información sobre la ciudad y el estado existen en el conjunto de datos principal y en el conjunto de datos de referencia. Los nombres de las columnas son diferentes en ambos conjuntos de datos. La regla comprueba si el conjunto de valores de las columnas en el conjunto de datos principal es exactamente igual al conjunto de valores de las columnas en el conjunto de datos de referencia.
```
ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" = 1.0
```
**Muestra de reglas 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
Compara el recuento de filas de un conjunto de datos con una expresión determinada. En la expresión, puede indicar el número de filas o un rango de filas mediante operadores como `>` y `<`.
**Sintaxis**
```
RowCount
```
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: comprobación numérica del recuento de filas**
La siguiente regla de ejemplo comprueba si el recuento de filas se encuentra dentro de un rango determinado.
```
RowCount between 10 and 100
RowCount between 1 and 50 where "Customer_ID < 10"
```
**Muestra de reglas dinámicas**
```
RowCount > avg(last(10)) *0.8
```
# RowCountMatch
Comprueba la relación entre el recuento de filas del conjunto de datos principal y el recuento de filas de un conjunto de datos de referencia con respecto a la expresión dada.
**Sintaxis**
```
RowCountMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS**: el alias del conjunto de datos de referencia con el que se comparan los recuentos de filas.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: comparación del recuento de filas con un conjunto de datos de referencia**
La siguiente regla de ejemplo comprueba si el recuento de filas del conjunto de datos principal es al menos el 90 % del recuento de filas del conjunto de datos de referencia.
```
RowCountMatch "reference" >= 0.9
```
# StandardDeviation
Comprueba la desviación estándar de todos los valores de una columna con respecto a una expresión determinada.
**Sintaxis**
```
StandardDeviation
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: desviación estándar**
La siguiente regla de ejemplo comprueba si la desviación estándar de los valores de una columna denominada `colA` es inferior a un valor especificado.
```
StandardDeviation "Star_Rating" < 1.5
StandardDeviation "Salary" < 3500 where "Customer_ID < 10"
```
**Muestra de reglas dinámicas**
+ `StandardDeviation "colA" > avg(last(10) + 0.1`
+ `StandardDeviation "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**Comportamiento nulo**
La regla `StandardDeviation` ignorará las filas con valores `NULL` al momento de calcular la desviación estándar. Por ejemplo:
```
+---+-----------+-----------+
|id |units1 |units2 |
+---+-----------+-----------+
|100|0 |0 |
|101|null |0 |
|102|20 |20 |
|103|null |0 |
|104|40 |40 |
+---+-----------+-----------+
```
La desviación estándar de la columna `units1` no tendrá en cuenta las filas 101 y 103 y su resultado será 16.33. La desviación estándar de la columna `units2` dará como resultado 16.
# Sum
Comprueba la suma de todos los valores de una columna con respecto a una expresión determinada.
**Sintaxis**
```
Sum
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: suma**
La siguiente regla de ejemplo comprueba si la suma de todos los valores de una columna supera un umbral dado.
```
Sum "transaction_total" > 500000
Sum "Salary" < 55600 where "Customer_ID < 10"
```
**Muestra de reglas dinámicas**
+ `Sum "ColA" > avg(last(10))`
+ `Sum "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**Comportamiento nulo**
La regla `Sum` ignorará las filas con valores `NULL` al momento de calcular la suma. Por ejemplo:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
La suma de la columna `units` no considerará las filas 101 y 103 y su resultado será (0 \$1 20 \$1 40) = 60.
# SchemaMatch
Comprueba si el esquema del conjunto de datos principal coincide con el esquema de un conjunto de datos de referencia. La verificación del esquema se realiza columna por columna. El esquema de dos columnas coincide si los nombres son idénticos y los tipos son idénticos. El orden de las columnas del archivo no importa.
**Sintaxis**
```
SchemaMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS**: el alias del conjunto de datos de referencia con el que se comparan los esquemas.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: SchemaMatch**
La siguiente regla de ejemplo comprueba si el esquema del conjunto de datos principal coincide exactamente con el esquema de un conjunto de datos de referencia.
```
SchemaMatch "reference" = 1.0
```
# Singularidad
Comprueba el porcentaje de valores únicos de una columna con respecto a una expresión determinada. Los valores únicos aparecen exactamente una vez.
**Sintaxis**
```
Uniqueness
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo**
La siguiente regla de ejemplo comprueba si el porcentaje de valores únicos de una columna coincide con ciertos criterios numéricos.
```
Uniqueness "email" = 1.0
Uniqueness "Customer_ID" != 1.0 where "Customer_ID < 10"
```
La siguiente regla de ejemplo verifica varias columnas.
```
Uniqueness "vendorid" "tpep_pickup_datetime" = 1
```
**Muestra de reglas dinámicas**
+ `Uniqueness "colA" between min(last(10)) and max(last(10))`
+ `Uniqueness "colA" >= avg(last(10))`
# UniqueValueRatio
Comprueba la *relación de valores únicos* de una columna con respecto a una expresión determinada. Una relación de valores únicos es la fracción de valores únicos dividida entre el número de todos los valores distintos de una columna. Los valores únicos aparecen exactamente una vez, mientras que los valores distintos aparecen *al menos* una vez.
Por ejemplo, el conjunto `[a, a, b]` contiene un valor único (`b`) y dos valores distintos (`a` y `b`). Por lo tanto, la relación de valores únicos del conjunto es ½ = 0,5.
**Sintaxis**
```
UniqueValueRatio
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: relación de valores únicos**
En este ejemplo, se comprueba la relación de valores única de una columna frente a un rango de valores.
```
UniqueValueRatio "test_score" between 0 and 0.5
UniqueValueRatio "Customer_ID" between 0 and 0.9 where "Customer_ID < 10"
```
**Muestra de reglas dinámicas**
+ `UniqueValueRatio "colA" > avg(last(10))`
+ `UniqueValueRatio "colA" <= index(last(10),2) + std(last(5))`
# DetectAnomalies
Detecta anomalías en una regla de calidad de datos determinada. Cada ejecución de la regla DetectAnomalies permite guardar el valor evaluado de la regla dada. Al recopilar suficientes datos, el algoritmo de detección de anomalías toma todos los datos históricos de esa regla determinada y ejecuta la detección de anomalías. La regla DetectAnomalies falla al momento de detectar una anomalía. Puede obtener más información sobre qué anomalía se detectó en Observaciones.
**Sintaxis**
```
DetectAnomalies
```
`RULE_NAME`: nombre de la regla que quiere evaluar y detectar anomalías. Reglas admitidas:
+ “RowCount”
+ “Completeness”
+ “Uniqueness”
+ “Mean”
+ “Sum”
+ “StandardDeviation”
+ “Entropy”
+ “DistinctValuesCount”
+ “UniqueValueRatio”
+ “ColumnLength”
+ “ColumnValues”
+ “ColumnCorrelation”
+ "CustomSQL"
+ "ColumnCount"
`RULE_PARAMETERS`: algunas reglas requieren parámetros adicionales para poder ejecutarse. Consulte la documentación de reglas dada para ver los parámetros necesarios.
**Ejemplo: Anomalías de RowCount**
Por ejemplo, si queremos detectar anomalías en RowCount, damos RowCount como nombre de regla.
```
DetectAnomalies "RowCount"
```
**Ejemplo: Anomalías para ColumnLength**
Por ejemplo, si queremos detectar anomalías en la longitud de la columna, daremos la longitud de columna como nombre de la regla y el nombre de la columna.
```
DetectAnomalies "ColumnLength" "id"
```
# FileFreshness
FileFreshness garantiza que sus archivos de datos estén actualizados en función de la condición que proporcione. Utiliza la hora de la última modificación de los archivos para garantizar que los archivos de datos o toda la carpeta estén actualizados.
Esta regla recopila dos métricas:
+ El cumplimiento de FileFreshness se basa en la regla que haya configurado
+ El número de archivos que ha analizado la regla
```
{"Dataset.*.FileFreshness.Compliance":1,"Dataset.*.FileCount":1}
```
La detección de anomalías no tiene en cuenta estas métricas.
**Cómo comprobar si los archivos están actualizados**
La siguiente regla garantiza que tickets.parquet se haya creado en las últimas 24 horas.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/tickets.parquet" > (now() - 24 hours)
```
**Cómo comprobar si la carpeta está actualizada**
La siguiente regla se aplica si todos los archivos de la carpeta se crearon o modificaron en las últimas 24 horas.
```
FileFreshness "s3://bucket/" >= (now() -1 days)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" >= (now() - 24 hours)
```
**Cómo comprobar si una carpeta o un archivo está actualizado (con umbral)**
La siguiente regla se aplica si el 10 % de los archivos de la carpeta “tickets” se crearon o modificaron en los últimos 10 días.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" < (now() - 10 days) with threshold > 0.1
```
**Cómo comprobar archivos o carpetas con fechas específicas**
Puede comprobar si los archivos se actualizaron en días 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"
```
**Cómo comprobar archivos o carpetas con fechas y horas**
Puede usar FileFreshness para asegurarse de que los archivos lleguen dentro de las horas previstas.
```
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"
```
Consideraciones clave:
+ FileFreshness puede evaluar los archivos utilizando unidades de días, horas y minutos
+ Es compatible con los formatos de tiempo AM/PM y 24 horas
+ Los horarios se calculan en UTC, a menos que se especifique una anulación
+ Las fechas se calculan en UTC a las 00:00 h
El análisis de FileFreshness basado en la fecha y la hora funciona de la siguiente manera:
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45"
```
+ En primer lugar, la hora “21:45” se combina con la fecha de hoy en formato UTC para crear un campo de fecha y hora
+ A continuación, la fecha y la hora se convierten en la zona horaria que haya especificado
+ Por último, se evalúa la regla
**Etiquetas de reglas opcionales basadas en archivos:**
Las etiquetas permiten controlar el comportamiento de las reglas.
**recentFiles**
Esta etiqueta limita el número de archivos procesados dejando primero el archivo más reciente.
```
FileFreshness "s3://amzn-s3-demo-bucket/" between (now() - 100 minutes) and (now() + 10 minutes) with recentFiles = 1
```
**uriRegex**
**nota**
La etiqueta AWS está disponible en `uriRegex` Glue 5.0 y versiones posteriores.
Esta etiqueta filtra los archivos mediante la aplicación de un patrón de expresión regular a la ruta del archivo. Solo se procesan los archivos cuyas rutas coinciden con el patrón. También puede usar una anticipación negativa para excluir los archivos que coinciden con un patrón.
```
# 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**
La etiqueta AWS está disponible en `filterOrder` Glue 5.0 y versiones posteriores.
Cuando utiliza varias etiquetas de filtro, como `recentFiles` y `uriRegex`, en conjunto, la etiqueta `filterOrder` controla el orden en que se aplican. El orden predeterminado es primero `recentFiles` y luego `uriRegex`.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with recentFiles = 1 with uriRegex = "inventory_" with filterOrder = ["uriRegex","recentFiles"]
```
En el ejemplo anterior, el filtro `uriRegex` se aplica primero para seleccionar únicamente los archivos que coinciden con “inventory\$1”, y luego `recentFiles = 1` toma el archivo más reciente de ese conjunto filtrado. Sin `filterOrder`, el comportamiento predeterminado tomaría primero el archivo más reciente y luego aplicaría la expresión regular, lo que podría dar como resultado que no haya archivos coincidentes si el archivo más reciente no coincide con el patrón.
**nota**
Todos los valores de la lista `filterOrder` deben hacer referencia a otras etiquetas de filtro (`recentFiles` o `uriRegex`) que también estén presentes en la misma regla. Las etiquetas que no son de filtro, como `timeZone` o `failFast`, no son válidas en `filterOrder`.
**failFast**
Cuando se establece en `"true"`, la regla devuelve un error de inmediato en el primer archivo que no cumple la condición de vigencia, en lugar de evaluar todos los archivos y calcular una tasa de cumplimiento.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with failFast = "true"
```
**timeZone**
Indica las anulaciones de zonas horaria aceptadas; consulte [Allowed Time Zones](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html) para ver las zonas horarias admitidas.
```
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"
```
**Cómo inferir los nombres de los archivos directamente de los marcos de datos**
No siempre tiene que proporcionar una ruta de archivo. Por ejemplo, al crear la regla en el catálogo de datos de AWS Glue, puede resultar difícil encontrar qué carpetas usan las tablas del catálogo. AWS Calidad de datos de Glue puede encontrar las carpetas o archivos específicos que se usan para rellenar su marco de datos y puede detectar si están actualizados.
**nota**
Esta característica solo funcionará cuando los archivos se lean correctamente en DynamicFrame o DataFrame.
```
FileFreshness > (now() - 24 hours)
```
Esta regla encontrará la ruta de la carpeta o los archivos que se usan para rellenar el marco dinámico o el marco de datos. Esto funciona para las rutas de Amazon S3 o las tablas de Catálogo de datos de AWS Glue basadas en Amazon S3. Existen algunas consideraciones:
1. En la ETL de AWS Glue, debe tener la transformación **EvaluateDataQuality** inmediatamente después de una transformación de Amazon S3 o del Catálogo de datos de AWS Glue.
![\[La instantánea muestra un nodo de evaluación de Calidad de datos conectado a un nodo de Amazon S3.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/data-quality-file-freshness.png)
1. Esta regla no funcionará en las sesiones interactivas de AWS Glue.
Si lo intenta en ambos casos, o si AWS Glue no encuentra los archivos, AWS Glue devolverá el siguiente error: `“Unable to parse file path from DataFrame”`
# FileMatch
La regla FileMatch le permite comparar archivos con otros archivos o sumas de comprobación. Esto puede ser útil en algunas situaciones:
1. Validación de archivos recibidos de fuentes externas: puede usar FileMatch para asegurarse de que haya recibido los archivos correctos de orígenes externos mediante su comparación con sumas de comprobación. Esto ayuda a validar la integridad de los datos que está ingiriendo.
1. Comparación de datos en dos carpetas diferentes: FileMatch se puede utilizar para comparar archivos entre dos carpetas.
Esta regla recopila una métrica: el número de archivos que ha analizado la regla.
```
{"Dataset.*.FileCount":1}
```
**Validación de un archivo con una suma de comprobación:**
FileMatch acepta un archivo y un conjunto de sumas de comprobación para garantizar que al menos una suma de comprobación coincida con el archivo.
```
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"]
```
Los siguientes algoritmos estándar son compatibles:
+ MD5
+ SHA-1
+ SHA-256
Si no proporciona ningún algoritmo, el valor predeterminado es SHA-256.
**Validación de todos los archivos de una carpeta con el conjunto de sumas de comprobación:**
```
FileMatch "s3://amzn-s3-demo-bucket /" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch "s3://amzn-s3-demo-bucket /internal-folder/" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"]
```
**Comparación de archivos en diferentes carpetas**
```
# Compare all files across two buckets
FileMatch "s3://original_bucket/" "s3://archive_bucket/"
# Compare files within specific subfolders
FileMatch "s3://original_bucket/internal-folder/" "s3://original_bucket/other-folder/"
# Compare only .json files across two folders
FileMatch "s3://original_bucket/" "s3://archive_bucket/" with uriRegex = "\.json$"
# Compare only the 5 most recent .csv files
FileMatch "s3://original_bucket/" "s3://archive_bucket/" with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"]
```
FileMatch comprobará el contenido de los archivos en `original_bucket` y se asegurará de que coincidan con lo que contiene `archive_bucket`. La regla fallará si no coinciden exactamente. También puede comprobar el contenido de las carpetas internas o de los archivos individuales.
FileMatch también puede comparar archivos individuales entre sí.
```
FileMatch "s3://amzn-s3-demo-bucket /file_old.json" "s3://amzn-s3-demo-bucket /file_new.json"
```
**Cómo inferir los nombres de los archivos directamente de los marcos de datos**
No siempre tiene que proporcionar una ruta de archivo. Por ejemplo, al crear la regla en el Catálogo de datos de AWS Glue (respaldado por Amazon S3), puede resultar difícil encontrar qué carpetas usan las tablas del catálogo. AWS Calidad de datos de Glue puede encontrar las carpetas o archivos específicos que se usan para rellenar su marco de datos.
**nota**
Esta característica solo funcionará cuando los archivos se lean correctamente en DynamicFrame o DataFrame.
```
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-1"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-256"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"]
```
Si la suma de comprobación proporcionada es diferente de la calculada, FileMatch le avisará de la diferencia.
![\[La instantánea muestra una regla con el estado Regla fallida de Calidad de datos. FileMatch explica el error.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/data-quality-file-match.png)
**Etiquetas de reglas opcionales basadas en archivos:**
Las etiquetas permiten controlar el comportamiento de las reglas.
**recentFiles**
Esta etiqueta limita el número de archivos procesados dejando primero el archivo más reciente.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1
```
**uriRegex**
**nota**
La etiqueta AWS está disponible en `uriRegex` Glue 5.0 y versiones posteriores.
Esta etiqueta filtra los archivos mediante la aplicación de un patrón de expresión regular a la ruta del archivo. Solo se procesan los archivos cuyas rutas coinciden con el patrón. También puede usar una anticipación negativa para excluir los archivos que coinciden con un patrón.
```
# 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**
La etiqueta AWS está disponible en `filterOrder` Glue 5.0 y versiones posteriores.
Cuando utiliza varias etiquetas de filtro, como `recentFiles` y `uriRegex`, en conjunto, la etiqueta `filterOrder` controla el orden en que se aplican. El orden predeterminado es primero `recentFiles` y luego `uriRegex`.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1 with uriRegex = "\.json$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
Esta etiqueta garantiza que los archivos no tengan nombres duplicados. El comportamiento predeterminado es false.
```
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac04179sam4713e5ef8f319"] with matchFileName = "true"
```
Existen algunas consideraciones:
1. En la ETL de AWS Glue, debe tener la transformación **EvaluateDataQuality** inmediatamente después de una transformación de Amazon S3 o del Catálogo de datos de AWS Glue.
![\[La instantánea muestra una regla con el estado Regla fallida de Calidad de datos. FileMatch explica el error.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/data-quality-file-match-transform.png)
1. Esta regla no funcionará en las sesiones interactivas de AWS Glue.
# FileUniqueness
FileUniqueness permite asegurarse de que no haya archivos duplicados en los datos que ha recibido de sus productores de datos.
Recopila las siguientes estadísticas de datos:
1. El número de archivos que ha analizado la regla
1. La relación de singularidad de los archivos
```
Dataset.*.FileUniquenessRatio: 1.00, Dataset.*.FileCount: 8.00
```
**Cómo encontrar archivos duplicados en una carpeta:**
```
FileUniqueness "s3://bucket/" > 0.5
FileUniqueness "s3://bucket/folder/" = 1
```
**Cómo inferir los nombres de las carpetas directamente de los marcos de datos para detectar duplicados:**
No siempre tiene que proporcionar una ruta de archivo. Por ejemplo, al crear la regla en el catálogo de datos de AWS Glue, puede resultar difícil encontrar qué carpetas usan las tablas del catálogo. AWS Calidad de datos de Glue puede encontrar las carpetas o archivos específicos que se usan para rellenar su marco de datos.
**nota**
Cuando se utiliza la inferencia, las reglas basadas en archivos solo pueden detectar los archivos leídos correctamente en DynamicFrame o DataFrame.
```
FileUniqueness > 0.5
```
**Etiquetas de reglas opcionales basadas en archivos:**
Las etiquetas permiten controlar el comportamiento de las reglas.
**recentFiles**
Esta etiqueta limita el número de archivos procesados dejando primero el archivo más reciente.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with recentFiles = 1
```
**uriRegex**
**nota**
La etiqueta AWS está disponible en `uriRegex` Glue 5.0 y versiones posteriores.
Esta etiqueta filtra los archivos mediante la aplicación de un patrón de expresión regular a la ruta del archivo. Solo se procesan los archivos cuyas rutas coinciden con el patrón. También puede usar una anticipación negativa para excluir los archivos que coinciden con un patrón.
```
# 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**
La etiqueta AWS está disponible en `filterOrder` Glue 5.0 y versiones posteriores.
Cuando utiliza varias etiquetas de filtro, como `recentFiles` y `uriRegex`, en conjunto, la etiqueta `filterOrder` controla el orden en que se aplican. El orden predeterminado es primero `recentFiles` y luego `uriRegex`.
```
FileUniqueness "s3://bucket/" > 0.5 with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
Esta etiqueta garantiza que los archivos no tengan nombres duplicados. El comportamiento predeterminado es false.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with matchFileName = "true"
```
Existen algunas consideraciones:
1. En la ETL de AWS Glue, debe tener la transformación **EvaluateDataQuality** inmediatamente después de una transformación de Amazon S3 o del Catálogo de datos de AWS Glue.
1. Esta regla no funcionará en las sesiones interactivas de AWS Glue.
# FileSize
El tipo de regla FileSize le permite asegurarse de que los archivos cumplan ciertos criterios de tamaño de archivo. Esto resulta útil para los siguientes casos de uso:
1. Asegurarse de que los productores no envíen archivos vacíos o sustancialmente más pequeños para su procesamiento.
1. Asegurarse de que sus buckets de destino no tengan archivos más pequeños, lo que podría provocar problemas de rendimiento.
FileSize recopila las siguientes métricas:
1. Conformidad: devuelve el porcentaje (%) de archivos que cumplen el umbral de la regla que ha establecido
1. Recuento de archivos: el número de archivos que ha analizado la regla
1. Tamaño mínimo de archivo en bytes
1. Tamaño máximo de archivo en bytes
```
Dataset.*.FileSize.Compliance: 1.00,
Dataset.*.FileCount: 8.00,
Dataset.*.MaximumFileSize: 327413121.00,
Dataset.*.MinimumFileSize: 204558920.00
```
Estas métricas no admiten la detección de anomalías.
**Validación del tamaño de los archivos**
Esta regla se aplicará cuando el archivo file.dat ocupe más de 2 MB.
```
FileSize "s3://amzn-s3-demo-bucket/file.dat" > 2 MB
```
Las unidades compatibles incluyen B (bytes), MB (megabytes), GB (gigabytes) y TB (terabytes).
**Validación del tamaño de los archivos en las carpetas**
```
FileSize "s3://bucket/" > 5 B
FileSize "s3://bucket/" < 2 GB
```
Esta regla se aplicará si el 70 % de los archivos de s3://amzn-s3-demo-bucket tienen entre 2 GB y 1 TB.
```
FileSize "s3://amzn-s3-demo-bucket/" between 2 GB and 1 TB with threshold > 0.7
```
**Cómo inferir los nombres de los archivos directamente de los marcos de datos**
No siempre tiene que proporcionar una ruta de archivo. Por ejemplo, al crear la regla en el Catálogo de datos, puede resultar difícil encontrar qué carpetas usan las tablas del catálogo. AWS Calidad de datos de Glue puede encontrar las carpetas o archivos específicos que se usan para rellenar su marco de datos.
**nota**
Esta característica solo funcionará cuando los archivos se lean correctamente en DynamicFrame o DataFrame.
```
FileSize < 10 MB with threshold > 0.7
```
**Etiquetas de reglas opcionales basadas en archivos:**
Las etiquetas permiten controlar el comportamiento de las reglas.
**recentFiles**
Esta etiqueta limita el número de archivos procesados dejando primero el archivo más reciente.
```
FileSize "s3://amzn-s3-demo-bucket/" > 5 B with recentFiles = 1
```
**uriRegex**
**nota**
La etiqueta AWS está disponible en `uriRegex` Glue 5.0 y versiones posteriores.
Esta etiqueta filtra los archivos mediante la aplicación de un patrón de expresión regular a la ruta del archivo. Solo se procesan los archivos cuyas rutas coinciden con el patrón. También puede usar una anticipación negativa para excluir los archivos que coinciden con un patrón.
```
# 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**
La etiqueta AWS está disponible en `filterOrder` Glue 5.0 y versiones posteriores.
Cuando utiliza varias etiquetas de filtro, como `recentFiles` y `uriRegex`, en conjunto, la etiqueta `filterOrder` controla el orden en que se aplican. El orden predeterminado es primero `recentFiles` y luego `uriRegex`.
```
FileSize "s3://bucket/" > 5 B with recentFiles = 5 with uriRegex = "\.dat$" with filterOrder = ["uriRegex","recentFiles"]
```
**failFast**
Cuando se establece en `"true"`, la regla devuelve un error de inmediato en el primer archivo que no cumple la condición de tamaño, en lugar de evaluar todos los archivos y calcular una tasa de cumplimiento.
```
FileSize "s3://bucket/" > 2 MB with failFast = "true"
```
Existen algunas consideraciones:
1. En la ETL de AWS Glue, debe tener la transformación EvaluateDataQuality inmediatamente después de una transformación de Amazon S3 o del Catálogo de datos.
1. Esta regla no funcionará en las sesiones interactivas de AWS Glue.