Oracle AWR을 활용한 주요 Stats 지표 추출 스크립트



 

해당 시점의 SNAP.SNAP_ID를 설정하여 추출한 데이터를 엑셀 또는 시각화 Tool로 뽑아내여 주요 Stats 상태 분석이 가능하도록 해준다. 각 Stats의 명칭을 조정하여 원하는 DB 상태를 조회해볼수 있다.



  SELECT SNAP_TIME,

         SNAP_TIME_RANGE,

         TO_CHAR (SUM (DECODE (STAT_NAME, 'session logical reads', VALUE)),

                  'FM999,999,999,999.9')

            "Session Logical Reads/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'physical reads', VALUE)),

                  'FM999,999,999.9')

            "Physical Reads/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'execute count', VALUE)),

                  'FM999,999,999.9')

            "Execute Count/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'user calls', VALUE)),

                  'FM999,999,999.9')

            "User Calls/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'user commits', VALUE)),

                  'FM999,999,999.9')

            "User Commits/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'user rollbacks', VALUE)),

                  'FM999,999,999.9')

            "User Rollbacks/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'CPU used by this session', VALUE)),

                  'FM999,999,999.9')

            "CPU used by this session/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'DB time', VALUE)),

                  'FM999,999,999.9')

            "DB time/Sec",

         TO_CHAR (

            (SUM (DECODE (STAT_NAME, 'DB time', VALUE)) * 10)

            / DECODE (SUM (DECODE (STAT_NAME, 'user calls', VALUE)),

                      0, 1,

                      SUM (DECODE (STAT_NAME, 'user calls', VALUE))),

            'FM999,999,999.999')

            "User Response Time(ms)/Sec",

         TO_CHAR (

            (SUM (DECODE (STAT_NAME, 'DB time', VALUE)) * 10)

            / DECODE (

                 (SUM (DECODE (STAT_NAME, 'user commits', VALUE))

                  + SUM (DECODE (STAT_NAME, 'user rollbacks', VALUE))),

                 0, 1,

                 (SUM (DECODE (STAT_NAME, 'user commits', VALUE))

                  + SUM (DECODE (STAT_NAME, 'user rollbacks', VALUE)))),

            'FM999,999,999.999')

            "TX Response Time(ms)/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'application wait time', VALUE)),

                  'FM999,999,999.9')

            "Application Wait Time(cs)/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'cluster wait time', VALUE)),

                  'FM999,999,999.9')

            "Cluster Wait Time(cs)/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'concurrency wait time', VALUE)),

                  'FM999,999,999.9')

            "Concurrency Wait Time(cs)/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'user I/O wait time', VALUE)),

                  'FM999,999,999.9')

            "User I/O Wait Time(cs)/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'CR blocks created', VALUE)),

                  'FM999,999,999.9')

            "CR blocks created/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'consistent gets', VALUE)),

                  'FM999,999,999.9')

            "Consistent Gets/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'consistent changes', VALUE)),

                  'FM999,999,999.9')

            "Consistent Changes/Sec",

         TO_CHAR (

            SUM (

               DECODE (

                  STAT_NAME,

                  'data blocks consistent reads - undo records applied', VALUE)),

            'FM999,999,999.9')

            "DB Blocks cr-undo rec appl/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'db block gets', VALUE)),

                  'FM999,999,999.9')

            "DB Block Gets/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'db block changes', VALUE)),

                  'FM999,999,999.9')

            "DB Block Changes/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'enqueue releases', VALUE)),

                  'FM999,999,999.9')

            "Enqueue Releases/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'enqueue waits', VALUE)),

                  'FM999,999,999.9')

            "Enqueue Waits/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'free buffer inspected', VALUE)),

                  'FM999,999,999.9')

            "Free Buffer Inspected/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'free buffer requested', VALUE)),

                  'FM999,999,999.9')

            "Free Buffer Requested/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'DBWR checkpoints', VALUE)),

                  'FM999,999,999.9')

            "DBWR checkpoints/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'DBWR lru scans', VALUE)),

                  'FM999,999,999.9')

            "DBWR lru scans/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'DBWR undo block writes', VALUE)),

                  'FM999,999,999.9')

            "DBWR undo block writes/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'physical writes', VALUE)),

                  'FM999,999,999.9')

            "Physical Writes/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'physical writes direct', VALUE)),

                  'FM999,999,999.9')

            "Physical Writes Direct/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'branch node splits', VALUE)),

                  'FM999,999,999.9')

            "Branch Node Splits/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'leaf node splits', VALUE)),

                  'FM999,999,999.9')

            "Leaf Node Splits/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'leaf node 90-10 splits', VALUE)),

                  'FM999,999,999.9')

            "Leaf Node 90-10 Splits/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'commit cleanouts', VALUE)),

                  'FM999,999,999.9')

            "Commit Cleanouts/Sec",

         TO_CHAR (

            SUM (

               DECODE (STAT_NAME,

                       'cleanouts only - consistent read gets', VALUE)),

            'FM999,999,999.9')

            "Cleanouts Only-CRgets/Sec",

         TO_CHAR (

            SUM (

               DECODE (STAT_NAME,

                       'cleanouts and rollbacks - consistent read gets', VALUE)),

            'FM999,999,999.9')

            "Cleanouts&Rollbacks-CRgets/Sec",

         TO_CHAR (

            SUM (DECODE (STAT_NAME, 'index fast full scans (full)', VALUE)),

            'FM999,999,999.9')

            "Index FastFullScans(full)/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'table fetch by rowid', VALUE)),

                  'FM999,999,999.9')

            "Table Fetch By Rowid/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'table fetch continued row', VALUE)),

                  'FM999,999,999.9')

            "Table Fetch Continued Row/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'table scans (long tables)', VALUE)),

                  'FM999,999,999.9')

            "Table Scans (long tables)/Sec",

         TO_CHAR (

            SUM (DECODE (STAT_NAME, 'table scans (short tables)', VALUE)),

            'FM999,999,999.9')

            "Table Scans (short tables)/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'table scan blocks gotten', VALUE)),

                  'FM999,999,999.9')

            "Table Scan Blocks gotten/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'table scan rows gotten', VALUE)),

                  'FM999,999,999.9')

            "Table Scan Rows gotten/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'logons cumulative', VALUE)),

                  'FM999,999,999.9')

            "Logons Cumulative/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'opened cursors cumulative', VALUE)),

                  'FM999,999,999.9')

            "Opened Cursors Cumulative/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'parse count (total)', VALUE)),

                  'FM999,999,999.9')

            "Parse Count (total)/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'parse count (hard)', VALUE)),

                  'FM999,999,999.9')

            "Parse Count (hard)/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'parse count (failures)', VALUE)),

                  'FM999,999,999.9')

            "Parse Count (failures)/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'parse time cpu', VALUE)),

                  'FM999,999,999.9')

            "Parse Time CPU/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'parse time elapsed', VALUE)),

                  'FM999,999,999.9')

            "Parse Time Elapsed/Sec",

         TO_CHAR (

            SUM (DECODE (STAT_NAME, 'session cursor cache count', VALUE)),

            'FM999,999,999.9')

            "Session Cursor Cache Count/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'session cursor cache hits', VALUE)),

                  'FM999,999,999.9')

            "Session Cursor Cache Hits/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'redo entries', VALUE)),

                  'FM999,999,999.9')

            "Redo Entries/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'redo size', VALUE)),

                  'FM999,999,999.9')

            "Redo Size/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'redo write time', VALUE)),

                  'FM999,999,999.9')

            "Redo Write Time/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'sorts (disk)', VALUE)),

                  'FM999,999,999.9')

            "Sorts (disk)/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'sorts (memory)', VALUE)),

                  'FM999,999,999.9')

            "Sorts (memory)/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'sorts (rows)', VALUE)),

                  'FM999,999,999.9')

            "Sorts (rows)/Sec",

         TO_CHAR (

            SUM (

               DECODE (

                  STAT_NAME,

                  'transaction tables consistent reads - undo records applied', VALUE)),

            'FM999,999,999.9')

            "TX cr Undo Record applied/Sec",

         TO_CHAR (

            SUM (

               DECODE (STAT_NAME,

                       'transaction tables consistent read rollbacks', VALUE)),

            'FM999,999,999.9')

            "TX cr read rollbacks/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'undo change vector size', VALUE)),

                  'FM999,999,999.9')

            "Undo Change Vector Size/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'logons current', VALUE)),

                  'FM999,999,999.9')

            "Logons Current",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'opened cursors current', VALUE)),

                  'FM999,999,999.9')

            "Opened Cursors Current",

         TO_CHAR (

            SUM (

               DECODE (STAT_NAME, 'SQL*Net roundtrips to/from client', VALUE)),

            'FM999,999,999.9')

            "SQLNet RoundTrip Client/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'physical read total bytes', VALUE)),

                  'FM999,999,999.9')

            "Physical Read Total Bytes/Sec",

         TO_CHAR (

            SUM (

               DECODE (STAT_NAME, 'cell physical IO interconnect bytes', VALUE)),

            'FM999,999,999.9')

            "CellPhy.IOInterconnectByte/Sec",

         TO_CHAR (

            SUM (

               DECODE (STAT_NAME,

                       'cell physical IO bytes saved by storage index', VALUE)),

            'FM999,999,999.9')

            "CellPhy.IOBytesSavedbySInd/Sec",

         TO_CHAR (

            SUM (

               DECODE (

                  STAT_NAME,

                  'cell physical IO interconnect bytes returned by smart scan', VALUE)),

            'FM999,999,999.9')

            "CellPhy.IOByteReturnedbySS/Sec",

         TO_CHAR (

            SUM (DECODE (STAT_NAME, 'physical read total IO requests', VALUE)),

            'FM999,999,999.9')

            "Physical Read Total IO Req/Sec",

         TO_CHAR (

            SUM (DECODE (STAT_NAME, 'physical read requests optimized', VALUE)),

            'FM999,999,999.9')

            "Physical Read Req Opt./Sec",

         TO_CHAR (

            SUM (DECODE (STAT_NAME, 'cell flash cache read hits', VALUE)),

            'FM999,999,999.9')

            "Cell Flash Cache Read Hits/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'cell scans', VALUE)),

                  'FM999,999,999.9')

            "Cell Scans/Sec",

         TO_CHAR (SUM (DECODE (STAT_NAME, 'cell index scans', VALUE)),

                  'FM999,999,999.9')

            "Cell Index Scans/Sec"

    FROM (SELECT STAT_NAME,

                 DECODE (G1,

                         1, 'SUB AVG',

                         SUBSTR (SNAP_TIME, 1, INSTR (SNAP_TIME, '-') - 1))

                    SNAP_TIME,

                 SNAP_TIME SNAP_TIME_RANGE,

                 VALUE,

                 VALUE_DIFF

            FROM (  SELECT STAT_NAME,

                           START_TIME || '-' || END_TIME SNAP_TIME,

                           ROUND (AVG (NVL (VALUE, 0)), 1) VALUE,

                           ROUND (AVG (NVL (VALUE_DIFF, 0)), 1) VALUE_DIFF,

                           GROUPING (START_TIME || '-' || END_TIME) G1,

                           GROUPING (STAT_NAME) G2

                      FROM (SELECT STAT_NAME,

                                   TO_CHAR (SNAP_TIME_C1, 'MM.DD HH24:MI')

                                      START_TIME,

                                   TO_CHAR (SNAP_TIME_C2, 'MM.DD HH24:MI')

                                      END_TIME,

                                   DECODE (

                                      SNAP_TIME_C2,

                                      NULL, 0,

                                      ROUND (

                                         (CASE

                                             WHEN VALUE_2 < VALUE_1 THEN 0

                                             ELSE VALUE_2 - VALUE_1

                                          END)

                                         / (EXTRACT (

                                               DAY FROM SNAP_TIME_C2

                                                        - SNAP_TIME_C1)

                                            * 86400

                                            + EXTRACT (

                                                 HOUR FROM SNAP_TIME_C2

                                                           - SNAP_TIME_C1)

                                              * 3600

                                            + EXTRACT (

                                                 MINUTE FROM SNAP_TIME_C2

                                                             - SNAP_TIME_C1)

                                              * 60

                                            + EXTRACT (

                                                 SECOND FROM SNAP_TIME_C2

                                                             - SNAP_TIME_C1)),

                                         1))

                                      VALUE,

                                   (CASE

                                       WHEN VALUE_2 < VALUE_1 THEN 0

                                       ELSE VALUE_2 - VALUE_1

                                    END)

                                      VALUE_DIFF,

                                   ROW_NUMBER ()

                                   OVER (PARTITION BY INSTANCE_NUMBER, STAT_NAME

                                         ORDER BY SNAP_ID)

                                      RNUM,

                                   SNAP_ID,

                                   INSTANCE_NUMBER

                              FROM (  SELECT /*+ LEADING(DBI) USE_HASH(SNAP STAT) */

                                            SNAP.END_INTERVAL_TIME

                                                SNAP_TIME_C1,

                                             LEAD (

                                                SNAP.END_INTERVAL_TIME)

                                             OVER (

                                                PARTITION BY DBI.INSTANCE_NUMBER,

                                                             STAT_NAME

                                                ORDER BY SNAP.SNAP_ID)

                                                SNAP_TIME_C2,

                                             STAT.STAT_NAME,

                                             STAT.VALUE VALUE_1,

                                             LEAD (

                                                STAT.VALUE)

                                             OVER (

                                                PARTITION BY DBI.INSTANCE_NUMBER,

                                                             STAT_NAME

                                                ORDER BY SNAP.SNAP_ID)

                                                VALUE_2,

                                             SNAP.SNAP_ID,

                                             DBI.INSTANCE_NUMBER

                                        FROM (SELECT           /*+ NO_MERGE */

                                                    DI.DBID,

                                                     DI.INSTANCE_NUMBER,

                                                     DI.STARTUP_TIME

                                                FROM DBA_HIST_DATABASE_INSTANCE DI

                                               WHERE     DI.DBID = (select dbid from v$database) --변경 

                                                     AND DI.INSTANCE_NUMBER = (select  INSTANCE_NUMBER from v$instance)  --변경

                                                     AND ROWNUM <= 1) DBI,

                                             DBA_HIST_SNAPSHOT SNAP,

                                             DBA_HIST_SYSSTAT STAT

                                       WHERE DBI.DBID = SNAP.DBID

                                             AND DBI.INSTANCE_NUMBER =

                                                    SNAP.INSTANCE_NUMBER

                                             AND DBI.DBID = SNAP.DBID

                                             AND SNAP.SNAP_ID >= :3

                                             AND SNAP.SNAP_ID <= :4

                                             AND SNAP.DBID = STAT.DBID

                                             AND SNAP.INSTANCE_NUMBER =

                                                    STAT.INSTANCE_NUMBER

                                             AND SNAP.SNAP_ID = STAT.SNAP_ID

                                             AND STAT.STAT_NAME IN

                                                    ('session logical reads',

                                                     'physical reads',

                                                     'execute count',

                                                     'user calls',

                                                     'user commits',

                                                     'user rollbacks',

                                                     'CPU used by this session',

                                                     'DB time',

                                                     'application wait time',

                                                     'cluster wait time',

                                                     'concurrency wait time',

                                                     'user I/O wait time',

                                                     'CR blocks created',

                                                     'consistent changes',

                                                     'consistent gets',

                                                     'db block changes',

                                                     'data blocks consistent reads - undo records applied',

                                                     'db block gets',

                                                     'enqueue releases',

                                                     'enqueue waits',

                                                     'DBWR checkpoints',

                                                     'DBWR lru scans',

                                                     'DBWR undo block writes',

                                                     'free buffer inspected',

                                                     'free buffer requested',

                                                     'physical writes',

                                                     'physical writes direct',

                                                     'branch node splits',

                                                     'leaf node 90-10 splits',

                                                     'leaf node splits',

                                                     'cleanouts and rollbacks - consistent read gets',

                                                     'cleanouts only - consistent read gets',

                                                     'commit cleanouts',

                                                     'index fast full scans (full)',

                                                     'table fetch by rowid',

                                                     'table fetch continued row',

                                                     'table scan blocks gotten',

                                                     'table scan rows gotten',

                                                     'table scans (long tables)',

                                                     'table scans (short tables)',

                                                     'logons cumulative',

                                                     'opened cursors cumulative',

                                                     'parse count (total)',

                                                     'parse count (hard)',

                                                     'parse count (failures)',

                                                     'parse time cpu',

                                                     'parse time elapsed',

                                                     'session cursor cache count',

                                                     'session cursor cache hits',

                                                     'redo entries',

                                                     'redo size',

                                                     'redo sync time',

                                                     'redo write time',

                                                     'sorts (disk)',

                                                     'sorts (memory)',

                                                     'sorts (rows)',

                                                     'sql area evicted',

                                                     'sql area purged',

                                                     'undo change vector size',

                                                     'SQL*Net roundtrips to/from client',

                                                     'transaction tables consistent reads - undo records applied',

                                                     'transaction tables consistent read rollbacks',

                                                     'physical read total bytes',

                                                     'physical read total IO requests',

                                                     'physical read requests optimized',

                                                     'cell physical IO interconnect bytes',

                                                     'cell physical IO bytes saved by storage index',

                                                     'cell physical IO interconnect bytes returned by smart scan',

                                                     'cell flash cache read hits',

                                                     'cell scans',

                                                     'cell index scans')

                                    ORDER BY SNAP.SNAP_ID)

                             WHERE SNAP_TIME_C2 <> SNAP_TIME_C1)

                     WHERE START_TIME IS NOT NULL AND END_TIME IS NOT NULL

                  GROUP BY ROLLUP (STAT_NAME, START_TIME || '-' || END_TIME))

           WHERE NOT (G1 = 1 AND G2 = 1)

          UNION ALL

          SELECT STAT_NAME,

                 DECODE (G1,

                         1, 'SUB AVG',

                         SUBSTR (SNAP_TIME, 1, INSTR (SNAP_TIME, '-') - 1))

                    SNAP_TIME,

                 SNAP_TIME SNAP_TIME_RANGE,

                 VALUE,

                 NULL VALUE_DIFF

            FROM (  SELECT STAT_NAME,

                           START_TIME || '-' || END_TIME SNAP_TIME,

                           ROUND (

                              AVG (DECODE (SIGN (VALUE), -1, 0, NVL (VALUE, 0))),

                              1)

                              VALUE,

                           GROUPING (START_TIME || '-' || END_TIME) G1,

                           GROUPING (STAT_NAME) G2

                      FROM (SELECT STAT_NAME,

                                   TO_CHAR (SNAP_TIME_1, 'MM.DD HH24:MI')

                                      START_TIME,

                                   TO_CHAR (SNAP_TIME_2, 'MM.DD HH24:MI')

                                      END_TIME,

                                   DECODE (SNAP_TIME_2,

                                           NULL, 0,

                                           ROUND ( (VALUE_1 - VALUE_2), 1))

                                      VALUE,

                                   ROW_NUMBER ()

                                   OVER (PARTITION BY INSTANCE_NUMBER, STAT_NAME

                                         ORDER BY SNAP_ID)

                                      RNUM,

                                   SNAP_ID,

                                   INSTANCE_NUMBER

                              FROM (  SELECT SNAP.BEGIN_INTERVAL_TIME SNAP_TIME_1,

                                             STAT.STAT_NAME,

                                             STAT.VALUE VALUE_1,

                                             0 VALUE_2,

                                             SNAP.END_INTERVAL_TIME SNAP_TIME_2,

                                             SNAP.SNAP_ID,

                                             DBI.INSTANCE_NUMBER

                                        FROM (SELECT DI.DBID,

                                                     DI.INSTANCE_NUMBER,

                                                     DI.STARTUP_TIME

                                                FROM DBA_HIST_DATABASE_INSTANCE DI

                                               WHERE     DI.DBID = (select dbid from v$database) --변경

                                                     AND DI.INSTANCE_NUMBER = (select  INSTANCE_NUMBER from v$instance)  --변경

                                                     AND ROWNUM <= 1) DBI,

                                             DBA_HIST_SNAPSHOT SNAP,

                                             DBA_HIST_SYSSTAT STAT

                                       WHERE DBI.DBID = SNAP.DBID

                                             AND DBI.INSTANCE_NUMBER =

                                                    SNAP.INSTANCE_NUMBER

                                             AND SNAP.SNAP_ID >= :7

                                             AND SNAP.SNAP_ID <= :8

                                             AND SNAP.DBID = STAT.DBID

                                             AND SNAP.INSTANCE_NUMBER =

                                                    STAT.INSTANCE_NUMBER

                                             AND SNAP.SNAP_ID = STAT.SNAP_ID

                                             AND STAT.STAT_NAME IN

                                                    ('opened cursors current',

                                                     'logons current',

                                                     'session pga memory',

                                                     'session uga memory',

                                                     'session pga memory max',

                                                     'session uga memory max')

                                    ORDER BY SNAP.SNAP_ID))

                     WHERE RNUM > 1

                  GROUP BY ROLLUP (STAT_NAME, START_TIME || '-' || END_TIME))

           WHERE NOT (G1 = 1 AND G2 = 1)

          ORDER BY STAT_NAME, SNAP_TIME)

