",
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"
}
"""
)
)
}
```
在 AWS Glue Data Catalog 中，您可以在用户界面中轻松配置此选项，如下所示。
![\[屏幕截图显示了一个“复合规则设置”窗口，您可以在其中选择行和列之间的规则评估配置。如果选择“行”，复合规则将作为评估整行的单个规则运行。如果选择“列”，则复合规则将评估整个数据集中的各个规则，然后将结果合并。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/composite-rule-settings.png)
设置完成后，复合规则将作为评估整行的单个规则运行。以下示例说明了此行为。
```
# 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 |
+------+------+------------------------------------------------------------+---------------------------+
```
此功能不支持某些规则，因为其总体结果依赖阈值或比率。不支持的规则列举如下。
依赖比率的规则：
+ 完整性
+ DatasetMatch
+ ReferentialIntegrity
+ 独特性
依赖阈值的规则：
当以下规则包含阈值时，则不支持这些规则。但是，不涉及 `with threshold` 的规则仍受支持。
+ ColumnDataType
+ ColumnValues
+ CustomSQL
### Expressions
如果规则类型不生成布尔响应，则必须提供表达式作为参数才能创建布尔响应。例如，以下规则根据表达式检查列中所有值的均值（平均值），以返回真或假结果。
```
Mean "colA" between 80 and 100
```
某些规则类型（例如 `IsUnique` 和 `IsComplete`）已经返回布尔响应。
下表列出了您可在 DL 规则中使用的表达式。
**支持的 DQDL 表达式**
| Expression | 说明 | 示例 |
| --- | --- | --- |
| =x | 如果规则类型响应等于 x，则解析为 true。 | Completeness "colA" = "1.0",
ColumnValues "colA" = "2022-06-30"
|
| \$1=x | x 如果规则类型响应不等于 x，则解析为 true。 | ColumnValues "colA" != "a",
ColumnValues "colA" != "2022-06-30"
|
| > x | 如果规则类型响应大于 x，则解析为 true。 | ColumnValues "colA" > 10
|
| < x | 如果规则类型响应小于 x，则解析为 true。 | ColumnValues "colA" < 1000,
ColumnValues "colA" < "2022-06-30"
|
| >= x | 如果规则类型响应大于 x，则解析为 true。 | ColumnValues "colA" >= 10
|
| <= x | 如果规则类型响应小于或等于 x，则解析为 true。 | ColumnValues "colA" <= 1000
|
| 介于 x 与 y 之间 | 如果规则类型响应在指定范围内（不包括），则解析为 true。仅将此表达式类型用于数字和日期类型。 | Mean "colA" between 8 and 100,
ColumnValues "colA" between "2022-05-31" and "2022-06-30"
|
| not between x and y | 如果规则类型响应不在指定范围内（包括首尾数），则解析为 true。您只能将此表达式类型用于数字和日期类型。 | ColumnValues "colA" not between "2022-05-31" and "2022-06-30"
|
| 在 [a, b, c, ...] 中 | 如果规则类型响应在指定的集合中，则解析为 true。 | ColumnValues "colA" in [ 1, 2, 3 ],
ColumnValues "colA" in [ "a", "b", "c" ]
|
| not in [a, b, c, ...] | 如果规则类型响应不在指定的集合中，则解析为 true。 | ColumnValues "colA" not in [ 1, 2, 3 ],
ColumnValues "colA" not in [ "a", "b", "c" ]
|
| 匹配 /ab\$1c/i | 如果规则类型响应与正则表达式匹配，则解析为 true。 | ColumnValues "colA" matches "[a-zA-Z]*"
|
| not matches /ab\$1c/i | 如果规则类型响应与正则表达式不匹配，则解析为 true。 | ColumnValues "colA" not matches "[a-zA-Z]*"
|
| now() | 仅适用于创建日期表达式的 ColumnValues 规则类型。 | ColumnValues "load_date" > (now() - 3 days)
|
| matches/in […]/not matches/not in [...] with threshold | 指定符合规则条件的值的百分比。仅适用于 ColumnValues、ColumnDataType 和 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
|
#### NULL、EMPTY 和 WHITESPACE\$1ONLY 的关键字
如果要验证字符串列是否为零、空或属于仅包含空格的字符串，则可以使用以下关键字：
+ NULL/null – 对于字符串列中的 `null` 值，此关键字解析为 true。
如果超过 50% 的数据没有零值，则 `ColumnValues "colA" != NULL with threshold > 0.5` 将返回 true。
对于所有具有零值或长度大于 5 的行，`(ColumnValues "colA" = NULL) or (ColumnLength "colA" > 5)` 都将返回 true。*请注意，这将需要使用“compositeRuleEvaluation.method” = “ROW”选项。*
+ EMPTY/empty – 对于字符串列中的空字符串（“”）值，此关键字将解析为 true。某些数据格式会将字符串列中的零值转换为空字符串。此关键字有助于过滤掉数据中的空字符串。
如果一行为空、“a”或“b”，`(ColumnValues "colA" = EMPTY) or (ColumnValues "colA" in ["a", "b"])` 将返回 true。*请注意，这需要使用“compositeRuleEvaluation.method” = “ROW”选项。*
+ WHITESPACES\$1ONLY /whitespaces\$1only – 对于字符串列中只有空格（“ ”）值的字符串，此关键字解析为 true。
如果一行既不是“a”或“b”，也不只是空格，`ColumnValues "colA" not in ["a", "b", WHITESPACES_ONLY]` 将返回 true。
支持的规则：
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
对于基于数值或日期的表达式，如果要验证列是否包含零值，则可以使用以下关键字。
+ NULL/null – 对于字符串列中的零值，此关键字解析为 true。
如果列中的日期为 `2023-01-01` 或零，`ColumnValues "colA" in [NULL, "2023-01-01"]` 将返回 true。
对于所有具有零值或值介于 1 到 9 之间的行，`(ColumnValues "colA" = NULL) or (ColumnValues "colA" between 1 and 9)` 都将返回 true。*请注意，这将需要使用“compositeRuleEvaluation.method” = “ROW”选项。*
支持的规则：
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
#### 使用 Where 子句进行筛选
**注意**
仅 AWS Glue 4.0 中支持 Where 子句。
您可以在编写规则时筛选数据。当您想要应用条件规则时，这会很有用。
```
where " "
```
必须使用 `where` 关键字指定筛选条件，后跟一个用引号 `("")` 括起有效 SparkSQL 语句。
如果您希望将 where 子句添加到具有阈值的规则中，则应在指定阈值条件之前指定 where 子句。
```
where "valid SparkSQL statement>" with threshold
```
您可以使用此语法编写如下规则。
```
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)"
```
我们将验证所提供的 SparkSQL 语句是否有效。如果无效，规则评估将失败，我们将按照以下格式引发 `IllegalArgumentException`：
```
Rule where "" has provided an invalid where clause :
```
**启用行级错误记录识别时的 where 子句行为**
借助 AWS Glue 数据质量自动监测功能，您可以识别失败的特定记录。将 where 子句应用于支持行级结果的规则时，我们会将 where 子句筛选出的行标记为 `Passed`。
如果您希望将筛选出的行单独标记为 `SKIPPED`，则可以为 ETL 作业设置以下 `additionalOptions`。
```
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"
}
"""
)
)
}
```
请参阅以下规则和数据框作为示例：
```
IsComplete att2 where "att1 = 'a'"
```
| id | att1 | att2 | 行级结果（默认） | 行级结果（跳过的选项） | 评论 |
| --- | --- | --- | --- | --- | --- |
| 1 | a | f | PASSED | PASSED | |
| 2 | b | d | PASSED | SKIPPED | 行已被筛选出，因为 att1 不是 "a" |
| 3 | a | null | FAILED | FAILED | |
| 4 | a | f | PASSED | PASSED | |
| 5 | b | null | PASSED | SKIPPED | 行已被筛选出，因为 att1 不是 "a" |
| 6 | a | f | PASSED | PASSED | |
### 常量
在 DQDL 中，您可以定义常量值并在整个脚本中引用这些值。这有助于防止与查询大小限制相关的问题，例如，在处理可能超出允许范围的大型 SQL 语句时。通过将这些值分配给常量，可以简化 DQDL 并避免达到这些限制。
以下示例演示了如何定义并使用常量：
```
mySql = "select count(*) from primary"
Rules = [
CustomSql $mySql between 0 and 100
]
```
在此示例中，将 SQL 查询分配给常量 `mySql`，然后使用 `$` 前缀在规则中引用该常量。
### 标签
标签为组织和分析数据质量结果提供了一种有效的方法。可以按特定标签查询结果，进而识别特定类别中的失败规则，按团队或域统计规则结果，并为不同的利益相关者创建有针对性的报告。
例如，可以使用标签 `"team=finance"` 应用与财务团队有关的所有规则，并生成自定义报告来展示财务团队特定的质量指标。可以将高优先级规则标注为 `"criticality=high"`，进而确定补救工作的优先级。标签可以作为 DQDL 的一部分创作。可以将标签作为规则结果、行级结果和 API 响应的一部分进行查询，从而轻松地与现有的监控和报告工作流程集成。
**注意**
标签仅在 AWS Glue ETL 中可用，在基于 AWS Glue Data Catalog 的数据质量自动监测功能中不可用。
#### DQDL 标签的语法
DQDL 支持默认标签和特定于规则的标签。默认标签是在规则集级别定义的，并自动应用于该规则集中的所有规则。各个规则也可以有自己的标签，并且由于标签是作为键值对实现的，因此在使用相同的键时，特定于规则的标签可以覆盖默认标签。
以下示例演示了如何使用默认和特定于规则的标签：
```
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]
]
```
##### 标签约束
标签具有以下约束：
+ 每个 DQDL 规则最多有 10 个标签。
+ 标签被指定为键值对列表。
+ 标签键和标签值区分大小写。
+ 标签键的最大长度是 128 个字符。标签键不得为空或为 null。
+ 标签值的最大长度是 256 个字符。标签值可以为空或为 null。
#### 检索 DQDL 标签
可以从规则结果、行级结果和 API 响应中检索 DQDL 标签。
##### 规则结果
DQDL 标签在规则结果中始终可见。无需额外配置即可启用这些标签。
##### 行级结果
默认情况下，行级结果中的 DQDL 标签处于禁用状态，但可以使用 `EvaluateDataQuality` 中的 `AdditionalOptions` 启用。
以下示例演示了如何在行级结果中启用标签：
```
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"
}""")
)
```
启用后，行级结果数据框将包含 `DataQualityRulesPass`、`DataQualityRulesFail` 和 `DataQualityRulesSkip` 列中每条规则的标签。
##### API 响应
DQDL 标签在 API 响应中 `RuleResults` 对象的新字段 `Labels` 下始终可见。
以下示例演示了 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"
}
}
]
}
```
### 动态规则
**注意**
动态规则仅在 AWS Glue ETL 中受支持，在 AWS Glue Data Catalog 中不受支持。
现在，您可以编写动态规则，将规则生成的当前指标与其历史值进行比较。这些历史比较通过在表达式中使用 `last()` 运算符启用。例如，当前运行中的行数大于同一数据集之前最近一次的行数时，`RowCount > last()` 规则就会成功。`last()` 采用一个可选的自然数参数，描述要考虑的先前指标数量；`k >= 1` 将引用的最后一个 `k` 指标 `last(k)`。
+ 如果没有可用的数据点，`last(k)` 将返回默认值 0.0。
+ 如果少于可用的 `k` 指标，则 `last(k)` 将返回所有之前的指标。
要形成有效的表达式，请使用 `last(k)`，其中 `k > 1` 需要聚合函数以将多个历史结果简化为单个数字。例如，`RowCount > avg(last(5))` 将检查当前数据集的行数是否严格大于同一数据集最后五行计数的平均值。`RowCount > last(5)` 将产生错误，因为无法将当前数据集的行数与列表进行有意义的比较。
支持的聚合函数：
+ `avg`
+ `median`
+ `max`
+ `min`
+ `sum`
+ `std`（标准偏差）
+ `abs`（绝对值）
+ `index(last(k), i)` 将允许从最后一个 `k` 中选择第 `i` 最新的值。`i` 为零索引，因此 `index(last(3), 0)` 将返回最新的数据点，并且 `index(last(3), 3)` 将导致错误，因为只有三个数据点，而我们尝试编制第四最新数据点的索引。
**示例表达式**
**ColumnCorrelation**
+ `ColumnCorrelation "colA" "colB" < avg(last(10))`
**DistinctValuesCount**
+ `DistinctValuesCount "colA" between min(last(10))-1 and max(last(10))+1`
大多数具有数字条件或阈值的规则类型都支持动态规则；请参阅提供的[分析器和规则](#dqdl-analyzers-table)表，以确定您的规则类型是否支持动态规则。
**从动态规则中排除统计信息**
有时，您需要从动态规则计算中排除数据统计信息。假设您加载了历史数据，但不希望其影响您的平均值。为此，请在 AWS Glue ETL 中打开作业并选择**数据质量**选项卡，然后依次选择**统计信息**和要排除的统计信息。您将能够看到趋势图和统计表。选择要排除的值，然后选择**排除统计信息**。排除的统计信息将不会包含在动态规则计算中。
![\[屏幕截图显示选择统计信息后从下拉菜单中排除或包含统计信息的选项。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/data-quality-excluding-statistics-from-dynamic-rules.png)
### 分析器
**注意**
AWS Glue Data Catalog 不支持分析器。
DQDL 规则使用名为*分析器*的功能收集有关您的数据的信息。规则的布尔表达式使用此信息确定规则应该成功还是失败。例如，RowCount 规则 `RowCount > 5 ` 将使用行计数分析器发现数据集中的行数，并将其与表达式 `> 5` 进行比较，以检查当前数据集中是否存在超过五行。
有时，我们建议创建分析器（而不是编写规则），然后让其生成可用于检测异常的统计信息。对于此类实例，您可以创建分析器。分析器在以下方面与规则不同。
| 特征 | 分析器 | Rules |
| --- | --- | --- |
| 规则集的一部分 | 支持 | 是 |
| 生成统计信息 | 支持 | 是 |
| 生成观测值 | 支持 | 是 |
| 可以评估和断言条件 | 否 | 是 |
| 您可以配置操作，例如在失败时停止作业、继续处理作业 | 否 | 是 |
分析器无需规则即可独立存在，因此您可以快速配置分析器并逐步构建数据质量规则。
可以在规则集的 `Analyzers` 块中输入某些规则类型，以运行分析器所需的规则并收集信息，而无需对任何条件进行检查。有些分析器与规则无关，只能在 `Analyzers` 块中输入。下表显示每个项目是作为规则还是作为独立分析器支持，以及每种规则类型的其他详细信息。
**带分析器的示例规则集**
以下规则集使用：
+ 一条动态规则，用于检查数据集在过去三次作业运行中，是否增长超过其尾随平均值
+ `DistinctValuesCount` 分析器，用于记录数据集 `Name` 列中不同值的数量
+ `ColumnLength` 分析器，用于跟踪一段时间内最小和最大 `Name` 大小
可以在作业运行的“数据质量”选项卡中，查看分析器指标结果。
```
Rules = [
RowCount > avg(last(3))
]
Analyzers = [
DistinctValuesCount "Name",
ColumnLength "Name"
]
```
AWS Glue 数据质量自动监测功能支持以下分析器。
| 分析器名称 | 功能 |
| --- | --- |
| RowCount | 计算数据集的行数 |
| Completeness | 计算列的完整性百分比 |
| Uniqueness | 计算列的唯一性百分比 |
| Mean | 计算数字列的平均值 |
| Sum | 计算数字列的总和 |
| StandardDeviation | 计算数字列的标准差 |
| Entropy | 计算数字列的熵 |
| DistinctValuesCount | 计算列中独特值的数量 |
| UniqueValueRatio | 计算列中的唯一值比率 |
| ColumnCount | 计算数据集中的列数 |
| ColumnLength | 计算列的长度 |
| ColumnValues | 计算数字列的最小值和最大值。计算非数字列的最小列长和最大列长 |
| ColumnCorrelation | 计算给定列的列相关性 |
| CustomSql | 计算 CustomSQL 返回的统计信息 |
| AllStatistics | 计算以下统计信息：[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/dqdl.html) |
### 评论
您可以使用“\$1”字符在 DQDL 文档中添加注释。DQDL 会忽略在“\$1”字符之后以及直到行尾的任何内容。
```
Rules = [
# More items should generally mean a higher price, so correlation should be positive
ColumnCorrelation "price" "num_items" > 0
]
```
# DL 规则类型引用
本部分介绍 AWS Glue Data Quality 支持的每种规则类型的参考。
**注意**
DQDL 目前不支持嵌套或列表类型的列数据。
下表中带括号的值将替换为规则参数中提供的信息。
规则通常需要一个额外的表达式参数。
| RuleType | 描述 | 参数 | 报告的指标 | 是否支持作为规则？ | 是否支持作为分析器？ | 返回行级结果？ | 动态规则支持？ | 生成观测值 | 是否支持 where 子句语法？ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| AggregateMatch | 通过比较总销售额等摘要指标，检查两个数据集是否匹配。如果所有数据都是从源系统提取的，金融机构可以进行比较。 | 一个或多个聚合 | 当第一个和第二个聚合列名匹配时： `Column.[Column].AggregateMatch` 当第一个和第二个聚合列名不同时： `Column.[Column1,Column2].AggregateMatch` | 是 | 否 | 否 | 否 | 否 | 否 |
| AllStatistics | 独立分析器，为数据集中提供的列收集多个指标。 | 单个列名 | 对于所有类型的列： `Dataset.*.RowCount` `Column.[Column].Completeness` `Column.[Column].Uniqueness` 字符串值列的其他指标： `ColumnLength metrics` 数字值列的其他指标： `ColumnValues metrics` | 否 | 是 | 否 | 否 | 否 | 否 |
| ColumnCorrelation | 检查两列的关联程度。 | 正好两个列名 | Multicolumn.[Column1,Column2].ColumnCorrelation | 支持 | 是 | 否 | 是 | 否 | 是 |
| ColumnCount | 检查是否删除了任何列。 | 无 | Dataset.\$1.ColumnCount | 支持 | 是 | 否 | 是 | 是 | 否 |
| ColumnDataType | 检查列是否符合数据类型。 | 只有一个列名 | Column.[Column].ColumnDataType.Compliance | 是 | 否 | 否 | 是，在行级阈值表达式中 | 否 | 是 |
| ColumnExists | 检查数据集中是否存在列。这允许客户构建自助服务数据平台以确保某些列可用。 | 只有一个列名 | 不适用 | 是 | 否 | 否 | 否 | 否 | 否 |
| ColumnLength | 检查数据长度是否一致。 | 只有一个列名 | `Column.[Column].MaximumLength` `Column.[Column].MinimumLength` 提供行级阈值时的其他指标： `Column.[Column].ColumnValues.Compliance` | 支持 | 是 | 是，如已提供行级阈值 | 否 | 是。仅通过分析最小长度和最大长度来生成观测值 | 是 |
| ColumnNamesMatchPattern | 检查列名是否与定义的模式匹配。对于治理团队来说，强制列名一致性很有用。 | 列名的正则表达式 | Dataset.\$1.ColumnNamesPatternMatchRatio | 是 | 否 | 否 | 否 | 否 | 否 |
| ColumnValues | 根据定义的值检查数据是否一致。此规则支持正则表达式。 | 只有一个列名 | `Column.[Column].Maximum` `Column.[Column].Minimum` 提供行级阈值时的其他指标： `Column.[Column].ColumnValues.Compliance` | 支持 | 是 | 是，如已提供行级阈值 | 否 | 是。仅通过分析最小值和最大值来生成观测值 | 是 |
| 完整性 | 检查数据中是否有任何空白或 NULL。 | 只有一个列名 | `Column.[Column].Completeness` | 支持 | 是 | 是 | 是 | 是 | 是 |
| CustomSql | 客户可以在 SQL 中实施几乎任何类型的数据质量检查。 | SQL 语句 （可选）行级阈值 | `Dataset.*.CustomSQL` 提供行级阈值时的其他指标： `Dataset.*.CustomSQL.Compliance` | 是 | 否 | 是，如已提供行级阈值 | 是 | 否 | 否 |
| DataFreshness | 检查数据是否是最新的。 | 只有一个列名 | Column.[Column].DataFreshness.Compliance | 是 | 否 | 是 | 否 | 否 | 是 |
| DatasetMatch | 比较两个数据集并确定它们是否同步。 | 引用数据集的名称 列映射 （可选）用于检查匹配项的列 | Dataset.[ReferenceDatasetAlias].DatasetMatch | 是 | 否 | 是 | 是 | 否 | 否 |
| DistinctValuesCount | 检查是否存在重复值。 | 只有一个列名 | Column.[Column].DistinctValuesCount | 支持 | 是 | 是 | 是 | 是 | 是 |
| DetectAnomalies | 检查其他规则类型报告的指标中是否存在异常。 | 规则类型 | 规则类型参数报告的指标 | 是 | 否 | 否 | 否 | 否 | 否 |
| 熵 | 检查数据的熵。 | 只有一个列名 | Column.[Column].Entropy | 支持 | 是 | 否 | 是 | 否 | 是 |
| IsComplete | 检查数据是否 100% 完整。 | 只有一个列名 | Column.[Column].Completeness | 是 | 否 | 是 | 否 | 否 | 是 |
| IsPrimaryKey | 检查列是否为主键（不是 NULL 且是唯一的）。 | 只有一个列名 | 对于单列： `Column.[Column].Uniqueness` 对于多列： `Multicolumn.[CommaDelimitedColumns].Uniqueness` | 是 | 否 | 是 | 否 | 否 | 是 |
| IsUnique | 检查数据是否 100% 唯一。 | 只有一个列名 | Column.[Column].Uniqueness | 是 | 否 | 是 | 否 | 否 | 是 |
| 平均值 | 检查均值是否与设定的阈值相符。 | 只有一个列名 | Column.[Column].Mean | 支持 | 是 | 是 | 是 | 否 | 是 |
| ReferentialIntegrity | 检查两个数据集是否具有引用完整性。 | 数据集中的一个或多个列名 引用数据集中的一个或多个列名 | Column.[ReferenceDatasetAlias].ReferentialIntegrity | 是 | 否 | 是 | 是 | 否 | 否 |
| RowCount | 检查记录计数是否与阈值匹配。 | 无 | Dataset.\$1.RowCount | 支持 | 是 | 否 | 是 | 是 | 是 |
| RowCountMatch | 检查两个数据集之间的记录计数是否匹配。 | 引用数据集别名 | Dataset.[ReferenceDatasetAlias].RowCountMatch | 是 | 否 | 否 | 是 | 否 | 否 |
| StandardDeviation | 检查标准偏差是否与阈值匹配。 | 只有一个列名 | Column.[Column].StandardDeviation | 支持 | 是 | 是 | 是 | 否 | 是 |
| SchemaMatch | 检查两个数据集之间的架构是否匹配。 | 引用数据集别名 | Dataset.[ReferenceDatasetAlias].SchemaMatch | 是 | 否 | 否 | 是 | 否 | 否 |
| 总和 | 检查总和是否与设定的阈值相符。 | 只有一个列名 | Column.[Column].Sum | 支持 | 是 | 否 | 是 | 否 | 是 |
| 独特性 | 检查数据集的唯一性是否与阈值匹配。 | 只有一个列名 | Column.[Column].Uniqueness | 支持 | 是 | 是 | 是 | 否 | 是 |
| UniqueValueRatio | 检查唯一值比率是否与阈值匹配。 | 只有一个列名 | Column.[Column].UniqueValueRatio | 支持 | 是 | 是 | 是 | 否 | 是 |
| FileFreshness | 检查 Amazon S3 中的文件是否为最新。 | 文件或文件夹路径和阈值。 | `Dataset.*.FileFreshness.Compliance` `Dataset.*.FileCount` | 是 | 否 | 否 | 否 | 否 | 否 |
| FileMatch | 检查文件内容是否与校验和或其他文件匹配。此规则使用校验和来验证两个文件是否相同。 | 源文件或文件夹路径以及目标文件或文件夹路径。 | 未生成任何统计信息。 | 是 | 否 | 否 | 否 | 否 | 否 |
| FileSize | 检查文件的大小是否符合指定的条件。 | 文件或文件夹路径和阈值。 | `Dataset.*.FileSize.Compliance` `Dataset.*.FileCount` `Dataset.*.MaximumFileSize` `Dataset.*.MinimumFileSize` | 是 | 否 | 否 | 否 | 否 | 否 |
| FileUniqueness | 使用校验和检查文件是否唯一。 | 文件或文件夹路径和阈值。 | `Dataset.*.FileUniquenessRatio` `Dataset.*.FileCount` | 是 | 否 | 否 | 否 | 否 | 否 |
**Topics**
+ [AggregateMatch](dqdl-rule-types-AggregateMatch.md)
+ [列相关性](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)
+ [完整性](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)
+ [熵](dqdl-rule-types-Entropy.md)
+ [IsComplete](dqdl-rule-types-IsComplete.md)
+ [IsPrimaryKey](dqdl-rule-types-IsPrimaryKey.md)
+ [IsUnique](dqdl-rule-types-IsUnique.md)
+ [平均值](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)
+ [总和](dqdl-rule-types-Sum.md)
+ [SchemaMatch](dqdl-rule-types-SchemaMatch.md)
+ [独特性](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
根据给定表达式检查两列聚合的比率。此规则类型适用于多个数据集。对两列聚合进行评估，并通过将第一列聚合的结果除以第二列聚合的结果得出比率。根据提供的表达式检查比率以生成布尔响应。
**语法**
**列聚合**
```
AggregateMatch (.)
```
+ **AGG\$1OPERATION** – 用于聚合的操作。目前支持 `sum` 和 `avg`。
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **OPTIONAL\$1REFERENCE\$1ALIAS** – 如果列来自引用数据集而不是主数据集，则需要提供此参数。如果您在 AWS Glue Data Catalog 中使用此规则，则您的引用别名必须遵循 "..
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **COL\$1NAME** – 要聚合列的名称。
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
**示例：平均值**
```
"avg(rating)"
```
**示例：总和**
```
"sum(amount)"
```
**示例：引用数据集中各列的平均值**
```
"avg(reference.rating)"
```
**规则**
```
AggregateMatch
```
+ **AGG\$1EXP\$11** – 第一列聚合。
支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **AGG\$1EXP\$12** – 第二列聚合。
支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：使用 sum 进行聚合匹配**
以下示例规则检查 `amount` 列中值的总和是否完全等于 `total_amount` 列中值的总和。
```
AggregateMatch "sum(amount)" "sum(total_amount)" = 1.0
```
**示例：使用 average 进行聚合匹配**
以下示例规则检查 `ratings` 列中值的平均值是否等于 `reference` 数据集中 `ratings` 列中值的至少 90% 平均值。在 ETL 或 Data Catalog 体验版中，引用数据集作为附加数据来源提供。
在 AWS Glue ETL 中，您可以使用：
```
AggregateMatch "avg(ratings)" "avg(reference.ratings)" >= 0.9
```
在 AWS Glue Data Catalog 中，您可以使用：
```
AggregateMatch "avg(ratings)" "avg(database_name.tablename.ratings)" >= 0.9
```
**零值行为**
在计算聚合方法（总和/均值）时，`AggregateMatch` 规则将忽略含有零值的行。例如：
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
列 `units` 的均值将为 (0 \$1 20 \$1 40)/3 = 20。在此计算中不会考虑第 101 行和第 103 行。
# 列相关性
检查两列与给定表达式之间的*相关性*。AWSGlue Data Quality 使用 Pearson 相关系数来测量两列之间的线性相关性。结果是一个介于 -1 和 1 之间的数字，用于衡量关系的强度和方向。
**语法**
```
ColumnCorrelation
```
+ **COL\$11\$1NAME** — 要根据其评估数据质量规则的第一列的名称。
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **COL\$12\$1NAME** — 要根据其评估数据质量规则的第二列的名称。
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：列相关性**
以下示例规则检查列 `height` 和 `weight` 之间的相关系数是否具有很强的正相关性（系数值大于 0.8）。
```
ColumnCorrelation "height" "weight" > 0.8
```
```
ColumnCorrelation "weightinkgs" "Salary" > 0.8 where "weightinkgs > 40"
```
**示例动态规则**
+ `ColumnCorrelation "colA" "colB" between min(last(10)) and max(last(10))`
+ `ColumnCorrelation "colA" "colB" < avg(last(5)) + std(last(5))`
**零值行为**
在相关性计算中，`ColumnCorrelation` 规则将忽略包含 `NULL` 值的行。例如：
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
第 101 行和第 103 行将被忽略，`ColumnCorrelation` 将为 1.0。
# ColumnCount
根据给定表达式检查主数据集的列数。在表达式中，您可以使用 `>` 和 `<` 等运算符指定列数或列范围。
**语法**
```
ColumnCount
```
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：列数数字校验**
以下示例规则检查列数是否在给定范围内。
```
ColumnCount between 10 and 20
```
**示例动态规则**
+ `ColumnCount >= avg(last(10))`
+ `ColumnCount between min(last(10))-1 and max(last(10))+1`
# ColumnDataType
检查给定列中的值是否可以在 Apache Spark 中转换为提供的类型。接受 `with threshold` 表达式以检查列中值的子集。
**语法**
```
ColumnDataType =
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
支持的列类型：字符串类型
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **EXPECTED\$1TYPE** – 列中值的预期类型。
支持的值：布尔值、日期、时间戳、整数、双精度、浮点数、长整型
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **EXPRESSION** – 一个可选表达式，用于指定应为预期类型的值的百分比。
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
**示例：将整数作为字符串的列数据类型**
以下示例规则检查给定列中字符串类型的值是否可以转换为整数。
```
ColumnDataType "colA" = "INTEGER"
```
**示例：列数据类型整数作为字符串检查值的子集**
以下示例规则检查给定列中是否有超过 90% 的字符串类型值可以转换为整数。
```
ColumnDataType "colA" = "INTEGER" with threshold > 0.9
```
# ColumnExists
检查列是否存在。
**语法**
```
ColumnExists
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：任何列类型
**示例：列存在**
以下示例规则检查名为 `Middle_Name` 的列是否存在。
```
ColumnExists "Middle_Name"
```
# ColumnLength
检查列中每行的长度是否符合给定表达式。
**语法**
```
ColumnLength
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：字符串
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：列行长**
以下示例规则检查名为 `Postal_Code` 的列中每行的值长度是否为 5 个字符。
```
ColumnLength "Postal_Code" = 5
ColumnLength "weightinkgs" = 2 where "weightinkgs > 10"
```
**零值行为**
`ColumnLength` 规则将 `NULL` 视为长度为 0 的字符串。对于 `NULL` 行：
```
ColumnLength "Postal_Code" > 4 # this will fail
```
```
ColumnLength "Postal_Code" < 6 # this will succeed
```
以下示例复合规则提供了一种让 `NULL` 值显式失效的方法：
```
(ColumnLength "Postal_Code" > 4) AND (ColumnValues "Postal_Code" != NULL)
```
# ColumnNamesMatchPattern
检查主数据集中所有列的名称是否与给定的正则表达式相匹配。
**语法**
```
ColumnNamesMatchPattern
```
+ **PATTERN - 您要评估数据质量规则依据的模式。**
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
**示例：列名匹配模式**
以下示例规则检查所有列是否以前缀“aws\$1”开头
```
ColumnNamesMatchPattern "aws_.*"
ColumnNamesMatchPattern "aws_.*" where "weightinkgs > 10"
```
# ColumnValues
针对列中的值运行表达式。
**语法**
```
ColumnValues
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：任何列类型
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：允许的值**
以下示例规则检查指定列中的每个值是否在允许的值集中（包括零值、空值以及仅包含空格的字符串）。
```
ColumnValues "Country" in [ "US", "CA", "UK", NULL, EMPTY, WHITESPACES_ONLY ]
ColumnValues "gender" in ["F", "M"] where "weightinkgs < 10"
```
**示例：正则表达式**
以下示例规则根据正则表达式检查列中的值。
```
ColumnValues "First_Name" matches "[a-zA-Z]*"
```
**示例：日期值**
以下示例规则根据日期表达式检查日期列中的值。
```
ColumnValues "Load_Date" > (now() - 3 days)
```
**示例：数值**
以下示例规则检查列值是否与特定的数字约束条件相匹配。
```
ColumnValues "Customer_ID" between 1 and 2000
```
**零值行为**
对于所有 `ColumnValues` 规则（`!=` 和 `NOT IN` 除外），`NULL` 行都不能通过该规则。如果由于零值而导致不能通过规则，则失效原因将显示如下：
```
Value: NULL does not meet the constraint requirement!
```
以下示例复合规则提供了一种显式允许 `NULL` 值的方法：
```
(ColumnValues "Age" > 21) OR (ColumnValues "Age" = NULL)
```
使用 `!=` 和 `not in` 语法的否定 ColumnValues 规则将允许 `NULL` 行。例如：
```
ColumnValues "Age" != 21
```
```
ColumnValues "Age" not in [21, 22, 23]
```
以下示例提供了一种让 `NULL` 值显式失效的方法
```
(ColumnValues "Age" != 21) AND (ColumnValues "Age" != NULL)
```
```
ColumnValues "Age" not in [21, 22, 23, NULL]
```
# 完整性
根据给定表达式检查列中完整（非空）值的百分比。
**语法**
```
Completeness
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：任何列类型
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：空值百分比**
以下示例规则检查列中是否有超过 95% 的值是完整的。
```
Completeness "First_Name" > 0.95
Completeness "First_Name" > 0.95 where "weightinkgs > 10"
```
**示例动态规则**
+ `Completeness "colA" between min(last(5)) - 1 and max(last(5)) + 1`
+ `Completeness "colA" <= avg(last(10))`
**零值行为**
关于 CSV 数据格式的注意事项：CSV 列上的空行可能会显示多种行为。
+ 如果列为 `String` 类型，则空行将被识别为空字符串，并且不会不通过 `Completeness` 规则。
+ 如果列属于类似于 `Int` 的其他数据类型，则空行将被识别为 `NULL`，并且将不会通过 `Completeness` 规则。
# CustomSQL
此规则类型已扩展为支持两个用例：
+ 针对数据集运行自定义 SQL 语句，并根据给定表达式检查返回值。
+ 运行自定义 SQL 语句，在 SELECT 语句中指定列名，与某个条件进行比较以获得行级结果。
**语法**
```
CustomSql
```
+ **SQL\$1STATEMENT** — 返回单个数值的 SQL 语句，由双引号包围。
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：用于检索整体规则结果的自定义 SQL**
此示例规则使用 SQL 语句检索数据集的记录数。然后，该规则检查记录数是否介于 10 到 20 之间。
```
CustomSql "select count(*) from primary" between 10 and 20
```
**示例：用于检索行级结果的自定义 SQL**
此示例规则使用 SQL 语句，在 SELECT 语句中指定列名，与某个条件进行比较以获得行级结果。阈值条件表达式定义了整个规则失败的记录数的阈值。请注意，规则不能同时包含条件和关键字。
```
CustomSql "select Name from primary where Age > 18"
```
或
```
CustomSql "select Name from primary where Age > 18" with threshold > 3
```
**重要**
`primary` 别名代表要评估的数据集的名称。在控制台上处理可视化 ETL 任务时，`primary` 始终表示传递给 `EvaluateDataQuality.apply()` 转换的 `DynamicFrame`。当您使用 AWS Glue 数据目录对表运行数据质量任务时，`primary` 表示该表。
如果您在 AWS Glue Data Catalog 中，也可以使用实际的表名：
```
CustomSql "select count(*) from database.table" between 10 and 20
```
您也可以联接多个表来比较不同的数据元素：
```
CustomSql "select count(*) from database.table inner join database.table2 on id1 = id2" between 10 and 20
```
在 AWS Glue ETL 中，CustomSQL 可以识别未通过数据质量检查的记录。要使此功能起作用，您需要返回作为您正在评估数据质量的主表一部分的记录。作为查询一部分返回的记录被视为成功，未返回的记录被视为失败。此功能通过连接 CustomSQL 查询的结果与原始数据集来实现。根据 SQL 查询的复杂程度，可能会对性能产生影响。
要实现此目的，应按照以下步骤进行：
+ 您需要从主表中选择至少 1 列。
+ `select count(*) from primary` 是对 OVERALL CustomSQL DQ 规则的有效查询，但不适用于行级自定义 SQL。
+ 此规则将在评估期间引发错误：`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.`
+ 在 SQL 查询中，从表中选择一个“主键”或选择一组构成复合键的列。如果不这样做，则可能会因匹配重复行而导致结果不一致，并降低性能。
+ 仅从主表中选择键，不要从参考表中选择键。
以下规则将确保将年龄小于 100 的记录标识为成功记录，并将超过该年龄的记录标记为失败。
```
CustomSql "select id from primary where age < 100"
```
当 50% 的记录年龄大于 10 时，此 CustomSQL 规则将通过，并且还将标识失败的记录。此 CustomSQL 返回的记录将被视为通过，而未返回的记录将被视为失败。
```
CustomSQL "select ID, CustomerID from primary where age > 10" with threshold > 0.5
```
注意：如果您返回数据集中不可用的记录，CustomSQL 规则将失败。
# DataFreshness
通过评估当前时间和日期列值之间的差异，来检查列中数据的新鲜度。您可以为此规则类型指定基于时间的表达式，以确保列值是最新的。
**语法**
```
DataFreshness
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：日期
+ **EXPRESSION** — 以小时或天为单位的数字表达式。必须在表达式中指定时间单位。
**示例：数据新鲜度**
以下示例规则检查数据的新鲜度。
```
DataFreshness "Order_Date" <= 24 hours
DataFreshness "Order_Date" between 2 days and 5 days
```
**零值行为**
对于含有 `NULL` 值的行，将不能通过 `DataFreshness` 规则。如果由于零值而导致不能通过规则，则失效原因将显示如下：
```
80.00 % of rows passed the threshold
```
其中 20% 未通过该规则的行包含带 `NULL` 的行。
以下示例复合规则提供了一种显式允许 `NULL` 值的方法：
```
(DataFreshness "Order_Date" <= 24 hours) OR (ColumnValues "Order_Date" = NULL)
```
**Amazon S3 对象的数据新鲜度**
有时，您需要根据 Amazon S3 文件的创建时间来验证数据的新鲜度。为此，您可以使用以下代码获取时间戳并将其添加到您的数据框中，然后应用数据新鲜度检查。
```
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
检查主数据集中的数据是否与引用数据集中的数据匹配。使用提供的键列映射将两个数据集联接起来。如果您只想检查这些列中的数据是否相等，则可以提供其他列映射。请注意，要让 **DataSetMatch** 起作用，您的联接键应该是唯一的，并且不应为 NULL（必须是主键）。如果您不满足这些条件，则会收到错误消息：“提供的键映射不适合给定的数据帧”。如果您无法使用唯一的交集键，请考虑使用其他规则类型（例如 **AggregateMatch**）来匹配摘要数据。
**语法**
```
DatasetMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS** – 用于比较主数据集数据的引用数据集的别名。
+ **KEY\$1COLUMN\$1MAPPINGS** – 以逗号分隔的列名列表，这些列名构成了数据集中的键。如果两个数据集中的列名不相同，则必须使用 `->` 分隔它们
+ **OPTIONAL\$1MATCH\$1COLUMN\$1MAPPINGS** – 如果您只想检查某些列中的匹配数据，则可以提供此参数。它使用与键列映射相同的语法。如果未提供此参数，我们将匹配所有剩余列中的数据。其余的非键列在两个数据集中必须具有相同的名称。
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：使用 ID 列匹配集合数据集**
以下示例规则使用“ID”列来检查主数据集中是否有超过 90% 与引用数据集相匹配。在本例中，它会比较所有列。
```
DatasetMatch "reference" "ID" >= 0.9
```
**示例：使用多个键列匹配集合数据集**
在以下示例中，主数据集和引用数据集的键列名称不同。`ID_1` 和 `ID_2` 共同构成主数据集中的复合键。`ID_ref1` 和 `ID_ref2` 共同构成引用数据集中的复合键。在这种情况下，您可以使用特殊语法来提供列名。
```
DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" >= 0.9
```
**示例：使用多个键列匹配集合数据集并检查特定列是否匹配**
此示例建立在前一个示例的基础上。我们要检查是否只有包含金额的列匹配。此列在主数据集中名为 `Amount1`，在引用数据集中名为 `Amount2`。您希望完全匹配。
```
DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" "Amount1->Amount2" >= 0.9
```
# DistinctValuesCount
根据给定的表达式检查列中的不同值的数量。
**语法**
```
DistinctValuesCount
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：任何列类型
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：不同的列值计数**
以下示例规则检查名为 `State` 的列是否包含 3 个以上的不同值。
```
DistinctValuesCount "State" > 3
DistinctValuesCount "Customer_ID" < 6 where "Customer_ID < 10"
```
**示例动态规则**
+ `DistinctValuesCount "colA" between avg(last(10))-1 and avg(last(10))+1`
+ `DistinctValuesCount "colA" <= index(last(10),2) + std(last(5))`
# 熵
检查列的*熵*值是否与给定表达式匹配。熵测量消息中包含的信息级别。给定列中值的概率分布，熵描述了识别一个值需要多少位。
**语法**
```
Entropy
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：任何列类型
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：列熵**
以下示例规则检查名 `Feedback` 为的列的熵值是否大于一。
```
Entropy "Star_Rating" > 1
Entropy "First_Name" > 1 where "Customer_ID < 10"
```
**示例动态规则**
+ `Entropy "colA" < max(last(10))`
+ `Entropy "colA" between min(last(10)) and max(last(10))`
# IsComplete
检查列中的所有值是否完整（非空）。
**语法**
```
IsComplete
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：任何列类型
**示例：空值**
以下示例检查名为 `email` 的列中的所有值是否均为非空值。
```
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"
```
**零值行为**
关于 CSV 数据格式的注意事项：CSV 列上的空行可能会显示多种行为。
+ 如果列为 `String` 类型，则空行将被识别为空字符串，并且不会不通过 `Completeness` 规则。
+ 如果列属于类似于 `Int` 的其他数据类型，则空行将被识别为 `NULL`，并且将不会通过 `Completeness` 规则。
# IsPrimaryKey
检查列是否包含主键。如果列中的所有值都是唯一且完整（非空值），则该列包含主键。您还可以检查是否存在包含多列的主键。
**语法**
```
IsPrimaryKey
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：任何列类型
**示例：主键：**
以下示例规则检查名为 `Customer_ID` 的列是否包含主键。
```
IsPrimaryKey "Customer_ID"
IsPrimaryKey "Customer_ID" where "Customer_ID < 10"
```
**示例：包含多列的主键。以下任何示例均有效。**
```
IsPrimaryKey "colA" "colB"
IsPrimaryKey "colA" "colB" "colC"
IsPrimaryKey colA "colB" "colC"
```
# IsUnique
检查列中的所有值是否唯一，并返回布尔值。
**语法**
```
IsUnique
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：任何列类型
**示例**
以下示例规则检查名为 `email` 的列中的所有值是否均为非空值。
```
IsUnique "email"
IsUnique "Customer_ID" where "Customer_ID < 10"]
```
以下示例规则会检查多个列。
```
IsUnique "vendorid" "tpep_pickup_datetime"
```
# 平均值
检查列中所有值的均值（平均值）是否与给定表达式匹配。
**语法**
```
Mean
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：平均值**
以下示例规则检查列中所有值的平均值是否超过阈值。
```
Mean "Star_Rating" > 3
Mean "Salary" < 6200 where "Customer_ID < 10"
```
**示例动态规则**
+ `Mean "colA" > avg(last(10)) + std(last(2))`
+ `Mean "colA" between min(last(5)) - 1 and max(last(5)) + 1`
**零值行为**
在计算均值时，`Mean` 规则将忽略含有 `NULL` 值的行。例如：
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
列 `units` 的均值将为 (0 \$1 20 \$1 40)/3 = 20。在此计算中不会考虑第 101 行和第 103 行。
# ReferentialIntegrity
检查主数据集中一组列的值在多大程度上是引用数据集中一组列值的子集。
**语法**
```
ReferentialIntegrity
```
+ **PRIMARY\$1COLS** – 主数据集中列名的逗号分隔列表。
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **REFERENCE\$1DATASET\$1COLS** – 此参数包含用句点分隔的两个部分。第一部分是引用数据集的别名。第二部分是用大括号括起的引用数据集中以逗号分隔的列名列表。
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：检查邮政编码列 ** 的引用完整性
以下示例规则检查主数据集 `zipcode` 列中是否有 90% 以上的值存在于 `reference` 数据集的 `zipcode` 列中。
```
ReferentialIntegrity "zipcode" "reference.zipcode" >= 0.9
```
**示例：检查城市和州列的引用完整性**
在以下示例中，包含城市和州信息的列存在于主数据集和引用数据集中。两个数据集中的列名不同。该规则检查主数据集中各列的值集是否与引用数据集中各列的值集完全相等。
```
ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" = 1.0
```
**示例动态规则**
+ `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
根据给定表达式检查数据集的行数。在表达式中，您可以使用 `>` 和 `<` 等运算符指定行数或行范围。
**语法**
```
RowCount
```
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：行数数字校验**
以下示例规则检查行数是否在给定范围内。
```
RowCount between 10 and 100
RowCount between 1 and 50 where "Customer_ID < 10"
```
**示例动态规则**
```
RowCount > avg(last(10)) *0.8
```
# RowCountMatch
检查主数据集的行数和引用数据集的行数与给定表达式的比率。
**语法**
```
RowCountMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS** – 用于比较行数的引用数据集的别名。
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：根据引用数据集检查行数**
以下示例规则检查主数据集的行数是否至少为引用数据集行数的 90%。
```
RowCountMatch "reference" >= 0.9
```
# StandardDeviation
根据给定表达式检查列中所有值的标准差。
**语法**
```
StandardDeviation
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：标准差**
以下示例规则检查名为 `colA` 的列中值的标准差是否小于指定值。
```
StandardDeviation "Star_Rating" < 1.5
StandardDeviation "Salary" < 3500 where "Customer_ID < 10"
```
**示例动态规则**
+ `StandardDeviation "colA" > avg(last(10) + 0.1`
+ `StandardDeviation "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**零值行为**
在计算标准差时，`StandardDeviation` 规则将忽略含有 `NULL` 值的行。例如：
```
+---+-----------+-----------+
|id |units1 |units2 |
+---+-----------+-----------+
|100|0 |0 |
|101|null |0 |
|102|20 |20 |
|103|null |0 |
|104|40 |40 |
+---+-----------+-----------+
```
列 `units1` 的标准差将不考虑第 101 行和第 103 行，结果为 16.33。列 `units2` 的标准差将为 16。
# 总和
根据给定表达式检查列中所有值的总和。
**语法**
```
Sum
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：总和**
以下示例规则检查列中所有值的总和是否超过给定阈值。
```
Sum "transaction_total" > 500000
Sum "Salary" < 55600 where "Customer_ID < 10"
```
**示例动态规则**
+ `Sum "ColA" > avg(last(10))`
+ `Sum "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**零值行为**
在计算总和时，`Sum` 规则将忽略含有 `NULL` 值的行。例如：
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
列 `units` 的总和将不考虑第 101 行和第 103 行，结果为 (0 \$1 20 \$1 40) = 60。
# SchemaMatch
检查主数据集中的架构是否与引用数据集中的架构匹配。架构检查逐列完成。如果名称相同且类型相同，则两列的架构相匹配。列的顺序不重要。
**语法**
```
SchemaMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS** – 用于比较架构的引用数据集的别名。
**支持的列类型**：字节、十进制、双精度、浮点数、整数、长整数、短整数
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：SchemaMatch**
以下示例规则检查主数据集的架构是否与引用数据集中的架构完全匹配。
```
SchemaMatch "reference" = 1.0
```
# 独特性
根据给定表达式检查列中唯一值的百分比。唯一值只出现一次。
**语法**
```
Uniqueness
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：任何列类型
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例**
以下示例规则检查列中唯一值的百分比是否与某些数字标准相匹配。
```
Uniqueness "email" = 1.0
Uniqueness "Customer_ID" != 1.0 where "Customer_ID < 10"
```
以下示例规则会检查多个列。
```
Uniqueness "vendorid" "tpep_pickup_datetime" = 1
```
**示例动态规则**
+ `Uniqueness "colA" between min(last(10)) and max(last(10))`
+ `Uniqueness "colA" >= avg(last(10))`
# UniqueValueRatio
根据给定表达式检查列中*唯一值比率*。唯一值比率是唯一值除以列中所有不同值的数量得出的分数。唯一值仅出现一次，而不同值*至少*出现一次。
例如，集合 `[a, a, b]` 包含一个唯一值 (`b`) 和两个不同值（`a` 和 `b`）。因此，集合的唯一值比率为 ½ = 0.5。
**语法**
```
UniqueValueRatio
```
+ **COL\$1NAME** — 要根据其评估数据质量规则的列的名称。
**支持的列类型**：任何列类型
+ **EXPRESSION** — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 [Expressions](dqdl.md#dqdl-syntax-rule-expressions)。
**示例：唯一值比率**
此示例检查列与一系列值的唯一值比率。
```
UniqueValueRatio "test_score" between 0 and 0.5
UniqueValueRatio "Customer_ID" between 0 and 0.9 where "Customer_ID < 10"
```
**示例动态规则**
+ `UniqueValueRatio "colA" > avg(last(10))`
+ `UniqueValueRatio "colA" <= index(last(10),2) + std(last(5))`
# DetectAnomalies
检测给定数据质量规则的异常。每次执行 DetectAnomalies 规则都会导致保存给定规则的评估值。当收集到足够的数据时，异常检测算法会获取该给定规则的所有历史数据，并运行异常检测。检测到异常时，DetectAnomalies 规则失败。可通过观测值获得有关检测到哪些异常的更多信息。
**语法**
```
DetectAnomalies
```
`RULE_NAME` – 要根据其评估和检测异常的规则的名称。支持的规则：
+ "RowCount"
+ "Completeness"
+ "Uniqueness"
+ "Mean"
+ "Sum"
+ "StandardDeviation"
+ "Entropy"
+ "DistinctValuesCount"
+ "UniqueValueRatio"
+ "ColumnLength"
+ "ColumnValues"
+ "ColumnCorrelation"
+ "CustomSQL"
+ "ColumnCount"
`RULE_PARAMETERS`– 有些规则需要其他参数才能运行。请参阅给定的规则文档以了解所需的参数。
**示例：RowCount 异常**
例如，如果想检测 RowCount 异常，我们会提供 rowCount 作为规则名称。
```
DetectAnomalies "RowCount"
```
**示例：ColumnLength 异常**
例如，如果想检测 ColumnLength 异常，我们会提供 ColumnLength 作为规则名称和列名。
```
DetectAnomalies "ColumnLength" "id"
```
# FileFreshness
FileFreshness 可根据您提供的条件确保您的数据文件是最新的。其使用文件的最后修改时间来确保数据文件或整个文件夹是最新的。
此规则收集两个指标：
+ 基于您所设置规则的 FileFreshness 合规性
+ 规则扫描的文件数
```
{"Dataset.*.FileFreshness.Compliance":1,"Dataset.*.FileCount":1}
```
异常检测不考虑这些指标。
**检查文件新鲜度**
以下规则可确保 tickets.parquet 是在过去 24 小时内创建的。
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/tickets.parquet" > (now() - 24 hours)
```
**检查文件夹新鲜度**
如果文件夹中的所有文件都是在过去 24 小时内创建或修改的，则以下规则通过。
```
FileFreshness "s3://bucket/" >= (now() -1 days)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" >= (now() - 24 hours)
```
**使用阈值检查文件夹或文件新鲜度**
如果“tickets”文件夹中有 10% 的文件是在过去 10 天内创建或修改的，则以下规则通过。
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" < (now() - 10 days) with threshold > 0.1
```
**检查特定日期的文件或文件夹**
您可以检查特定日期的文件新鲜度。
```
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"
```
**随时间检查文件或文件夹**
您可以使用 FileFreshness 来确保文件在特定时间送达。
```
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"
```
重要注意事项：
+ FileFreshness 可以使用天、小时和分钟单位来评估文件
+ 对于时间，它支持上午/下午和 24 小时
+ 除非指定了替换，否则时间以 UTC 计算
+ 日期以 UTC 时间 00:00 计算
基于时间的 FileFreshness 的工作方式如下所示：
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45"
```
+ 首先，将时间“21:45”与 UTC 格式的今天日期结合，以创建日期时间字段
+ 接下来，将日期时间转换为您指定的时区
+ 最后，对规则进行评估
**可选的基于文件的规则标签：**
通过标签，您可以控制规则行为。
**recentFiles**
此标签通过将最新文件放在最前面，来限制处理的文件数。
```
FileFreshness "s3://amzn-s3-demo-bucket/" between (now() - 100 minutes) and (now() + 10 minutes) with recentFiles = 1
```
**uriRegex**
**注意**
`uriRegex` 标签在 AWS Glue 5.0 及更高版本中可用。
此标签通过对文件路径应用正则表达式模式来筛选文件。只有路径与该模式匹配的文件才会被处理。您也可以使用负向先行断言来排除与某个模式匹配的文件。
```
# 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**
**注意**
`filterOrder` 标签在 AWS Glue 5.0 及更高版本中可用。
当您同时使用多个筛选标签（例如 `recentFiles` 和 `uriRegex`）时，`filterOrder` 标签用来控制这些标签的应用顺序。默认顺序为首先应用 `recentFiles`，然后应用 `uriRegex`。
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with recentFiles = 1 with uriRegex = "inventory_" with filterOrder = ["uriRegex","recentFiles"]
```
上例会首先应用 `uriRegex` 筛选条件来仅选择与 “inventory\$1” 匹配的文件，然后使用 `recentFiles = 1` 从筛选后到结果集中获取最新的文件。如果未设置 `filterOrder`，则默认行为将是首先获取最新的单个文件，然后再应用正则表达式。如果最新的文件与该模式不匹配，则可能导致没有任何文件匹配。
**注意**
`filterOrder` 列表中的所有值必须引用同一规则中同时存在的其他筛选条件标签（`recentFiles` 或 `uriRegex`）。非筛选条件标签（例如 `timeZone` 或 `failFast`）在 `filterOrder` 中无效。
**failFast**
如果设置为 `"true"`，则该规则会在遇到第一个不符合新鲜度条件的文件时立即返回失败，而不会评估所有文件并计算合规率。
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with failFast = "true"
```
**timeZone**
可接受的时区覆盖，有关支持的时区，请参阅[允许的时区](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html)。
```
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"
```
**直接从数据帧推断文件名**
您不必总是提供文件路径。例如，当您在 AWS Glue Data Catalog 中编写规则时，可能很难找到目录表使用的文件夹。AWSGlue 数据质量自动监测功能可以找到用于填充数据帧的特定文件夹或文件，并可检测其是否为最新。
**注意**
仅当文件成功读取到 DynamicFrame 或 DataFrame 时，此功能才起作用。
```
FileFreshness > (now() - 24 hours)
```
此规则将查找用于填充动态帧或数据帧的文件夹路径或文件。这适用于 Amazon S3 路径或基于 Amazon S3 的 AWS Glue Data Catalog 表。有几个注意事项：
1. 在 AWS Glue ETL 中，您必须在 Amazon S3 或 AWS Glue Data Catalog 转换之后立即进行 **EvaluateDataQuality** 转换。
![\[屏幕截图显示连接到 Amazon S3 节点的评估数据质量节点。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/data-quality-file-freshness.png)
1. 此规则在 AWS Glue 交互式会话中不起作用。
如果您在上述两种情况下都尝试这样做，或者当 AWS Glue 找不到文件时，则 AWS Glue 会抛出以下错误：`“Unable to parse file path from DataFrame”`
# FileMatch
FileMatch 规则允许您将文件与其他文件或校验和进行比较。这可能在一些方案中非常有用：
1. 验证从外部来源接收的文件：您可以使用 FileMatch 通过与校验和进行比较，确保从外部来源接收正确的文件。这有助于验证您所摄取数据的完整性。
1. 比较两个不同文件夹中的数据：FileMatch 可用于比较两个文件夹之间的文件。
此规则收集一个指标：规则扫描的文件数。
```
{"Dataset.*.FileCount":1}
```
**使用校验和验证文件：**
FileMatch 接受一个文件和一组校验和，以确保至少有一个校验和与该文件匹配。
```
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"]
```
支持下列标准算法：
+ MD5
+ SHA-1
+ SHA-256
如果您不提供算法，则默认为 SHA-256。
**使用一组校验和验证文件夹中的所有文件：**
```
FileMatch "s3://amzn-s3-demo-bucket /" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch "s3://amzn-s3-demo-bucket /internal-folder/" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"]
```
**比较不同文件夹中的文件**
```
# 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 将检查 `original_bucket` 中文件的内容，并确保其与 `archive_bucket` 中的内容相匹配。如果不完全匹配，则该规则将失效。它还可以检查内部文件夹或单个文件的内容。
FileMatch 还可以相互检查各个文件。
```
FileMatch "s3://amzn-s3-demo-bucket /file_old.json" "s3://amzn-s3-demo-bucket /file_new.json"
```
**直接从数据帧推断文件名**
您不必总是提供文件路径。例如，当您在 AWS Glue Data Catalog（由 Amazon S3 支持）中编写规则时，可能很难找到目录表使用的文件夹。AWSGlue 数据质量自动监测功能可以找到用于填充数据帧的特定文件夹或文件。
**注意**
仅当文件成功读取到 DynamicFrame 或 DataFrame 时，此功能才起作用。
```
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-1"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-256"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"]
```
如果提供的校验和与计算的校验和不同，则 FileMatch 将提醒您注意差异。
![\[屏幕截图显示 DQ 状态为规则失效的一条规则。FileMatch 说明失效的原因。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/data-quality-file-match.png)
**可选的基于文件的规则标签：**
通过标签，您可以控制规则行为。
**recentFiles**
此标签通过将最新文件放在最前面，来限制处理的文件数。
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1
```
**uriRegex**
**注意**
`uriRegex` 标签在 AWS Glue 5.0 及更高版本中可用。
此标签通过对文件路径应用正则表达式模式来筛选文件。只有路径与该模式匹配的文件才会被处理。您也可以使用负向先行断言来排除与某个模式匹配的文件。
```
# 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**
**注意**
`filterOrder` 标签在 AWS Glue 5.0 及更高版本中可用。
当您同时使用多个筛选标签（例如 `recentFiles` 和 `uriRegex`）时，`filterOrder` 标签用来控制这些标签的应用顺序。默认顺序为首先应用 `recentFiles`，然后应用 `uriRegex`。
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1 with uriRegex = "\.json$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
此标签可确保文件没有重复的名称。默认行为是 false。
```
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac04179sam4713e5ef8f319"] with matchFileName = "true"
```
有几个注意事项：
1. 在 AWS Glue ETL 中，您必须在 Amazon S3 或 AWS Glue Data Catalog 转换之后立即进行 **EvaluateDataQuality** 转换。
![\[屏幕截图显示 DQ 状态为规则失效的一条规则。FileMatch 说明失效的原因。\]](http://docs.aws.amazon.com/zh_cn/glue/latest/dg/images/data-quality-file-match-transform.png)
1. 此规则在 AWS Glue 交互式会话中不起作用。
# FileUniqueness
文件唯一性可以确保从数据创建器收到的数据中没有重复文件。
其收集以下数据统计信息：
1. 规则扫描的文件数
1. 文件的唯一性比率
```
Dataset.*.FileUniquenessRatio: 1.00, Dataset.*.FileCount: 8.00
```
**查找文件夹中的重复文件：**
```
FileUniqueness "s3://bucket/" > 0.5
FileUniqueness "s3://bucket/folder/" = 1
```
**直接从数据帧推断文件夹名称以检测重复项：**
您不必总是提供文件路径。例如，当您在 AWS Glue Data Catalog 中编写规则时，可能很难找到目录表使用的文件夹。AWSGlue 数据质量自动监测功能可以找到用于填充数据帧的特定文件夹或文件。
**注意**
使用推理时，基于文件的规则只能检测成功读取到 DynamicFrame 或 DataFrame 的文件。
```
FileUniqueness > 0.5
```
**可选的基于文件的规则标签：**
通过标签，您可以控制规则行为。
**recentFiles**
此标签通过将最新文件放在最前面，来限制处理的文件数。
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with recentFiles = 1
```
**uriRegex**
**注意**
`uriRegex` 标签在 AWS Glue 5.0 及更高版本中可用。
此标签通过对文件路径应用正则表达式模式来筛选文件。只有路径与该模式匹配的文件才会被处理。您也可以使用负向先行断言来排除与某个模式匹配的文件。
```
# 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**
**注意**
`filterOrder` 标签在 AWS Glue 5.0 及更高版本中可用。
当您同时使用多个筛选标签（例如 `recentFiles` 和 `uriRegex`）时，`filterOrder` 标签用来控制这些标签的应用顺序。默认顺序为首先应用 `recentFiles`，然后应用 `uriRegex`。
```
FileUniqueness "s3://bucket/" > 0.5 with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
此标签可确保文件没有重复的名称。默认行为是 false。
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with matchFileName = "true"
```
有几个注意事项：
1. 在 AWS Glue ETL 中，您必须在 Amazon S3 或 AWS Glue Data Catalog 转换之后立即进行 **EvaluateDataQuality** 转换。
1. 此规则在 AWS Glue 交互式会话中不起作用。
# FileSize
FileSize 规则类型允许您确保文件符合特定的文件大小标准。这在以下用例中非常有用：
1. 确保创建器不会发送空文件或小得多的文件进行处理。
1. 确保您的目标存储桶中没有可能导致性能的问题较小文件。
FileSize 会收集以下指标：
1. 合规性：返回符合您设定的规则阈值的文件百分比
1. 文件计数：规则扫描的文件数
1. 最小文件大小（字节）
1. 最大文件大小（字节）
```
Dataset.*.FileSize.Compliance: 1.00,
Dataset.*.FileCount: 8.00,
Dataset.*.MaximumFileSize: 327413121.00,
Dataset.*.MinimumFileSize: 204558920.00
```
这些指标不支持异常检测。
**验证文件大小**
如果 file.dat 大于 2 MB，则此规则将通过。
```
FileSize "s3://amzn-s3-demo-bucket/file.dat" > 2 MB
```
支持的单位包括 B（字节）、MB（兆字节）、GB（千兆字节）和 TB（太字节）。
**验证文件夹中文件的大小**
```
FileSize "s3://bucket/" > 5 B
FileSize "s3://bucket/" < 2 GB
```
如果 s3://amzn-s3-demo-bucket 中有 70% 的文件大小在 2 GB 到 1 TB 之间，则此规则将通过。
```
FileSize "s3://amzn-s3-demo-bucket/" between 2 GB and 1 TB with threshold > 0.7
```
**直接从数据帧推断文件名**
您不必总是提供文件路径。例如，当您在 Data Catalog 中编写规则时，可能很难找到目录表使用的文件夹。AWSGlue 数据质量自动监测功能可以找到用于填充数据帧的特定文件夹或文件。
**注意**
仅当文件成功读取到 DynamicFrame 或 DataFrame 时，此功能才起作用。
```
FileSize < 10 MB with threshold > 0.7
```
**可选的基于文件的规则标签：**
通过标签，您可以控制规则行为。
**recentFiles**
此标签通过将最新文件放在最前面，来限制处理的文件数。
```
FileSize "s3://amzn-s3-demo-bucket/" > 5 B with recentFiles = 1
```
**uriRegex**
**注意**
`uriRegex` 标签在 AWS Glue 5.0 及更高版本中可用。
此标签通过对文件路径应用正则表达式模式来筛选文件。只有路径与该模式匹配的文件才会被处理。您也可以使用负向先行断言来排除与某个模式匹配的文件。
```
# 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**
**注意**
`filterOrder` 标签在 AWS Glue 5.0 及更高版本中可用。
当您同时使用多个筛选标签（例如 `recentFiles` 和 `uriRegex`）时，`filterOrder` 标签用来控制这些标签的应用顺序。默认顺序为首先应用 `recentFiles`，然后应用 `uriRegex`。
```
FileSize "s3://bucket/" > 5 B with recentFiles = 5 with uriRegex = "\.dat$" with filterOrder = ["uriRegex","recentFiles"]
```
**failFast**
如果设置为 `"true"`，则该规则会在遇到第一个不符合大小条件的文件时立即返回失败，而不会评估所有文件并计算合规率。
```
FileSize "s3://bucket/" > 2 MB with failFast = "true"
```
有几个注意事项：
1. 在 AWS Glue ETL 中，您必须在 Amazon S3 或 Data Catalog 转换之后立即进行 Evaluate DataQuality 转换。
1. 此规则在 AWS Glue 交互式会话中不起作用。