카테고리:

시스템 함수 (쿼리 정보) , 테이블 함수

GET_QUERY_OPERATOR_STATS

완료한 쿼리 내의 개별 쿼리 연산자에 대한 통계를 반환합니다. 지난 14일간 실행된 모든 완료된 쿼리에 대해 이 함수를 실행할 수 있습니다.

이 정보를 사용하여 쿼리 구조를 이해하고 성능 문제를 일으키는 쿼리 연산자(예: 조인 연산자)를 식별할 수 있습니다.

예를 들어 이 정보를 사용하여 가장 많은 리소스를 사용 중인 연산자를 확인할 수 있습니다. 또 다른 예로, 이 함수를 사용하여 입력 행보다 출력 행이 더 많은 조인을 식별할 수 있는데, 이는 《폭증하는》 조인 (예: 의도하지 않은 데카르트 곱)의 징후일 수 있습니다.

이러한 통계는 Snowsight 의 쿼리 프로필 탭에서도 사용할 수 있습니다. GET_QUERY_OPERATOR_STATS() 함수는 프로그래밍 방식의 인터페이스를 통해 동일한 정보를 제공합니다.

문제가 있는 쿼리 연산자를 찾는 방법에 대한 자세한 내용은 쿼리 프로필을 통해 확인된 일반 쿼리 문제 섹션을 참조하십시오.

구문

GET_QUERY_OPERATOR_STATS( <query_id> )

인자

query_id

쿼리의 ID입니다. 다음을 사용할 수 있습니다.

  • 문자열 리터럴(작은따옴표로 묶인 문자열).

  • 쿼리 ID를 포함하는 세션 변수.

  • LAST_QUERY_ID 함수에 대한 호출의 반환 값.

반환

GET_QUERY_OPERATOR_STATS 함수는 테이블 함수 입니다. 쿼리의 각 쿼리 연산자에 대한 통계가 포함된 행을 반환합니다. 자세한 내용은 아래의 사용법 노트출력 섹션을 참조하십시오.