GROUP BY SNAP_TIME, SNAP_TIME_RANGE

ORDER BY SNAP_TIME








블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,



압축기술 (데이터 전송효율을 높이기 위한)



1. 압축 기술의 개요

1-1. 개념

 - Text, 멀티 미디어(오디오, 영상) 서비스를 위한 효과적 데이터 저장공간, 전송을 위해 부피를 줄이고(부호화), 원데이터로 복원(복호화)하는 기술

- 데이터를 더 작은 크기로 변환하는 인코딩, 원래 데이터로 복원하는 디코딩으로 이루어짐


1-2. 데이터 압축의 원리

 - 중복제거: 공간적 중복성 (연속되는 공간에서 상관되는 정보들), 시간적 중복성(현재 프레임과 이전 프레임 중 상관되는 정보)

 - 크기 축소: 압축률 = 압축 전 비트수 / 압축 후 비트수 >= 1

 - 압축 대상 특성 반영 : 텍스트(Run-Length, Huffman), 정지화상(JPEG, GIF, TIFF), 디지털 컨텐츠( MPEG1, MPEG2~4 )


2. 데이터 압축의 분류 및 압축 기법

2-1. 데이터 압축의 분류

 1) 무손실 압축 : 복원 후 압축전의 데이터와 완전 일치하는 방법 (Run-Length Coding, Huffman Coding 등)

     - 데이터의 통계적 특징 이용 효율적으로 압축 (텍스트, 프로그램, 의료영상)


 2) 손실 압축 : 복원 후 압축전의 데이터와 일치 하지 않는 방법 (예측 기법, 변환기법(FFT, DCT, 계층적 기법)

     - 연속 매체를 압축하는데 적상 ( 이미지, 사운드, 멀티미디어)


 3) 혼합 압축 : 손실압축과 무손실 압축 방법을 모두 사용 (JPEG, MEPG, H.264)

     - 영상 압축에서 많이 사용하는 방식, 매우 큰 압축률 (영상)

