数据质量定义语言（DQDL）引用

数据质量定义语言 (DQDL) 是一种特定领域的语言，用于定义 Glue 数据 AWS 质量规则。

本指南介绍了关键的 DQDL 概念，以帮助您理解该语言。它还通过语法和示例为 DQDL 规则类型提供了参考。在使用本指南之前，我们建议您熟悉 AWS Glue 数据质量。有关更多信息，请参阅 AWS Glue Data Quality。

注意

DynamicRules 仅在 AWS Glue ETL 中支持。

目录

• DL 语法
  • 规则结构
  • 复合规则
    • 复合规则的工作原理
  • Expressions
    • NULL、EMPTY 和 WHITESPACE_ONLY 的关键字
    • 使用 Where 子句筛选
  • 动态规则
  • 分析器
  • 注释
• DL 规则类型引用
  • AggregateMatch
  • ColumnCorrelation
  • ColumnCount
  • ColumnDataType
  • ColumnExists
  • ColumnLength
  • ColumnNamesMatchPattern
  • ColumnValues
  • 完整性
  • CustomSQL
  • DataFreshness
  • DatasetMatch
  • DistinctValuesCount
  • 熵
  • IsComplete
  • IsPrimaryKey
  • IsUnique
  • 平均值
  • ReferentialIntegrity
  • RowCount
  • RowCountMatch
  • StandardDeviation
  • 总和
  • SchemaMatch
  • 独特性
  • UniqueValueRatio
  • DetectAnomalies

DL 语法

DQDL 文档区分大小写，并包含一个规则集，该规则集将各个数据质量规则组合在一起。要构造规则集，必须创建一个名为 Rules（大写）的列表，由一对方括号分隔。该列表应包含一个或多个以逗号分隔的 DQDL 规则，如下例所示。

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

规则结构

DQDL 规则的结构取决于规则类型。但是，DQDL 规则通常符合以下格式。

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

RuleType 是要配置的规则类型的区分大小写名称。例如，IsComplete、IsUnique 或 CustomSql。每种规则类型的规则参数都不同。有关 DQDL 规则类型及其参数的完整参考，请参阅DL 规则类型引用。

复合规则

DQDL 支持以下逻辑运算符，您可以使用这些运算符来组合规则。这些规则被称为复合规则。

以及

当且仅当逻辑 and 运算符连接的规则为 true，逻辑运算符才会产生结果 true。否则，组合规则将导致 false。与 and 运算符连接的每条规则都必须用圆括号括起来。

以下示例使用 and 运算符将两个 DL 规则组合。

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

或者

当且仅当逻辑 or 运算符连接的一个或多个规则为 true，逻辑运算符才会产生结果 true。与 or 运算符连接的每条规则都必须用圆括号括起来。

以下示例使用 or 运算符将两个 DL 规则组合。

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

您可以使用同一个运算符连接多个规则，因此允许使用以下规则组合。

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

但是，您不能将逻辑运算符组合成一个表达式。例如，不允许以下组合。

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

复合规则的工作原理

默认情况下，复合规则将作为整个数据集或表中的单个规则进行评估，然后合并结果。换句话说，它会首先评估整列，然后应用运算符。下面举例说明这种默认行为：

# Dataset

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

# Overall outcome

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

在上面的示例中，AWS Glue Data Quality 会首先评估会导致失效的 (ColumnValues "myCol1" > 1)。然后它将评估同时也会出现失效的 (ColumnValues "myCol2" > 2)。两个结果的组合将被标记为 FAILED。

但是，如果您更喜欢与 SQL 类似的行为，即需要评估整行，则必须显式设置 ruleEvaluation.scope 参数，如下面代码片段中的 additionalOptions 所示。

object GlueApp {
  val datasource = glueContext.getCatalogSource(
    database="<db>",
    tableName="<table>",
    transformationContext="datasource"
  ).getDynamicFrame()

  val ruleset = """
    Rules = [
        (ColumnValues "age" >= 26) OR (ColumnLength "name" >= 4)        
    ]
  """

  val dq_results = EvaluateDataQuality.processRows(
    frame=datasource,
    ruleset=ruleset,
    additionalOptions=JsonOptions("""
        {
          "compositeRuleEvaluation.method":"ROW"
        }
      """
    )
  )
}     
      

在 AWS Glue Studio 和 AWS Glue 数据目录中，您可以在用户界面中轻松设置此选项，如下所示。

设置完成后，复合规则将作为评估整行的单个规则运行。以下示例说明了此行为。

# 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"
!=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+c/i	如果规则类型响应与正则表达式匹配，则解析为 true。	ColumnValues "colA" matches "[a-zA-Z]*"
not matches /ab+c/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_ONLY 的关键字