사용법 노트

  • 이 함수는 완료된 쿼리에 대한 통계만 반환합니다.

  • 이 함수는 지정된 쿼리에 사용된 각 쿼리 연산자에 대한 자세한 통계를 제공합니다. 가능한 쿼리 연산자에는 다음이 포함됩니다.

    • Aggregate: 입력을 그룹화하고 집계 함수를 계산합니다.

    • CartesianJoin: 특수한 조인 유형.

    • Delete: 테이블에서 레코드를 제거합니다.

    • ExternalFunction: 외부 함수에 의한 처리를 나타냅니다.

    • ExternalScan: 스테이지 오브젝트에 저장된 데이터에 대한 액세스를 나타냅니다.

    • Filter: 행을 필터링하는 작업을 나타냅니다.

    • Flatten: VARIANT 레코드를 처리하여 지정된 경로에서 평면화할 수 있습니다.

    • Generator: TABLE(GENERATOR(…)) 구문을 사용하여 레코드를 생성합니다.

    • GroupingSets: GROUPING SETS, ROLLUP, CUBE 등의 구문을 나타냅니다.

    • Insert: INSERT 또는 COPY 작업을 통해 테이블에 레코드를 추가합니다.

    • InternalObject: 내부 데이터 오브젝트(예: Information Schema 또는 이전 쿼리 결과에서)에 대한 액세스를 나타냅니다.

    • Join: 지정된 조건에서 두 입력을 결합합니다.

    • JoinFilter: 쿼리 계획에서 더 이상 조인 조건과 일치하지 않는 것으로 식별될 수 있는 튜플을 제거하는 특수 필터링 작업입니다.

    • Merge: 테이블에 대한 MERGE 연산을 수행합니다.

    • Pivot: 열의 고유 값을 여러 열로 변환하고 필요한 집계를 수행합니다.

    • Result: 쿼리 결과를 반환합니다.

    • Sort: 지정된 식에서 입력을 정렬합니다.

    • SortWithLimit: 일반적으로 ORDER BY ... LIMIT ... OFFSET ... 구문의 결과인 정렬 후 입력 시퀀스의 일부를 생성합니다.

    • TableScan: 단일 테이블에 대한 액세스를 나타냅니다.

    • UnionAll: 두 입력을 연결합니다.

    • Unload: 테이블의 데이터를 스테이지의 파일로 내보내는 COPY 작업을 나타냅니다.

    • Unpivot: 열을 행으로 변환하여 테이블을 회전합니다.

    • Update: 테이블에서 레코드를 업데이트합니다.

    • ValuesClause: VALUES 절과 함께 제공되는 값 목록입니다.

    • WindowFunction: 윈도우 함수를 계산합니다.

  • 이 정보는 테이블로 반환됩니다. 테이블의 각 행은 하나의 연산자에 해당합니다. 이 행에는 해당 연산자에 대한 실행 분석 및 쿼리 통계가 포함됩니다.

    이 행에는 연산자 특성 도 나열될 수 있습니다(이러한 특성은 연산자 유형에 따라 다름).

    쿼리 실행 시간을 분석한 통계는 전체 쿼리에서 사용한 시간의 백분율로 표현됩니다.

    특정 통계에 대한 자세한 내용은 이 항목의 출력 섹션을 참조하십시오.

  • 이 함수는 테이블 함수이므로 FROM 절에서 사용해야 하며 TABLE() 로 래핑해야 합니다. 예:

    select *
        from table(get_query_operator_stats(last_query_id()));
    
  • 특정 쿼리(즉, 특정 UUID)의 각 개별 실행에 대해 이 함수는 결정적이며, 매번 똑같은 값을 반환합니다.

    하지만 같은 쿼리 텍스트의 다른 실행에 대해 이 함수는 다른 런타임 통계를 반환할 수 있습니다. 통계는 많은 요인에 따라 달라집니다. 다음 요인은 실행에 중대한 영향을 미치며 따라서 이 함수에서 반환되는 통계에도 중대한 영향을 미칠 수 있습니다.

    • 데이터의 양.

    • 구체화된 뷰 의 가용성과 이러한 구체화된 뷰를 마지막으로 새로 고친 이후 데이터에 대한 변경 사항(있는 경우).

    • 클러스터링 의 존재 또는 부재.

    • 이전에 캐시된 데이터의 존재 또는 부재.

    • 가상 웨어하우스의 크기.

    값은 사용자의 쿼리와 데이터 외부 요인의 영향을 받을 수도 있습니다. 이러한 요인은 대개 작습니다. 이러한 요인에는 다음이 포함됩니다.

    • 가상 웨어하우스 초기화 시간.

    • 외부 함수 사용 시의 대기 시간.

출력

이 함수는 다음 열을 반환합니다.

열 이름

데이터 타입

설명

QUERY_ID

VARCHAR

SQL 문에 대한 내부의 시스템 생성 식별자인 쿼리 ID.

STEP_ID

NUMBER(38, 0)

쿼리 계획의 단계 식별자.

OPERATOR_ID

NUMBER(38, 0)

연산자의 식별자. 이것은 쿼리 내에서 고유합니다. 값은 0에서 시작합니다.

PARENT_OPERATOR_ID

NUMBER(38, 0)

이 연산자에 대한 상위 연산자의 식별자로, 쿼리 계획의 마지막 연산자(보통은 Result 연산자)인 경우 NULL입니다.

OPERATOR_TYPE

VARCHAR

쿼리 연산자의 유형(예: TableScan 또는 Filter).

OPERATOR_STATISTICS

OBJECT를 포함하는 VARIANT

연산자에 대한 통계(예: 연산자의 출력 행 수).

EXECUTION_TIME_BREAKDOWN

OBJECT를 포함하는 VARIANT

연산자의 실행 시간에 대한 정보.

OPERATOR_ATTRIBUTES

OBJECT를 포함하는 VARIANT

연산자에 대한 정보. 이 정보는 연산자 유형에 따라 다릅니다.

연산자의 특정 열에 대한 정보가 없는 경우 값은 NULL입니다.

이러한 열 중 세 개에 OBJECTs 가 포함됩니다. 각 오브젝트에는 키/값 페어가 있습니다. 아래 테이블에서는 이러한 테이블의 키에 대한 정보를 보여줍니다.

OPERATOR_STATISTICS

OPERATOR_STATISTICS 열의 OBJECTs에 있는 필드에서는 연산자에 대한 추가 정보를 제공합니다. 정보에는 다음이 포함될 수 있습니다.

중첩 키(해당되는 경우)

데이터 타입

설명

dml

데이터 조작 언어(DML) 쿼리에 대한 통계:

number_of_rows_inserted

DOUBLE

테이블 1개(또는 테이블 여러 개)에 삽입된 행 수.

number_of_rows_updated

DOUBLE

테이블에서 업데이트된 행 수.

number_of_rows_deleted

DOUBLE

테이블에서 삭제된 행 수.

number_of_rows_unloaded

DOUBLE

데이터 내보내기 중 언로드된 행 수.

external_functions

외부 함수 호출에 대한 정보. 예를 들어 필드 retries_due_to_transient_errors 의 값이 0이면 필드가 표시되지 않습니다.

total_invocations

DOUBLE

외부 함수가 호출된 횟수. (행을 나누는 일괄 처리의 수, 재시도 횟수(일시적인 네트워크 장애가 있는 경우) 등으로 인해 SQL 문의 텍스트에 표시된 외부 함수 호출 횟수와 다를 수 있음)

rows_sent

DOUBLE

외부 함수로 전송된 행의 개수.

rows_received

DOUBLE

외부 함수로부터 수신된 행의 개수.

bytes_sent (x-region)

DOUBLE

외부 함수로 전송된 행의 개수. 키에 (x-region) 이 포함된 경우, 데이터가 여러 리전으로 전송되었습니다(청구에 영향을 줄 수 있음).

bytes_received (x-region)

DOUBLE

외부 함수로부터 수신된 행의 개수. 키에 (x-region) 이 포함된 경우, 데이터가 여러 리전으로 전송되었습니다(청구에 영향을 줄 수 있음).

retries_due_to_transient_errors

DOUBLE

일시적인 오류로 인한 재시도 횟수.

average_latency_per_call

DOUBLE

Snowflake가 데이터를 전송한 후 반환된 데이터를 수신한 시간 사이의 호출당 평균 시간(밀리초)입니다.

input_rows

INTEGER

입력 행 수. 이것은 다른 연산자의 입력 에지가 없는 연산자의 경우 누락될 수 있습니다.

io

쿼리 중에 수행된 I/O(입출력) 작업에 대한 정보.

scan_progress

DOUBLE

해당 테이블에서 현재 스캔한 데이터의 백분율.

bytes_scanned

DOUBLE

현재까지 스캔한 바이트 수.

percentage_scanned_from_cache

DOUBLE

로컬 디스크 캐시에서 스캔한 데이터의 백분율입니다.

bytes_written

DOUBLE

기록된 바이트 수(예: 테이블에 로드할 때).

bytes_written_to_result

DOUBLE

결과 오브젝트에 기록된 바이트 수.

예를 들어, select * from . . . 은 선택 항목에 있는 각 필드를 나타내는 표 형식의 결과 세트를 생성합니다.

일반적으로, 결과의 결과로 생성된 모든 것을 나타내고 bytes_written_to_result 는 반환된 결과의 크기를 나타냅니다.

bytes_read_from_result

DOUBLE

결과 오브젝트에서 읽은 바이트 수.

external_bytes_scanned

DOUBLE

외부 오브젝트(예: 스테이지)에서 읽은 바이트 수.

network

network_bytes

DOUBLE

네트워크를 통해 전송된 데이터의 양.

output_rows

INTEGER

출력 행 수. 이것은 결과를 사용자에게 반환하는 연산자(보통 RESULT 연산자)의 경우 누락될 수 있습니다.

pruning

테이블 잘라내기에 대한 정보.

partitions_scanned

DOUBLE

현재까지 스캔한 파티션의 수.

partitions_total

DOUBLE

지정된 테이블의 총 파티션 수.

spilling

임시 결과가 메모리에 적합하지 않는 작업에 대한 디스크 사용량 정보.

bytes_spilled_remote_storage

DOUBLE

원격 디스크로 유출된 데이터의 볼륨.

bytes_spilled_local_storage

DOUBLE

로컬 디스크로 유출된 데이터의 볼륨.

EXECUTION_TIME_BREAKDOWN

EXECUTION_TIME_BREAKDOWN 열의 OBJECTs에 있는 필드가 아래에 나와 있습니다.

데이터 타입

설명

overall_percentage

DOUBLE

이 연산자가 사용한 총 쿼리 시간의 백분율.

initialization

DOUBLE

쿼리 처리 설정에 사용한 시간.

processing

DOUBLE

CPU에서 데이터를 처리하는 데 사용한 시간.