2-2. 데이터 압축 기법

 1) 반복순차 부호화

   - 연속길이 부호화 : 반복되는 코드와 개수를 코드로 작성 (영화 동일장면 연속, 음악 한음의 연속적인 구간)

   - 제로 및 공백 변호나 부호화 : 연속길이 부호화의 특별한 경우로 데이터 스트림에서 제로나 공백 문자는 제거


 2) 통계적 부호화

   - 허프만 부호화: 빈도수가 높은 코드에 가중치를 부여하여 새롭게 부호의 코드를 설정하는 방법

   - 산술 부화화 : 심볼의 표본값과 예측된 표본 값의 차를 부호화 하여 정보량을 감소 시킴


 3)  차분/예측 부호화, 변환부호화 등 존재


2-3. 데이터 압축시 장/단점

 1) 장점 : 공간 효율화, 시간 효율화, 프로세싱 효율화, 전송 효율화, ILM 실현(정보생명주기관리)

 2) 단점 : 자원 사용증가, SW 비용증가, SW 개발 복잡도 증가, 품질 저하 가능성, 효율성 저하 가능


3. 데이터 압축시 고려사항

 - 압축수준 : 문자수준, 단어 수준

 - 데이터 모델의 유형 선택 고려 : 정적, 적응, 반정적 모델 

 - 정확한 용도를 파악하여 용도에 알맞는 압축기법 사용 


