",
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/ko_kr/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
+ Uniqueness
임계값에 따른 규칙:
다음 규칙에 with threshold가 포함된 경우 해당 규칙은 지원되지 않습니다. 그러나 `with threshold`를 포함하지 않는 규칙은 계속 지원됩니다.
+ ColumnDataType
+ ColumnValues
+ CustomSQL
### Expressions
규칙 유형이 부울 응답을 생성하지 않는 경우 부울 응답을 생성하려면 표현식을 파라미터로 제공해야 합니다. 예를 들어 다음 규칙은 열에 있는 모든 값의 중앙값(평균)을 표현식과 비교하여 true 또는 false 결과를 반환합니다.
```
Mean "colA" between 80 and 100
```
`IsUnique` 및 `IsComplete`와 같은 일부 규칙 유형은 이미 부울 응답을 반환합니다.
다음 표는 DQDL 규칙에서 사용할 수 있는 표현식을 나열합니다.
**지원되는 DQDL 표현식**
| 표현식 | 설명 | 예제 |
| --- | --- | --- |
| =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
|
| between x and y | 규칙 유형 응답이 지정된 범위(제외)에 속하는 경우 true로 확인됩니다. 이 표현식 유형은 숫자 및 날짜 유형에만 사용해야 합니다. | Mean "colA" between 8 and 100,
ColumnValues "colA" between "2022-05-31" and "2022-06-30"
|
| x 및 y 사이가 아님 | 규칙 유형 응답이 지정된 범위(포함)에 속하지 않으면 true로 확인됩니다. 이 표현식 유형은 숫자 및 날짜 유형에만 사용해야 합니다. | ColumnValues "colA" not between "2022-05-31" and "2022-06-30"
|
| in [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" ]
|
| matches /ab\$1c/i | 규칙 유형 응답이 정규 표현식과 일치하는 경우 true로 확인됩니다. | ColumnValues "colA" matches "[a-zA-Z]*"
|
| /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, WHITESPACES\$1ONLY에 대한 키워드
문자열 열에 null, 비어 있음 또는 공백만 있는 문자열이 있는지 확인하려면 다음 키워드를 사용할 수 있습니다.
+ NULL/null - 이 키워드는 문자열 열의 `null` 값에 대해 true로 확인됩니다.
`ColumnValues "colA" != NULL with threshold > 0.5`는 데이터의 50% 이상에 null 값이 없는 경우 true를 반환합니다.
`(ColumnValues "colA" = NULL) or (ColumnLength "colA" > 5)`는 null 값이 있거나 길이가 5를 초과하는 모든 행에 대해 true를 반환합니다. **이 경우 "compositeRuleEvaluation.method" = "ROW" 옵션을 사용해야 한다는 점에 유의하세요.
+ EMPTY/empty - 이 키워드는 문자열 열의 빈 문자열("") 값에 대해 true로 확인됩니다. 일부 데이터 형식은 문자열 열의 null을 빈 문자열로 변환합니다. 이 키워드는 데이터에서 빈 문자열을 필터링하는 데 도움이 됩니다.
`(ColumnValues "colA" = EMPTY) or (ColumnValues "colA" in ["a", "b"])`는 행이 비어 있거나 "a" 또는 "b"인 경우 true를 반환합니다. **이 경우 "compositeRuleEvaluation.method" = "ROW" 옵션을 사용해야 한다는 점에 유의하세요.
+ WHITESPACES\$1ONLY/whitespaces\$1only - 이 키워드는 문자열 열에 공백(" ") 값만 있는 문자열에 대해 true로 확인됩니다.
`ColumnValues "colA" not in ["a", "b", WHITESPACES_ONLY]`는 ‘a’, ‘b’ 또는 공백만 있는 행이 아닌 경우 true를 반환합니다.
지원되는 규칙:
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
숫자 또는 날짜 기반 표현식에서 열에 null이 있는지 확인하려는 경우 다음 키워드를 사용할 수 있습니다.
+ NULL/null - 이 키워드는 문자열 열의 null 값에 대해 true로 확인됩니다.
`ColumnValues "colA" in [NULL, "2023-01-01"]`은 열의 날짜가 `2023-01-01`이거나 null인 경우 true를 반환합니다.
`(ColumnValues "colA" = NULL) or (ColumnValues "colA" between 1 and 9)`는 null 값이 있거나 1에서 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` 키워드와 따옴표(`("")`)로 묶인 유효한 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 Data Quality를 사용하면 실패한 특정 레코드를 식별할 수 있습니다. 행 수준 결과를 지원하는 규칙에 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 | 행 수준 결과(기본값) | 행 수준 결과(Skipped 옵션) | 설명 |
| --- | --- | --- | --- | --- | --- |
| 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 | 통과 | 통과 | |
### 상수
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 기반 Data Quality에서는 사용할 수 없습니다.
#### 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 레이블을 활성화하기 위해 필요한 추가 구성은 없습니다.
##### 행 수준 결과
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 레이블은 `RuleResults` 객체의 새 필드 `Labels` 아래에 있는 API 응답에 항상 표시됩니다.
다음 예제는 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()`는 고려할 기록 지표의 개수를 나타내는 선택적 자연수 인수를 취하고, `last(k)`는 마지막 `k` 지표를 참조하는 `k >= 1`을 취합니다.
+ 사용 가능한 데이터 포인트가 없는 경우 `last(k)`는 기본값 0.0을 반환합니다.
+ 사용할 수 있는 지표가 `k`개 미만인 경우 `last(k)`는 이전 지표를 모두 반환합니다.
유효한 표현식을 만들려면 `last(k)`를 사용합니다. 여기서 `k > 1`에는 여러 개의 기록 결과를 하나의 숫자로 줄이는 집계 함수가 필요합니다. 예를 들어 `RowCount > avg(last(5))`는 현재 데이터 세트의 행 수가 동일한 데이터 세트의 최근 5개 행 수의 평균보다 확실하게 큰지 확인합니다. `RowCount > last(5)`는 현재 데이터 세트 행 수를 목록과 유의미하게 비교할 수 없기 때문에 오류를 생성합니다.
지원되는 집계 함수:
+ `avg`
+ `median`
+ `max`
+ `min`
+ `sum`
+ `std`(표준 편차)
+ `abs`(절대값)
+ `index(last(k), i)`를 사용하면 최근 `k`개 중 가장 최근인 `i`번째 값을 선택할 수 있습니다. `i`는 0으로 인덱싱되므로 `index(last(3), 0)`은 가장 최근의 데이터 포인트를 반환하고, `index(last(3), 3)`은 데이터 포인트가 3개뿐이지만 4번째 가장 최근의 데이터 포인트를 인덱싱하려고 시도하기 때문에 오류가 발생합니다.
**샘플 표현식**
**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/ko_kr/glue/latest/dg/images/data-quality-excluding-statistics-from-dynamic-rules.png)
### 분석기
**참고**
분석기는 AWS Glue 데이터 카탈로그에서 지원되지 않습니다.
DQDL 규칙은 분석기**라는 함수를 사용하여 데이터에 대한 정보를 수집합니다. 이 정보는 규칙의 부울 표현식에 의해 사용되어 규칙의 성공 또는 실패 여부를 결정합니다. 예를 들어 RowCount 규칙 `RowCount > 5 `는 행 수 분석기를 사용하여 데이터 세트의 행 수를 검색하고, 그 수를 표현식 `> 5`와 비교하여 현재 데이터 세트에 5개 이상의 행이 존재하는지 확인합니다.
때로는 규칙을 작성하는 대신 분석기를 생성한 다음 이상을 탐지하는 데 사용할 수 있는 통계를 생성하는 것을 권장합니다. 이러한 경우에는 분석기를 생성할 수 있습니다. 분석기는 다음과 같은 점에서 규칙과 다릅니다.
| 기능 | 분석기 | 규칙 |
| --- | --- | --- |
| 규칙 세트의 일부 | 예 | 예 |
| 통계 생성 | 예 | 예 |
| 관찰 결과 생성 | 예 | 예 |
| 조건 평가 및 어설션 가능 | 아니요 | 예 |
| 실패 시 작업 중지, 작업 계속 처리 등의 작업을 구성할 수 있음 | 아니요 | 예 |
분석기는 규칙 없이 독립적으로 존재할 수 있으므로 신속하게 구성하고 데이터 품질 규칙을 점진적으로 구축할 수 있습니다.
일부 규칙 유형은 규칙 세트의 `Analyzers` 블록에 입력하여 분석기에 필요한 규칙을 실행하고 조건에 대한 검사를 적용하지 않고 정보를 수집할 수 있습니다. 일부 분석기는 규칙과 연결되지 않으며 `Analyzers` 블록에만 입력할 수 있습니다. 다음 테이블에는 각 항목이 규칙 또는 독립 실행형 분석기로 지원되는지 여부와 각 규칙 유형에 대한 추가 세부 정보가 나와 있습니다.
**분석기를 사용한 규칙 세트 예제**
다음 규칙 세트는 다음을 사용합니다.
+ 데이터 세트가 지난 세 번의 작업 실행에 대한 후행 평균보다 증가하고 있는지 확인하는 동적 규칙
+ 데이터 세트의 `Name` 열에 고유한 값의 수를 기록하는 `DistinctValuesCount` 분석기
+ 시간 경과에 따른 최소 및 최대 `Name` 크기를 추적하는 `ColumnLength` 분석기
분석기 메트릭 결과는 작업 실행의 Data Quality 탭에서 확인할 수 있습니다.
```
Rules = [
RowCount > avg(last(3))
]
Analyzers = [
DistinctValuesCount "Name",
ColumnLength "Name"
]
```
AWS Glue Data Quality는 다음 분석기를 지원합니다.
| 분석기 이름 | 기능 |
| --- | --- |
| 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/ko_kr/glue/latest/dg/dqdl.html) |
### 설명
‘\$1’ 문자를 사용하여 DQDL 문서에 설명을 추가할 수 있습니다. ‘\$1’ 문자 이후부터 줄 끝까지의 모든 내용은 DQDL에서 무시됩니다.
```
Rules = [
# More items should generally mean a higher price, so correlation should be positive
ColumnCorrelation "price" "num_items" > 0
]
```
# DQDL 규칙 유형 참조
이 섹션에서는 AWS Glue 데이터 품질에서 지원하는 각 규칙 유형에 대한 참조를 제공합니다.
**참고**
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 | 데이터 세트에 열이 있는지 확인합니다. 이를 통해 고객은 특정 열을 사용할 수 있도록 셀프 서비스 데이터 플랫폼을 구축할 수 있습니다. | 정확히 하나의 열 이름 | N/A | 예 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| 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 | 다른 규칙 유형의 보고된 지표에서 이상이 있는지 확인합니다. | 규칙 유형 | 규칙 유형 인수로 보고된 지표 | 예 | 아니요 | 아니요 | 아니요 | 아니요 | 아니요 |
| Entropy | 데이터의 엔트로피를 확인합니다. | 정확히 하나의 열 이름 | 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 | 예 | 아니요 | 아니요 | 예 | 아니요 | 아니요 |
| Sum | 합계가 설정된 임곗값과 일치하는지 확인합니다. | 정확히 하나의 열 이름 | Column.[Column].Sum | 예 | 예 | 아니요 | 예 | 아니요 | 예 |
| Uniqueness | 데이터 세트의 고유성이 임곗값과 일치하는지 확인합니다. | 정확히 하나의 열 이름 | 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)
+ [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)
+ [완전성](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)
+ [Entropy](dqdl-rule-types-Entropy.md)
+ [IsComplete](dqdl-rule-types-IsComplete.md)
+ [IsPrimaryKey](dqdl-rule-types-IsPrimaryKey.md)
+ [IsUnique](dqdl-rule-types-IsUnique.md)
+ [Mean](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)
+ [Uniqueness](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`가 지원됩니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **OPTIONAL\$1REFERENCE\$1ALIAS** – 기본 데이터 세트가 아닌 참조 데이터 세트에서 열을 가져온 경우 이 파라미터를 제공해야 합니다. AWS Glue 데이터 카탈로그에서 이 규칙을 사용하는 경우 참조 별칭은 '..' 형식을 따라야 합니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **COL\$1NAME** - 집계할 열의 이름입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
**예: 평균**
```
"avg(rating)"
```
**예: 합계**
```
"sum(amount)"
```
**예: 참조 데이터 세트의 열 평균**
```
"avg(reference.rating)"
```
**규칙**
```
AggregateMatch
```
+ **AGG\$1EXP\$11** - 첫 번째 열 집계입니다.
지원되는 열 유형: Byte, Decimal, Double, Float, Integer, Long, Short
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **AGG\$1EXP\$12** - 두 번째 열 집계입니다.
지원되는 열 유형: Byte, Decimal, Double, Float, Integer, Long, Short
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 합계를 사용한 일치 항목 집계**
다음 예제 규칙은 `amount` 열에서 값의 합계가 `total_amount` 열에서 값의 합계와 정확히 같은지 여부를 확인합니다.
```
AggregateMatch "sum(amount)" "sum(total_amount)" = 1.0
```
**예: 평균을 사용한 일치 항목 집계**
다음 예제 규칙은 `ratings` 열에서 값의 평균이 `reference` 데이터 세트 내 `ratings` 열에서 값의 평균 중 90% 이상인지를 확인합니다. 참조 데이터 세트는 ETL 또는 데이터 카탈로그 환경에서 추가 데이터 소스로 제공됩니다.
AWS Glue ETL에서 다음을 사용할 수 있습니다.
```
AggregateMatch "avg(ratings)" "avg(reference.ratings)" >= 0.9
```
AWS Glue 데이터 카탈로그에서 다음을 사용할 수 있습니다.
```
AggregateMatch "avg(ratings)" "avg(database_name.tablename.ratings)" >= 0.9
```
**Null 동작**
`AggregateMatch` 규칙은 집계 방법(합계/평균)의 계산에서 NULL 값이 있는 행을 무시합니다. 예:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
`units`열의 평균은 (0 \$1 20 \$1 40)/3 = 20이 됩니다. 101행과 103행은 이 계산에서 고려되지 않습니다.
# ColumnCorrelation
주어진 표현식을 기준으로 두 열 간의 **상관 관계를 확인합니다. AWS Glue 데이터 품질에서는 피어슨 상관 계수를 사용하여 두 열 간의 선형 상관 관계를 측정합니다. 결과는 관계의 강도와 방향을 측정하는 -1과 1 사이의 숫자입니다.
**구문**
```
ColumnCorrelation
```
+ **COL\$11\$1NAME** - 데이터 품질 규칙을 평가할 첫 번째 열의 이름입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **COL\$12\$1NAME** - 데이터 품질 규칙을 평가할 첫 번째 열의 이름입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **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))`
**Null 동작**
`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** - 데이터 품질 규칙을 평가할 열의 이름입니다.
지원되는 열 유형: 문자열 유형
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPECTED\$1TYPE** - 열에 있는 값의 예상 유형입니다.
지원되는 값: Boolean, Date, Timestamp, Integer, Double, Float, Long
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPRESSION** - 예상 유형이어야 하는 값의 백분율을 지정하는 선택적 표현식입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
**예: 열 데이터 형식 정수 역할의 문자열**
다음 예제 규칙은 문자열 유형인 지정된 열의 값을 정수로 캐스팅할 수 있는지 여부를 확인합니다.
```
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"
```
**Null 동작**
`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** – 데이터 품질 규칙을 평가하는 데 사용할 패턴입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
**예: 열 이름 일치 패턴**
다음 예제 규칙은 모든 열이 접두사 'aws\$1'로 시작하는지 여부를 확인합니다.
```
ColumnNamesMatchPattern "aws_.*"
ColumnNamesMatchPattern "aws_.*" where "weightinkgs > 10"
```
# ColumnValues
열의 값에 대해 표현식을 실행합니다.
**구문**
```
ColumnValues
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 모든 열 유형
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 허용된 값**
다음 예제 규칙은 지정된 열의 각 값이 허용되는 값 세트(null, 비어 있음, 공백만 있는 문자열 포함)에 있는지 확인합니다.
```
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
```
**Null 동작**
모든 `ColumnValues` 규칙(`!=` 및 `NOT IN` 제외)의 경우 `NULL` 행이 규칙에 실패합니다. 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]
```
# 완전성
지정된 표현식을 기준으로 열에서 전체(null이 아닌) 값의 백분율을 검사합니다.
**구문**
```
Completeness
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 모든 열 유형
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: Null 값 백분율**
다음 예제 규칙은 열에 있는 값의 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))`
**Null 동작**
CSV 데이터 형식에 대한 참고 사항: CSV 열의 빈 행은 여러 동작을 표시할 수 있습니다.
+ 열의 유형이 `String`인 경우 빈 행은 빈 문자열로 인식되어 `Completeness` 규칙에 실패하지 않습니다.
+ 열이 `Int`와 같은 다른 데이터 유형인 경우 빈 행이 `NULL`로 인식되어 `Completeness` 규칙에 실패합니다.
# CustomSQL
이 규칙 유형은 다음과 같은 두 가지 사용 사례를 지원하도록 확장되었습니다.
+ 데이터 세트에 대해 사용자 지정 SQL 문을 실행하고 지정된 표현식을 기준으로 반환 값을 확인합니다.
+ 일부 조건과 비교하여 행 수준 결과를 얻는 SELECT 문에 열 이름을 지정하는 사용자 지정 SQL 문을 실행합니다.
**구문**
```
CustomSql
```
+ **SQL\$1STATEMENT** - 큰따옴표로 묶인 단일 숫자 값을 반환하는 SQL 문입니다.
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 전체 규칙 결과를 검색하기 위한 사용자 지정 SQL**
이 예제 규칙에서는 SQL 문을 사용하여 데이터 세트의 레코드 수를 검색합니다. 그런 다음 레코드 수가 10\$120 사이인지 확인합니다.
```
CustomSql "select count(*) from primary" between 10 and 20
```
**예: 행 수준 결과를 검색하기 위한 사용자 지정 SQL**
이 예제 규칙은 일부 조건과 비교하여 행 수준 결과를 얻는 SELECT 문에 열 이름을 지정하는 SQL 문을 사용합니다. 임곗값 조건 표현식에서는 전체 규칙이 실패하기 위해 실패해야 하는 레코드 수의 임곗값을 정의합니다. 규칙에는 조건과 키워드가 모두 포함되지 않을 수도 있습니다.
```
CustomSql "select Name from primary where Age > 18"
```
or
```
CustomSql "select Name from primary where Age > 18" with threshold > 3
```
**중요**
`primary` 별칭은 평가하려는 데이터 세트의 이름을 나타냅니다. 콘솔에서 시각적 ETL 작업을 수행할 때 `primary`에서는 항상 `EvaluateDataQuality.apply()` 변환에 전달 중인 `DynamicFrame`을 나타냅니다. AWS Glue 데이터 카탈로그를 사용하여 테이블에 대해 데이터 품질 작업을 실행하는 경우 `primary`는 테이블을 나타냅니다.
AWS Glue 데이터 카탈로그에 있는 경우 실제 테이블 이름을 사용할 수도 있습니다.
```
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 쿼리의 복잡성에 따라 성능에 영향을 미칠 수 있습니다.
방법:
+ 기본 테이블에서 열을 하나 이상 선택해야 합니다.
+ `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 쿼리에서는 테이블에서 '프라이머리 키'를 선택하거나 복합 키를 구성하는 열 세트를 선택합니다. 이렇게 하지 않으면 중복된 행이 일치되어 결과가 일관되지 않고 성능이 저하될 수 있습니다.
+ 기본 테이블에서만 키를 선택하고 참조 테이블에서는 선택하지 않습니다.
다음 규칙에서는 age가 100 미만인 레코드는 성공으로, 그 이상인 레코드는 실패로 표시됩니다.
```
CustomSql "select id from primary where age < 100"
```
레코드 중 50%에서 age가 10을 초과하는 경우 이 CustomSQL 규칙은 통과되며 실패한 레코드도 식별합니다. 이 CustomSQL에서 반환된 레코드는 통과로 간주되고 반환되지 않은 레코드는 실패로 간주됩니다.
```
CustomSQL "select ID, CustomerID from primary where age > 10" with threshold > 0.5
```
참고: 데이터 세트에서 사용할 수 없는 레코드를 반환하면 CustomSQL 규칙이 실패합니다.
# DataFreshness
현재 시간과 날짜 열 값 간의 차이를 평가하여 열에 있는 데이터의 최신성을 검사합니다. 이 규칙 유형에 시간 기반 표현식을 지정하여 열 값이 최신 상태인지 확인할 수 있습니다.
**구문**
```
DataFreshness
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 날짜
+ **표현식** - 시간 또는 일 단위의 숫자 표현식입니다. 표현식에 시간 단위를 지정해야 합니다.
**예: 데이터 최신성**
다음 예제 규칙은 데이터 최신성을 확인합니다.
```
DataFreshness "Order_Date" <= 24 hours
DataFreshness "Order_Date" between 2 days and 5 days
```
**Null 동작**
`DataFreshness` 규칙은 `NULL` 값이 있는 행에 대해 실패합니다. null 값으로 인해 규칙이 실패하면 실패 이유가 다음과 같이 표시됩니다.
```
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
기본 데이터 세트의 데이터가 참조 데이터 세트의 데이터와 일치하는지 확인합니다. 제공된 키 열 매핑을 사용하여 두 데이터 세트를 조인합니다. 해당 열에서만 데이터의 관계(equality)를 확인하려는 경우 추가 열 매핑을 제공할 수 있습니다. **DataSetMatch**를 사용하려면 조인 키가 고유해야 하고 NULL이 아니어야 합니다(프라이머리 키여야 함). 이러한 조건을 충족하지 않으면 'Provided key map not suitable for given data frames' 오류 메시지가 표시됩니다. 고유한 조인 키를 사용할 수 없는 경우에는 **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
열의 **엔트로피 값이 지정된 표현식과 일치하는지 확인합니다. 엔트로피는 메시지에 포함된 정보의 수준을 측정합니다. 열의 값에 대한 확률 분포를 고려할 때 엔트로피는 값을 식별하는 데 필요한 비트 수를 설명합니다.
**구문**
```
Entropy
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 모든 열 유형
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 열 엔트로피**
다음 예제 규칙은 `Feedback` 열의 엔트로피 값이 1보다 큰지 확인합니다.
```
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
열의 모든 값이 완전한지(null이 아님) 확인합니다.
**구문**
```
IsComplete
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: 모든 열 유형
**예: Null 값**
다음 예에서는 `email` 열의 모든 값이 null이 아닌지 확인합니다.
```
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"
```
**Null 동작**
CSV 데이터 형식에 대한 참고 사항: CSV 열의 빈 행은 여러 동작을 표시할 수 있습니다.
+ 열의 유형이 `String`인 경우 빈 행은 빈 문자열로 인식되어 `Completeness` 규칙에 실패하지 않습니다.
+ 열이 `Int`와 같은 다른 데이터 유형인 경우 빈 행이 `NULL`로 인식되어 `Completeness` 규칙에 실패합니다.
# IsPrimaryKey
열에 기본 키가 포함되어 있는지 확인합니다. 열의 모든 값이 고유하고 완전한 경우(null이 아닌 경우) 열에 기본 키가 포함됩니다. 여러 열이 있는 프라이머리 키를 확인할 수도 있습니다.
**구문**
```
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
열에 있는 모든 값의 평균이 지정된 표현식과 일치하는지 확인합니다.
**구문**
```
Mean
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **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`
**Null 동작**
`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** - 기본 데이터 세트의 쉼표로 구분된 열 이름 목록입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **REFERENCE\$1DATASET\$1COLS** - 이 파라미터는 마침표로 구분된 두 부분을 포함합니다. 첫 번째 부분은 참조 데이터 세트의 별칭입니다. 두 번째 부분은 참조 데이터 세트에서 괄호로 묶인 쉼표로 구분된 열 이름 목록입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: zip code 열의 참조 무결성 확인**
다음 예제 규칙은 기본 데이터 세트의 `zipcode` 열에 있는 값 중 90%가 넘는 항목이 `reference` 데이터 세트의 `zipcode` 열에 있는지 확인합니다.
```
ReferentialIntegrity "zipcode" "reference.zipcode" >= 0.9
```
**예: city 및 state 열의 참조 무결성 확인**
다음 예제에서는 city 및 state 정보가 포함된 열이 기본 데이터 세트과 참조 데이터 세트에 있습니다. 두 데이터 세트의 열 이름은 서로 다릅니다. 이 규칙은 기본 데이터 세트의 열 값 세트가 참조 데이터 세트의 열 값 세트와 정확히 같은지 확인합니다.
```
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** - 행 수를 비교할 참조 데이터 세트의 별칭입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: 참조 데이터 세트를 기준으로 행 수 확인**
다음 예제 규칙은 기본 데이터 세트의 행 수가 참조 데이터 세트 행 수의 90% 이상인지 확인합니다.
```
RowCountMatch "reference" >= 0.9
```
# StandardDeviation
지정된 표현식을 기준으로 열에 있는 모든 값의 표준 편차를 검사합니다.
**구문**
```
StandardDeviation
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **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`
**Null 동작**
`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
지정된 표현식을 기준으로 열에 있는 모든 값의 합계를 확인합니다.
**구문**
```
Sum
```
+ **COL\$1NAME** - 데이터 품질 규칙을 평가할 열의 이름입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **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`
**Null 동작**
`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** - 스키마를 비교할 때 사용할 참조 데이터 세트의 별칭입니다.
**지원되는 열 유형**: Byte, Decimal, Double, Float, Integer, Long, Short
+ **EXPRESSION** - 부울 값을 생성하기 위해 규칙 유형 응답에 대해 실행할 표현식입니다. 자세한 내용은 [Expressions](dqdl.md#dqdl-syntax-rule-expressions) 섹션을 참조하세요.
**예: SchemaMatch**
다음 예제 규칙은 기본 데이터 세트의 스키마가 참조 데이터 세트의 스키마와 정확히 일치하는지 확인합니다.
```
SchemaMatch "reference" = 1.0
```
# Uniqueness
지정된 표현식을 기준으로 열에서 고유한 값의 백분율을 검사합니다. 고유한 값은 정확히 한 번 발생합니다.
**구문**
```
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]` 세트에는 고유 값 1개(`b`)와 개별 값 2개(`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)
```
**임계치를 사용하여 폴더 또는 파일 최신성 확인**
다음 규칙은 지난 10일 동안 "tickets" 폴더에 있는 파일의 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로 계산됩니다.
+ 날짜는 00:00 시간의 UTC로 계산됩니다.
시간 기반 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**
허용되는 시간대 재정의는 지원되는 시간대에 [Allowed Time Zones](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에서 규칙을 작성할 때 카탈로그 테이블에서 사용 중인 폴더를 찾기 어려울 수 있습니다. AWS Glue Data Quality에서는 데이터 프레임을 채우는 데 사용되는 특정 폴더나 파일을 찾고 해당 항목이 최신 상태인지를 감지할 수 있습니다.
**참고**
이 기능은 파일이 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/ko_kr/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 지원)에서 규칙을 작성하는 경우 카탈로그 테이블에서 사용 중인 폴더를 찾기 어려울 수 있습니다. AWS Glue Data Quality에서는 데이터 프레임을 채우는 데 사용되는 특정 폴더나 파일을 찾을 수 있습니다.
**참고**
이 기능은 파일이 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/ko_kr/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/ko_kr/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에서 규칙을 작성할 때 카탈로그 테이블에서 사용 중인 폴더를 찾기 어려울 수 있습니다. AWS Glue Data Quality에서는 데이터 프레임을 채우는 데 사용되는 특정 폴더나 파일을 찾을 수 있습니다.
**참고**
추론을 사용하는 경우 파일 기반 규칙은 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가 2MB를 초과하면 이 규칙이 통과됩니다.
```
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%가 2GB\$11TB인 경우 이 규칙을 통과합니다.
```
FileSize "s3://amzn-s3-demo-bucket/" between 2 GB and 1 TB with threshold > 0.7
```
**데이터 프레임에서 직접 파일 이름 추론**
항상 파일 경로를 제공하지 않아도 됩니다. 예를 들어 Data Catalog에서 규칙을 작성할 때 카탈로그 테이블에서 사용 중인 폴더를 찾기 어려울 수 있습니다. AWS Glue Data Quality에서는 데이터 프레임을 채우는 데 사용되는 특정 폴더나 파일을 찾을 수 있습니다.
**참고**
이 기능은 파일이 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 변환 직후 DataQuality 평가 변환이 있어야 합니다.
1. 이 규칙은 AWS Glue 대화형 세션에서 작동하지 않습니다.