본 번역은 검증되지 않았습니다. AIP를 통해 영문원문으로부터 번역되었습니다.

참조

다음은 모든 가능한 데이터 기대치의 분류된 목록입니다.

연산자

Copied!1
2
3
4
5
6
7
from transforms import expectations as E

E.true()           # 항상 통과
E.false()          # 항상 실패
E.all(e1,e2,...)   # 모든 하위 기대가 통과할 때 통과
E.any(e1,e2,...)   # 하위 기대 중 하나라도 통과하면 통과
E.negate(e1)       # 하위 기대가 실패할 때 통과

예시:

Copied!1
2
3
4
5
6
7
8
9
10
from transforms import expectations as E

E.all(
    E.col('a').gt(0),  # 'a'열의 모든 값이 0보다 큰지 확인합니다.
    E.col('a').lt(100),  # 'a'열의 모든 값이 100보다 작은지 확인합니다.
    E.any(
        E.col('b').gt(100),  # 'b'열의 어떤 값이라도 100보다 큰지 확인합니다.
        E.col('b').lt(0)  # 'b'열의 어떤 값이라도 0보다 작은지 확인합니다.
    )
)

열 기대값

열 기대값은 E.col('column_name')으로 시작합니다.

any 연산자를 사용할 때 각 행은 열 기대값에 대해 개별적으로 확인됩니다. 예를 들어, 열 c1의 값이 10보다 크거나 0보다 작아야 하는 경우 검증하려면:

Copied!1
2
3
4
5
6
7
8
9
# transforms 라이브러리에서 expectations 모듈을 가져옵니다.
from transforms import expectations as E

# "c1" 열의 값이 0보다 작거나 10보다 큰지 검사합니다.
# 어느 하나라도 만족하면 True를 반환합니다.
E.any(
    E.col("c1").lt(0),  # "c1" 열의 값이 0보다 작은지 검사합니다.
    E.col("c1").gt(10)  # "c1" 열의 값이 10보다 큰지 검사합니다.
)

크거나 작음

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
from transforms import expectations as E

# E.col('c').gt(number|string) : 'c' 열의 값이 주어진 숫자 또는 문자열보다 큰 경우
E.col('c').gt(number|string)

# E.col('c').gte(number|string) : 'c' 열의 값이 주어진 숫자 또는 문자열보다 크거나 같은 경우
E.col('c').gte(number|string)

# E.col('c').lt(number|string) : 'c' 열의 값이 주어진 숫자 또는 문자열보다 작은 경우
E.col('c').lt(number|string)

# E.col('c').lte(number|string) : 'c' 열의 값이 주어진 숫자 또는 문자열보다 작거나 같은 경우
E.col('c').lte(number|string)

예를 들어:

Copied!1
2
3
4
from transforms import expectations as E

# 'age' 열의 값이 120 미만인지 확인합니다.
E.col('age').lt(120)

이 기대치는 null 값을 무시합니다 (즉, null 값은 자동으로 통과합니다). null을 확인하려면 E.col('col').non_null()을 사용하세요.

열 비교

Copied!1
2
3
4
5
6
7
8
from transforms import expectations as E

E.col('c1').equals_col('c2')  # 열 c1 값이 열 c2 값과 같음
E.col('c1').not_equals_col('c2')  # 열 c1 값이 열 c2 값과 다름
E.col('c1').gt_col('c2')  # 열 c1 값이 열 c2 값보다 큼
E.col('c1').gte_col('c2') # c1 값이 c2 값보다 크거나 같음
E.col('c1').lt_col('c2')  # 열 c1 값이 열 c2 값보다 작음
E.col('c1').lte_col('c2') # c1 값이 c2 값보다 작거나 같음

속성 비교

Copied!1
2
3
4
5
6
7
8
9
from transforms import expectations as E

E.col('c').null_percentage().lt(value) # 'c' 열의 널 값 비율이 특정 값보다 작은지 확인합니다.
E.col('c').null_count().gt(value) # 'c' 열의 널 값 개수가 특정 값보다 큰지 확인합니다.
E.col('c').distinct_count().equals(value) # 'c' 열의 고유한 값의 개수가 특정 값과 같은지 확인합니다.
E.col('c').approx_distinct_count().equals(value) # 'c' 열의 대략적인 고유한 값의 개수가 특정 값과 같은지 확인합니다. 이는 distinct_count의 더 빠른 버전으로, 오류의 상대 표준 편차가 최대 5%임을 보장합니다.
E.col('c').sum().gt(value) # 'c' 열의 합이 특정 값보다 큰지 확인합니다. 이는 숫자 열에서만 작동합니다.
E.col('c').standard_deviation_sample().gt(value) # 'c' 열의 샘플 표준 편차가 특정 값보다 큰지 확인합니다. 이는 숫자 열에서만 작동합니다.
E.col('c').standard_deviation_population().gt(value) # 'c' 열의 모집단 표준 편차가 특정 값보다 큰지 확인합니다. 이는 숫자 열에서만 작동합니다.