블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,

Oracle 테이블 사이즈 및 테이블별 카운트 출력 스크립트



1. 테이블 사이즈 조회


  SELECT owner,

         segment_name,

         bytes,

         SUM (bytes / 1024 / 1024)

    FROM dba_segments

   WHERE segment_type = 'TABLE'

         AND owner NOT IN

                ('SYSTEM',

                 'SYS',

                 )

GROUP BY owner, segment_name, bytes order by bytes desc;

 

2. 테이블별 카운트 출력


set serveroutput on

exec dbms_output.enable(1000000);

declare

      CURSOR cur_mytables IS

        select * from dba_tables where owner in (

'TEST'     

,'JOB'   

)         order by owner, table_name;

      v_cnt NUMBER;

    begin

      FOR i IN cur_mytables

      LOOP

        EXECUTE IMMEDIATE ('SELECT /*+ parallel ('||i.table_name||',4) */ COUNT(*) FROM '||i.owner || '.' ||i.table_name) INTO v_cnt;

        --EXECUTE IMMEDIATE ('SELECT COUNT(*) FROM '||i.table_name) INTO v_cnt;

        DBMS_OUTPUT.PUT_LINE(i.owner|| ',' || i.table_name||','||v_cnt);

   END LOOP;

 end;

/ 


블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,