synchronization

DOUBLE

참여 프로세스 간의 활동 동기화에 사용한 시간.

local_disk_io

DOUBLE

로컬 디스크 액세스를 기다리는 동안 처리가 차단된 시간.

remote_disk_io

DOUBLE

원격 디스크 액세스를 기다리는 동안 처리가 차단된 시간.

network_communication

DOUBLE

처리에서 네트워크 데이터 전송을 기다렸던 시간.

OPERATOR_ATTRIBUTES

각 출력 행은 쿼리에서 한 연산자를 설명합니다. 아래 표에서는 가능한 연산자 유형(예: Filter 연산자)을 보여줍니다. 이 표에는 각 유형의 연산자에 대해 가능한 특성(예: 행을 필터링하는 데 사용되는 식)이 나와 있습니다.

연산자 특성은 VARIANT 형식이고 OBJECT 를 포함하는 OPERATOR_ATTRIBUTES 열에 저장됩니다. OBJECT는 키/값 페어를 포함합니다. 각각의 키는 연산자의 한 특성에 대응됩니다.

연산자 이름

데이터 타입

설명

Aggregate

functions

VARCHAR로 구성된 ARRAY

계산된 함수의 목록.

grouping_keys

VARCHAR로 구성된 ARRAY

group-by 식.

CartesianJoin

additional_join_condition

VARCHAR

같지 않음 조인 식.

equality_join_condition

VARCHAR

같음 조인 식.

join_type

VARCHAR

조인 타입(INNER).

Delete

table_name

VARCHAR

업데이트된 테이블의 이름.

ExternalScan

stage_name

VARCHAR

데이터를 읽는 원본 스테이지의 이름.

stage_type

VARCHAR

스테이지의 유형.

Filter

filter_condition

VARCHAR

데이터를 필터링하는 데 사용되는 식.

Flatten

input

VARCHAR

데이터를 평면화하기 위해 사용되는 입력 식.

Generator

row_count

NUMBER

입력 매개 변수 ROWCOUNT의 값.

time_limit

NUMBER

입력 매개 변수 TIMELIMIT의 값.

GroupingSets

functions

VARCHAR로 구성된 ARRAY

계산된 함수의 목록.

key_sets

VARCHAR로 구성된 ARRAY

그룹화 세트의 목록.

Insert

input_expression

VARCHAR

삽입되는 식.

table_names

VARCHAR로 구성된 ARRAY

레코드가 추가된 테이블 이름의 목록.

InternalObject

object_name

VARCHAR

액세스한 오브젝트의 이름.

Join

additional_join_condition

VARCHAR

같지 않음 조인 식.

equality_join_condition

VARCHAR

같음 조인 식.

join_type

VARCHAR

조인 타입(INNER, OUTER, LEFT JOIN 등).

JoinFilter

join_id

NUMBER

필터링할 수 있는 튜플을 식별하는 데 사용되는 조인의 연산자 ID.

Merge

table_name

VARCHAR

업데이트된 테이블의 이름.

Pivot

grouping_keys

VARCHAR로 구성된 ARRAY

결과가 집계되는 나머지 열.

pivot_column

VARCHAR로 구성된 ARRAY

피벗 값의 결과 열.

Result

expressions

VARCHAR로 구성된 ARRAY

생성된 식의 목록.

Sort

sort_keys

VARCHAR로 구성된 ARRAY

정렬 순서를 정의하는 식.

SortWithLimit

offset

NUMBER

생성된 튜플이 출력되는 순서가 지정된 시퀀스의 위치.

rows

NUMBER

생성된 행의 개수.

sort_keys

VARCHAR로 구성된 ARRAY

정렬 순서를 정의하는 식.

TableScan

columns

VARCHAR로 구성된 ARRAY

스캔된 열의 목록.

extracted_variant_paths

VARCHAR로 구성된 ARRAY

베리언트 열에서 추출된 경로의 목록.

table_alias

VARCHAR

액세스 중인 테이블의 별칭.

table_name

VARCHAR

액세스 중인 테이블의 이름.

Unload

location

VARCHAR

데이터가 저장되는 스테이지.

Unpivot

expressions

VARCHAR로 구성된 ARRAY

피벗 해제 쿼리의 출력 열.

Update

table_name

VARCHAR

업데이트된 테이블의 이름.

ValuesClause

value_count

NUMBER