예시:

Copied!1
2
3
4
5
6
7
8
9
from transforms import expectations as E

E.col("myCol").null_percentage().lt(0.1)    # myCol이 null 값의 10% 미만
E.col("myCol").null_count().gt(100)         # myCol이 null 값이 100개 이상
E.col("myCol").distinct_count().equals(5)   # myCol의 고유 값이 5개 (버전 0.11.0부터)
E.col('myCol').approx_distinct_count().equals(5)   # myCol의 대략적인 고유 값이 5개
E.col('myCol').sum().equals(5)              # myCol 값의 합계가 5
E.col('myCol').standard_deviation_sample().gt(5) # myCol의 표본 표준 편차가 5보다 큼
E.col('myCol').standard_deviation_population().gt(5) # myCol의 모집단 표준 편차가 5보다 큼

같음

Copied!1
2
3
from transforms import expectations as E

E.col('c').equals(value)    # 컬럼 값이 입력 값과 같습니다

예를 들어:

Copied!1
2
3
4
5
# transforms 라이브러리에서 expectations 모듈을 E라는 이름으로 가져옵니다.
from transforms import expectations as E

# 'test_column'이라는 이름의 컬럼 값이 "success"와 같은지 검사합니다.
E.col('test_column').equals("success")

이 기대는 null 값을 무시합니다 (즉, null 값은 자동으로 통과합니다). null을 확인하려면 E.col('col').non_null()을 사용하세요.

같지 않음

Copied!1
2
3
from transforms import expectations as E

E.col('c').not_equals(value)    # 컬럼 값이 입력 값과 같지 않음

예를 들어:

Copied!1
2
3
4
from transforms import expectations as E

# 'test_column' 열의 값이 "failure"와 다른 경우를 확인합니다.
E.col('test_column').not_equals("failure")

이 기대치는 널 값을 무시합니다(즉, 널 값은 자동으로 통과합니다). 널을 확인하려면 E.col('col').non_null()을 사용하세요.

널

Copied!1
2
3
4
from transforms import expectations as E

E.col('c').non_null()    # 컬럼 값이 null이 아님
E.col('c').is_null()     # 컬럼 값이 null임

포함됨

이 기대값은 열 값이 승인된 값 목록 내에 있는지 확인합니다. 배열 열의 경우 포함됨 (배열)을 참조하세요.

Copied!1
2
3
from transforms import expectations as E

E.col('c').is_in(a, b, ...)    # 컬럼 값이 주어진 리스트 안에 있음

이 기대치는 허용된 값에 None을 추가하지 않으면 null 값에서 실패합니다.

rlike (정규 표현식)

정규 표현식의 부분 일치, pyspark.sql.functions.rlike과 유사합니다.

Copied!1
2
3
from transforms import expectations as E

E.col('c').rlike(regex expression)    # 컬럼 값이 정규 표현식과 일치합니다 (부분 일치)

예를 들어:

Copied!1
2
3
4
5
from transforms import expectations as E

# 'flight_number' 열에 대해 정규식을 적용합니다.
# 해당 정규식은 두 개의 알파벳으로 시작하고 그 뒤에 2에서 4개의 숫자가 오는 패턴을 찾습니다.
E.col('flight_number').rlike(r"^\D{2}\d{2,4}$")

이 기대치는 널 값(null values)을 무시합니다(즉, 널 값이 자동으로 통과됩니다). 널 값(nulls)을 확인하려면 E.col('col').non_null()을 사용하세요.

유형을 가지고 있음

Copied!1
2
3
from transforms import expectations as E

E.col('c').has_type(Type)   # 컬럼 'c'는 Type 유형입니다

이 기대는 pyspark.sql에서 types를 가져와야 합니다 (예제에서: as T)

예를 들면:

Copied!1
2
3
4
from transforms import expectations as E

# 'age' 열의 데이터 타입이 LongType인지 확인
E.col('age').has_type(T.LongType())

존재함