GRC(Governance, Risk & Compliance)


1. GRC(Governance, Risk & Compliance)의 개요

1-1. 정의

 - 개별적 위험/규제 대응이 아닌 기업 전반의 위험관리, Compliance를 IT 거버넌스에 통합, 지속적. 효과성, 투명성을 확보하기 위한 전략


1-2. 배경

- 시대적 변화에 맞추어 리스크 요소들을 적절히 대응하며, 여러가지 법규 및 통제에 효과적으로 대응하기위하여 GRC 개념수립 필요

- 기업 전반의 여러가지 리스크의 정확한 인식 및 효과적인 관리 방안 필요


2. GRC의 개념도, 리스크 관리 절차

2-1. GRC의 개념도

 

 - Risk & Compliance 대응을 통한 IT 거버넌스 실현

2-2. GRC 달성을 위한 리스크 관리 절차

 1) 리스크를 평가하고 관리하기 위한 종합적인 체계 정착 및 프로세스 수립

 2) 중요 리스크 및 취약성 식별과 대응 계획의 수립, 기업가치의 평가

 3) 리스크 선호도와 수용 정도 결정, 추가 리스크 수용여부 의사결정

 4) 리스크 수용에 대한 책임과 권한의 설정


3. GRC의 문제점과 해결 방안

