SELECT DEPTNO, JOB, SUM(SAL)

FROM EMP

GROUP BY ROLLUP(DEPTNO,JOB)

ORDER BY 1,2;



는 기본적으로 다음과 같은 쿼리이다.


SELECT DEPTNO, JOB, SUM(SAL)

FROM EMP

GROUP BY DEPTNO, JOB

UNION ALL

SELECT DEPTNO, NULL JOB, SUM(SAL)

FROM EMP

GROUP BY DEPTNO

UNION ALL

SELECT NULL DEPTNO, NULL JOB, SUM(SAL)

FROM EMP

GROUP BY NULL

ORDER BY 1,2

;


즉,  

1. ROLLUP 안 전체 GROUP BY 

2. ROLLUP 안의 첫번째 컬럼부터 빠짐


그렇다면 다음과 같은 부분 ROLLUP은?

SELECT A, B, C, MAX(D)

FROM   TAB1

GROUP BY C, ROLLUP(A,B)


SELECT A, B, C, MAX(D)

FROM   TAB1

GROUP BY C, A, B

UNION ALL

SELECT A, NULL B, C, MAX(D)

FROM   TAB1

GROUP BY C, A

UNION ALL

SELECT NULL A, NULL B, C, MAX(D)

FROM   TAB1

GROUP BY C, NULL


즉 아까와 같다 . ROLLUP 밖의 컬럼과 ROLLUP 안의 컬럼포함 전부 GROUP BY 한 후 ROLLUP안의 컬럼이 순차적으로 빠진다.



CUBE는 가능한 모든 집합을 만들어낸다.

SELECT DEPTNO, JOB, SUM(SAL)

FROM EMP

GROUP BY CUBE(DEPTNO,JOB)

ORDER BY 1,2;


는 아래와 같은 쿼리가 된다.

SELECT DEPTNO, JOB, SUM(SAL)

FROM   EMP

GROUP BY DEPTNO, JOB

UNION ALL

SELECT DEPTNO, NULL JOB, SUM(SAL)

FROM   EMP

GROUP BY DEPTNO

UNION ALL

SELECT NULL DEPTNO, JOB, SUM(SAL)

FROM   EMP

GROUP BY JOB

UNION ALL

SELECT NULL DEPTNO, NULL JOB, SUM(SAL)

FROM   EMP

GROUP BY NULL

ORDER BY 1,2;



'SQL 기본' 카테고리의 다른 글

SQL 실행 순서  (0) 2016.12.23
블로그 이미지

마스터오라클

오라클 성능 튜닝에 관해 STUDY한 자료를 정리하는 블로그입니다.

,

Oracle XE is limited to:

  • only use one core of CPU on a system
  • use up to 1GB of RAM
  • store up to 4GB of data, 11GB of data on 11.2

The following database features are not supported:

  • partitioned objects
  • internal Java virtual machine (JVM)  -> 조동욱님의 tpack 설치 불가
  • materialized view query rewrite
  • changing character set on 11.2 (only AL32UTF8)


'참고 서적 및 사이트' 카테고리의 다른 글

참고 사이트  (0) 2017.01.03
오라클 성능 향상을 위해 유용한 도서  (0) 2016.12.20
블로그 이미지

마스터오라클

오라클 성능 튜닝에 관해 STUDY한 자료를 정리하는 블로그입니다.

,

오라클 성능 QnA

티팩 : 오동규님의 pl/sql 라이브러리

http://sites.google.com/site/otpack


예제

http://wiki.ex-em.com/index.php/Ask_exem_1


스크립트

http://sites.google.com/site/ukja/sql-scripts-1



http://yjan.tistory.com/


블로그 이미지

마스터오라클

오라클 성능 튜닝에 관해 STUDY한 자료를 정리하는 블로그입니다.

,

모든 DBMS의 I/O는 블록단위로 이루어짐


아래 두 쿼리는 서버의 I/O측면에선 같은 일량

SELECT ENAME FROM EMP WHERE SAL >=2000

SELECT * FROM EMP WHERE SAL >=2000


*엑세스 해야할 블록 수를 줄이는게 튜닝의 핵심


