일반적인 의견
흔히 Sort Merge Join에 대해 다음과 같이 이야기 한다. “조인에 참여하는 양측 집합에 Sort가 발생하므로 대용량 집합간의 조인에는 불리하다. 그러나 조인 되는 양쪽 집합에 적절한 인덱스가 있다면 Sort가 발생되지 않으므로 성능이 좋다.일견 일리가 있는 말이다. 하지만 이 정도는 튜닝에 입문하는 단계에서 언급되는 정도일 뿐이다. 2단을 외운다고 해서 구구단을 모두 안다고 할 수는 없다. 튜닝에 입문하는 사람과는 반대로 경력이 있는 사람들은 좀더 구체적인 사실들을 알고 있다. Sort Merge Join과 관련된 튜닝을 많이 해보고, Merge Join에 대해 여기저기 튜닝서적들을 탐독한다. 그 결과 다음과 같은 섣부른 결론을 내리는 사람이 많이 있다.

 

1. 양쪽 집합이 Full Table Scan을 사용하면 조인순서에 상관없이 일량이 동일하므로 처리시간도 동일하다.

2. 조인순서에 상관없이 Sort량은 동일하다.

3. 부분범위처리가 안 된다.

4. Full Scan이 발생하면 인덱스를 사용할 수 없으므로 항상 Sort 작업을 동반한다.

5. Sort Merge Join 대신 Cartesian Merge Join이 나오면 조인조건이 빠진 악성 SQL이다.

6. 조인컬럼 기준으로 Sort되므로 Order by절과 조인 컬럼이 일치해야만 Sort가 발생하지 않는다.

 

완벽하지 않거나 잘못된 결론

혹시 당신도 Sort Merge Join에 대해서 1~6번이 옳다고 생각하는가? 위의 List는 깊이 고민해 보지 않고 내린 결론이다. 물론 1~6 번이 옳은 경우도 있다. 하지만 그것은 잘못된 것 혹은 완벽하지 않은 결론이다. 왜냐하면 간단한 테스트로 1~6번이 잘못된 개념임을 증명하거나, 1~6번에 해당하지 않는 경우를 증명할 수 있기 때문이다. 지금부터 시작해 보자.

 

먼저 실습용 테이블을 생성한다.

<환경: Oracle 11.2.0.1>

 

CREATE TABLE SALES_T AS SELECT * FROM SALES;

 

 

1. 조인순서에 상관없이 처리시간이 동일할까?

 

ALTER SYSTEM FLUSH BUFFER_CACHE; 

  

SELECT /*+ leading(s) full(p) full(s) use_merge(p) */

       s.*, p.prod_id

  FROM sales_t s, products p

 WHERE p.prod_name = 'CD-R with Jewel Cases, pACK OF 12'

   AND p.prod_id = s.prod_id ;

 

-----------------------------------------------------------------------------------------------------

| Id  | Operation           | Name     | Starts | A-Rows |   A-Time   | Buffers | Reads  | Used-Mem |

-----------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT    |          |      1 |  22189 |00:00:07.74 |    4447 |   4439 |          |

|   1 |  MERGE JOIN         |          |      1 |  22189 |00:00:07.74 |    4447 |   4439 |          |

|   2 |   SORT JOIN         |          |      1 |    590K|00:00:04.75 |    4440 |   4433 |   43M (0)|

|   3 |    TABLE ACCESS FULL| SALES_T  |      1 |    918K|00:00:01.23 |    4440 |   4433 |          |

|*  4 |   SORT JOIN         |          |    590K|  22189 |00:00:01.29 |       7 |      6 | 2048  (0)|

|*  5 |    TABLE ACCESS FULL| PRODUCTS |      1 |      1 |00:00:00.01 |       7 |      6 |          |

-----------------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   4 - access("P"."PROD_ID"="S"."PROD_ID")

       filter("P"."PROD_ID"="S"."PROD_ID")

   5 - filter("P"."PROD_NAME"='CD-R with Jewel Cases, pACK OF 12')

 

Sales_t 집합을 선행으로 실행하니 Scan한 블록수는 4447 이며 Sort량은 43M + 2048 이다. 그리고 처리시간은 7 74이다. 그리고 조인시도(Merge)횟수는 59만 번이다. 그러면 이제 조인 순서만 바꿔보자. 과연 처리시간이 동일 할까?

 

ALTER SYSTEM FLUSH BUFFER_CACHE; 

 

SELECT /*+ leading(p) full(p) full(s) use_merge(s) */

       s.*, p.prod_id

  FROM sales_t s, products p

 WHERE p.prod_name = 'CD-R with Jewel Cases, pACK OF 12'

   AND p.prod_id = s.prod_id ;

 

-----------------------------------------------------------------------------------------------------

| Id  | Operation           | Name     | Starts | A-Rows |   A-Time   | Buffers | Reads  | Used-Mem |

-----------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT    |          |      1 |  22189 |00:00:02.52 |    4447 |   4439 |          |

|   1 |  MERGE JOIN         |          |      1 |  22189 |00:00:02.52 |    4447 |   4439 |          |

|   2 |   SORT JOIN         |          |      1 |      1 |00:00:00.03 |       7 |      6 | 2048  (0)|

|*  3 |    TABLE ACCESS FULL| PRODUCTS |      1 |      1 |00:00:00.03 |       7 |      6 |          |

|*  4 |   SORT JOIN         |          |      1 |  22189 |00:00:02.44 |    4440 |   4433 |   43M (0)|

|   5 |    TABLE ACCESS FULL| SALES_T  |      1 |    918K|00:00:01.25 |    4440 |   4433 |          |

-----------------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   3 - filter("P"."PROD_NAME"='CD-R with Jewel Cases, pACK OF 12')

   4 - access("P"."PROD_ID"="S"."PROD_ID")

       filter("P"."PROD_ID"="S"."PROD_ID")

 

일량이 같은데 수행시간은 세배이상 빠르다. 그 이유는?

조인 순서를 바꾸어 Products를 선행집합으로 Sort Merge Join을 해도 Scan한 블록 수와 Sort량은 완전히 같다. 일량이 같으므로 처리시간도 같을 것으로 생각해서는 안 된다. 처리시간이 2 52로 무려 세배이상 빨라졌다. 그 이유는 조인시도(Merge)횟수가 단 한번이기 때문이다. 이와는 대조적으로 Sales_t가 선행집합인 경우는 Merge 횟수가 무려 59만 번에 이르므로 성능이 느릴 수 밖에 없는 것이다. 그러므로 다음과 같은 결론을 낼 수 있다.

 

양쪽 집합이 Full Table Scan을 사용하면 조인순서에 상관없이 일량이 동일하므로 처리시간도 동일하다 ( X )

-->일량은 동일하더라도 Merge 횟수가 달라지면 처리시간이 달라진다 ( O )

 

 

2. 조인순서에 상관없이 Sort량이 동일할까?

 

실습을 위해 테이블을 두 개 만든다.

 

CREATE TABLE TAB1 NOLOGGING AS

SELECT ROWNUM AS SALES_NO, A.* FROM SALES A;

 

CREATE INDEX IDX_TAB1_01 ON TAB1 (PROD_ID, SALES_NO); 

 

CREATE TABLE TAB2 NOLOGGING AS

SELECT A.*, B.SEQ

  FROM TAB1 A,

       (SELECT LEVEL AS SEQ

          FROM DUAL

       CONNECT BY LEVEL <= 5) B  ;

    

CREATE INDEX IDX_TAB2_01 ON TAB2 (PROD_ID, SALES_NO, SEQ);

 

SELECT /*+ LEADING(A) INDEX(A)  INDEX(B) USE_MERGE(B) */

       B.*, A.CHANNEL_ID AS  CHAN

  FROM TAB1 a, TAB2 b

 WHERE A.SALES_NO = B.SALES_NO

   AND A.PROD_ID = 22

   AND B.PROD_ID = 22  ;

 

---------------------------------------------------------------------------------------------------------

| Id  | Operation                     | Name        | Starts | A-Rows |   A-Time   | Buffers | Used-Mem |

---------------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT              |             |      1 |  17205 |00:00:00.22 |   17355 |          |

|   1 |  MERGE JOIN                   |             |      1 |  17205 |00:00:00.22 |   17355 |          |

|   2 |   TABLE ACCESS BY INDEX ROWID | TAB1        |      1 |   3441 |00:00:00.01 |      94 |          |

|*  3 |    INDEX RANGE SCAN           | IDX_TAB1_01 |      1 |   3441 |00:00:00.01 |      14 |          |

|*  4 |   SORT JOIN                   |             |   3441 |  17205 |00:00:00.16 |   17261 | 1054K (0)|

|   5 |    TABLE ACCESS BY INDEX ROWID| TAB2        |      1 |  17205 |00:00:00.11 |   17261 |          |

|*  6 |     INDEX RANGE SCAN          | IDX_TAB2_01 |      1 |  17205 |00:00:00.02 |      56 |          |

---------------------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   3 - access("A"."PROD_ID"=22)

   4 - access("A"."SALES_NO"="B"."SALES_NO")

       filter("A"."SALES_NO"="B"."SALES_NO")

   6 - access("B"."PROD_ID"=22)

 

건수가 적은 tab1을 선행집합으로 하여 실행하였다. 선행집합은 적절한 인덱스 덕분으로 Sort가 발생하지 않았다. 하지만 후행집합 tab2 17205건을 Sort하여 1054K PGA를 사용하였다. 이제 선행집합을 바꿔서 실행하여 Sort량이 같은지 검증해보자.

 

SELECT /*+ LEADING(B) INDEX(A)  INDEX(B) USE_MERGE(A) */

       B.*, A.CHANNEL_ID AS  CHAN

  FROM TAB1 a, TAB2 b

 WHERE A.SALES_NO = B.SALES_NO

   AND A.PROD_ID = 22

   AND B.PROD_ID = 22  ;

 

---------------------------------------------------------------------------------------------------------

| Id  | Operation                     | Name        | Starts | A-Rows |   A-Time   | Buffers | Used-Mem |

---------------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT              |             |      1 |  17205 |00:00:00.34 |   17354 |          |

|   1 |  MERGE JOIN                   |             |      1 |  17205 |00:00:00.34 |   17354 |          |

|   2 |   TABLE ACCESS BY INDEX ROWID | TAB2        |      1 |  17205 |00:00:00.15 |   17263 |          |

|*  3 |    INDEX RANGE SCAN           | IDX_TAB2_01 |      1 |  17205 |00:00:00.04 |      58 |          |

|*  4 |   SORT JOIN                   |             |  17205 |  17205 |00:00:00.08 |      91 |83968  (0)|

|   5 |    TABLE ACCESS BY INDEX ROWID| TAB1        |      1 |   3441 |00:00:00.01 |      91 |          |

|*  6 |     INDEX RANGE SCAN          | IDX_TAB1_01 |      1 |   3441 |00:00:00.01 |      12 |          |

---------------------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   3 - access("B"."PROD_ID"=22)

   4 - access("A"."SALES_NO"="B"."SALES_NO")

       filter("A"."SALES_NO"="B"."SALES_NO")

   6 - access("A"."PROD_ID"=22)

 

Sort Merge Join도 조인순서가 중요하다

선행집합을 tab2 로 바꾸어 실행하였다. 이번에는 tab1 3441건만 Sort하였으므로 PGA 83K 만 사용하였다. Tab2 Sort하는 경우는 PGA 1054K 나 사용하였으므로 12배 이상 차이가 난다. 다시 말해, 적절한 인덱스가 존재하는 경우는 Filtering 된 건수가 적은 집합을 후행집합으로 하는 것이 Sort의 부하를 줄일 수 있다.

 

하나는 안다. 하지만 둘은?

Sort의 부하를 12배 이상 줄였으므로 만족해서는 안 된다. Sort량이 극적으로 줄어도 속도는 오히려 떨어질 수 있다. 위의 실행계획 두 가지의 처리속도를 비교해보면 Sort량이 많은 것이 오히려 더 빠르다. 그 이유는 건수가 적은 집합을 후행으로 놓으면 선행집합이 건수가 많아지므로 Merge 시도횟수가 증가하기 때문이다. Sort의 부하와 Merge 횟수를 모두 고려해야 최적의 튜닝을 할 수 있다.

 

튜닝의 목적이 무엇인가?

예를 들면, 배치 SQL을 튜닝할 때 응답시간을 단축시키려면 작은 집합을 선행집합으로 하여 Merge 횟수를 줄여야 한다. 이와는 반대로 Sort의 부하가 커서 multi-pass가 나오는 경우라면 작은 집합을 후행집합으로 하여 Sort의 부하를 줄여야 한다. , 응답시간 단축이냐 아니면 Sort량을 감소가 목적이냐에 따라서 튜닝방법이 달라져야 한다.

 

이 테스트를 통하여 다음을 증명해 보았다.

 

조인순서에 상관없이 Sort량이 동일하다 ( X )

-->적절한 인덱스를 사용하는 경우, Sort량은 Join 순서에 의해 달라진다 ( O )

 

참고사항: 첫 번째 조건이 참이 되려면 두 가지 전제가 필요하다. 전체범위를 처리해야 하며, 양측집합이 Full Scan인 경우에 해당한다.

 

 

3. Merge Join은 부분범위처리가 안 될까?

 