3-1. GRC의 문제점

 - GRC를 IT 차원의 것으로 여기는 오인식 문제

 - 기업 조직상 통합 GRC 추진 어려움

 - 리스크 관리 총 책임자 부재


3-2. GRC의 문제점 해결 방안

 - 전사적 통합 추진이 가능한 책임자와 전담/전문 조직구성

 - 기업 전반의 문제로 인식 전환을 위한 교육



블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,


Oracle Cold(콜드) 백업 스크립트



define 3 = /backup/cold/

 

Set Heading Off

 

Set Verify Off

 

Set FeedBack Off

 

Set LineSize 132

 

Set PageSize 1000

 

set termout off

 

Spool runcoldbackup.sh

 

/* Data Files */

Select 'cp ' || File_Name || ' &&3 ' From DBA_Data_Files

/

 

/* Redo Log Files */

Select 'cp ' || Member || ' &&3 ' From V$LogFile

/

 

/* Control Files */

Select 'cp ' || name || ' &&3 ' From V$controlfile

/

 

/* Temp files */

Select 'cp ' || File_Name || ' &&3 ' From dba_temp_files

 

Spool Off 




블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,


ISO/IEC 38500, IT Governance 국제표준




1. ISO/IEC 38500의 개요

1-1. 개념

 - 조직의 IT활용을 평가(Evaluate), 지휘(Direct), 모니터링(Monitoring)하는데 활용할 수 있는 원칙의 프레임 워크를 제공

 - 정의, 모델, 원칙, 원칙을 구현하기 위한 지침 