Copied!1
2
3
from transforms import expectations as E

E.col('c').exists()  # 출력 데이터프레임에 'c' 열이 존재합니다

이 기대치는 결과 데이터프레임에 제공된 이름의 열이 있는지 확인합니다. 열은 모든 유형일 수 있습니다.

타임스탬프 기대치

타임스탬프 기대치는 타임스탬프 유형의 열에서만 작동합니다. 현재 날짜 열은 지원되지 않습니다.

정적 타임스탬프 비교

타임스탬프 열의 값과 정적 타임스탬프를 비교합니다. 정적 타임스탬프는 ISO8601 형식의 문자열이나 파이썬 datetime 객체로 제공될 수 있습니다. 모든 타임스탬프는 모호함을 피하기 위해 시간대를 인식해야 합니다.

경고

datetime.now()에서 파생된 타임스탬프와 정적 타임스탬프 기대치를 사용하지 마십시오. 이것은 처음에는 올바른 결과를 제공하는 것처럼 보일 수 있지만, 이 동작은 지원되지 않으며 경고 없이 잘못된 결과를 초래할 수 있습니다. 또한, datetime.now()에서 파생된 타임스탬프와 정적 타임스탬프 기대치를 사용하면 Data Health와 Foundry 전체의 메시지가 올바른 타임스탬프를 참조하지 않습니다. 대신, 상대 타임스탬프 비교 기대치를 사용하십시오.

Copied!1
2
3
4
5
6
7
8
9
10
from transforms import expectations as E

# 타임스탬프가 2020-12-14T11:32:23+0000 이후인지 확인
E.col("timestamp").is_after("2020-12-14T11:32:23+0000")
# 타임스탬프가 2017-11-28T23:55:59.342380 이전인지 확인
E.col("timestamp").is_before(datetime(2017, 11, 28, 23, 55, 59, 342380))
# 타임스탬프가 2020-12-14T11:32:23+0000 이후 또는 같은 시간인지 확인
E.col("timestamp").is_on_or_after("2020-12-14T11:32:23+0000")
# 타임스탬프가 2020-12-14T11:32:23+0000 이전 또는 같은 시간인지 확인
E.col("timestamp").is_on_or_before("2020-12-14T11:32:23+0000")

열 타임스탬프 비교

타임스탬프 열의 값과 다른 타임스탬프 열의 값 비교하기. 선택적 오프셋(초 단위의 정수)을 제공할 수 있으며, 다른 열의 값에 추가됩니다.

비교는 다음과 같이 이루어집니다:

first_column ($OPERATOR) second_column + offset_in_seconds # 첫 번째 열 ($OPERATOR) 두 번째 열 + 초 단위 오프셋

Copied!1
2
3
4
5
6
7
8
9
from transforms import expectations as E

E.col("timestamp").is_after_col("second_timestamp")
E.col("timestamp").is_on_or_after_col("second_timestamp")
# 연산자는 선택적으로 offset_in_second 인자를 받습니다.
# `second_timestamp`가 `timestamp`보다 1시간 이내인지 확인
E.col("timestamp").is_before_col("second_timestamp", 3600)
# `second_timestamp`가 `timestamp`보다 2시간 이전인지 확인
E.col("timestamp").is_on_or_before_col("second_timestamp", -7200)

상대 타임스탬프 비교

타임스탬프 열의 값을 검사 시간(예: 빌드 시간)과 사용자 지정 오프셋과 비교합니다. 오프셋은 초 단위의 정수 또는 timedelta 파이썬 객체로 제공할 수 있습니다.

상대 타임스탬프 비교 정밀도

상대 타임스탬프 비교의 정밀도는 몇 분 정도라고 예상합니다. 이는 검사가 실행되거나 인스턴스화된 시간의 정밀도 때문입니다. 사용된 정확한 타임스탬프는 검사가 실행된 후 기대값 검사 결과에 표시됩니다.

두 가지 주요 방법이 제공됩니다: timestamp_offset_from_current_time 및 timestamp_offset_to_current_time. 상대 시간 오프셋에 대한 자연스러운 추론을 돕기 위해 두 가지 다른 방법을 제공합니다. 따라서, 인수로서 양의 시간 오프셋만 지원합니다. 음의 오프셋을 사용해야 하는 경우 대신 다른 방법을 사용해 주세요.

`timestamp_offset_from_current_time`