如果要验证字符串列是否为零、空或属于仅包含空格的字符串，则可以使用以下关键字：

• 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_ONLY /whitespaces_only – 对于字符串列中只有空格（“ ”）值的字符串，此关键字解析为 true。

  如果一行既不是“a”或“b”，也不只是空格，ColumnValues "colA" not in ["a", "b", WHITESPACES_ONLY] 将返回 true。

  支持的规则：

  • 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

使用 Where 子句筛选

您可以在制定规则时筛选数据。当你想应用条件规则时，这很有用。

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

必须使用where关键字指定过滤器，然后使用引号括起有效的 sparkSQL 语句。("")

如果要将规则添加 where 子句添加到具有阈值的规则中，则应在阈值条件之前指定 where 子句。

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

使用此语法，您可以编写如下规则。

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使用以下格式抛出 a：

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

开启行级错误记录识别时的 Where 子句行为

借 AWS 助 Glue 数据质量，您可以识别失败的特定记录。将 where 子句应用于支持行级结果的规则时，我们会将由 where 子句过滤掉的行标记为Passed。

如果您希望将筛选出的行分别标记为SKIPPED，则可以为 ETL 作业设置以下内容additionalOptions。

object GlueApp {
  val datasource = glueContext.getCatalogSource(
    database="<db>",
    tableName="<table>",
    transformationContext="datasource"
  ).getDynamicFrame()

  val ruleset = """
    Rules = [
       IsComplete "att2" where "att1 = 'a'"        
    ]
  """

  val dq_results = EvaluateDataQuality.processRows(
    frame=datasource,
    ruleset=ruleset,
    additionalOptions=JsonOptions("""
        {
          "rowLevelConfiguration.filteredRowLabel":"SKIPPED"
        }
      """
    )
  )
}

例如，请参阅以下规则和 dataFrame：

IsComplete att2 where "att1 = 'a'"

id	att1	att2	行级结果（默认）	行级结果（跳过的选项）	注释
1	a	f	通过了	通过了
2	b	d	通过了	SKIPPED	行已被过滤掉，因为不att1是 "a"
3	a	null	FAILED	FAILED
4	a	f	通过了	通过了
5	b	null	通过了	SKIPPED	行已被过滤掉，因为不att1是 "a"
6	a	f	通过了	通过了

动态规则

现在，您可以编写动态规则，将规则生成的当前指标与其历史值进行比较。这些历史比较通过在表达式中使用 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

大多数具有数字条件或阈值的规则类型都支持动态规则；请参阅提供的分析器和规则表，以确定您的规则类型是否支持动态规则。

分析器

注意

AWS Glue 数据目录不支持分析器。

DQDL 规则使用名为分析器的功能收集有关您的数据的信息。规则的布尔表达式使用此信息确定规则应该成功还是失败。例如，该 RowCount 规则RowCount > 5 将使用行计数分析器来发现数据集中的行数，并将该计数与表达式进行比较，> 5以检查当前数据集中是否存在超过五行。

有时，我们建议创建分析器（而不是编写规则），然后让其生成可用于检测异常的统计信息。对于此类实例，您可以创建分析器。分析器在以下方面与规则不同。

特征	分析器	规则
规则集的一部分	是	是
生成统计信息	是	是
生成观测值	是	是
可以评估和断言条件	否	是
您可以配置操作，例如在失败时停止作业、继续处理作业	否	是

分析器无需规则即可独立存在，因此您可以快速配置分析器并逐步构建数据质量规则。

可以在规则集的 Analyzers 块中输入某些规则类型，以运行分析器所需的规则并收集信息，而无需对任何条件进行检查。有些分析器与规则无关，只能在 Analyzers 块中输入。下表显示每个项目是作为规则还是作为独立分析器支持，以及每种规则类型的其他详细信息。

带分析器的示例规则集

以下规则集使用：

• 一条动态规则，用于检查数据集在过去三次作业运行中，是否增长超过其尾随平均值

• DistinctValuesCount 分析器，用于记录数据集 Name 列中不同值的数量

• ColumnLength 分析器，用于跟踪一段时间内最小和最大 Name 大小

可以在作业运行的“数据质量”选项卡中，查看分析器指标结果。

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

注释

您可以使用“#”字符在 DQDL 文档中添加注释。DQDL 会忽略在“#”字符之后以及直到行尾的任何内容。

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

DL 规则类型引用

本节提供了 Glue 数据质量支持的每 AWS 种规则类型的参考。

注意

• DQDL 目前不支持嵌套或列表类型的列数据。