1-2. 목적

 - 대부분 조직들이 IT를 기본적인 경영 도구로 활용함

 - IT 없이는 효과적으로 작동 될수 없음

 - IT 활용을 전반적인 비즈니스 관점이 아니라 IT 활동의 기술, 재무, 일정에만 초점


2. ISO/IEC 38500의 모델과 원칙

2-1. ISO/IEC 38500 모델

 - 평가(Evaluate) : IT 활용에 대한 평가는 비즈니스 상의 내외부적 압력, 기술의 변화, 경제/문화/사회적 동향, 정치적 환경등을 고려함

 - 지시(Direct) : 비즈니스 목표를 이루기 위한 IT의 활용을 보장하는 계획과 정책을 준비하고 구현될수 있도록 지시

 - 모니터링(Monitoring) : 적적한 측정 체계에 따라 정책을 준수하는지, 수립된 계획과 비즈니스 목표에 대한 IT 성과 모니터링

2-2. ISO/IEC 38500 원칙

 1) Responsibility : 조직원들은 IT 제공/ 활용에 대한 책임/권한을 이해하고 수용

 2) Strategy : 경영 전략은 IT의 역량을 고려하고, IT 계획은 조직의 니즈를 충족시킴

 3) Acquisition : IT 구매는 투명한 의사결정을 통해서 타당한 목적 하에 이루어진다.

 4) Performance : IT는 요직의 요구를 충적시킨다.

 5) Conformance : IT는 모든 규정/법규를 준수한다.

 6) Human Behavior : IT는 인간행동적 요인을 존중한다.


3. ISO/IEC 38500 표준 활동을 통한 효과

- 준수 : 이사진이 IT의 활용에 대한 책임 (법규, 계약) 준수를 지원