생성된 값의 개수.

values

VARCHAR

값의 목록.

WindowFunction

functions

VARCHAR로 구성된 ARRAY

계산된 함수의 목록.

연산자가 나열되지 않으면 아무런 특성도 생성되지 않고 값이 {} 으로 보고됩니다.

참고

  • 다음 연산자에는 연산자 특성이 없으므로 OPERATOR_ATTRIBUTES테이블 에 포함되지 않습니다.

    • UnionAll

    • ExternalFunction

단일 쿼리에 대한 데이터 검색하기

이 예에서는 작은 테이블 두 개를 조인하는 SELECT의 통계를 보여줍니다.

SELECT 문을 실행합니다.

select x1.i, x2.i
    from x1 inner join x2 on x2.i = x1.i
    order by x1.i, x2.i;

쿼리 ID를 가져옵니다.

set lqid = (select last_query_id());

GET_QUERY_OPERATOR_STATS()를 호출하여 쿼리의 개별 쿼리 연산자에 대한 통계를 가져옵니다.

select * from table(get_query_operator_stats($lqid));
+--------------------------------------+---------+-------------+--------------------+---------------+-----------------------------------------+-----------------------------------------------+----------------------------------------------------------------------+
| QUERY_ID                             | STEP_ID | OPERATOR_ID | PARENT_OPERATOR_ID | OPERATOR_TYPE | OPERATOR_STATISTICS                     | EXECUTION_TIME_BREAKDOWN                      | OPERATOR_ATTRIBUTES                                                  |
|--------------------------------------+---------+-------------+--------------------+---------------+-----------------------------------------+-----------------------------------------------+----------------------------------------------------------------------|
| 01a8f330-0507-3f5b-0000-43830248e09a |       1 |           0 |               NULL | Result        | {                                       | {                                             | {                                                                    |
|                                      |         |             |                    |               |   "input_rows": 64                      |   "overall_percentage": 0.000000000000000e+00 |   "expressions": [                                                   |
|                                      |         |             |                    |               | }                                       | }                                             |     "X1.I",                                                          |
|                                      |         |             |                    |               |                                         |                                               |     "X2.I"                                                           |
|                                      |         |             |                    |               |                                         |                                               |   ]                                                                  |
|                                      |         |             |                    |               |                                         |                                               | }                                                                    |
| 01a8f330-0507-3f5b-0000-43830248e09a |       1 |           1 |                  0 | Sort          | {                                       | {                                             | {                                                                    |
|                                      |         |             |                    |               |   "input_rows": 64,                     |   "overall_percentage": 0.000000000000000e+00 |   "sort_keys": [                                                     |
|                                      |         |             |                    |               |   "output_rows": 64                     | }                                             |     "X1.I ASC NULLS LAST",                                           |
|                                      |         |             |                    |               | }                                       |                                               |     "X2.I ASC NULLS LAST"                                            |
|                                      |         |             |                    |               |                                         |                                               |   ]                                                                  |
|                                      |         |             |                    |               |                                         |                                               | }                                                                    |
| 01a8f330-0507-3f5b-0000-43830248e09a |       1 |           2 |                  1 | Join          | {                                       | {                                             | {                                                                    |
|                                      |         |             |                    |               |   "input_rows": 128,                    |   "overall_percentage": 0.000000000000000e+00 |   "equality_join_condition": "(X2.I = X1.I)",                        |
|                                      |         |             |                    |               |   "output_rows": 64                     | }                                             |   "join_type": "INNER"                                               |
|                                      |         |             |                    |               | }                                       |                                               | }                                                                    |
| 01a8f330-0507-3f5b-0000-43830248e09a |       1 |           3 |                  2 | TableScan     | {                                       | {                                             | {                                                                    |
|                                      |         |             |                    |               |   "io": {                               |   "overall_percentage": 0.000000000000000e+00 |   "columns": [                                                       |
|                                      |         |             |                    |               |     "bytes_scanned": 1024,              | }                                             |     "I"                                                              |
|                                      |         |             |                    |               |     "percentage_scanned_from_cache": 1, |                                               |   ],                                                                 |
|                                      |         |             |                    |               |     "scan_progress": 1                  |                                               |   "table_name": "MY_DB.MY_SCHEMA.X2" |
|                                      |         |             |                    |               |   },                                    |                                               | }                                                                    |
|                                      |         |             |                    |               |   "output_rows": 64,                    |                                               |                                                                      |
|                                      |         |             |                    |               |   "pruning": {                          |                                               |                                                                      |
|                                      |         |             |                    |               |     "partitions_scanned": 1,            |                                               |                                                                      |
|                                      |         |             |                    |               |     "partitions_total": 1               |                                               |                                                                      |
|                                      |         |             |                    |               |   }                                     |                                               |                                                                      |
|                                      |         |             |                    |               | }                                       |                                               |                                                                      |
| 01a8f330-0507-3f5b-0000-43830248e09a |       1 |           4 |                  2 | JoinFilter    | {                                       | {                                             | {                                                                    |
|                                      |         |             |                    |               |   "input_rows": 64,                     |   "overall_percentage": 0.000000000000000e+00 |   "join_id": "2"                                                     |
|                                      |         |             |                    |               |   "output_rows": 64                     | }                                             | }                                                                    |
|                                      |         |             |                    |               | }                                       |                                               |                                                                      |
| 01a8f330-0507-3f5b-0000-43830248e09a |       1 |           5 |                  4 | TableScan     | {                                       | {                                             | {                                                                    |
|                                      |         |             |                    |               |   "io": {                               |   "overall_percentage": 0.000000000000000e+00 |   "columns": [                                                       |
|                                      |         |             |                    |               |     "bytes_scanned": 1024,              | }                                             |     "I"                                                              |
|                                      |         |             |                    |               |     "percentage_scanned_from_cache": 1, |                                               |   ],                                                                 |
|                                      |         |             |                    |               |     "scan_progress": 1                  |                                               |   "table_name": "MY_DB.MY_SCHEMA.X1" |
|                                      |         |             |                    |               |   },                                    |                                               | }                                                                    |
|                                      |         |             |                    |               |   "output_rows": 64,                    |                                               |                                                                      |
|                                      |         |             |                    |               |   "pruning": {                          |                                               |                                                                      |
|                                      |         |             |                    |               |     "partitions_scanned": 1,            |                                               |                                                                      |
|                                      |         |             |                    |               |     "partitions_total": 1               |                                               |                                                                      |
|                                      |         |             |                    |               |   }                                     |                                               |                                                                      |
|                                      |         |             |                    |               | }                                       |                                               |                                                                      |
+--------------------------------------+---------+-------------+--------------------+---------------+-----------------------------------------+-----------------------------------------------+----------------------------------------------------------------------+