SELECT *

  FROM (SELECT /*+ LEADING(B) INDEX(A)  INDEX(B) USE_MERGE(A) */

               B.*, A.CHANNEL_ID AS  CHAN

          FROM TAB1 a, TAB2 b

         WHERE A.SALES_NO = B.SALES_NO

           AND A.PROD_ID = 22

           AND B.PROD_ID = 22

         ORDER BY B.PROD_ID, B.SALES_NO, B.SEQ )

WHERE ROWNUM <= 1 ;

 

-----------------------------------------------------------------------------------------------------------

| Id  | Operation                       | Name        | Starts | A-Rows |   A-Time   | Buffers | Used-Mem |

-----------------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT                |             |      1 |      1 |00:00:00.02 |      95 |          |

|*  1 |  COUNT STOPKEY                  |             |      1 |      1 |00:00:00.02 |      95 |          |

|   2 |   VIEW                          |             |      1 |      1 |00:00:00.02 |      95 |          |

|   3 |    MERGE JOIN                   |             |      1 |      1 |00:00:00.02 |      95 |          |

|   4 |     TABLE ACCESS BY INDEX ROWID | TAB2        |      1 |      1 |00:00:00.01 |       4 |          |

|*  5 |      INDEX RANGE SCAN           | IDX_TAB2_01 |      1 |      1 |00:00:00.01 |       3 |          |

|*  6 |     SORT JOIN                   |             |      1 |      1 |00:00:00.02 |      91 |83968  (0)|

|   7 |      TABLE ACCESS BY INDEX ROWID| TAB1        |      1 |   3441 |00:00:00.02 |      91 |          |

|*  8 |       INDEX RANGE SCAN          | IDX_TAB1_01 |      1 |   3441 |00:00:00.01 |      12 |          |

-----------------------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   1 - filter(ROWNUM<=1)

   5 - access("B"."PROD_ID"=22)

   6 - access("A"."SALES_NO"="B"."SALES_NO")

       filter("A"."SALES_NO"="B"."SALES_NO")

   8 - access("A"."PROD_ID"=22)

 

 

단 한 건만 읽는다

인라인뷰 외부에서 ROWNUM <= 1 조건을 사용하자, 후행집합은 전체 건을 읽었지만 선행집합은 정확히 한 건만 읽었다. 선행집합이 전체범위로 처리되었다면 17205건을 읽었을 것이다. 즉 선행집합에 대해서는 완벽히 부분범위로 처리된다. 만약 후행집합이 몇 건 안 된다면 부분범위처리의 효율은 더욱 높아진다.

이제 Rownum 조건을 10, 100으로 변경해 가면서 실행계획을 관찰 해보자.

 

ROWNUM <= 10 조건일 때의 실행계획  

-----------------------------------------------------------------------------------------------------------

| Id  | Operation                       | Name        | Starts | A-Rows |   A-Time   | Buffers | Used-Mem |

-----------------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT                |             |      1 |     10 |00:00:00.02 |     105 |          |

|*  1 |  COUNT STOPKEY                  |             |      1 |     10 |00:00:00.02 |     105 |          |

|   2 |   VIEW                          |             |      1 |     10 |00:00:00.02 |     105 |          |

|   3 |    MERGE JOIN                   |             |      1 |     10 |00:00:00.02 |     105 |          |

|   4 |     TABLE ACCESS BY INDEX ROWID | TAB2        |      1 |     10 |00:00:00.01 |      14 |          |

|*  5 |      INDEX RANGE SCAN           | IDX_TAB2_01 |      1 |     10 |00:00:00.01 |       4 |          |

|*  6 |     SORT JOIN                   |             |     10 |     10 |00:00:00.02 |      91 |83968  (0)|

|   7 |      TABLE ACCESS BY INDEX ROWID| TAB1        |      1 |   3441 |00:00:00.02 |      91 |          |

|*  8 |       INDEX RANGE SCAN          | IDX_TAB1_01 |      1 |   3441 |00:00:00.01 |      12 |          |

-----------------------------------------------------------------------------------------------------------

 

ROWNUM <= 100 조건일 때의 실행계획 

-----------------------------------------------------------------------------------------------------------

| Id  | Operation                       | Name        | Starts | A-Rows |   A-Time   | Buffers | Used-Mem |

-----------------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT                |             |      1 |    100 |00:00:00.03 |     195 |          |

|*  1 |  COUNT STOPKEY                  |             |      1 |    100 |00:00:00.03 |     195 |          |

|   2 |   VIEW                          |             |      1 |    100 |00:00:00.03 |     195 |          |

|   3 |    MERGE JOIN                   |             |      1 |    100 |00:00:00.03 |     195 |          |

|   4 |     TABLE ACCESS BY INDEX ROWID | TAB2        |      1 |    100 |00:00:00.01 |     104 |          |

|*  5 |      INDEX RANGE SCAN           | IDX_TAB2_01 |      1 |    100 |00:00:00.01 |       4 |          |

|*  6 |     SORT JOIN                   |             |    100 |    100 |00:00:00.03 |      91 |83968  (0)|

|   7 |      TABLE ACCESS BY INDEX ROWID| TAB1        |      1 |   3441 |00:00:00.02 |      91 |          |

|*  8 |       INDEX RANGE SCAN          | IDX_TAB1_01 |      1 |   3441 |00:00:00.01 |      12 |          |

-----------------------------------------------------------------------------------------------------------

 

Rownum 조건을 10, 100으로 변경하자 tab2를 정확히 10, 100건만 읽는다. 도대체 누가 “Sort Merge Join은 부분범위처리가 안 된다라는 말을 한 것일까?

 

Sort Merge Join은 부분범위처리가 안 된다 ( X )

-->적절한 인덱스가 있다면 선행집합은 부분범위처리가 가능하다 ( O )

 

 

4. Full Scan을 하면 인덱스를 사용할 수 없으므로 항상 Sort 작업이 발생할까?

 

SELECT /*+ leading(s) full(p) full(s) use_merge(p) */

       s.*, p.prod_id

  FROM sales_t s, products p

 WHERE p.prod_id = 119

   AND p.prod_id = s.prod_id;

 

---------------------------------------------------------------------------------------------

| Id  | Operation            | Name     | Starts | A-Rows |   A-Time   | Buffers | Used-Mem |

---------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT     |          |      1 |  22189 |00:00:00.29 |    4450 |          |

|   1 |  MERGE JOIN CARTESIAN|          |      1 |  22189 |00:00:00.29 |    4450 |          |

|*  2 |   TABLE ACCESS FULL  | SALES_T  |      1 |  22189 |00:00:00.06 |    4443 |          |

|   3 |   BUFFER SORT        |          |  22189 |  22189 |00:00:00.07 |       7 | 2048  (0)|

|*  4 |    TABLE ACCESS FULL | PRODUCTS |      1 |      1 |00:00:00.01 |       7 |          |

---------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   2 - filter("S"."PROD_ID"=119)

   4 - filter("P"."PROD_ID"=119)

 

Sort Join이 사라진 이유

힌트를 주어 sales_t products 모두 full table scan을 발생시켰다. 그러자 product 테이블 쪽은 buffer sort가 존재하지만 sales_t 테이블 쪽은 Sort가 사라졌다. Sort가 사라질 수 있는 이유는 product 쪽에 unique 조건(prod_id = 119)에 의해서 집합이 항상 한 건임을 보장하기 때문이다. , 집합이 한 건뿐이므로 조인이 필요 없어지는 것이다. 바로 이것이 Sort Merge Join Cartesian Merge Join 으로 바뀔 수 있는 이유이다. 반대로 이야기하면, 위의 SQL에서 unique 조건이 없다면 Cartesian Merge Join buffer sort는 결코 발생하지 않는다.

 

Full Scan이 발생하면 인덱스를 사용할 수 없으므로 항상 Sort 작업을 동반한다 ( X )

-->Full Scan이 발생해도 Unique 조건이 들어오면 Sort Join Operation이 사라진다 ( O )

 

 

5. Sort Merge Join 대신에 Cartesian Merge Join이 나오면 조인조건이 빠진 악성 SQL일까?

 

위에서 Unique 조건 때문에 Sort Merge Join Cartesian Merge Join으로 바뀐다고 했다. 이 현상은 아주 바람 직한 것이다. 왜냐하면 불필요한 Sort를 없애버리기 때문이다. 따라서 Cartesian Merge Join이라고 해서 항상 실수로 조인을 하지 않은 악성 SQL은 아니다.

 

이번에는 Unique 인덱스를 사용하는 경우를 보자.

 

SELECT /*+ leading(p) full(s) use_merge(s) */

       s.*, p.prod_id

  FROM sales_t s, products p

 WHERE p.prod_id = 119

   AND p.prod_id = s.prod_id;

 

-------------------------------------------------------------------------------------

| Id  | Operation            | Name        | Starts | A-Rows |   A-Time   | Buffers |

-------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT     |             |      1 |  22189 |00:00:00.14 |    4444 |

|   1 |  MERGE JOIN CARTESIAN|             |      1 |  22189 |00:00:00.14 |    4444 |

|*  2 |   INDEX UNIQUE SCAN  | PRODUCTS_PK |      1 |      1 |00:00:00.01 |       1 |

|*  3 |   TABLE ACCESS FULL  | SALES_T     |      1 |  22189 |00:00:00.05 |    4443 |

-------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   2 - access("P"."PROD_ID"=119)

   3 - filter("S"."PROD_ID"=119)

 

Unique 인덱스를 사용하자 Sort가 사라졌고, 심지어 Buffer Sort도 사라졌다. 따라서 성능도 최적이 되었다. 그러므로 MERGE JOIN CARTESIAN 이라는 operation 만 보고 조인절이 빠졌다거나 악성 SQL 이라고 판단해서는 안 된다.

 

만약 조인 순서가 바뀌면 buffer sort가 나타나므로 주의해야 한다. 아래의 SQL을 보자.

 

SELECT /*+ leading(s) full(s) use_merge(p) */

       s.*, p.prod_id

  FROM sales_t s, products p

 WHERE p.prod_id = 119

   AND p.prod_id = s.prod_id;

 

------------------------------------------------------------------------------------------------

| Id  | Operation            | Name        | Starts | A-Rows |   A-Time   | Buffers | Used-Mem |

------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT     |             |      1 |  22189 |00:00:00.28 |    4444 |          |

|   1 |  MERGE JOIN CARTESIAN|             |      1 |  22189 |00:00:00.28 |    4444 |          |

|*  2 |   TABLE ACCESS FULL  | SALES_T     |      1 |  22189 |00:00:00.06 |    4443 |          |

|   3 |   BUFFER SORT        |             |  22189 |  22189 |00:00:00.07 |       1 | 2048  (0)|

|*  4 |    INDEX UNIQUE SCAN | PRODUCTS_PK |      1 |      1 |00:00:00.01 |       1 |          |

------------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   2 - filter("S"."PROD_ID"=119)

   4 - access("P"."PROD_ID"=119)

 

카테시안 조인도 순서대로 실행해야 한다

Buffer sort 뿐만 아니라 merge 횟수도 22189번이나 시도되어 성능이 저하되었다. 위의 실행계획에서 볼 수 있듯이 CARTESIAN MERGE JOIN 도 조인의 순서가 중요하므로 실행계획을 유심히 살펴야 한다.

 

카테시안 조인의 발생조건

Unique 컬럼에 조건이 Equal로 들어오면 옵티마이져가 성능향상을 위해서 조인절을 삭제한다. 만약 Unique 컬럼이라도 Equal 조건이 아니라 Range 조건이라면 위의 CARTESIAN MERGE JOIN 실행계획이 나타나지 않는다. 아래의 SQL이 그것을 증명한다.

 

SELECT /*+ leading(s) full(s) use_merge(p) */

       s.*, p.prod_id

  FROM sales_t s, products p

 WHERE p.prod_id >= 119

   AND p.prod_id < 120

   AND p.prod_id = s.prod_id;

  

-----------------------------------------------------------------------------------------------

| Id  | Operation           | Name        | Starts | A-Rows |   A-Time   | Buffers | Used-Mem |

-----------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT    |             |      1 |  22189 |00:00:00.35 |    4441 |          |

|   1 |  MERGE JOIN         |             |      1 |  22189 |00:00:00.35 |    4441 |          |

|   2 |   SORT JOIN         |             |      1 |  22189 |00:00:00.16 |    4440 | 1117K (0)|

|*  3 |    TABLE ACCESS FULL| SALES_T     |      1 |  22189 |00:00:00.06 |    4440 |          |

|*  4 |   SORT JOIN         |             |  22189 |  22189 |00:00:00.08 |       1 | 2048  (0)|

|*  5 |    INDEX RANGE SCAN | PRODUCTS_PK |      1 |      1 |00:00:00.01 |       1 |          |

-----------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   3 - filter(("S"."PROD_ID">=119 AND "S"."PROD_ID"<120))

   4 - access("P"."PROD_ID"="S"."PROD_ID")

       filter("P"."PROD_ID"="S"."PROD_ID")

   5 - access("P"."PROD_ID">=119 AND "P"."PROD_ID"<120)

 

카테시안 조인이 더 빠르다