• 下表中带括号的值将替换为规则参数中提供的信息。

• 规则通常需要一个额外的表达式参数。

RuleType	描述	参数	报告的指标	是否支持作为规则？	是否支持作为分析器？	返回行级结果？	动态规则支持？	生成观测值	支持 Where 子句语法？
AggregateMatch	通过比较总销售额等摘要指标，检查两个数据集是否匹配。如果所有数据都是从源系统提取的，金融机构可以进行比较。	一个或多个聚合	当第一个和第二个聚合列名匹配时： Column.[Column].AggregateMatch 当第一个和第二个聚合列名不同时： Column.[Column1,Column2].AggregateMatch	是	否	否	否	否	否
AllStatistics	独立分析器，为提供的列或数据集中的所有列收集多个指标。	单个列名，或 “AllColumns”	对于所有类型的列： Dataset.*.RowCount Column.[Column].Completeness Column.[Column].Uniqueness 字符串值列的其他指标： ColumnLength metrics 数字值列的其他指标： ColumnValues metrics	否	是	否	否	否	否
ColumnCorrelation	检查两列的关联程度。	正好两个列名	Multicolumn.[Column1],[Column2].ColumnCorrelation	是	是	否	是	否	是
ColumnCount	检查是否删除了任何列。	无	Dataset.*.ColumnCount	是	否	否	是	是	不支持
ColumnDataType	检查列是否符合数据类型。	只有一个列名	Column.[Column].ColumnDataType.Compliance	是	否	否	是，在行级阈值表达式中	否	是
ColumnExists	检查数据集中是否存在列。这允许客户构建自助服务数据平台以确保某些列可用。	只有一个列名	不适用	是	否	否	否	否	否
ColumnLength	检查数据长度是否一致。	只有一个列名	Column.[Column].MaximumLength Column.[Column].MinimumLength 提供行级阈值时的其他指标： Column.[Column].ColumnValues.Compliance	是	是	是，如已提供行级阈值	否	是。仅通过分析最小长度和最大长度来生成观测值	是
ColumnNamesMatchPattern	检查列名是否与定义的模式匹配。对于治理团队来说，强制列名一致性很有用。	列名的正则表达式	Dataset.*.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.*.RowCount	是	是	否	是	是	是
RowCountMatch	检查两个数据集之间的记录计数是否匹配。	引用数据集别名	Dataset.[ReferenceDatasetAlias].RowCountMatch	是	否	否	是	否	否
StandardDeviation	检查标准偏差是否与阈值匹配。	只有一个列名	Column.[Column].StandardDeviation	是	是	是	是	否	是
SchemaMatch	检查两个数据集之间的架构是否匹配。	引用数据集别名	Dataset.[ReferenceDatasetAlias].SchemaMatch	是	否	否	是	否	否
总和	检查总和是否与设定的阈值相符。	只有一个列名	Column.[Column].Sum	是	是	否	是	否	是
独特性	检查数据集的唯一性是否与阈值匹配。	只有一个列名	Column.[Column].Uniqueness	是	是	是	是	否	是
UniqueValueRatio	检查唯一值比率是否与阈值匹配。	只有一个列名	Column.[Column].UniqueValueRatio	是	是	是	是	否	是

主题

• AggregateMatch
• ColumnCorrelation
• ColumnCount
• ColumnDataType
• ColumnExists
• ColumnLength
• ColumnNamesMatchPattern
• ColumnValues
• 完整性
• CustomSQL
• DataFreshness
• DatasetMatch
• DistinctValuesCount
• 熵
• IsComplete
• IsPrimaryKey
• IsUnique
• 平均值
• ReferentialIntegrity
• RowCount
• RowCountMatch
• StandardDeviation
• 总和
• SchemaMatch
• 独特性
• UniqueValueRatio
• DetectAnomalies

AggregateMatch

根据给定表达式检查两列聚合的比率。此规则类型适用于多个数据集。对两列聚合进行评估，并通过将第一列聚合的结果除以第二列聚合的结果得出比率。根据提供的表达式检查比率以生成布尔响应。

语法

列聚合

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

• AGG_OPERATION – 用于聚合的操作。目前支持 sum 和 avg。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• OPTIONAL_REFERENCE_ALIAS – 如果列来自引用数据集而不是主数据集，则需要提供此参数。如果您在 AWS Glue 数据目录中使用此规则，则您的参考别名必须遵循 “” 格式<database_name>。 <table_name>。 <column_name>

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• COL_NAME – 要聚合列的名称。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

示例：平均值

"avg(rating)"

示例：总和

"sum(amount)"