《폭증하는》 조인 연산자 식별하기

다음 예에서는 GET_QUERY_OPERATOR_STATS를 사용하여 복잡한 쿼리를 검사하는 방법을 보여줍니다. 이 예에서는 그 연산자에 입력된 것보다 훨씬 더 많은 행을 생성하는 쿼리 내에서 연산자를 찾습니다.

분석할 쿼리는 다음과 같습니다.

select *
from t1
    join t2 on t1.a = t2.a
    join t3 on t1.b = t3.b
    join t4 on t1.c = t4.c
;

이전 쿼리의 쿼리 ID를 가져옵니다.

set lid = last_query_id();

다음 쿼리는 쿼리에서 각 조인 연산자의 입력 행에 대한 출력 행의 비율을 보여줍니다.

select
        operator_id,
        operator_attributes,
        operator_statistics:output_rows / operator_statistics:input_rows as row_multiple
    from table(get_query_operator_stats($lid))
    where operator_type = 'Join'
    order by step_id, operator_id;

+---------+-------------+--------------------------------------------------------------------------+---------------+
| STEP_ID | OPERATOR_ID | OPERATOR_ATTRIBUTES                                                      | ROW_MULTIPLE  |
+---------+-------------+--------------------------------------------------------------------------+---------------+
|       1 |           1 | {  "equality_join_condition": "(T4.C = T1.C)",   "join_type": "INNER"  } |  49.969249692 |
|       1 |           3 | {  "equality_join_condition": "(T3.B = T1.B)",   "join_type": "INNER"  } | 116.071428571 |
|       1 |           5 | {  "equality_join_condition": "(T2.A = T1.A)",   "join_type": "INNER"  } |  12.20657277  |
+---------+-------------+--------------------------------------------------------------------------+---------------+

폭증하는 조인을 식별한 후 각 조인 조건을 검토하여 조건이 올바른지 확인할 수 있습니다.