이 방법은 timestamp - now() 값이 양수인 미래의 상대 시간에 사용하기 위한 것입니다. 이 값은 제공된 오프셋과 비교됩니다. 모든 일반 비교 연산자가 비교에 사용 가능합니다.

Copied!1
2
3
4
5
6
7
8
from datetime import timedelta
from transforms import expectations as E

# 타임스탬프 값들이 현재 시간으로부터 1시간 이내인 경우
A = E.col("timestamp").timestamp_offset_from_current_time().lt(3600)

# 타임스탬프 값들이 현재 시간으로부터 2시간 이후인 경우
B = E.col("timestamp").timestamp_offset_from_current_time().gt(timedelta(hours=2))

`timestamp_offset_to_current_time`

이 메소드는 now() - timestamp가 양수인 과거의 상대적인 시간을 사용할 때 사용되도록 설계되었습니다. 이 값은 제공된 오프셋과 비교됩니다. 모든 일반 비교 연산자가 비교에 사용 가능합니다.

Copied!1
2
3
4
5
6
7
8
from datetime import timedelta
from transforms import expectations as E

# 타임스탬프 값들은 90분 전보다 작습니다
C = E.col("timestamp").timestamp_offset_to_current_time().lt(5400)

# 타임스탬프 값들은 2시간 전보다 큽니다
D = E.col("timestamp").timestamp_offset_to_current_time().gt(timedelta(hours=2))

예시: 예상 결과

체크가 1월 1일 오후 4시에 실행되고 있다고 가정하면, 위의 체크에 대한 다양한 타임스탬프 값에 대한 예상 결과는 다음과 같습니다.

   < ------- 과거 ---------------------  현재  -------------------- 미래 ------>
   |    1pm   |    2pm   |    3pm   |    4pm   |    5pm   |    6pm   |    7pm   |
---+----------+----------+----------+----------+----------+----------+----------+
 A |   합격   |   합격   |   합격   |   합격   |   불합격   |   불합격   |   불합격   |
---+----------+----------+----------+----------+----------+----------+----------+
 B |   불합격   |   불합격   |   불합격   |   불합격   |   불합격   |   불합격*  |   합격   |
---+----------+----------+----------+----------+----------+----------+----------+
 C |   불합격   |   불합격   |   합격   |   합격   |   합격   |   합격   |   합격   |
---+----------+----------+----------+----------+----------+----------+----------+
 D |   합격   |   불합격*  |   불합격   |   불합격   |   불합격   |   불합격   |   불합격   |
---+----------+----------+----------+----------+----------+----------+----------+

검사 B와 D의 비교는 엄격한 비교입니다. 비 엄격한 비교를 위해 ge와 le를 사용하세요.

그룹 및 속성 타임스탬프 비교

대부분의 타임스탬프 비교는 일반 데이터프레임 또는 그룹화된 데이터프레임의 파생 속성에서도 사용 가능합니다.

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from datetime import timedelta
from transforms import expectations as E

# 주어진 고정 날짜 이후에 가장 높은 타임스탬프가 있는지 확인
E.col("timestamp").max_value().is_after("2020-12-14T12:23:50+0000")

# 가장 오래된 타임스탬프가 1일 이내인지 확인
E.col("timestamp").min_value().timestamp_offset_to_current_time().lt(timedelta(days=1))

# 각 카테고리별 마지막 날짜가 미래의 2개월 이상인지 확인
E.group_by("category")
    .col("timestamp")
    .max_value()
    .timestamp_offset_from_current_time()
    .gt(timedelta(months=2))

배열 기대치

모든 기대치가 배열 유형의 열에 대해 작동하는 것은 아닙니다. 배열 유형의 열은 아래에 설명된 특정 기대치만 사용할 수 있습니다.

배열이 내장되어 있음

is_in 기대치는 배열 유형의 열에서도 작동합니다. 배열의 경우 이 기대치는 배열이 is_in 절에 명시된 값만 포함하는지 테스트합니다.

Copied!1
2
3
from transforms import expectations as E

E.col('array_col').is_in('a', 'b', 'c') # 'array_col'의 모든 배열은 'a', 'b', 'c' 값만 포함할 수 있습니다.

배열 포함

array_contains 기대치는 배열 열의 각 행이 특정 값이 포함되어 있는지 확인할 수 있게 해줍니다.

Copied!1
2
3
4
5
# transforms 모듈에서 expectations을 E라는 이름으로 가져옵니다.
from transforms import expectations as E

# 'array_col' 열의 모든 행은 'a' 값을 포함해야 합니다.
E.col('array_col').array_contains('a')