示例：引用数据集中各列的平均值

"avg(reference.rating)"

规则

AggregateMatch <AGG_EXP_1> <AGG_EXP_2> <EXPRESSION>

• AGG_EXP_1 – 第一列聚合。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• AGG_EXP_2 – 第二列聚合。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 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 数据目录中，你可以使用：

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 + 20 + 40)/3 = 20。在此计算中不会考虑第 101 行和第 103 行。

ColumnCorrelation

根据给定表达式检查两列之间的相关性。 AWS Glue Data Quality 使用 Pearson 相关系数来测量两列之间的线性相关性。结果是一个介于 -1 和 1 之间的数字，用于衡量关系的强度和方向。

语法

ColumnCorrelation <COL_1_NAME> <COL_2_NAME> <EXPRESSION>

• COL_1_NAME — 要根据其评估数据质量规则的第一列的名称。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• COL_2_NAME — 要根据其评估数据质量规则的第二列的名称。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 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>

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 Expressions。

示例：列数数字校验

以下示例规则检查列数是否在给定范围内。

ColumnCount between 10 and 20

示例动态规则

• ColumnCount >= avg(last(10))

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

ColumnDataType

根据提供的预期类型检查给定列中值的固有数据类型。接受 with threshold 表达式以检查列中值的子集。

语法

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

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：字符串类型

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• EXPECTED_TYPE – 列中值的预期类型。

  支持的值：布尔值、日期、时间戳、整数、双精度、浮点数、长整型

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• EXPRESSION – 一个可选表达式，用于指定应为预期类型的值的百分比。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

示例：将整数作为字符串的列数据类型

以下示例规则检查给定列中字符串类型的值是否实际为整数。

ColumnDataType "colA" = "INTEGER"

示例：列数据类型整数作为字符串检查值的子集

以下示例规则检查给定列中字符串类型超过 90% 的值是否实际为整数。

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

ColumnExists

检查列是否存在。

语法

ColumnExists <COL_NAME>

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：任何列类型

示例：列存在

以下示例规则检查名为 Middle_Name 的列是否存在。

ColumnExists "Middle_Name"

ColumnLength

检查列中每行的长度是否符合给定表达式。

语法

ColumnLength <COL_NAME><EXPRESSION>

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：字符串

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 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 != NULL)

ColumnNamesMatchPattern

检查主数据集中所有列的名称是否与给定的正则表达式相匹配。

语法

ColumnNamesMatchPattern <PATTERN>

• PATTERN - 您要评估数据质量规则依据的模式。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

示例：列名匹配模式

以下示例规则检查所有列是否以前缀“aws_”开头

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

ColumnValues

针对列中的值运行表达式。

语法

ColumnValues <COL_NAME> <EXPRESSION>

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：任何列类型

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 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_NAME> <EXPRESSION>

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：任何列类型

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 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_STATEMENT> <EXPRESSION>

• SQL_STATEMENT — 返回单个数值的 SQL 语句，由双引号包围。

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 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 可以识别未通过数据质量检查的记录。要使此功能起作用，您需要返回作为您正在评估数据质量的主表一部分的记录。作为查询一部分返回的记录被视为成功，未返回的记录被视为失败。

以下规则将确保将年龄小于 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_NAME> <EXPRESSION>

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：日期

• 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_DATASET_ALIAS> <JOIN CONDITION WITH MAPPING> <OPTIONAL_MATCH_COLUMN_MAPPINGS> <EXPRESSION>

• REFERENCE_DATASET_ALIAS – 用于比较主数据集数据的引用数据集的别名。

• KEY_COLUMN_MAPPINGS – 以逗号分隔的列名列表，这些列名构成了数据集中的键。如果两个数据集中的列名不相同，则必须使用 -> 分隔它们

• OPTIONAL_MATCH_COLUMN_MAPPINGS – 如果您只想检查某些列中的匹配数据，则可以提供此参数。它使用与键列映射相同的语法。如果未提供此参数，我们将匹配所有剩余列中的数据。其余的非键列在两个数据集中必须具有相同的名称。

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 Expressions。

示例：使用 ID 列匹配集合数据集

以下示例规则使用“ID”列来检查主数据集中是否有超过 90% 与引用数据集相匹配。在本例中，它会比较所有列。

DatasetMatch "reference" "ID" >= 0.9

示例：使用多个键列匹配集合数据集

在以下示例中，主数据集和引用数据集的键列名称不同。ID_1 和 ID_2 共同构成主数据集中的复合键。ID_ref1 和 ID_ref2 共同构成引用数据集中的复合键。在这种情况下，您可以使用特殊语法来提供列名。

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