딕셔너리 캐시는 로우 단위로 I/O 수행


I/O 튜닝의 핵심 2가지 원리

* SEQUENTIAL 엑세스의 선택도 높임

* RANDOM 엑세스의 발생량 줄임


SEQUENTIAL 엑세스의 선택도 높이기

LEAF가 정렬되어 있는 인덱스를 활용 (인덱스 순서 조정)


RANDOM 엑세스 발생량 줄이기

인덱스 컬럼 추가로 인한 RANDOM ACCESS 줄임


버퍼캐시히트율(Buffer Cache Hit Ratio)

물리적 디스크 읽기를 수행하지 않고 곧바로 메모리에서 블록을 찾은 비율

BCHR = ( 캐시에서 곧바로 찾은 블록 수 / 총 읽은 블록 수 ) * 100

        = ( ( 논리적 블록읽기 - 물리적 블록읽기) / 논리적 블록읽기 ) * 100

        = ( 1 - (물리적 블록읽기) / (논리적 블록읽기) ) * 100


같은 블록을 반복 ACCESS하는 경우 BCHR이 매우 높게 나타나므로 BCHR만 볼게 아니라 논리적 블록 ACCESS를 줄여야 한다. (대량테이블의 NL 조인)


SINGLE BLOCK I/O : 한번의 I/O CALL 에 하나의 데이터 블록만 읽어 메모리에 적재

MULTI BLOCK I/O : 한번의 I/O CALL 에 다수의 데이터 블록만 읽어 메모리에 적재


INDEX FAST FULL SCAN, 인덱스만 스캔하는 경우 말고는 대부분의 인덱스 스캔시에는 SINGLE BLOCK I/O 로 읽음


PREFETCH : 한번에 여러개의 SINGLE BLOCK I/O를 수행해서 버퍼캐시에 적재


버퍼피닝 : 랜덤 액세스에 의한 논리적 블록 요청 횟수 감소

테이블 PREFETCH : 디스크 I/O 에 의한 대기 횟수 감소


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

DIRECT PATH I/O

버퍼캐시를 경유하지 않고 데이터블록을 읽고 씀 

1. Temp 세그먼트 블록들을 읽고 쓸 때

2. 병렬쿼리로 Full Scan을 수행할 때

3. nocache 옵션을 지정한 LOB컬럼을 읽을때

4. direct 옵션을 지정하고 export를 수행할때

5. parallel DML 을 수행할때

6. Direct Path Insert를 수행할때


1. SORT시 PGA의 SORT AREA 초과시 TEMP TABLE SPACE에 읽고, 쓸때

2. 병렬 FULL SCAN일때 10G부터는 병렬쿼리와 관련된 세그먼트만 메모리와 디스크를 동기화 함

3. 병렬 DML 수행, Direct Path Insert 방식으로 데이터를 insert할때 

    (undo 발생량 최소화)

    - insert....select 문장에 /*+ append*/

    - 병렬모드로 insert

    - direct 옵션 지정하고 sql*loader로 데이터 로드

    - CTAS 문장 실행



redo로그까지 최소화하려면

alter table t nologging; 


** Direct Path Insert 방식일 경우 Exclusive 모드 테이블 Lock이 걸리므로 주의 (야간 사용)

다음과 같은 경우도 포함

alter session enable parallel dml;

delete /*+ parallel(b 4) */ from big_table b;  ->Exclusive 모드 TM Lock


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

Result캐시

버퍼캐시에 위치하지 않고 Shared Pool에 위치, 인스턴스 재기동시 초기화

한번 수행한 쿼리 또는 pl/sql 함수의 결과값을 result 캐시에 저장 (11g버전이후)

DML이 거의 발생하지 않는 테이블을 참조하면서 반복수행 요청이 많은 쿼리에 효과적


select /*+ result_cache */ ~~

쿼리 수행시 result 캐시 메모리에서 먼저 찾아보고 없을경우에만 쿼리 실행해서 result 캐시에 저장


결과 집합을 캐싱하지 못하는 경우

1. Dictionary 오브젝트 참조할때

2. Temporary 테이블 참조할때