비록 SQL의 결과는 같지만 sort join operation에 의해서 PGA를 소모한다. where절의 prod_idequal 조건이냐 아니면 Range조건이냐에 따라서 성능이 좌우된다. , 성능이 나쁜 Sort Merge Join으로 풀리느냐 아니면, 추가적인 Sort가 없어서 성능이 우수한 CARTESIAN MERGE JOIN으로 풀리느냐는 where 조건에 따라 좌우된다. Unique 컬럼에 = 조건인지 아닌지에 따라 Sort의 부하가 좌우되는 것이다.

 

만약 Unique 컬럼에 = 조건이 들어오면 옵티마이져가 hash join을 선택하는 경우가 있을까?

 

SELECT /*+ leading(p) use_hash(s) */

       s.*, p.prod_id

  FROM sales_t s, products p

 WHERE p.prod_id = 119

   AND p.prod_id = s.prod_id;

 

------------------------------------------------------------------------------------

| Id  | Operation          | Name        | Starts |  A-Rows |   A-Time   | Buffers |

------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT   |             |      1 |   22189 |00:00:00.10 |    4444 |

|   1 |  NESTED LOOPS      |             |      1 |   22189 |00:00:00.10 |    4444 |

|*  2 |   INDEX UNIQUE SCAN| PRODUCTS_PK |      1 |       1 |00:00:00.01 |       1 |

|*  3 |   TABLE ACCESS FULL| SALES_T     |      1 |   22189 |00:00:00.06 |    4443 |

------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   2 - access("P"."PROD_ID"=119)

   3 - filter("S"."PROD_ID"=119)

 

Hash join은 실행할 수 없다

Unique 컬럼에 = 조건이 들어오면 결코 hash join을 선택하지 않는다. 강제로 힌트를 사용해도 merge join이나 nested loop join을 선택한다. 왜냐하면 Hash Join은 반드시 Equal Join이 필요한데, 조인절이 삭제되어 hash join이 발생될 수 없기 때문이다.

 

Sort Merge Join 대신 Cartesian Merge Join이 나오면 조인조건이 빠진 악성 SQL이다 ( X )

-->Unique 조건이 Equal로 들어오고 같은 컬럼으로 조인하면 옵티마이저는 성능향상을 위해 조인절을 삭제한다 ( O )

 

 

6. 조인컬럼 기준으로 Sort되므로 Order by절과 조인 컬럼이 일치할 때만 Sort가 발생되지 않는다. 정말 그럴까?

 

Sort의 기준이 조인컬럼이라는 말이 항상 참일까? 아래의 SQL을 보자.

 

SELECT /*+ LEADING(B) FULL(A)  FULL(B) USE_MERGE(A) */

       B.*, A.CHANNEL_ID AS  CHAN

  FROM TAB1 a, TAB2 b

 WHERE A.SALES_NO = B.SALES_NO

   AND A.PROD_ID = 22

   AND B.PROD_ID = 22

 ORDER BY B.PROD_ID, B.SALES_NO, B.SEQ ;

 

-----------------------------------------------------------------------------------------

| Id  | Operation            | Name | Starts | A-Rows |   A-Time   | Buffers | Used-Mem |

-----------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT     |      |      1 |  17205 |00:00:03.34 |   32327 |          |

|   1 |  SORT ORDER BY       |      |      1 |  17205 |00:00:03.34 |   32327 | 1180K (0)|

|   2 |   MERGE JOIN         |      |      1 |  17205 |00:00:03.29 |   32327 |          |

|   3 |    SORT JOIN         |      |      1 |  17205 |00:00:02.62 |   27257 | 1054K (0)|

|*  4 |     TABLE ACCESS FULL| TAB2 |      1 |  17205 |00:00:02.53 |   27257 |          |

|*  5 |    SORT JOIN         |      |  17205 |  17205 |00:00:00.59 |    5070 |83968  (0)|

|*  6 |     TABLE ACCESS FULL| TAB1 |      1 |   3441 |00:00:00.52 |    5070 |          |

-----------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   4 - filter("B"."PROD_ID"=22)

   5 - access("A"."SALES_NO"="B"."SALES_NO")

       filter("A"."SALES_NO"="B"."SALES_NO")

   6 - filter("A"."PROD_ID"=22)

 

Order by 절에 조인컬럼(SALES_NO) 이외의 것들이 있으므로 SORT ORDER BY operation이 추가로 발생하여 성능이 저하되었다. 이제 조인컬럼으로만 order by를 해보자.

 

 

SELECT /*+ LEADING(B) FULL(A)  FULL(B) USE_MERGE(A) */

       B.*, A.CHANNEL_ID AS  CHAN

  FROM TAB1 a, TAB2 b

 WHERE A.SALES_NO = B.SALES_NO

   AND A.PROD_ID = 22

   AND B.PROD_ID = 22

 ORDER BY B.SALES_NO;

 

----------------------------------------------------------------------------------------

| Id  | Operation           | Name | Starts | A-Rows |   A-Time   | Buffers | Used-Mem |

----------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT    |      |      1 |  17205 |00:00:02.69 |   32331 |          |

|   1 |  MERGE JOIN         |      |      1 |  17205 |00:00:02.69 |   32331 |          |

|   2 |   SORT JOIN         |      |      1 |  17205 |00:00:02.49 |   27257 | 1054K (0)|

|*  3 |    TABLE ACCESS FULL| TAB2 |      1 |  17205 |00:00:02.41 |   27257 |          |

|*  4 |   SORT JOIN         |      |  17205 |  17205 |00:00:00.11 |    5074 |83968  (0)|

|*  5 |    TABLE ACCESS FULL| TAB1 |      1 |   3441 |00:00:00.04 |    5074 |          |

----------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   3 - filter("B"."PROD_ID"=22)

   4 - access("A"."SALES_NO"="B"."SALES_NO")

       filter("A"."SALES_NO"="B"."SALES_NO")

   5 - filter("A"."PROD_ID"=22)

 

참고사항으로 알아두자. Order by절에 prod_id가 추가되어도 위의 실행계획은 같다. 왜냐하면 prod_id는 상수 22로 고정되어 있으므로 Sort가 필요 없기 때문이다.

 

조인컬럼으로 sort를 하니 SORT ORDER BY operation이 사라져 버렸다. 얼핏 보면 Sort의 기준은 조인컬럼인 것처럼 보인다. 하지만 이 조건을 항상 만족하려면 Full Scan을 해야 한다는 전제조건이 붙어야 한다. 그러면 이제 Full Scan 대신에 인덱스를 사용해보자.

 

 

SELECT /*+ LEADING(A) INDEX(A)  INDEX(B) USE_MERGE(B) */

       B.*, A.CHANNEL_ID AS  CHAN

  FROM TAB1 a, TAB2 b

 WHERE A.SALES_NO = B.SALES_NO

   AND A.PROD_ID = 22

   AND B.PROD_ID = 22

 ORDER BY B.PROD_ID, B.SALES_NO, B.SEQ ;

 

----------------------------------------------------------------------------------------------------------

| Id  | Operation                      | Name        | Starts | A-Rows |   A-Time   | Buffers | Used-Mem |

----------------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT               |             |      1 |  17205 |00:00:02.21 |   17352 |          |

|   1 |  SORT ORDER BY                 |             |      1 |  17205 |00:00:02.21 |   17352 | 1117K (0)|

|   2 |   MERGE JOIN                   |             |      1 |  17205 |00:00:02.16 |   17352 |          |

|   3 |    TABLE ACCESS BY INDEX ROWID | TAB1        |      1 |   3441 |00:00:00.31 |      91 |          |

|*  4 |     INDEX RANGE SCAN           | IDX_TAB1_01 |      1 |   3441 |00:00:00.05 |      12 |          |

|*  5 |    SORT JOIN                   |             |   3441 |  17205 |00:00:01.80 |   17261 | 1054K (0)|

|   6 |     TABLE ACCESS BY INDEX ROWID| TAB2        |      1 |  17205 |00:00:01.75 |   17261 |          |

|*  7 |      INDEX RANGE SCAN          | IDX_TAB2_01 |      1 |  17205 |00:00:00.06 |      56 |          |

----------------------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   4 - access("A"."PROD_ID"=22)

   5 - access("A"."SALES_NO"="B"."SALES_NO")

       filter("A"."SALES_NO"="B"."SALES_NO")

   7 - access("B"."PROD_ID"=22)

 

인덱스를 사용했음에도 추가적인 Sort가 발생하는 이유

이런! 인덱스를 사용했지만, SORT ORDER BY가 발생하였다. 왜 그럴까? 인덱스를 사용할 때 Sort의 기준은 선행집합의 인덱스 컬럼이다. , 선행집합의 인덱스컬럼이 order by절에 나온다면 Sort가 발생하지 않는다. 위의 SQL에서 선행집합의 인덱스컬럼은 PROD_ID + SALES_NO 이다. 따라서 B.SEQ 컬럼 때문에 Sort가 발생한 것이다. 그러면 이제 Sort를 없애기 위하여 선행집합을 바꿔보자.

 

SELECT /*+ LEADING(B) INDEX(A)  INDEX(B) USE_MERGE(A) */

       B.*, A.CHANNEL_ID AS  CHAN

  FROM TAB1 a, TAB2 b

 WHERE A.SALES_NO = B.SALES_NO

   AND A.PROD_ID = 22

   AND B.PROD_ID = 22

 ORDER BY B.PROD_ID, B.SALES_NO, B.SEQ ;

 

---------------------------------------------------------------------------------------------------------

| Id  | Operation                     | Name        | Starts | A-Rows |   A-Time   | Buffers | Used-Mem |

---------------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT              |             |      1 |  17205 |00:00:03.09 |   17387 |          |

|   1 |  MERGE JOIN                   |             |      1 |  17205 |00:00:03.09 |   17387 |          |

|   2 |   TABLE ACCESS BY INDEX ROWID | TAB2        |      1 |  17205 |00:00:02.58 |   17296 |          |

|*  3 |    INDEX RANGE SCAN           | IDX_TAB2_01 |      1 |  17205 |00:00:00.14 |      91 |          |

|*  4 |   SORT JOIN                   |             |  17205 |  17205 |00:00:00.39 |      91 |83968  (0)|

|   5 |    TABLE ACCESS BY INDEX ROWID| TAB1        |      1 |   3441 |00:00:00.32 |      91 |          |

|*  6 |     INDEX RANGE SCAN          | IDX_TAB1_01 |      1 |   3441 |00:00:00.06 |      12 |          |

---------------------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   3 - access("B"."PROD_ID"=22)

   4 - access("A"."SALES_NO"="B"."SALES_NO")

       filter("A"."SALES_NO"="B"."SALES_NO")

   6 - access("A"."PROD_ID"=22)

 

선행집합의 인덱스 컬럼과 Order By절의 컬럼이 동일하다. 그리고 인덱스와 Order by절의 컬럼순서도 동일하다. 이 두 가지 조건을 만족하므로 추가적인 SORT ORDER BY operation이 발생하지 않았다. Order By 뿐만 아니라 Group By도 마찬가지이다. 이제 Order by Group By를 동시에 사용해보자.

 

SELECT /*+ LEADING(B) INDEX(A)  INDEX(B) NO_PLACE_GROUP_BY USE_MERGE(A) */

       B.PROD_ID, B.SALES_NO, COUNT(*)

  FROM TAB1 a, TAB2 b

 WHERE A.SALES_NO = B.SALES_NO

   AND A.PROD_ID = 22

   AND B.PROD_ID = 22

 GROUP BY B.PROD_ID, B.SALES_NO, B.SEQ

ORDER BY B.PROD_ID, B.SALES_NO ;

 

------------------------------------------------------------------------------------------------

| Id  | Operation            | Name        | Starts | A-Rows |   A-Time   | Buffers | Used-Mem |

------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT     |             |      1 |  17205 |00:00:00.30 |      70 |          |

|   1 |  SORT GROUP BY NOSORT|             |      1 |  17205 |00:00:00.30 |      70 |          |

|   2 |   MERGE JOIN         |             |      1 |  17205 |00:00:00.25 |      70 |          |

|*  3 |    INDEX RANGE SCAN  | IDX_TAB2_01 |      1 |  17205 |00:00:00.02 |      58 |          |

|*  4 |    SORT JOIN         |             |  17205 |  17205 |00:00:00.08 |      12 |57344  (0)|

|*  5 |     INDEX RANGE SCAN | IDX_TAB1_01 |      1 |   3441 |00:00:00.01 |      12 |          |

------------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   3 - access("B"."PROD_ID"=22)

   4 - access("A"."SALES_NO"="B"."SALES_NO")

       filter("A"."SALES_NO"="B"."SALES_NO")

   5 - access("A"."PROD_ID"=22)

 

Order By/Group By절의 컬럼이 모두 선행집합의 인덱스 컬럼과 순서가 같으므로 추가적인 Sort가 전혀 발생하지 않았다. 따라서 다음과 같은 결론을 낼 수 있다.

 

조인컬럼 기준으로 Sort되므로 Order by절과 조인 컬럼이 일치해야만 Sort가 발생하지 않는다. ( X )

-->Full table scan일 때는 조인컬럼 기준으로 sort 되는 것이 옳다. 하지만, index를 사용한다면 조인컬럼 뿐만 아니라, 선행집합의 인덱스 컬럼과 order by/group by절을 일치시켜도 Sort가 발생하지 않는다 ( O )

 

 

결론