배열 크기

size 기대값은 배열의 각 행이 특정 크기를 가지고 있는지 확인할 수 있게 해줍니다.

Copied!1
2
3
4
from transforms import expectations as E

E.col('array_col').size().gt(1) # 'array_col'은 길이가 1보다 커야 합니다.
E.col('array_col').size().equals(2) # 'array_col'은 길이가 2와 같아야 합니다.

그룹화 기대값

그룹화 기대값은 E.group_by('column_1', 'column_2', ...)로 시작합니다. 그룹화 기대값을 사용하면 열 조합에 대한 기대값을 설정할 수 있습니다.

고유함

Copied!1
2
3
from transforms import expectations as E

E.group_by('col1', 'col2').is_unique()   # 'col1'과 'col2'를 결합할 때, 결합된 열의 값들은 데이터셋 내에서 고유합니다.

행 개수

행 개수 기대값은 각 그룹의 행 개수를 테스트합니다. group_by가 비어 있으면 전체 데이터셋의 행 개수에 대해 테스트합니다.

Copied!1
2
3
4
5
from transforms import expectations as E

E.group_by('col1', 'col2').count().gt(100)    # 'col1', 'col2'별 그룹화를 한 후 각 그룹의 행 개수가 100을 초과해야 함
E.group_by().count().lt(100)    # 데이터셋의 행 개수가 100 미만이어야 함
E.count().equals(0)    # group_by를 비워두는 대신 사용할 수 있는 축약형. 데이터셋의 행 개수가 0과 같아야 함

그룹화된 속성 기대치

모든 속성 비교 기대치는 그룹화된 기대치로도 사용할 수 있습니다.

Copied!1
2
3
4
from transforms import expectations as E

E.group_by('col1').col('value_col').distinct_count().equals(3) # 'col1'으로 그룹화된 각 그룹에서 'value_col'의 고유한 개수는 3이어야 합니다.
E.group_by('col1').col('value_col').null_percentage().lt(0.5) # 'col1'으로 그룹화된 각 그룹에서 'value_col'의 null 비율은 50% 미만이어야 합니다.

기본키

기본키 기대치는 하나 이상의 열 이름을 받아 검증합니다:

각 열에는 null 값이 없습니다
열의 조합이 고유합니다

Copied!1
2
3
4
from transforms import expectations as E

E.primary_key('c1')             # `c1`열은 고유하며 널(null)이 아닙니다.
E.primary_key('c1', 'c2',...)   # {'c1', 'c2',...} 각 열은 널(null)이 아니며 함께 사용할 경우 고유합니다.

기대치	설명	예시
E.primary_key('c1')	열 `c1`은 고유하며 null이 아닙니다	E.primary_key('object_id')
E.primary_key('c1', 'c2',...)	열들 {'c1', 'c2',...} 각각이 null이 아니며 함께 고유합니다	E.primary_key('time', 'event')

예를 들면:

Copied!1
2
3
4
5
# transforms 라이브러리에서 expectations 모듈을 가져옵니다.
from transforms import expectations as E

# 'time' 과 'event' 를 기본 키로 설정합니다.
E.primary_key('time', 'event')

스키마 기대값

모든 스키마 기대값은 E.schema()로 시작합니다.

Copied!1
2
3
4
5
6
7
from transforms import expectations as E

E.schema().contains({'col_name':type})  # 데이터셋의 열은 나열된 열을 포함해야 합니다.
E.schema().equals({'col_name':type})   # 데이터셋의 열은 정확히 나열된 열과 일치해야 합니다(추가 없음)
E.schema().is_subset_of({'col_name':type})   # 데이터셋의 열은 나열된 열의 부분집합이어야 합니다.
                                             # 데이터셋의 모든 열은 체크에 정의되어야 합니다.
                                             # 열은 데이터셋에 존재하지 않아도 체크에 정의될 수 있습니다.

예를 들어:

Copied!1
2
3
4
5
6
7
8
9
10
11
from transforms import expectations as E

# 스키마를 검증하기 위한 expectations 객체 생성
E.schema().contains(
    {
        # 'id' 열은 정수 타입이어야 함
        'id': T.IntegerType(),
        # 'name' 열은 문자열 타입이어야 함
        'name': T.StringType()
    }
)

이 기대치는 pyspark.sql에서 types를 가져오는 것이 필요합니다 (예시: as T)

조건부

조건부 기대치는 세 가지 기대치를 사용하여 다음을 확인합니다:

when-expectation을 통과한 행은 then-expectation도 통과합니다.
when-expectation에 실패한 행은 otherwise-expectations를 통과합니다.

Copied!1
2
3
4
5
6
7
8
9
10
from transforms import expectations as E

# when_exp 조건이 True일 때, then_exp를 실행합니다.
E.when(
    when_exp,
    then_exp
# 그렇지 않으면, otherwise_exp를 실행합니다.
).otherwise(
    otherwise_exp
)

예를 들어, "myCol"이 0보다 클 때, "myOtherCol"은 ["a"]에 있어야 하며, 그렇지 않으면 "myOtherCol"은 ["b"]에 있어야 합니다.

Copied!1
2
3
4
5
6
7
8
9
10
11
# "transforms" 모듈에서 "expectations"을 "E"로 가져옵니다.
from transforms import expectations as E

# E.col("myCol")이 0보다 클 때 E.col("myOtherCol")이 "a"에 있으면 참(True)을 반환합니다.
E.when(
    E.col("myCol").gt(0),
    E.col("myOtherCol").is_in("a")
# 그렇지 않은 경우 E.col("myOtherCol")이 "b"에 있으면 참(True)을 반환합니다.
).otherwise(
    E.col("myOtherCol").is_in("b")
)

항상 참 / 항상 거짓 기대치

E.true() 및 E.false()를 사용하여 조건부 기대치의 otherwise 분기에 대한 간단한 기본값을 설정합니다.

외부 값 기대치

경고: 이것은 실험적인 기능입니다.

외부 값 기대치는 다른 데이터셋의 데이터 간 관계를 검증합니다. 이 기대치는 조인을 포함하며 평가하는 데 매우 많은 비용이 들 수 있으므로 신중하게 사용하세요.

참조 무결성

이 기대치는 예상 데이터셋의 선택된 열의 모든 값이 외부 데이터셋의 지정된 열에 존재하는지 확인합니다. Null 값은 무시됩니다.

일치시킬 외부 열은 다른 데이터셋의 이름을 사용하여 생성된 데이터셋 참조에 의해 확인됩니다: E.dataset_ref('other_dataset_name').col('f_col').

외부 데이터셋은 변환에 입력해야 합니다(단순히 RID 또는 경로를 전달할 수 없음) 및 E.dataset_ref의 참조는 할당된 변수의 이름이어야 합니다.

열 참조 사용은 is_in() 사용과 유사합니다:

Copied!1
E.col('pk').is_in_foreign_col(E.dataset_ref('other_dataset').col('fk'))

데이터셋 간 행 수 비교

데이터셋 간 행 수 비교는 한 데이터셋의 행 수와 다른 데이터셋의 행 수를 비교하는 데 사용될 수 있습니다.

예를 들어, 출력 행 수가 입력 데이터셋의 행 수와 동일한지 확인할 수 있습니다:

Copied!1
E.count().equals(E.dataset_ref('input_dataset_name').count())

# 위 코드는 다음과 같은 의미를 가집니다:
# E.col('pk')는 현재 데이터셋의 'pk' 열을 참조하고,
# E.dataset_ref('other_dataset').col('fk')는 'other_dataset'이라는 다른 데이터셋의 'fk' 열을 참조합니다.
# is_in_foreign_col 메소드는 'pk' 열의 각 값이 'fk' 열에 존재하는지 확인합니다.

# 아래 코드는 현재 데이터셋의 행 수가 'input_dataset_name'이라는 입력 데이터셋의 행 수와 같은지 확인합니다.
# E.count()는 현재 데이터셋의 행 수를 반환하고, E.dataset_ref('input_dataset_name').count()는 'input_dataset_name' 데이터셋의 행 수를 반환합니다.
# equals 메소드는 두 행 수가 동일한지 비교합니다.

비교 대상인 데이터셋은 다른 데이터셋의 이름을 사용하여 생성된 데이터셋 출처로 지정됩니다.

데이터셋 행 수 비교에 다음 연산자를 사용할 수 있습니다:

Copied!1
2
3
4
5
6
7
from transforms import expectations as E

E.count().equals(E.dataset_ref('input_dataset_name').count()) # 같음
E.count().lt(E.dataset_ref('input_dataset_name').count()) # 미만
E.count().lte(E.dataset_ref('input_dataset_name').count()) # 이하
E.count().gte(E.dataset_ref('input_dataset_name').count()) # 이상
E.count().gt(E.dataset_ref('input_dataset_name').count()) # 초과