3. 시퀀스로부터 currval, nextval pseudo 컬럼 호출할때

4. 아래 sql 함수 사용시

   (CURRENT_DATE, CURRENT_TIMESTAMP, LOCAL_TIMESTAMP, SYS_CONTEXT, SYS_GUID, SYSDATE, SYSTIMESTAMP, USERENV)


바인드 변수 사용시는 바인드변수별로 캐싱 (V$RESULT_CACHE_OBJECTS 뷰 확인)

캐싱에 참조되는 테이블 DML시 RESULT_CACHE는 무효화

특정 블록에서도 캐싱 가능

1.(SELECT * FROM TAB1, (SELECT /*+RESULT_CACHE */ FROM TAB2) ~~

2.WITH WV_TEST AS (SELECT /*+RESULT_CACHE */ ~~

3.SELECT ~~ UNION ALL SELECT /*+RESULT_CACHE */ ~~~

4. WHERE 절 서브쿼리 캐싱은 불가능


다음에 효과적

- 작은 결과 집합을 얻으려고 대용량 데이터를 읽어야 할 때

- 읽기 전용의 작은 테이블을 반복적으로 읽어야 할 때

- 읽기 전용 코드 테이블을 읽어 코드명칭을 반환하는 함수


다음에는 사용X

- 쿼리가 참조하는 테이블에 DML 이 자주 발생

- 함수 또는 바인드 변수를 가진 쿼리에서 입력되는 값의 종류가 많고, 다양할때


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

I/O 효율화


필요한 최소 블록만 읽도록 쿼리 작성 

  -> 함수 사용은 제일 바깥쪽 쿼리에

  -> 조인도 가능하면 제일 바깥쪽 쿼리에

  -> 스칼라 서브쿼리에 같은 테이블을 조회하면 FROM 절에서 한번만 조회하게

최적의 옵티마이징 팩터 제공

  -> 통계정보 수집, 윈도우 함수 사용

힌트 사용으로 최적의 엑세스 경로 유도



오라클 성능고도화

블로그 이미지

마스터오라클

오라클 성능 튜닝에 관해 STUDY한 자료를 정리하는 블로그입니다.

,

Call 통계

Parse Call : 커서를 파싱하는 과정에 대한 통계 (실행계획 생성하거나 찾음)

Execute Call : 커서를 실행하는 단계에 대한 통계

Fetch Call : 레코드를 읽어 사용자가 요구한 결과집합을 반환하는 과정에 대한 통계


select : execute 단계에서는 커서만 오픈, 실제 데이터 처리과정은 fetch에서 이루어짐

dml : execute 단계에서 모든 처리, fetch call은 없슴


User Call : 오라클 외부에서 들어오는 Call

Recursive Call : 오라클 내부에서 발생하는 Call



User Call을 줄이려면....

1. One-Sql 구현

2. Array Processing

3. 부분범위처리 활용

4. 페이징 처리

5. 사용자정의함수/프로시져 활용


Recursive Call을 줄이려면...

1. 바인드변수 사용

2. 무분별한 Pl/sql 사용 금지하고 적절한 경우만 사용

3. 대용량 쿼리에서 함수 호출 자재->조인 OR 스칼라 서브쿼리로 대체


PL/SQL은 빈번히 호출시 컨텍스트 스위칭 때문에 성능 저하



Call 구분 

User 

Recursive 

Parse 

 Parse Call 최소화 -> 애플리케이션 커서 캐싱

(사용자 정의 함수/프로시저에서는 자동으로 기능)

Execute

Array Processing

One-Sql 구현

AP 설계 및 표준 가이드 

Array Processing

함수 반복 호출 최소화

->조인.스칼라서브쿼리사용 

Fetch

Array 단위 Fetch

부분범위처리 활용

페이지 처리

Cursor For Loop 문 사용(10g) 



데이타베이스 CALL을 최소화 하기 위한 방법

1. SELECT 한 후 LOOP 돌면서 INSERT 하는 쿼리는

INSERT INTO ~

SELECT ~

형태로 바꾸는걸 고려


2. 같은 테이블을 탐색하는 다수의 INLINE VIEW

CASE 구문이나 DECODE로 변경


3. 여러개의 테이블에 저장할 때는 INSERT ALL 이나 INSERT FIRST 활용

insert all / first
when sal in (800,1600) then
into emp (empno,ename,job) values (empno,ename,job)
when sal = 3200 then
into emp_1 (empno,ename,job) values (empno,ename,job)
else
into emp_2 (empno,ename,job) values (empno,ename,job)
select empno,ename,job
from emp


INSERT FIRST 첫번째 조건을 만족하면 다음 조건은 보지 않음

INSERT ALL 첫번째 조건을 만족해도 모든 조건을 다봄



Array Processing 활용

java

addBatch, setFetchSize 를 활용해서 array size 늘려줌 (java 기본은 10)


pl/sql

FOR ALL i in p_empno.first..p_empno.last INSERT INTO emp2~~

~~

FETCH  c BULK COLLECT INTO col1, col2 LIMIT l_fetch_size



Fetch Call 최소화

부분범위처리

ArraySize 조정으로 Fetch Call 최소화

->ArraySize를 키울수록 어느 임계점까지 Fetch Count, Block I/O가 줄어들음..

->OLTP 환경에서는 부분으로 보여주는 경우가 많으므로 적게 DW성에서는 전체를 대상으로 하기때문에 많이 잡아주는게 유리


SDU(Session Data Unit) : 세션 레이어 데이터 버퍼에 대한 규격, 네트워크를 통해 전송하기 전에 Oracle Net이 데이터를 담아두려고 사용하는 버퍼


TDU(Transport Data Unit) : Transport 레이어 데이터 버퍼에 대한 규격, 물리적인 하부 레이어로 내려보내기 전에 데이터를 잘개 쪼개어 클라이언트에게 전송되는 도중에 유실이나 에러가 없도록 제어


pl/sql

for item in cusor

loop

....

end loop;


java

stmt.setFetchSize(100); --Statement

rs.setFetchSize(100); --ResultSet

-> rs.next() 시 최초 100건을 가져와서 Client Array 버퍼에 캐싱 이후 100건을 소진시까지 Array버퍼에서 가져옴 100건 이후부터는 다시 100건을 가져옴



pl/sql 함수 사용의 주의점

인터프리터 언어로서 실행시마다 sql 실행엔진과 pl/sql 가상머신 사이에 컨텍스트 스위칭 발생, 대부분 생성시 Recursive Call을 포함하므로  Execute Call, Fetch Call이 기하 급수적으로 늘어남

--> 사용자 정의함수는 소량의 데이터 조회에만 사용하거나 대용량이라도 부분범위 처리가 가능한 환경에서만 사용--> 가급적 조인이나 스칼라 서브쿼리 이용

--> 조건절에 함수 사용시 인덱스 엑세스를 이용하는 조건에 사용해서 호출 회수 줄임

--> 함수내에서 수행되는 Recursive 쿼리는 메인쿼리의 시작 시점과 무관하게 그 쿼리가 수행되는 시점을 기준으로 블록을 읽기 때문에 문장수준 일관성이 보장 안된다.  -> 가급적 조인이나 스칼라 서브쿼리를 이용해야 한다.

--> 변경이 자주 안 일어나는 코드성 테이블에 사용 혹은 코드성 테이블을 생성

--> decode나 case문 활용

--> 뷰머징 방지 (transformer가 쿼리변환으로 뷰머징 했을 경우를 방지) no_merge 힌트나 rownum 삽입

--> (SELECT FN_FUNC() FROM DUAL) 처럼 스칼라 서브쿼리로 만들어 캐싱효과를 주자. 입력값이 많으면 해시탐색에 걸리는 시간이 많으므로 주의해서 사용

--> Deterministic 사용 (스칼라 서브 쿼리는 uga에 입력되서 입/출력값이 db call 에 상관없이 끝까지 유지하지만 Deterministic은 cga에 입력되서 db call 에 한해서만 유지: fetch call 완료되면 소멸) 일반함수처럼 일관성 보장 못하므로 동일 결과를 출력하는 함수만 사용




 



오라클 성능고도화


블로그 이미지

마스터오라클

오라클 성능 튜닝에 관해 STUDY한 자료를 정리하는 블로그입니다.

,


1. SQL에서 참조하는 오브젝트명이 같지만 SQL을 실행한 사용자에 따라 다른 오브젝트를 가리킬때


2. 참조 오브젝트가 변경돼 커서가 무효화되면 이후 그 커서를 처음 사용하려는 세션에 의해 다시 하드파싱돼야 하는데, 특정 세션이 아직 기존 커서를 사용중(PIN) 일 때


3. 옵티마이저 모드를 비롯해 옵티마이저 관련 파라미터가 다를때


4. 입렫된 바인드 값의 길이가 크게 다를 때  (VARCHAR)


5. NLS 파라미터를 다르게 설정했을 때


6. SQL 트레이스를 활성화 했을 때




오라클 성능고도화

블로그 이미지

마스터오라클

오라클 성능 튜닝에 관해 STUDY한 자료를 정리하는 블로그입니다.

,

1. SQL 처리 과정

A.SQL PARSING -> B.OPTIMIZER  -> C. ROW-SOURCE GENERATION  -> D.EXECUTION


A : 문법검사(문맥오류) -> 의미검사(오브젝트 존재 유무)

B : OPTIMIZER 3가지 SUB 엔진

1. QUERY TRANSFORMATION : 쿼리 변환(MERGE, UNEST 등)

2. PLAN GENERATOR : 실행계획 생성

3. ESTIMATOR : 비용 계산(선택도 카디널리 계산 및 총 비용 계산)

C : 오라클 내부만의 코드 생성



* 라이브러리 캐시 안에 SQL을 찾기 위해 사용되는 SQLID는 SQL문장 그 자체로 들어가 있슴 (대소문자,공백,주석등 달라지면 다른 SQL)


* 소프트 파싱 : A를 거친 후 메모리(LIBRARY CACHE)에서 같은 SQL을 찾아 D로 바로 실행

* 하드 파싱 : A를 거친 후 메모리(LIBRARY CACHE)에서 같은 SQL을 찾지 못해 B-C 과정을 거침 (하드란 말처럼 OPTIMIZER의 단계는 그만큼 무겁다)


커서 (다음의 3가지 모두 커서라고 호칭)

공유커서 : 라이브러리 캐시에 공유되 잇는 Shared SQL Area  (클래스 상태)

세션커서 : Private Sql Area 에 저장된 커서 , 

공유커서를 실행하기 위해 PGA에 메모리(Private Sql Area)를 할당 (인스턴스상태)하고 공유커서에 대한 포인터를 유지 = 커서를 오픈한다고 표현

에플리케이션커서 : 세션 커서를 가리키는 핸들 (java, vb같은 애플리케이션에 메모리 할당)



** 하드 파싱을 줄이기 위해선 바인드 변수의 사용이 중요하다.


바인드변수 사용의 단점

실행단계에서 변수가 바인드 되기 때문에 SQL 최적화 시점에 컬럼의 히스토그램을 사용하지 못한다. -> 분포도에 따라 인덱스 스캔 OR 풀스캔이 유리한데 균등분포를 사용하기 때문에 실행계획이 고정된다. 그렇더라도 OLTP 환경에선 동시접속자가 많으므로 하드파싱으로 인한 부하를 줄이는게 효과적이다.


** DW 나 OLAP 환경에선 상수가 오히려 유리


바인드 변수 PEEKING : SQL이 첫 번째 수행되면서 하드파싱할때 함께 딸려온 바인드 변수 값을 훔쳐보고 그 값에 대한 컬럼 분포를 이용해 실행 계획을 결정

-> 분포도에 따라 최악의 실행 계획 결정 가능성이 있슴


적응적 커서 공유 : 바인드변수에 따라 커서를 분기해서 실행계획을 결정, 선택도가 비슷한 변수는 같은 커서를 공유 (조건절 컬럼에 히스토그램이 생성되어 있어야 한다.)

V$SQL 에서 IS_BIND_AWARE = 'Y' 로 나타남


쿼리에서 라이브러리 캐시 최적화를 구현

DW

SELECT /*+FULL */

FROM    테이블 A

WHERE   선택도 높은 컬럼 조건

UNION ALL

SELECT /*+INDEX A(IDX01) */

FROM    테이블 A

WHERE   선택도 낮은 컬럼 조건


ON-LINE 

ONLINE 에선 위처럼 작성하면 하드파싱의 부하도 높이고 실행단계의 CPU 사용량도 높아짐

1. 변수에 따른 UNION ALL로 분리

SELECT /*+FULL */

FROM    테이블 A

WHERE   :bind is null

AND    ~~

UNION ALL

SELECT /*+INDEX A(IDX01) */

FROM    테이블 A

WHERE   :bind is not null

AND       A.COL1 = :bind


2.IF ELSE 로 분기



조건절에 따른 쿼리기준

1. NOT NULL 컬럼일때는 NVL, DECODE 사용

2. NULL 컬럼일때는 위와 같이 UNION ALL 로 분기

3. 인덱스 ACCESS 조건이 아닐때는 :C IS NULL OR COL=:C  또는 C LIKE :C || '%' 사용


STATIC SQL 구현을 위한 쿼리

1. IN 조건절이 가변적이면서 갯수가 많지 않을때

   최대 조건 만큼 IN (:A, :B, :C~~)

2. IN 조건절이 가변적이면서 갯수가 많을때 (코드길이가 일정할때)

방법 1 

:inList = '01,02,03,04,55,99'

INSTR(:inList, 분류코드) > 0   -> 분류코드가 인덱스 선두컬럼일때 비효율


방법2

:inList = '010203045599'

select /*+ ordered use_nl(B) */ B.*

from  (select substr(:inList, (level-1)*2+1, 2) 분류코드

         from  dual

         connect by level <= length(:inList) /2 ) A

        ,수시공시내역 B

where B.분류코드 = A.분류코드

3. Exists 쿼리안의 조건이 가변적일경우 

   (exits의 첫번째 만족 조건시 리턴 이용)

and exists (

select 'x' from dual where :chk = 'N'

union all

select 'x'

from  tab1

where tab1.종목 = main.종목

and    otherCond = 'Y'

and    :chk = 'Y'

)

4. select가 동적일때

decode(gbn,1,sum(col1), avg(col1))

sum(decode(gbn,1,col1, col2)) => decode함수를 집계대상 건수만큼 반복하므로 비효율

5. 콤보박스의 이상,이상,미만 등의 조건처럼 가변적일때

where col1 between :min1 and max1

and    col2 between :min2 and max2

      and    col3 between :min3 and max3


세션커서캐싱  

자주 수행하는 SQL에 대한 세션 커서를 세션 커서 캐시에 저장

SQL 텍스트와 공유 커서를 가리키는 포인터를 저장

커서는 닫혀도 포인터는 유지하기때문에 다음 수행시 커서를 빨리 오픈



애플리케이션 커서캐싱

세션커서를 캐싱해도 공유 커서 힙을 PIN하고 실행에 필요한 메모리 공간을 PGA에 할당하는 작업은 하는데 이과정을 생략하는것이 애플리케이션 커서 캐싱

PRO-C

for(;;) {

EXEC ORACLE OPTION (HOLD_CURSOR = YES);

EXEC ORACLE OPTION (RELEASE_CURSOR = NO);

EXE SQL........

EXEC ORACLE OPTION (RELEASE_CURSOR = YES);

}

-> EXECUTE는 다수일지라도 PARSE CALL 은 1번


JAVA 1 : statement를 loop 밖에 선언, 해제

PreparedStatement stmt = con.preparedStatement(~~);

Resultset rs;

for(;;) {

stmt.setInt(1,i);

stmt.setString(2,"abc");

rs = stmt.executeQuery();

rs.close();

}

stmt.close();


JAVA 2 : 묵시적 캐싱 사용

((OracleConnection)conn).setStatementCacheSize(1);    //캐시사이즈 지정

((OracleConnection)conn).setImplicitCachingEnabled(true);        //묵시적 캐싱 기능 활성화

for(;;) {

PreparedStatement stmt = con.preparedStatement(~~);

stmt.setInt(1,i);

stmt.setString(2,"abc");

rs = stmt.executeQuery();

rs.close();

stmt.close();    //커서는 닫지만 내부적으로 닫히지 않은 채 캐시에 보관

}


오라클 성능고도화


블로그 이미지

마스터오라클

오라클 성능 튜닝에 관해 STUDY한 자료를 정리하는 블로그입니다.

,

select parsing_schema_name 

     , count(*) sql_cnt

     , count(distinct substr(sql_text, 1, 100)) sql_cnt2

     , sum(executions) executions

     , round(avg(buffer_gets/executions)) buffer_gets

     , round(avg(disk_reads/executions)) disk_reads

     , round(avg(rows_processed/executions)) rows_processed

     , round(avg(elapsed_time/executions/1000000),2) "ELAPSED_TIME(AVG)"

     , count(case when elapsed_time/executions/1000000 >= 10 then 1 end) "BAD SQL"

     , round(max(elapsed_time/executions/1000000),2) "ELAPSED_TIME(MAX)"

from   v$sql

where  last_active_time >= sysdate - 7

and    executions > 0

group by parsing_schema_name

;


sql_cnt : sql 개수

sql_cnt2 : sql 개수(unique)

executions : 수행횟수

buffer_gets : 논리적 I/O

disk_reads : 디스크 I/O

rows_processed : 처리건수

ELAPSED_TIME(AVG) :  평균처리시간

BAD SQL : 악성 SQL (10초 이상)

ELAPSED_TIME(MAX) : 최대소요시간



* sql_cnt와  sql_cnt2 의 차이가 크다면 하드파싱 부하 심함

buffer_gets, ELAPSED_TIME 가 큰 항목은 집중 튜닝 대상




--오라클 성능고도화

블로그 이미지

마스터오라클

오라클 성능 튜닝에 관해 STUDY한 자료를 정리하는 블로그입니다.

,

v$system_event

튜닝 2016. 12. 26. 08:28

v$system_event

인스턴스 기동 후 현재까지 누적된 이벤트 발생현화을 시스템 레벨로 확인


v$session_event

개별 세션별로 확인


v$session_wait

세션별로 현재 진행중이거나 바로 직전에 발생했던 이벤트



특정 세션의 이벤트 발생 현황 보기

select  event

      , wait_time

      , seconds_in_wait

      , state

      , p1text || '->' || p1 || ',' || p2text || '->' || p2

        || ',' || p3text || '->' || p3 param

from    v$session_wait

where   sid=47

order by wait_class_id;


wait_time > 0 : 마지막 대기이벤트를 대기한 시간

wait_time = 0 : 이 이벤트를 현재 대기중

wait_time = -1 : 마지막 대기 이벤트를 대기한 시간이 10ms 미만

wait_time = -2 : 타이밍이 활성화되지 않음





--오라클 성능 고도화 원리와 해법

블로그 이미지

마스터오라클

오라클 성능 튜닝에 관해 STUDY한 자료를 정리하는 블로그입니다.

,

SQL 실행 순서

SQL 기본 2016. 12. 23. 08:53

SQL 실행 순서를 의외로 모르시는 분들이 있는 거 같네요..


기본 SQL

SELECT    DEPTNO, SUM(SAL)             5

FROM      EMP                          1

WHERE    JOB = ‘SALESMAN’              2

GROUP BY DEPTNO                        3

HAVING  SAL > 2000                     4  

ORDER BY DEPTNO                        6



조인이 있는 SQL (DRIVING TABLE :EMP)

SELECT E.EMPNO, E.ENAME, D.DNAME      5

FROM EMP E, DEPT D        1

WHERE E.DEPTNO = D.DEPTNO                3

AND E.JOB = ‘SALESMAN’           2

AND D.LOC = ‘NEW YORK’                4

'SQL 기본' 카테고리의 다른 글

ROLLUP, CUBE, GROUPING SET 의 원리_작성중  (0) 2017.01.05
블로그 이미지

마스터오라클

오라클 성능 튜닝에 관해 STUDY한 자료를 정리하는 블로그입니다.

,