6가지의 오만과 편견 중에 하나라도 얻은 것이 있다면 성공이다. 다시 한번 여섯 가지를 정리하기 바란다.

 

양쪽 집합이 Full Table Scan을 사용하면 조인순서에 상관없이 일량이 동일하므로 처리시간도 동일하다 ( X )

-->일량은 동일하더라도 Merge 횟수가 달라지면 처리시간이 달라진다  ( O )

 

조인순서에 상관없이 Sort량이 동일하다 ( X )

-->적절한 인덱스를 사용하는 경우, Sort량은 Join 순서에 의해 달라진다 ( O )

 

Sort Merge Join은 부분범위처리가 안 된다 ( X )

-->적절한 인덱스가 있다면 선행집합은 부분범위처리가 가능하다 ( O )

 

Full Scan이 발생하면 인덱스를 사용할 수 없으므로 항상 Sort 작업을 동반한다 ( X )

-->Full Scan이 발생해도 Unique 조건이 들어오면 Sort Join Operation이 사라진다 ( O )

 

Sort Merge Join 대신 Cartesian Merge Join이 나오면 조인조건이 빠진 악성 SQL이다 ( X )

-->Unique 조건이 Equal로 들어오고 같은 컬럼으로 조인하면 옵티마이저는 성능향상을 위해 조인절을 삭제한다 ( O )

 

조인컬럼 기준으로 Sort되므로 Order by절과 조인 컬럼이 일치해야만 Sort가 발생하지 않는다. ( X )

-->Full table scan일 때는 조인컬럼 기준으로 sort 되는 것이 옳다. 하지만, index를 사용한다면 조인컬럼 뿐만 아니라, 선행집합의 인덱스 컬럼과 order by/group by절을 일치시켜도 Sort가 발생하지 않는다 ( O )


PS
요즘 워낙 바빠서 예전에 미리 글을 써놓지 않았더라면 글을 하나도 올리지 못할뻔 하였다. 
저작자 표시 비영리 동일 조건 변경 허락
신고
Posted by extremedb