(보안표준, 프라이버시 법규, 스팸 법규, 상거리 법규, 지적재산권 등)


- 조직의 성과 : 이사진이 IT 활용이 조직의 성과에 기여하는 것을 지원

(비즈니스 연속성 확보, 자원의 효울적인 배분, 서비스, 시장, 비즈니스의 혁신 비용절감, ROI 실현 등)









블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,


경영-IT Governance



1. IT Governance의 개요

1-1. 정의

- 기업의 전략과 목표에 부합되도록 IT와 관련된 리소스와 프로세스를 통제하고 관리하는 체계

- IT활용에 있어 바람직한 행동을 지원하기 위한 의사결정 및 책임에 대한 Framework(가트너)


1-2. 필요성

- Coporate Governance 중요성 증대

- IT의 중요성

- 기업의 위험 증대

- 의사결정의 Agility 요구


2. IT Governance의 개념도, 구성요소

2-1. IT Governance의 개념도

               - IT Governance 목표를 위한 원칙/표준과 관리 프로세스에 대한 전체 개념도

2-2. IT Governance의 구성요소

1) 전략적 연계 : 경영, 사업, 기술 전락의 Alignment를 통한 최적의 의사결정 방향제시

   - ITA/EA, ISP, PPM, BPR

2) 가치제공 : 전락적 비즈니스 목표 달성을 위한 개별 비즈니스 프로세스 최적화

    - ERP, CRM, SCM, BPM

3) 위험관리 : 재해복구 및 비즈니스 연속성 확보를 위한 전사적 위험관리

    - DR, BCP, ERM, ISO27000 시리즈

4) 자원관리 : 비즈니스 요구사항에 신속히 대응하기 위한 IT 자원 활용의 극대화

    - ITIL/ITSM, ITAM

5) 성과측정 : 무형자산의 가치를 포함한 IT ROI 평가

    - IT-BSC, IT_ROI, KPI


2-3. IT Governance 구현을 위한 프레임워크, 참조모델

1) 프레임워크: IT Governance Framework(ITGI), COBIT, 의사결정 Framework, IT Governance Model, COSO

2) 참조모델: Cobit, EA/ITA, CMMI/SPICE, ITIL, IT BSC, ISO 38500


3. IT Governance 발전 전망

- IT 통제는 IT 부서에서부터 CEO,CFO등이 무엇을 해야 하는지, 전사차원에서 설계

- IT 운영을 구성하는 기능, 프로세스, 조직에 대한 3위 일체 필요

- 기업의 특성에 맞는 구축 및 프로세스 정립


블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,

정보보안-방화벽



1. 방화벽의 개요

1-1. 정의

- 외부로부터 불법침입과 내부의 불법 정보 유출 방지

- 내, 외부 네트워크의 상호간 영향을 차단하기 위한 보안 시스템


1-2. 필요성

- 네트워크를 필터링하여 서브넷 상에 있는 호스트ㄹ의 위험을 감소

- 외부 N/W에서 내부 N/W에 있는 호스트로 접속하고자 할 때 원하지 않는 액세스 차단 필요


2. 방화벽 구성도, 주요보안 기능

2-1. 방화벽 구성도

  - 외부/내부 망의 상호간 패킷 필터링 및 주소 변환 기능 제공하는 시스템 구성도


2-2. 방화벽의 시스템의 주요 보안기능

1) 접근제어 : 특정 송신원의 주소 혹은 발신원 주소 등을 가진 패킷 통과를 제한

2) 사용자 인증 : 트래픽에 대한 사용자 신분 증명

3) 감사 및 로그 : 트래픽에 대한 접근 정보 기록

4) 프록시 기능 : Application 계층에 대한 필터링 기능 (OSI 7 Layer)

5) 주소변환 : 발신자 호스트의 IP주소나 목적지 호스트의 IP주소를 전송 단계에서 변경하여 전달

6) 데이터 암호화 : 데이터 암호화하여 전송(VPN) 


2-3. 방화벽의 유형

1) Packet Flitering

2) Application Gateway

3) Circuit Gateway


3. 방화벽의 한계와 보안대책

3-1. 방화벽의 한계

1) 침입 알림 기능

2) 백도어

3) 바이러스 검색 불능

4) 내부 사용자의 의한 보안 침해

5) 다이얼 모뎀


3-2 보안 대책

1) 능동적 방화벽

2) 방화벽 + IDS 결합 -> IPS 사용

3) 속도, 정책, 보안관리 관점 개선

블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,