示例：使用多个键列匹配集合数据集并检查特定列是否匹配

此示例建立在前一个示例的基础上。我们要检查是否只有包含金额的列匹配。此列在主数据集中名为 Amount1，在引用数据集中名为 Amount2。您希望完全匹配。

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

DistinctValuesCount

根据给定的表达式检查列中的不同值的数量。

语法

DistinctValuesCount <COL_NAME> <EXPRESSION>

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：任何列类型

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 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_NAME> <EXPRESSION>

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：任何列类型

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 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_NAME>

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：任何列类型

示例：空值

以下示例检查名为 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_NAME>

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：任何列类型

示例：主键：

以下示例规则检查名为 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_NAME>

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：任何列类型

示例：唯一列值

以下示例规则检查名为 email 的列中的所有值是否均为非空值。

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

平均值

检查列中所有值的均值（平均值）是否与给定表达式匹配。

语法

Mean <COL_NAME> <EXPRESSION>

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 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 + 20 + 40)/3 = 20。在此计算中不会考虑第 101 行和第 103 行。

ReferentialIntegrity

检查主数据集中一组列的值在多大程度上是引用数据集中一组列值的子集。

语法

ReferentialIntegrity <PRIMARY_COLS> <REFERENCE_DATASET_COLS> <EXPRESSION>

• PRIMARY_COLS – 主数据集中列名的逗号分隔列表。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• REFERENCE_DATASET_COLS – 此参数包含用句点分隔的两个部分。第一部分是引用数据集的别名。第二部分是用大括号括起的引用数据集中以逗号分隔的列名列表。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 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>

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 Expressions。

示例：行数数字校验

以下示例规则检查行数是否在给定范围内。

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

示例动态规则

RowCount > avg(lats(10)) *0.8

RowCountMatch

检查主数据集的行数和引用数据集的行数与给定表达式的比率。

语法

RowCountMatch <REFERENCE_DATASET_ALIAS> <EXPRESSION>

• REFERENCE_DATASET_ALIAS – 用于比较行数的引用数据集的别名。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 Expressions。

示例：根据引用数据集检查行数

以下示例规则检查主数据集的行数是否至少为引用数据集行数的 90%。

RowCountMatch "reference" >= 0.9

StandardDeviation

根据给定表达式检查列中所有值的标准差。

语法

StandardDeviation <COL_NAME> <EXPRESSION>

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 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_NAME> <EXPRESSION>

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 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 + 20 + 40) = 60。

SchemaMatch

检查主数据集中的架构是否与引用数据集中的架构匹配。架构检查逐列完成。如果名称相同且类型相同，则两列的架构相匹配。列的顺序不重要。

语法

SchemaMatch <REFERENCE_DATASET_ALIAS> <EXPRESSION>

• REFERENCE_DATASET_ALIAS – 用于比较架构的引用数据集的别名。

  支持的列类型：字节、十进制、双精度、浮点数、整数、长整数、短整数

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 Expressions。

示例： SchemaMatch

以下示例规则检查主数据集的架构是否与引用数据集中的架构完全匹配。

SchemaMatch "reference" = 1.0

独特性

根据给定表达式检查列中唯一值的百分比。唯一值只出现一次。

语法

Uniqueness <COL_NAME> <EXPRESSION>

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：任何列类型

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 Expressions。

示例：唯一性百分比

以下示例规则检查列中唯一值的百分比是否与某些数字标准相匹配。

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

示例动态规则

• 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_NAME> <EXPRESSION>
      

• COL_NAME — 要根据其评估数据质量规则的列的名称。

  支持的列类型：任何列类型

• EXPRESSION — 针对规则类型响应运行以生成布尔值的表达式。有关更多信息，请参阅 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> <RULE_PARAMETERS>
     

RULE_NAME – 要根据其评估和检测异常的规则的名称。支持的规则：

• "RowCount"

• "Completeness"

• "Uniqueness"

• "Mean"

• "Sum"

• "StandardDeviation"

• "Entropy"

• "DistinctValuesCount"

• "UniqueValueRatio"

• "ColumnLength"

• "ColumnValues"

• "ColumnCorrelation"

RULE_PARAMETERS– 有些规则需要其他参数才能运行。请参阅给定的规则文档以了解所需的参数。

示例：的异常 RowCount

例如，如果我们要检测 RowCount 异常，我们会提供 RowCount 规则名称。

DetectAnomalies "RowCount"

示例：的异常 ColumnLength

例如，如果我们要检测 ColumnLength 异常，我们会提供 ColumnLength 规则名称和列名。

DetectAnomalies "ColumnLength" "id"