댓글을 달아 주세요

  1. 라튜니 2011.04.28 10:17 신고  댓글주소  수정/삭제  댓글쓰기

    병풍에 관한 포스팅 이후 다음 포스팅을 오래 기다렸는데~ 정말 좋은 내용을 포스팅 해주셨네요. 항상 좋은 내용 감사합니다. 특히 Cartesian Merge Join에 관한 내용은 새롭게 안 내용이네요. 이번 포스팅을 계기로 Sort Merge Join에 대해 정리할 수 있는 계기가 되었습니다. 감사합니다.

    • Favicon of http://scidb.tistory.com BlogIcon extremedb 2011.04.29 09:19 신고  댓글주소  수정/삭제

      글을 미리 써놓은 것이 다행이라고 생각합니다.^^
      한가지 걱정은 어떤 주제에 대해 정리하려다 보니 글이 너무 길어진다는 단점입니다. 위의 글도 14페이지나 됩니다. 블로그에 올리기에는 너무.....
      블로그 글이라기보다는 논문이 되버린 느낌 이네요

  2. Favicon of http://1ststreet.tistory.com BlogIcon SITD 2011.04.29 15:08 신고  댓글주소  수정/삭제  댓글쓰기

    카르테시안이란 실행계획만 봐도 경기를 일으켜야 한다고 생각했는데, 역시 오라클이 더 빠른 걸 찾아가는 거였군요, 좋은 글 감사드림니다 ^^

    참, 3번의 경우 rownum 조건에 의해 1건만 가져온 데이터가 후행 테이블에 없을 땐 당연히 다음 데이터를 가져와서 후행 테이블과 비교를 하겠죠?
    후행은 소트조인의 형태를, 그리고 선행에서 후행을 찾는 방식은 네스티드 루프랑 비슷한 형식이 되지 않을까 싶어서요.

    • Favicon of http://scidb.tistory.com BlogIcon extremedb 2011.04.29 15:53 신고  댓글주소  수정/삭제

      SITD님이 말씀하신대로 입니다.
      선행집합의 동작은 nested loop join과 같습니다.
      조인 두번중에 한번을 실패하게 만들어서 테스트 해보시면 정확히 알 수 있습니다.
      아래 조건을 인라인뷰 안에 넣으시고 rownum <= 100건으로 테스트 하시면 merge 횟수가 정확히 두배인것을 관찰 하실수 있을 겁니다. 한번 해보세요.

      ...생략
      AND MOD(A.SALES_NO,2) = 1 --> 추가조건
      ORDER BY B.PROD_ID, B.SALES_NO, B.SEQ )
      WHERE ROWNUM <= 100 ;

    • Favicon of http://1ststreet.tistory.com BlogIcon SITD 2011.05.03 14:24 신고  댓글주소  수정/삭제

      DB 생성 권한이 없어서, 집에가서 한번 해봐야겠네요 ^^
      답변 감사드립니다.

  3. feelie 2011.05.03 22:26 신고  댓글주소  수정/삭제  댓글쓰기

    sort merge join 의 새로운 느낌입니다. 그래서일까요 이해하기가 어렵습니다.
    sort merge join은 각 테이블에 대하여 입력조건으로 데이터를 조회하여 조인컬럼으로 각각 sort을 하고
    하나씩 비교하는 방식인것으로 알고 있습니다.
    이런 개념에 사로잡혀있어서 그런가요? 아님 제가 sort merge join을 잘못 이해하고 있는건가요?
    1. 일량은 동일하더라도 Merge 횟수가 달라지면 처리시간이 달라진다
    => Merge의 횟수는 동일할것 같고,
    2. 적절한 인덱스를 사용하는 경우, Sort량은 Join 순서에 의해 달라진다
    => 개별 처리가되니 sort 량은 동일할것 같습니다.
    참 어렵습니다..

    • Favicon of http://scidb.tistory.com BlogIcon extremedb 2011.05.04 11:39 신고  댓글주소  수정/삭제

      승필님 반갑습니다.
      Sort Merge Join의 두 집합이 독립적으로 처리되므로 조인순서는 아무런 상관이 없다는 미신을 깨기 위해서 이글이 작성되었습니다.

      1.Merge 횟수는 선행집합이 filter 된 후의 건수에 비례합니다. 따라서 작은 집합을 선행으로 두면 merge 횟수가 감소하므로 성능이 향상됩니다. 이 성격은 nested loop join과 유사합니다.

      2.Sort를 방지하는 적절한 인덱스가 있으면 후행집합을 작은것으로 선택하면 sort가 최소화 됩니다. 왜냐하면 인덱스가 있으므로 선행집합은 sort를 전혀 하지 않기 때문입니다. sort량을 튜닝하려면 1번과는 반대로 후행집합을 작은 것으로 해야합니다.

      감사합니다.

    • feelie 2011.05.19 09:15 신고  댓글주소  수정/삭제

      볼때마다 생소하니 아직도 너무많이 부족한것 같습니다.
      2. 조인순서에 상관없이 Sort량이 동일할까 ?
      에서 후행테이블은 인덱스을 사용했지만
      소트를 수행한다.
      소트머지의 특징인가요??
      후행테이블도 인덱스를 사용하였으므로 소트가 필요없을것 같은데요..

  4. salvationism 2011.05.09 14:27 신고  댓글주소  수정/삭제  댓글쓰기

    테스트할 수 있도록 스크립도 같이 올려 주셔서 도움이 많이 되고 있습니다.
    보통 정성으로는 힘든 것인데.. ㅎㅎ
    열정 본 받고 싶습니다. ^^

  5. salvationism 2011.05.09 17:19 신고  댓글주소  수정/삭제  댓글쓰기

    5번에서 Unique 컬럼에 = 조건이 들어오면 결코 hash join을 선택하지 않는다고 하셨는데
    다음과 같이 Hash 조인으로 풀립니다.
    왜 그런지요???
    SH 스키마 테이블 입니다.

    SELECT /*+ leading(p) use_hash(s) */
    s.*, p.prod_id
    FROM sales_t s, products p
    WHERE p.prod_id = 119
    AND p.prod_id = s.prod_id;

    -----------------------------------------------------------------------------------------------------------------------
    | Id | Operation | Name | Starts | A-Rows | A-Time | Buffers | Reads | OMem | 1Mem | Used-Mem |
    -----------------------------------------------------------------------------------------------------------------------
    | 0 | SELECT STATEMENT | | 1 | 106 |00:00:00.11 | 130 | 148 | | | |
    |* 1 | HASH JOIN | | 1 | 106 |00:00:00.11 | 130 | 148 | 1036K| 1036K| 348K (0)|
    |* 2 | INDEX UNIQUE SCAN| PRODUCTS_PK | 1 | 1 |00:00:00.01 | 1 | 0 | | | |
    |* 3 | TABLE ACCESS FULL| SALES_T | 1 | 106 |00:00:00.10 | 129 | 148 | | | |
    -----------------------------------------------------------------------------------------------------------------------

    Predicate Information (identified by operation id):
    ---------------------------------------------------
    1 - access("P"."PROD_ID"="S"."PROD_ID";)
    2 - access("P"."PROD_ID"=119)
    3 - filter("S"."PROD_ID"=119



    *************************
    Join Elimination (JE)
    *************************
    SQL:******* UNPARSED QUERY IS *******
    SELECT /*+ LEADING ("P";) USE_HASH ("S";) */ "S"."PROD_ID" "PROD_ID","S"."CUST_ID" "CUST_ID","S"."TIME_ID" "TIME_ID","S"."CHANNEL_ID" "CHANNEL_ID","S"."PROMO_ID" "PROMO_ID","S"."QUANTITY_SOLD" "QUANTITY_SOLD","S"."AMOUNT_SOLD" "AMOUNT_SOLD","P"."PROD_ID" "PROD_ID" FROM "SH"."SALES_T" "S","SH"."PRODUCTS" "P" WHERE "P"."PROD_ID"=119 AND "P"."PROD_ID"="S"."PROD_ID"
    SQL:******* UNPARSED QUERY IS *******
    SELECT /*+ LEADING ("P";) USE_HASH ("S";) */ "S"."PROD_ID" "PROD_ID","S"."CUST_ID" "CUST_ID","S"."TIME_ID" "TIME_ID","S"."CHANNEL_ID" "CHANNEL_ID","S"."PROMO_ID" "PROMO_ID","S"."QUANTITY_SOLD" "QUANTITY_SOLD","S"."AMOUNT_SOLD" "AMOUNT_SOLD","P"."PROD_ID" "PROD_ID" FROM "SH"."SALES_T" "S","SH"."PRODUCTS" "P" WHERE "P"."PROD_ID"=119 AND "P"."PROD_ID"="S"."PROD_ID"
    Query block SEL$1 (#0) unchanged
    PM: Considering predicate move-around in query block SEL$1 (#0)
    **************************
    Predicate Move-Around (PM)
    **************************
    PM: PM bypassed: Outer query contains no views.
    PM: PM bypassed: Outer query contains no views.
    query block SEL$1 (#0) unchanged
    FPD: Considering simple filter push in query block SEL$1 (#0)
    "P"."PROD_ID"=119 AND "P"."PROD_ID"="S"."PROD_ID"
    try to generate transitive predicate from check constraints for query block SEL$1 (#0)
    finally: "P"."PROD_ID"=119 AND "P"."PROD_ID"="S"."PROD_ID" AND "S"."PROD_ID"=119

    FPD: transitive predicates are generated in query block SEL$1 (#0)
    "P"."PROD_ID"=119 AND "P"."PROD_ID"="S"."PROD_ID" AND "S"."PROD_ID"=119
    apadrv-start sqlid=14344755796783354000
    :
    call(in-use=26684, alloc=32736), compile(in-use=61628, alloc=64696), execution(in-use=2024, alloc=4060)

    • Favicon of http://scidb.tistory.com BlogIcon extremedb 2011.05.13 00:54 신고  댓글주소  수정/삭제

      equal 조인조건이 삭제되지 않아서 hash join이 가능한 것입니다.

      products 테이블이 문제인것 같습니다. pk constraint가 valid 하지 않습니다. 아래처럼 products_t 테이블을 만들고 새로 테스트 해보시기 바랍니다. 그럼 카테시안 조인이 발생할 것입니다.

      create table sh.products_t as select * from sh.products;

      ALTER TABLE SH.PRODUCTS_T ADD CONSTRAINT PRODUCTS_T_PK PRIMARY KEY (PROD_ID) USING INDEX;



      SELECT /*+ leading(s) full(p) full(s) use_merge(p) */
      s.*, p.prod_id
      FROM sales_t s, products_t p
      WHERE p.prod_id = 119
      AND p.prod_id = s.prod_id;

      SELECT /*+ leading(p) use_hash(s) */
      s.*, p.prod_id
      FROM sales_t s, products_t p
      WHERE p.prod_id = 119
      AND p.prod_id = s.prod_id;

      감사합니다.

  6. salvationism 2011.05.09 17:29 신고  댓글주소  수정/삭제  댓글쓰기

    4번 테스트에서 같은 버전인데 결과가 좀 다르게 나오네요.
    글 올리신 것처럼 발생하려면 JE만 발생해야 할거 같은데 FPD로 인해 join predicate가 그대로 있는거 같습니다.
    동일한 Unique 조건인데 왜 그런지 이해가 잘 안가네요.


    SQL> select * from v$version;

    BANNER
    --------------------------------------------------------------------------------
    Oracle Database 11g Enterprise Edition Release 11.2.0.1.0 - Production
    PL/SQL Release 11.2.0.1.0 - Production
    CORE 11.2.0.1.0 Production
    TNS for 32-bit Windows: Version 11.2.0.1.0 - Production
    NLSRTL Version 11.2.0.1.0 - Production


    SELECT /*+ leading(s) full(p) full(s) use_merge(p) */
    s.*, p.prod_id
    FROM sales_t s, products p
    WHERE p.prod_id = 119
    AND p.prod_id = s.prod_id;

    ---------------------------------------------------------------------------------------------------------------------
    | Id | Operation | Name | Starts | A-Rows | A-Time | Buffers | Reads | OMem | 1Mem | Used-Mem |
    ---------------------------------------------------------------------------------------------------------------------
    | 0 | SELECT STATEMENT | | 1 | 101 |00:00:00.05 | 127 | 151 | | | |
    | 1 | MERGE JOIN | | 1 | 101 |00:00:00.05 | 127 | 151 | | | |
    |* 2 | TABLE ACCESS FULL | SALES_T | 1 | 101 |00:00:00.03 | 123 | 148 | | | |
    |* 3 | SORT JOIN | | 101 | 101 |00:00:00.02 | 4 | 3 | 73728 | 73728 | |
    |* 4 | TABLE ACCESS FULL| PRODUCTS | 1 | 1 |00:00:00.01 | 4 | 3 | | | |
    ---------------------------------------------------------------------------------------------------------------------

    Predicate Information (identified by operation id):
    ---------------------------------------------------
    2 - filter("S"."PROD_ID"=119)
    3 - access("P"."PROD_ID"="S"."PROD_ID";)
    filter("P"."PROD_ID"="S"."PROD_ID";)
    4 - filter("P"."PROD_ID"=119)

    (10053 TRACE)
    *************************
    Join Elimination (JE)
    *************************
    SQL:******* UNPARSED QUERY IS *******
    SELECT /*+ LEADING ("S";) USE_MERGE ("P";) FULL ("P";) FULL ("S";) */ "S"."PROD_ID" "PROD_ID","S"."CUST_ID" "CUST_ID","S"."TIME_ID" "TIME_ID","S"."CHANNEL_ID" "CHANNEL_ID","S"."PROMO_ID" "PROMO_ID","S"."QUANTITY_SOLD" "QUANTITY_SOLD","S"."AMOUNT_SOLD" "AMOUNT_SOLD","P"."PROD_ID" "PROD_ID" FROM "SH"."SALES_T" "S","SH"."PRODUCTS" "P" WHERE "P"."PROD_ID"=119 AND "P"."PROD_ID"="S"."PROD_ID"
    SQL:******* UNPARSED QUERY IS *******
    SELECT /*+ LEADING ("S";) USE_MERGE ("P";) FULL ("P";) FULL ("S";) */ "S"."PROD_ID" "PROD_ID","S"."CUST_ID" "CUST_ID","S"."TIME_ID" "TIME_ID","S"."CHANNEL_ID" "CHANNEL_ID","S"."PROMO_ID" "PROMO_ID","S"."QUANTITY_SOLD" "QUANTITY_SOLD","S"."AMOUNT_SOLD" "AMOUNT_SOLD","P"."PROD_ID" "PROD_ID" FROM "SH"."SALES_T" "S","SH"."PRODUCTS" "P" WHERE "P"."PROD_ID"=119 AND "P"."PROD_ID"="S"."PROD_ID"
    Query block SEL$1 (#0) unchanged
    PM: Considering predicate move-around in query block SEL$1 (#0)

    **************************
    Predicate Move-Around (PM)
    *************************
    PM: PM bypassed: Outer query contains no views.
    PM: PM bypassed: Outer query contains no views.
    query block SEL$1 (#0) unchanged
    FPD: Considering simple filter push in query block SEL$1 (#0)
    "P"."PROD_ID"=119 AND "P"."PROD_ID"="S"."PROD_ID"
    try to generate transitive predicate from check constraints for query block SEL$1 (#0)
    finally: "P"."PROD_ID"=119 AND "P"."PROD_ID"="S"."PROD_ID" AND "S"."PROD_ID"=119

    FPD: transitive predicates are generated in query block SEL$1 (#0)
    "P"."PROD_ID"=119 AND "P"."PROD_ID"="S"."PROD_ID" AND "S"."PROD_ID"=119

영화 다이하드 4.0을 보면 파이어 세일이라는 용어가 나온다. 이 용어는 3단계의 해킹과 크래킹 과정을 의미한다. 그 과정을 통해 가공할 만한 전상장애를 일으켜 국가를 붕괴시켜버리는 것이다. 1단계는 교통기관 시스템 마비, 2단계는 금융·통신 전산 장애, 3단계는 가스·수도·전기·원자력 시스템을 점령하는 것이다. 모든 것이 컴퓨터 속의 소프트웨어로 컨트롤 되고 있으므로 위의 3단계와 같은 전산장애만 일으킨다면 국가가 무너지는 것은 불을 보듯 뻔한 것이다.

 

국가가 아니라 당신이 위험하다
현실에서의 전산장애는 영화처럼 1,2,3 단계가 동시에 발생하지는 않으므로 국가가 아니라 개인과 기업을 위협한다. 현실에서 실제로 발생하는 전산장애를 생각해보자. 오늘이 만기일이라고 가정하자. 오후 4시에 송금을 하려고 했는데 은행에 전산장애가 발행해 송금이 불가능 하다면 기업이 부도가 날 수 있고 개인이라면 신용불량자가 될 수 있다. 이로 인해 부도난 기업의 CEO는 자살할 수도 있다. 30분의 전산장애로 기업과 개인의 운명이 바뀔 수 있는 것이다.
 
늑장 대응을 도마 위로 올려보자
의도적인 해킹과 크래킹 등을 통한 전산장애는 보안 솔루션을 도입하면 전산장애를 최소화 할 수는 있다. 하지만 전산장애를 완벽히 막을 수는 없다. 왜냐하면 해킹뿐 아니라 자연재해, 인재(사람의 실수)등은 예고되지 않을뿐더러, 막기도 힘들다. 따라서 전산장애 발생의 확률을 최대한 낮추는 것과 전산장애를 만났을 때 빨리 대처하는 것이 최선이다. 전산장애를 만났을 때 빨리 해결해야만 당신의 피해가 최소화되는 것이다. 그런데 많은 기업에서는 왜 전산장애에 늑장 대응을 하는 것일까? 오늘은 이 부분을 다루려고 한다.


전산 장애를 해결하는데 시간이 오래 걸리는 이유는 장애가 발생했을 때 신속히 전산 담당자들에게 알리는 경보 시스템이 없다거나, 장애 복구 시스템(DR)이 없거나, 담당자가 없어서 원인을 분석할 수 없기 때문이 아니다. 물론 그런 경우도 있겠지만 기본적인 것들을 준비하지 않고서 장애를 빨리 해결하려는 것은 당치도 않은 욕심이다. 많은 기업들이 기본적인 것들은 준비하고 있다. 그럼에도 불구하고 장애가 빨리 해결되지 않는 이유는 세 가지로 볼 수 있다. 이 세 가지 문제들은 지난 몇 십 년간 방치되어 왔다. 장애를 빨리 해결하려면 이제는 더 이상 방치하면 안될 것이다. 다행히, 일부의 기업에서 이런 문제를 간파하여 장애시의 Down Time을 최소화 하고 있지만 아직 갈 길은 멀다

늑장의 원인 세 가지는 무엇인가?
많은 기업들이 간과하는 세 가지 문제는 간단한 것이다. 첫 번째, 장애상황에서 대응을 못하도록 정신적인 고통을 주는 사람이 당신의 조직에 있다는 것을 알고 있는가? 말도 안 된다고과연 그런가두 번째, 장애상황을 극복하려면 해당분야의 전문 지식이 필요하다. 그런데 전문 지식을 가질 수 없게 만드는 사람이 여러분의 주위에 있다면 당신은 믿겠는가? 세 번째, 일단 장애를 해결했으면 앞으로 비슷한 유형의 장애는 발생하지 않게 해법을 만들어야 한다. 하지만 많은 경우에 해법이라는 것이 임시방편이므로 같은 유형의 장애를 또 만나게 된다는 것을 알고 있는가? 다시 말해, 소를 잃었음에도, 외양간을 고치지 않고 있다. 여러분이 근무하는 곳은 어떤가? 위의 세 가지 일이 발생하지 않는다고 장담할 수 있는가? 이제부터 세 가지에 대해 좀더 상세히 알아보자.


 

1. 심리적 관점

병풍치기가 무엇인가?
장애가 나면 언제나 볼 수 있는 풍경이 있다. 조치를 하고 있는 전산담당자의 바로 뒤편에 관리자들이 주~욱 둘러선다. 장애 때문에 발을 동동 구를 수도 있고, 언제 장애가 풀릴 것인지 궁금해서 그럴 수도 있고, 담당자가 얼마나 빠른 조치를 하는지 보려는 사람도 있을 것이다. 필자는 이런 현상을 “장애시의 병풍치기”라고 한다. 병풍치기만 없어져도 장애가 빨리 해결될 수 있다. 수십 명이 담당자의 뒤편에 병풍을 치고 있는데, 이 사람들은 감시자인가? 아니면 담당자의 도우미인가? 도우미는 경험 많은 사람 한 명, 그리고 관련분야의 지식이 풍부한 전문가 한 명, 총 두 명이면 충분하다. 이 두 명도 뒤편에서 병풍을 칠 것이 아니라 담당자의 왼편과 오른편에서 모니터를 같이 바라보아야 한다. 문제를 해결하려는 동료의 관점에서 말이다

장애를 해결하는 당사자의 심리
서버 담당자가 장애를 해결하기 위해 특정 명령어를 날리려고 한다. 그런데 1년에 한번 쓸까 말까 한 명령어이므로 기억하기 힘들다. 그래서 매뉴얼을 보거나 인터넷으로 명령어를 찾아야 한다. 그런데 병풍이 쳐져 있으면 책을 보거나, 인터넷을 뒤져보기 힘들다. 왜냐하면 병풍이 쳐져 있을 때, 담당자는 다음처럼 생각하기 때문이다. 내가 명령어를 찾으려고 인터넷을 뒤지면 내 뒤에 있는 관리자들이 어떻게 생각 할까? “서버 담당자 맞아? 어떻게 명령어도 모를 수가 있지?” 라고 생각하겠군. 

Walking Dictionary?
이런 생각은 담당자의 머릿속에만 존재하는 것이 아니라 여지없이 현실로 나타난다. 장애 담당자가 명령어를 인터넷에서 찾기라도 하면, 기다렸다는 듯이 뒤편의 사람들이 수군거리기 시작한다. 도대체 누가 모든 명령어를 외우고 다닌단 말인가? 다른 분야의 전문가들에게 물어보라. 의사가 의학서적을 뒤지는 이유, 변호사가 법률서적을 뒤지는 이유, 영문학 번역가가 영어사전을 뒤지는 이유를 물어보라.

병풍은 장애당당자를 어떻게 방해하나?
뒤편의 사람들이 수군거리기 시작하고, 장애로 인해 타격을 받는 부서의 사람들은 계속 발을 동동 구르고 있고, 전산부서의 관리자들은 사태가 언제쯤 해결될지 계속해서 담당자에게 질문을 해대고…… 전형적인 병풍치기 광경이다. 전산당당자들이 이런 상황에서 제대로 일을 할 수 있을까? 담당자의 실력을 의심하는것, 발을 동동 구르는 것, 담당자에게 계속 질문을 해대는 것, 모두가 담당자를 방해하는 것이다.

역지사지 (易地思之)
장애 담당장의 뒤편에 서있을 뿐, 그 사람의 실력을 의심한 적은 없다고 혹자는 생각 할 수도 있다. 하지만 불행히도 그런 생각과는 아무 상관이 없다. 무슨 말이냐 하면, 어떤 사람이 술집에서 음란한 이야기를 했다고 치자. 그 자리에 같이 있던 여성이 나중에 수치심을 느끼고 그 사람을 신고할 수 있다. 그 사람은 재미로 이야기 한 것이지만, 그 여성이 어떻게 받아들이느냐에 따라서 신고할 수도 아닐 수도 있는 것이다. 마찬가지로 장애를 복구하는 담당자가 뒤편에서 팔짱을 끼고 있는 사람을 어떻게 받아들이느냐가 중요한 것이다. 장애 담당자의 대부분은 뒤에 서있는 사람을 불편하게 생각한다는 것을 알고 있는가?


장애보고는 단 한번으로 족하다

내가 만나본 최악의 상황은 전산 담당자가 똑 같은 장애상황을 다섯 번이나 보고한 것이다. 서로 다른 병풍이 다섯 번이나 나타난 것이다. 즉 관리자A가 나타나서 어떻게 된 일인지 질문을 하면 담당자는 장애 상황에 대해 답변을 해야 한다. 그런데 관리자가 어디 한 명뿐인가? 관리자 B, 관리자 C, 관리자 D, …… 계속해서 관리자나 장애와 관련된 사람들이 나타나고 담당자는 계속 설명한다. 조금이라도 빨리 장애를 복구해야할 담당자가 일은 하지 않고 5분간 말만하고 있다. 장애가 어떻게 발생된 것인지 궁금하겠지만 조금이라도 장애시간을 줄이려면 담당자에게 질문하지 말아야 한다. 필자 또한 이런 질문을 한 적이 있다. 명백한 나의 실수였다.   

조선시대에 왕은 일반인이 알아볼 수 없도록 변장을 하고, 백성들이 어떻게 사는지 살펴보곤 하였다. 변장을 하지 않으면 어떤 식으로든 백성들에 민폐를 끼치기 때문이다. 조선시대의 왕처럼 전산실을 넘나드는 사람들도 장애를 복구하는 사람에게 어떠한 방해도 끼쳐서는 안 된다. 이 둘간의 차이점은 민폐를 끼치지 않으려는 방법이 서로 다른 것이다. 변장을 하는 것과 병풍을 치우는 것.

그림의 출처 http://www.chosun.com/site/data/html_dir/2007/10/04/2007100400081.html

병풍을 치워라
병풍치기는 담당자를 얼어붙게 만들며, 뒤편의 사람들에게 지속적으로 신경을 써야 하므로 장애상황에 집중할 수 없게 한다. 장애상황에서 빨리 해결하도록 담당자를 돕고 싶으면 병풍을 없애라. 담당자에게 장애보고를 받아야 한다고? 그렇게 하면 뭐가 달라지는가? 선 조치 후 보고를 하면 왜 안 되는가? 장애의 해결이 먼저인가? 아니면 보고가 먼저인가? 물론 관리자의 의사결정이 필요한 경우는 있다. 그러면 담당자가 자연스럽게 물어볼 것이다. 그때 결정 해주면 된다. 장애의 해결을 막는 병풍은 필요 없다. 담당자는 누구보다 장애에 대해 큰 스트레스를 받는다. 이 상태에서 병풍까지 만들어 심리적으로 괴롭히면 문제를 해결하는데 방해가 될 뿐이다.


2. 조직문화
원인을 파악하고 해결책을 구하는데 며칠이 걸린다면 이미 끝난 게임이다. 이런 일이 발생하지 않으려면 평소에 관련분야의 매뉴얼과 책을 읽어야 장애 시에 빠른 원인 파악과 조치가 가능하다. 전산 담당자는 이런 사실을 알고 있으므로 평소에 책과 매뉴얼을 읽으려고 노력한다. 책꽂이에 관련분야의 책이 꼽혀있는 이유 중 하나도 그것 때문이다. 하지만 지난 몇 십 년간 책꽂이가 전시용이라는 사실을 알고 있는가?


전문가로 키울 수 없는 회사 분위기
전산 담당자가 업무시간 중에 책을 읽으려고 하면 난리가 난다. 일은 안하고 책이나 본다는 것. 얼마나 무책임한 관리자인가? 회사를 위해 매뉴얼과 책을 읽는다는 생각은 하지 못하는 것일까? 평소에 지식을 충분히 습득하고 있으면, 장애가 발생했을 때 당황하지 않을뿐더러 장애 시간을 줄일 수 있다. 이런 것이 개인적인 일인가? 아니면 회사를 위한 일인가? 관리자는 전산담당자에게 매뉴얼과 책을 읽을 수 있는 분위기를 조성해야 한다.

 

혹시 인터넷을 금지하고 있는가? 이런 상황 또한 전문가가 만들어지기 힘든 환경이다. 많은 기업들이 제품매뉴얼을 책으로 배포하는 대신에 인터넷으로 대체하고 있다. 이런 상황에서 인터넷을 금지한다는 것은 시대착오적인 발상이다. 물론 책과 인터넷이 업무와 전혀 상관없는 일에 몰두하게 만든다면 방해가 될 수도 있다. 그런 경우까지 방치해야 한다고 주장하는 것은 아니다.

 

지식장려상을 만들어라

농담이라도업무시간 중에 책 보지 말고 시스템 모니터링을 하라라는 이야기는 하지 않아야 한다. 직원은 관리자의 눈치를 보게 마련이다. 또한 그 들은 바보가 아니다. 장애의 상황에서 시스템을 분석하지 않고 만화책을 보겠는가? 절대 그럴 일은 없다. 오히려 전문 지식의 습득을 장려하고, 정기적으로 세미나를 열어서 개인들이 공부한 것들을 조직원들에게 공유하는 것으로 회사문화를 바꾸기 바란다. 전산장애시 빠르고, 정확한 대응을 할 수 있는 전문가는 번쩍 하고 태어나는 것이 아니라, 천천히 만들어지는 것이므로.


3.
인과관계와 장기적 해법

원인의 인과관계를 끝까지 밝혀라
실제로 전산장애가 발생하면, 가정 먼저 해야 할 것은 원인 파악이다. 그 원인이라는 것이 발견하기 쉽다면 다행이지만 그렇지 않은 경우라면 시간이 많이 걸린다. 예를 들면, 단순히 Disk가 꽉 차서 서비스가 안 된다고 판단할 수 있다. 그렇다면 Disk만 추가하면 될까? 하지만 그런 단편적인 생각은 또 다른 재앙을 부를 수 있다. 좀더 면밀히 분석한 결과 Disk가 꽉 차는 현상은 Hacking에 의한 것으로 판명될 수 있다. 원인을 파악했다고 생각하지 말고 한번 더 생각하기 바란다. 즉 원인의 원인은 무엇인지 파악해야 한다.

해법인가 임시방편인가?
원인의 인과관계를 밝혔다면 근본적인 해결책을 생각해야 한다. Disk를 추가하고, Hacker IP를 잡아내어 접속하는 것을 막았다고 하자. 여기가 끝일까? 이런 일은 임시방편에 불과하다. Hacker IP를 바꿔서 공격해 온다면? 불과 몇 초 후에 시스템은 다시 뚫릴 수 있다. Hacker IP를 잡아내어 접속하는 것을 막았다고 안심하지 말고, 방화벽의 허점을 강화 할 것인지, 추가적인 보안 솔루션을 구매할 것인지를 고려하라는 것이다. 지금 당장 장애를 해결하기 위한 조치(임시방편)는 중요하다. 하지만 여기서 멈추면 안 된다. 근본적인 해결방법이 없는지 생각해 보아야 한다. 그렇지 않으면 비슷한 패턴의 장애를 또 맞을 수 있다.

 

결론
의도적이지 않은 장애는 두 가지로 구분할 수 있다. 인재(사람이 실수로 장애를 발생시킴)와 자연재해이다. 자연재해는 대비는 할 수 있지만 발생을 막을 수는 없다. 하지만, 인재는 발생을 최소화 할 수도 있고, 피해를 최소화 할 수도 있다. 그렇게 하기 위해서는 무엇보다 사람에 집중해야 한다. 즉 담당자에게 심리적 안정감을 주고 (1) 조직문화를 올바른 방향으로 유도(2)하는 것이 좋은 방법이다. 이와는 반대로 문제해결에만 집착하는 것은 발등에 덜어진 불을 끌 수는 있으나 장기적으로는 현명한 방법이 아니다. 하지만 안타깝게도 많은 기업들은 오직 문제해결의 방법(3 )에만 집중할 것이다. 1, 2, 3번을 평등하게 바라보아야 한다.

다시 한번 말하지만, 장애상황에서 담당자의 뒤를 받쳐야 하는 것은 병풍이 아니라 심리적 안정감과 풍부한 전문지식을 권장하는 조직문화이다. 이 두 가지가 장애상황을 더 빨리 해결할 수 있고, 장애를 예방할 수 있는 방법일 뿐만 아니라, 전산장애로 인한 개인과 기업의 피해를 최소화 할 수 있는 근본적인 해결책임은 물론이다. 

저작자 표시 비영리 동일 조건 변경 허락
신고
Posted by extremedb

댓글을 달아 주세요

  1. 보안? 그거 돈들아가잔아? 잉 2011.04.11 12:52 신고  댓글주소  수정/삭제  댓글쓰기

    15년전부터 보안. 안전. 방어. 등등 이런 문제를 유심히 생각하고 살아가는 나는 아파트 9층에 살지만 와이어 30M를 베란다에 튼튼히 고정하여 장착시키는게 이사후 젤 먼저 하는일이다.. 튼튼한 등산용 조끼와 장값, X반도로 아이들을 가슴에 안고 내려갈수있도록 준비하였다.. 왜? 할까? 아마도 화재를 대비하는것이지요,, 왜하냐고여? 글쎄? 내가족을 지키기 위해서다.. 그리고 아파트 옆집에 열쇠를 분실한경우 옆집 베란다를 통해서 가볍게 대문을 풀수가있기에 안전줄로 사용도 한다, 난 이미 2번이나 옆집 대문을 열어준 실제 사건이 있었다.. 지금은 컴퓨터 관련일을 하지만 소읽고 외양간 고치는 일이 만연된 사회의 공통점... 보안이나 방어체계는 돈이들고 관리하는게 귀찬고 해봐야 불필요하다고 생각하는 경영자가 있기에 발생하는것이다.. 그런 경영자에게 과연 보안이란게 얼마나 허접덩어리로 생각하는지..ㅎㅎㅎㅎ 강을 건너는 나룻배에서 젤 중요한게 뭘까요? 라는 이야기가 생각난다. 물론 건강이고 수영실력이겟죠? 그런데 수영을 못하면? 죽어야죠? 잉 이런 단순한 이야기는 누구나 다 알지만 실천하는 사람은 절반도? 아니면 절절반도 안될꺼 같은데..잉 ㅎㅎㅎ 돈 들어가는 그런데 뭐하러 돈써?? 사장님..한번 털려야 후회하겟지요,,ㅎㅎㅎㅎ

    • Favicon of http://scidb.tistory.com BlogIcon extremedb 2011.04.11 13:00 신고  댓글주소  수정/삭제

      꼭 필요한 일을 먼저 하시는 분인것 같습니다.
      저도 5층에 살기때문에 대비가 필요한데 아직 실행하지는 못햇습니다. 평소에 준비해야 겟습니다. 좋은 글 감사드립니다.

  2. 타락천사 2011.04.11 16:23 신고  댓글주소  수정/삭제  댓글쓰기

    옥에 티
    의도적이지 않은 장애는 장애는 두 가지로 구분할 수 있다.
    ==> 장애는 이 중복이네요..

  3. widow7 2011.04.11 17:41 신고  댓글주소  수정/삭제  댓글쓰기

    시덥찮은 연예프로 보고 나서 감상문 따위의 포스팅에는 열나 추천 클릭하면서 이런 좋은 글에는 현재 제가 찍기 전까지 추천 횟수 10밖에 없네요. 이런 글이야말로 우리 나라 30대 기업 모든 임원의 머리끄댕이를 쥐고 모니터에 코를 박게 해서라도 읽게 해야 함! ......작년인가 재작년 뉴스가 기억이 나는데, 부산으로 기억하는데, 구급요원을 확충해야 한다는 여론에, 부산시 높은 분은 응급환자가 생기지 않는 한은 구급요원이 평소 빈둥거리며 놀기 때문에 확충할 필요를 느끼지 않는다는 답변을 tv에서 보고 열받은 적이 있습니다. 빈둥거리는 구급요원 월급주는게 저런 높은 분 월급 주는 것보다 아깝지 않거든!

  4. 병풍 2011.04.11 20:46 신고  댓글주소  수정/삭제  댓글쓰기

    악.. 공포의 병풍치기 ㅎ
    저는 인프라의 가장 베이스인 스토리지 와 SAN 엔지니어 이다보니, 장애가 발생되면, 담당자, 관리자들 뿐만 아니라, 제가 마쳐야 뒤로 작업을 시작하게되는 여러 분야의 엔지니어들까지 가세하여 죄다 병풍을 치기 때문에 큰 사이트에서는 그 병풍의 두께가 최강입니다.
    그 심적 부담이란.. -_-

  5. Favicon of http://1ststreet.tistory.com BlogIcon SITD 2011.04.12 17:41 신고  댓글주소  수정/삭제  댓글쓰기

    아...네이트 판이나 디씨에 퍼가고 싶은 글이네요 ㅎ
    (윗분들이 보진 않겠지만 이슈화 시키고 싶달까요. 여론 분위기상 이슈화 되기 힘들 것 같긴 합니다만 ^^)

    회사입장에선 근무시간에 일은 안하고 별도로 실력 키워서 회사엔 도움 안주고, 이직만 하려는 걸 방지하려는 목적일수도 있겠다는 생각도 들긴합니다.
    헌데 그건 회사 입장에서 실력에 맞는 대우를 먼저 해줘야 하는 거라는 생각도 드네요.

    그냥 맡겨 뒀다가 나중에 어떻게 해결했는지만 물어보면 되는거 아닌지...

    아니면 뒤에서 구경할 만큼 할일들이 없는건지..

  6. 매컬리 2011.04.13 16:57 신고  댓글주소  수정/삭제  댓글쓰기

    정말 공감하는 글입니다.

    병풍치기 ㅋㅋ

  7. Favicon of http://scidb.tistory.com BlogIcon extremedb 2011.04.13 17:42 신고  댓글주소  수정/삭제  댓글쓰기

    SITD님 매컬리님 반갑습니다.
    제가 선견지명이 있었던 것일까요?
    제가 근무하던 곳에서 장애가 발생했습니다.^^

  8. 김승훈 2011.04.18 11:54 신고  댓글주소  수정/삭제  댓글쓰기

    완전 200% 공감합니다..ㅋㅋ
    농X 의 사태와 맞물려 적절한 타이밍에 글이네요 ㅎㅎ
    듣기로는 거기 차세대 참여했던것으로 아는데..
    거기 상황이 대충 눈에 그려지셔서 이 글을 쓴게 아닌가 생각되네요ㅎㅎ

    • Favicon of http://scidb.tistory.com BlogIcon extremedb 2011.04.18 12:53 신고  댓글주소  수정/삭제

      반갑습니다. 승훈님

      은행(1 금융권)은 위의 삽질을 하지 않습니다.
      1분 1초가 아깝기 때문에 아예 시스템실에 못들어오게 통제를 합니다.^^

  9. 김영태 2011.04.21 18:38 신고  댓글주소  수정/삭제  댓글쓰기

    병풍을 학익진으로 펼치면 정말 아무것도 못하겠어요

  10. sid 2011.04.22 00:44 신고  댓글주소  수정/삭제  댓글쓰기

    아...농협 생각이 갑자기..;;

    농협 언제 해결되려나요 ;

  11. Favicon of http://ihoney.pe.kr BlogIcon 허니몬 2011.04.29 09:20 신고  댓글주소  수정/삭제  댓글쓰기

    지금 농협에도 여기서 말한, 거대한 '병풍치기'가 시전되어 있는 상태겠지요.
    개발자들은 늦은 밤까지 장애를 해결하기 위해 야근하고,
    관리자들은 그런 개발자들의 뒤에 팔짱을 끼고 서서 인상쓰며 노려보고...

    잘 읽었습니다. 문득 어제 어느 관리자분과의 대화가 떠오르네요. ^^

  12. Favicon of http://1ststreet.tistory.com BlogIcon SITD 2011.05.03 14:25 신고  댓글주소  수정/삭제  댓글쓰기

    모든 글이 농협으로 통하는 기적이 발현되는군요.
    농협 북한 소행이라던데...

  13. Favicon of http://scidb.tistory.com BlogIcon extremedb 2011.05.04 11:51 신고  댓글주소  수정/삭제  댓글쓰기

    다행히 농협은 병풍이 없었습니다.^^

  14. Favicon of http://www.abercrombiefitch-saleuk.org.uk BlogIcon abercrombie and fitch uk 2011.09.26 19:29 신고  댓글주소  수정/삭제  댓글쓰기

    모든 글이 농협으로 통하는 기적이 발현되는군요.

  15. 금융전산인 2012.01.19 17:59 신고  댓글주소  수정/삭제  댓글쓰기

    완전 공감합니다. 보험회사 보험금 지급업무를 담당하다보니, 장애에 대해서 타 부서보다 굉장히 민감합니다.
    안내장 혹은 sms, 해약처리, 보험약관대출 처리, 약관대출에 대한 청구 및 결제 정리, 금액 고객이체, 고객에게 빼옴 등
    너무나 신경 쓸 일이 많습니다. 가끔 어쩌다 장애가 나면, 역시나 뒤에는 병풍이 후다다닥..

    심리적인 안정감이 있은 후, 장애 원인 및 DATA 해결, 그리고 해결 방안등을 해야 하지만
    기획에서 한명, 업무리더 한명, 현업담당 한명, 장애위원회 1명 등, 미쳐버립니다.

    IT 전문기술이 없는 윗분들은 야..머가 문제야.. 언제 해결돼.. 왜그랫어 등.. 지방방송만 합니다.

    담당자가 원활하게 할 수 있도록 한 후, 그에 대한 보고, 향후 대책을 애기하면 좋은데.. 그래서 참 짜증이 납니다..

    님의 글을 윗분에게 품질개선 회의할때 발표 한번 해봐야 겠내요^^

더미 테이블을 사용해서 장애를 만나는 경우

더미 테이블을 사용하는 이유

더미 테이블을 사용하지 않는 방법

 

포장마차에서 지인에게 재미있는 이야기를 들었다. 물론 공장 이야기 이다. 나는 이야기를 재미있게 들었지만, 지인의 입장에서는 머리가 쭈뼛쭈뼛 서는 심각한 일이었다. 사건은 2011년 겨울에 시작된다.

 

2011 1 1일 이른 아침, 갑자기 잘 돌아가던 시스템에 몇몇 프로그램들이 작동하지 않는 장애를 만났다. Y2K 버그도 아니고 2011 1 1일에 장애라니? 서버와 네트워크 그리고 Database는 정상이므로 관심의 화살은 개발팀으로 집중되었다. 개발팀에서 장애 프로그램을 조사해보니 지난 한 달간 프로그램 수정이 없다고 하였다. 결국 모든 것이 정상인데 프로그램만 돌아가지 않는 상황이다. 귀신이 곡할 노릇이 아닌가? 빨리 정상적인 서비스를 해야 하므로 1, 1초가 아쉬운 시점이었다. 모두들 땀을 흘리며 원인을 찾고 있었다. 프로그램 담당자는 장애를 일으킨 사람을 찾으면 죽여버리겠다고 소리쳤다.

 

여러분은 이런 장애에서 안전한가?

다행히 오래 걸리지 않고 원인을 찾았다. 돌아가지 않는 프로그램들의 공통점은 더미테이블을 사용한다는 것이었다. 즉 Copy_ymd를 사용한 것이다. 그 테이블을 조사해보니 일자가 2010년 까지만 들어가 있었다. 그래서 2011년이 되자마자 장애가 발생한 것이었다. 다시 말해, Copy_ymd 테이블에 2011년 데이터가 없으므로, 이 테이블과 조인하면 한 건도 나오지 않는 것이다. 생각해보니, 모든 시스템에 이런 일이 발생할 수 있다. 이야기를 듣는 필자의 간담이 갑자기 서늘해진다.

 

시스템을 구축한 업체에게 항의하려고 문서를 찾아보니 2001년에 Open한 시스템으로 2001년 기준으로 미래의 일자를 10년치 넣어 놓았다. 소프트웨어의 라이프 사이클을 고려한다면, 10년이면 충분하다고 생각했을 것이다. 하지만 운이 없게도 차세대 프로젝트를 하지 않고 10년간 유지보수를 하면서 사용한 것이다. 그리고 인수인계서에 2011년이 되기 전에 몇 년치의 데이터를 더 넣어놓으라고 명시되어 있었다. 시스템을 구축한 업체에게 항의할 수 도 없는 일이었다. 인수인계서를 보는 사람이 한 명이라도 있었을까?

 

왜 더미 테이블을 사용할까?

데이터베이스에 관심이 있는 개발자라면 Copy_ymd, Copy_ym, Copy_y, Copy_t 등 네 개의 더미테이블을 알 것이다. 많은 시스템에 이런 더미 테이블들이 있다. 과거에는 이런 테이블들을 사용해야만 했다. 하지만 2011년의 시점에서 새로운 프로젝트를 할 때 이런 테이블들이 필요할까? 필요한지 아닌지를 알려면 먼저 더미테이블의 용도를 알아야 한다. 이 테이블들의 용도 중에서 대표적인 것은 아래와 같이 세 가지로 볼 수 있다.

 

1. Copy: 같은 집합을 여러 번 복제하여 원하는 결과집합을 구한다.

2. 데이터 체크: 일자의 경우 입력된 값이 올바른지 확인한다. 예를 들면, 2 30일은 잘못된 일자이다.

3. 인덱스의 효율적 사용: 인덱스의 첫 번째 컬럼 혹은 중간 컬럼이 Where 조건에 사용되지 않을 때 더미 테이블을 이용하여 IN으로 공급해주면 인덱스를 효율적으로 사용할 수 있다.

 

물론, 다른 용도로 더미테이블을 사용할 수 도 있지만, 대부분은 위의 세가지 경우 때문에 더미테이블이 필요하다. 가끔 기준일자를 관리하는 테이블을 볼 수 있는데, 이것은 더미테이블이 아니라 business에 필요한 것이다. 더미테이블은 업무적인 것이 아니라, 성능적인 관점, 혹은 관리적인 목적으로 사용되는 것이다. 업무적인 데이터가 없으므로 차세대 시스템을 구축할 때 더미 테이블은 분석 대상에서 빠져도 된다. 이런 이유 때문에 모델러들도 더미테이블을 중요하게 생각하지 않는다.

 

더미 테이블의 단점

위의 세 가지를 더미 테이블을 사용하지 않고 처리할 수 있다면 굳이 사용할 필요는 없다. 왜냐하면 아래와 같은 단점이 있기 때문이다.

 

첫 번째, 더미 테이블이라고 해도 시스템 속성을 추가해야만 한다. 시스템 속성이란 입력자, 입력일시, 수정자, 수정일시 등을 의미한다. 모든 테이블에 이런 컬럼들이 4 ~ 6개 정도 존재한다. 많은 기업들이 메타시스템을 사용하고 있다. 메타시스템에 테이블에 시스템 속성이 없으면 등록할 수가 없는 경우가 많다. 심지어 자동으로 시스템속성을 추가하는 메타시스템도 있다.

 

그런데 더미테이블은 튜닝의 목적이 있으므로 매우 가벼워야 한다. 생각해보라. Copy_t에 존재하는 숫자컬럼의 length3 byte에 불과한데 시스템 속성 네 개가 48 byte를 차지한다. 3 byte를 위해서 건건이 48 byte를 낭비해야 한다. 테이블이 무거워 질 수 밖에 없다. 더미 테이블은 메타시스템으로 관리하지 말고 엑셀로 관리하면 된다고? 왜 추가적인 관리를 해야만 하는가?

 

두 번째, 누가 더미 테이블을 중요하게 생각하는가? 더미 테이블을 인수인계 시 중요항목으로 관리되고 있는가? 2011년이 가까이 다가와도, Copy_ymd에 데이터를 넣어줄 생각을 하는 사람은 아무도 없었다. 왜냐하면 10년간 담당자가 세 번이나 바뀌었고, 더미테이블은 인수인계 시 중요관심사가 아니었기 때문이다. 결국 더미테이블을 신경 쓰는 사람은 아무도 없을 수 있다. 시스템은 이렇게 중요 테이블이 아니더라도 조그만 블랙홀이 생기면 장애를 맞는다. 이런 일이 발생할 수 밖에 없는 걸까?

 

세 번째, 관리해야 할 DB 서버가 많다면 위험이 증가한다. DB 팀이 관리하는 DB30개라고 가정하자. 지금 30개의 DB에 대해서 더미테이블을 관리하고 있는가? Copy_ymd에 추가적인 데이터를 insert 해야 하는 시기를 알고 있는가? 관리하고 있지 않다면 장애를 맞을 가능성이 높다. 그렇다면, 신경 쓰지 않아도 되도록, 시간이 되면 자동으로 insert되는 프로그램을 고려해 보아야 하는가? 아니면 시스템마다 더미테이블 들을 뒤져서 안전하게 100년치를 넣을 것인가? 왜 그래야 하는가? 아예 더미테이블을 사용하지 않으면 될 것을

 

지금은 운영 중이기 때문에 SQL을 바꾸는 것이 어렵다고 하더라도, 차세대 시스템을 구축할 때는 테이블을 관리할 필요도 없고, 장애도 일으키지 않는 방법이 무엇인지 고려하기 바란다. 방법은 얼마든지 있다. 이미 똑똑한 개발자들은 아래의 방법을 사용하고 하고 있다.

 

1. Copy

Copy_t 대신에 Rollup, Cube, Grouping Sets를 활용하면 원하는 집합을 만들 수 있다. 사용방법은 해당 을 참고하라. 물론 내부적으로 쿼리변환이 발생되어 UNION ALL로 풀릴 수도 있으므로 성능이 저하되는지 실행계획의 확인은 필요하다. 이런 경우에도 COPY_T는 필요 없으며 DUAL + CONNECT BY LEVEL을 사용하면 된다. 또한 LEAD/LAG를 사용한다면 복제하지 않고도 전/후의 데이터를 비교할 수 있다.

 

2. 데이터 체크

데이터를 Insert 하기 전에 일자 컬럼을 체크하려고, DBMS Call을 해야만 하나? 다시 말해, 무슨 이유 때문에 DB에 불필요한 부하를 주어야 하는가? 비슷한 노력을 들이고도 DBMS Call을 하지 않을 수 있다. 화면 단에서 Java Script로 처리하던지, 아니면 Constraint를 걸면 Insert할 때에 자동으로 체크 되므로 별도의 DBMS Call은 필요 없다. Constraint에 대해서는 관련 을 참조하라.

 

3. 인덱스의 효율적 사용

INDEX SKIP SCAN 기능이 추가되었기 때문에 IN 서브쿼리를 사용해야 되는 경우는 많이 한정 되었다. 또한 IN 서브쿼리를 사용한다고 하더라도 Copy_t, Copy_ymd 대신에 Dual + Connect By를 사용하면, Pseudo 컬럼인 Level을 사용할 수 있다. 물론 주의사항은 있다. 해당 을 참조하라.

 

3번에 대해서 어느 개발자가 다음과 같이 질문한다.

 

질문1

개발자: 인덱스가 거래일자 + 고객번호 입니다. 거래일자에 Between 조건이 들어오고 고객번호에 = 조건이 들어온다고 칩시다. 인덱스의 선두 컬럼이 Range 조건이므로 똑똑한 고객번호를 인덱스로 액세스 할 수 없습니다. 이럴 때, Copy_ymd가 있어서 거래일자를 IN 서브쿼리로 공급할 수 있었습니다. 그런데 Copy_ymd 테이블 없이 Dual + Connect By + Level로 처리가 가능 한가요? Copy_tLevel로 처리가 가능하지만 일자는 Range 조건으로 만들기 힘들 것 같은데요.

필자: 됩니다.

개발자: 어떻게요?

 

질문2

개발자: INDEX SKIP SCAN은 인덱스가 A+B+C 로 되어있고, A 혹은 B Where 조건에서 생략될 때만 사용할 수 있는 것 아닙니까? , A 컬럼에 Range 조건이 오고 B = 조건이 오면 INDEX SKIP SCAN을 사용할 수 없는 걸로 알고 있습니다만.

필자: 꼭 그런 것은 아닙니다. A 컬럼에 조건이 Between이나 LIKE 조건이 오고 B 컬럼에 = 조건이 오더라도 INDEX SKIP SCAN이 발생합니다. , 선두나 중간 컬럼의 조건이 생략될 때만 INDEX SKIP SCAN이 발생하는 것은 아니며, 선두나 중간 컬럼에 조건이 Range로 들어올 때도 발생합니다.  

개발자: 그럴 리가요?

 

이제부터 두 가지 질문에 대해 대답해보자. 먼저 Sales 테이블에 인덱스를 하나 만들고 Copy_ymd를 만들자.

 

CREATE INDEX IDX_SALES_01 ON SALES (time_id, cust_id, prod_id) ;

 

CREATE TABLE COPY_YMD AS

SELECT TO_CHAR(ROWNUM + TO_DATE('19800101', 'YYYYMMDD'), 'YYYYMMDD') AS YMD_CHAR,

       ROWNUM + TO_DATE('19800101', 'YYYYMMDD') AS YMD_DT

  FROM SALES

WHERE ROWNUM <= 14600;

 

ALTER TABLE COPY_YMD ADD CONSTRAINT PK_COPY_YMD

PRIMARY KEY (YMD_CHAR) USING INDEX; 

 

CREATE UNIQUE INDEX IDX_COPY_YMD_01 ON COPY_YMD(YMD_DT);

 

Sales 테이블의 인덱스는 Time_id _+ cust_id + Prod_id 이다. 해당 매출테이블의 transaction이 많아서 인덱스를 변경할 수도, 생성할 수도 없는 상황이라고 가정한다. 이제 테스트를 시작해보자.

 

참고로 아래의 힌트는 INDEX SKIP SCAN을 방지할 목적으로 사용한 것이다. INDEX SKIP SCAN이 나오기 전에는 이렇게 INDEX RANGE SCAN으로 수행되었다.

 

SELECT /*+ NO_INDEX_SS(S IDX_SALES_01) INDEX_RS_ASC(S IDX_SALES_01) */ s.*

  FROM sales s

 WHERE time_id BETWEEN TO_DATE('20011001', 'YYYYMMDD')

                   AND TO_DATE('20011130', 'YYYYMMDD')

   AND cust_id = 53;

 

----------------------------------------------------------------------------------------------------

| Id  | Operation                          | Name         | Starts | A-Rows |   A-Time   | Buffers |

----------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT                   |              |      1 |      6 |00:00:00.01 |     209 |

|   1 |  TABLE ACCESS BY GLOBAL INDEX ROWID| SALES        |      1 |      6 |00:00:00.01 |     209 |

|*  2 |   INDEX RANGE SCAN                 | IDX_SALES_01 |      1 |      6 |00:00:00.01 |     203 |

----------------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   2 - access("TIME_ID">=TO_DATE(' 2001-10-01 00:00:00', 'syyyy-mm-dd hh24:mi:ss') AND "CUST_ID"=53

              AND "TIME_ID"<=TO_DATE(' 2001-11-30 00:00:00', 'syyyy-mm-dd hh24:mi:ss'))

       filter("CUST_ID"=53)

 

과거에는 선두컬럼이 Between이나 Like등의 Range 조건이 들어오면 위의 실행통계에서 볼 수 있듯이 비효율이 심했다. 고작 6건을 출력하기 위해 209 블록이나 Scan했다. 왜냐하면, 똑똑한 조건인 고객번호가 선두컬럼의 Range 조건 때문에 Access 조건이 못되고 Filter로 빠졌기 때문이다. 이런 비효율을 없애기 위해 예전에는 아래와 같이 더미테이블을 이용한 서브쿼리를 사용하였다.

 

SELECT /*+ LEADING(C@SUB) USE_NL(S) */ s.*

  FROM sales s

 WHERE time_id IN ( SELECT /*+ QB_NAME(SUB) */ ymd_dt

                      FROM copy_ymd c

                     WHERE ymd_dt BETWEEN TO_DATE('20011001', 'YYYYMMDD')

                                      AND TO_DATE('20011130', 'YYYYMMDD') )

   AND cust_id = 53;

 

--------------------------------------------------------------------------------------------------------

| Id  | Operation                           | Name            | Starts | A-Rows |   A-Time   | Buffers |

--------------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT                    |                 |      1 |      6 |00:00:00.01 |     136 |

|   1 |  NESTED LOOPS                       |                 |      1 |      6 |00:00:00.01 |     136 |

|   2 |   NESTED LOOPS                      |                 |      1 |      6 |00:00:00.01 |     130 |

|*  3 |    INDEX RANGE SCAN                 | IDX_COPY_YMD_01 |      1 |     61 |00:00:00.01 |       4 |

|*  4 |    INDEX RANGE SCAN                 | IDX_SALES_01    |     61 |      6 |00:00:00.01 |     126 |

|   5 |   TABLE ACCESS BY GLOBAL INDEX ROWID| SALES           |      6 |      6 |00:00:00.01 |       6 |

--------------------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   3 - access("YMD_DT">=TO_DATE(' 2001-10-01 00:00:00', 'syyyy-mm-dd hh24:mi:ss') AND

              "YMD_DT"<=TO_DATE(' 2001-11-30 00:00:00', 'syyyy-mm-dd hh24:mi:ss'))

   4 - access("TIME_ID"="YMD_DT" AND "CUST_ID"=53)

       filter(("TIME_ID"<=TO_DATE(' 2001-11-30 00:00:00', 'syyyy-mm-dd hh24:mi:ss') AND

              "TIME_ID">=TO_DATE(' 2001-10-01 00:00:00', 'syyyy-mm-dd hh24:mi:ss')))

 

서브쿼리를 사용하자 고객번호를 Access 조건으로 사용할 수 있게 되었다. 이에 따라 서브쿼리를 사용하지 않은 경우(209 블럭)보다는 Scan량이 줄어 136 블록이 되었지만 약간의 비효율이 있다. Copy_ymd 때문에 4블럭을 Scan 하였다. 이것을 해결하려면 아래처럼 Dual + Connect By Level을 사용하면 된다. 위의 SQL과 아래의 SQL의 답은 같으며 아래의 SQL은 질문1의 답변에 해당한다.  

 

SELECT s.*

  FROM sales s,

      ( SELECT TO_DATE('20011001', 'YYYYMMDD') + LEVEL - 1 AS time_id

          FROM dual

       CONNECT BY LEVEL <= TO_DATE('20011130', 'YYYYMMDD') - TO_DATE('20011001', 'YYYYMMDD') + 1) d

 WHERE s.time_id = d.time_id

   AND s.cust_id = 53; 

 

-----------------------------------------------------------------------------------------------------

| Id  | Operation                           | Name         | Starts | A-Rows |   A-Time   | Buffers |

-----------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT                    |              |      1 |      6 |00:00:00.01 |     132 |

|   1 |  NESTED LOOPS                       |              |      1 |      6 |00:00:00.01 |     132 |

|   2 |   NESTED LOOPS                      |              |      1 |      6 |00:00:00.01 |     126 |

|   3 |    VIEW                             |              |      1 |     61 |00:00:00.01 |       0 |

|   4 |     CONNECT BY WITHOUT FILTERING    |              |      1 |     61 |00:00:00.01 |       0 |

|   5 |      FAST DUAL                      |              |      1 |      1 |00:00:00.01 |       0 |

|*  6 |    INDEX RANGE SCAN                 | IDX_SALES_01 |     61 |      6 |00:00:00.01 |     126 |

|   7 |   TABLE ACCESS BY GLOBAL INDEX ROWID| SALES        |      6 |      6 |00:00:00.01 |       6 |

-----------------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   6 - access("S"."TIME_ID"=INTERNAL_FUNCTION("D"."TIME_ID") AND "S"."CUST_ID"=53)

 

Dual을 사용했기 때문에 Block I/O가 없어졌다. 하지만 여기서 만족하면 안 된다. 왜냐하면 쓸모 없는 조인이 61번이나 시도되었고 이에 따라 126블록을 Scan하였기 때문이다. 따라서 SQL을 아래처럼 바꾸어야 한다.

 

SELECT /*+ INDEX_SS(S IDX_SALES_01) */ s.*

  FROM sales s

 WHERE time_id BETWEEN TO_DATE('20011001', 'YYYYMMDD')

                   AND TO_DATE('20011130', 'YYYYMMDD')

   AND cust_id = 53;

 

----------------------------------------------------------------------------------------------------

| Id  | Operation                          | Name         | Starts | A-Rows |   A-Time   | Buffers |

----------------------------------------------------------------------------------------------------

|   0 | SELECT STATEMENT                   |              |      1 |      6 |00:00:00.01 |      70 |

|   1 |  TABLE ACCESS BY GLOBAL INDEX ROWID| SALES        |      1 |      6 |00:00:00.01 |      70 |

|*  2 |   INDEX SKIP SCAN                  | IDX_SALES_01 |      1 |      6 |00:00:00.01 |      64 |

----------------------------------------------------------------------------------------------------

 

Predicate Information (identified by operation id):

---------------------------------------------------

   2 - access("TIME_ID">=TO_DATE(' 2001-10-01 00:00:00', 'syyyy-mm-dd hh24:mi:ss') AND "CUST_ID"=53

              AND "TIME_ID"<=TO_DATE(' 2001-11-30 00:00:00', 'syyyy-mm-dd hh24:mi:ss'))

       filter("CUST_ID"=53)

 

불필요한 조인도 없어졌으며 Block I/O도 서브쿼리를 사용할 때에 비해서 약 절반으로 줄어들었다. 이것이 질문 2에 대한 대답이다.

 

참고사항

위의 SQL들을 보면 인덱스가 cust_id + time_id로 되어 있는 것이 최적이지만 막상 튜너가 현장에 투입되면 인덱스를 변경/생성/삭제 하기는 대단히 어려우므로 위의 방법을 잘 알아놓아야 한다.

 

결론

Copy_ymd, Copy_ym, Copy_y, Copy_t는 구시대의 유물이다. 성능에도 좋지 않으며, 코드가 길어지고, 장애가 발생할 수 있음에도 여러 가지 이유를 대어 차세대 시스템에 더미 테이블들이 또 포함될 수 있다. 안타깝게도 관행이나 표준으로 생각하는 사람이 많기 때문이다. 이제는 바뀔 때가 되었다. 지금 운영되는 모든 시스템에서 더미테이블을 사용하는 SQL을 모조리 조사해서 고치라는 이야기가 아니다. 그렇게 하기는 힘들 것이다. 다만 모든 더미테이블을 찾아서 미래의 데이터를 미리 그리고 넉넉히 넣자는 이야기 이다. 그리고 앞으로 시작될 프로젝트에서 더미테이블을 사용하지 않았으면 하는 것이 나의 바램이다. 당신이 발 뻗고 잘 수 있도록
저작자 표시 비영리 동일 조건 변경 허락
신고

'Oracle > SQL Tuning' 카테고리의 다른 글

COPY_T 테이블 필요한가?  (6) 2011.04.04
Sort 부하를 좌우하는 두 가지 원리  (9) 2011.03.29
SQL튜닝 방법론  (17) 2011.01.27
Pagination과 분석함수의 위험한 조합  (26) 2010.12.23
오라클의 Update문은 적절한가?  (15) 2010.04.14
Connect By VS ANSI SQL  (6) 2010.02.11
Posted by extremedb

댓글을 달아 주세요

  1. finecomp 2011.04.06 00:43 신고  댓글주소  수정/삭제  댓글쓰기

    8i, 9i 등 ~i 이전 시대의 방법론들을 현재의 ~g시대에도 고수하려는 고집들은 대부분 말도 안되는 논리인 듯 보입니다.
    (물론, 예~~전엔 그 방법들이 최적일 때가 분명히 있었더랬죠...)

    DB모델링이나 SQL만의 현상은 아니더군요...항상 잘 보고, 느끼고 갑니다...^^;;;

  2. 에너자이져 2011.04.06 09:32 신고  댓글주소  수정/삭제  댓글쓰기

    예전에 유용하게 사용한 적이 있었는데 구시대의 유물이 되어버렸네요..
    좋은글 감사합니다.

  3. 최윤호 2011.04.06 11:32 신고  댓글주소  수정/삭제  댓글쓰기

    좋은 글 항상 감사합니다.