'IT & 인생'에 해당되는 글 473건

1. PK(Unique) 인덱스를 가지고 있지 않은 테이블 확인

SELECT table_catalog, table_schema, table_name

FROM information_schema.tables

WHERE table_schema NOT IN ('information_schema', 'pg_catalog')

EXCEPT SELECT table_catalog, table_schema, table_name

FROM information_schema.table_constraints

WHERE constraint_type IN ('PRIMARY KEY', 'UNIQUE') 

AND table_schema NOT IN ('information_schema', 'pg_catalog');

2. 인덱스 중복 생성 확인

WITH index_info AS

(

SELECT 

pg_get_indexdef(indexrelid) AS index_def, 

indexrelid::regclass index_name, 

indrelid::regclass table_name, 

array_agg(attname) AS index_att

FROM pg_index i 

JOIN pg_attribute a 

ON i.indexrelid = a.attrelid

GROUP BY pg_get_indexdef(indexrelid), indrelid,  indexrelid

)

SELECT DISTINCT

  CASE WHEN a.index_name > b.index_name THEN a.index_def ELSE b.index_def END AS index_def,

  CASE WHEN a.index_name > b.index_name THEN a.index_name ELSE b.index_name END AS index_name,

  CASE WHEN a.index_name > b.index_name THEN b.index_def ELSE a.index_def END AS overlap_index_def,

  CASE WHEN a.index_name > b.index_name THEN b.index_def ELSE a.index_def END AS overlap_index_name,

  a.table_name

FROM index_info a 

INNER JOIN index_info b 

ON (

a.index_name != b.index_name 

AND a.table_name = b.table_name 

AND a.index_att && b.index_att 

);

SELECT col.table_schema AS schema_name, col.table_name, col.column_name, 

col.character_maximum_length, col.is_nullable, col.numeric_precision, 

col.numeric_scale, col.datptime_precision, col.ordinal_position, b.atttypmod, b.attndims, col.data_type AS col_type,

pt.typelem, pt.typlen, pt.typtype, nbt.nspname AS elem_schema, bt.typname AS elem_name, b.atttypid, col.udt_schema, col.udt_name, 

col.domain_catalog, col.domain_schema, col.domain_name, col_description(c.oid, col.ordinal_position) AS comment,

col.column_default AS col_default, b.attacl, colnsp.nspname AS collation_schema_name, 

coll.collname, c.relkind, b.attfdwoptions AS foreign_options 

FROM information_schema.columns AS col 

LEFT JOIN pg_namespace ns ON ns.nspname = col.table_schema 

LEFT JOIN pg_class c ON col.table_name = c.relname 

AND c.relnamespace = ns.oid 

LEFT JOIN pg_attrdef a 

ON c.oid = a.adrelid 

AND col.ordinal_position = a.adnum 

LEFT JOIN pg_attribute b 

ON b.attrelid = c.oid 

AND b.attname = col.column_name 

LEFT JOIN pg_type pt 

ON pt.oid = b.atttypid 

LEFT JOIN pg_collation coll 

ON coll.oid = b.attcollation 

LEFT JOIN pg_namespace colnsp 

ON coll.collnamespace = colnsp.oid 

LEFT JOIN pg_type bt 

ON pt.typelem = bt.oid 

LEFT JOIN pg_namespace nbt 

ON bt.typnamespace = nbt.oid 

 WHERE col.table_schema = 'cbsadm' 

 ORDER BY col.table_schema, col.table_name, col.ordinal_position

SELECT 

n.nspname as "Schema",

c.relname as "Name",

CASE c.relkind WHEN 'r' THEN 'table' WHEN 'v' THEN 'view' WHEN 'm' THEN 'materialized view' WHEN 'i' THEN 'index' WHEN 'S' THEN 'sequence' WHEN 's' THEN 'special' WHEN 'f' THEN 'foreign table' END as "Type",

pg_catalog.pg_get_userbyid(c.relowner) as "Owner",

TO_CHAR( pg_catalog.pg_table_size(c.oid)/1024 , '999,999,999,999,999') as "Size_MB",

TRIM(TRIM(n.nspname)||'.'||TRIM(c.relname))AS TB_NAME , 

pg_catalog.obj_description(c.oid, 'pg_class') as "Description"

FROM pg_catalog.pg_class c

LEFT JOIN pg_catalog.pg_namespace n 

ON n.oid = c.relnamespace

WHERE c.relkind IN ('r','')

AND n.nspname <> 'pg_catalog'

AND n.nspname <> 'information_schema'

AND n.nspname <> 'sys'

AND n.nspname <> 'dbo'

AND n.nspname !~ '^pg_toast'

ORDER BY  

pg_catalog.pg_table_size(c.oid) desc;

WITH RECURSIVE lt AS (

    SELECT   p.datname

           , p.usename

           , p.pid

           , pg_blocking_pids(p.pid) AS blocking_by

           , p.application_name

           , p.wait_event_type

           , p.state

           , p.query_start

           , p.query

           , ( 

SELECT array_agg(( SELECT relname 

                                    FROM pg_class pc 

                                   WHERE pc.oid = pl.relation ))

                 FROM pg_locks pl

                 WHERE pl.pid = p.pid

                      AND locktype = 'relation'

             ) AS relation

           , 0 AS level

           , row_number() over() AS rn

     FROM pg_stat_activity p

     WHERE cardinality(pg_blocking_pids(p.pid))= 0

     UNION 

    SELECT   p.datname

           , p.usename

           , p.pid

           , pg_blocking_pids(p.pid) AS blocking_by

           , p.application_name

           , p.wait_event_type

           , p.state

           , p.query_start

           , p.query

           , ( SELECT array_agg(( SELECT relname FROM pg_class pc WHERE pc.oid = pl.relation ))

                 FROM pg_locks pl

                WHERE pl.pid = p.pid

                      AND locktype = 'relation'

             ) AS relation

           , level + 1 as level

           , lt.rn

      FROM pg_stat_activity p

           INNER JOIN lt ON lt.pid = any(pg_blocking_pids(p.pid))

) 

SELECT   p.datname

       , p.usename

       , p.pid

       , p.blocking_by

       , p.application_name

       , p.wait_event_type

       , p.state

       , p.relation

       , now() - p.query_start AS elapsed_time

       , p.query

FROM   ( 

      SELECT   lt.rn

     , lt.level

     , lt.datname

     , lt.usename

     , lt.pid

     , lt.blocking_by

     , lt.application_name

     , lt.wait_event_type

                     , lt.state

                     , lt.relation

                     , lt.query_start

                     , lt.query

                     , count( rn ) over( PARTITION BY rn ) AS blocked_cnt

              FROM lt

       ) AS p

WHERE p.blocked_cnt > 1

ORDER by p.rn, p.level, p.blocking_by

;

1) pg_cancel_backend(pid)            -- current query kill and not disconnect

2) pg_terminate_backend(pid)        -- connection disconnect. 

3) kill -9 process

SELECT SNAP_TIME,         SNAP_TIME_RANGE,

         TO_CHAR ("Estd.Interconnect Traffic(KB)", 'FM999,999,999.9')

            "Estd.Interconnect Traffic(KB)",

         TO_CHAR (

            "Blocks Receive Time"

            / DECODE ("Blocks Received", 0, 1, "Blocks Received"),

            'FM999,999,999.9')

            "Interconnect Latency(ms)",

         TO_CHAR (

            "Blocks Served Time"

            / DECODE ("Blocks Served", 0, 1, "Blocks Served"),

            'FM999,999,999.9')

            "Prepare Latency(ms)",

         TO_CHAR (

            ("Blocks Receive Time"

             / DECODE ("Blocks Received", 0, 1, "Blocks Received"))

            - ("Blocks Served Time"

               / DECODE ("Blocks Served", 0, 1, "Blocks Served")),

            'FM999,999,999.9')

            "Transfer Latency(ms)",

         TO_CHAR ("gc cr blocks served", 'FM999,999,999.9')

            "gc cr blocks served",

         TO_CHAR ("gc current blocks served", 'FM999,999,999.9')

            "gc current blocks served",

         TO_CHAR ("gc cr blocks received", 'FM999,999,999.9')

            "gc cr blocks received",

         TO_CHAR ("gc current blocks received", 'FM999,999,999.9')

            "gc current blocks received",

         TO_CHAR ("gcs messages sent", 'FM999,999,999.9') "gcs messages sent",

         TO_CHAR ("ges messages sent", 'FM999,999,999.9') "ges messages sent",

         TO_CHAR ("gcs msgs received", 'FM999,999,999.9') "gcs msgs received",

         TO_CHAR ("ges msgs received", 'FM999,999,999.9') "ges msgs received",

         TO_CHAR ("gc blocks lost", 'FM999,999,999.9') "gc blocks lost",

         TO_CHAR ("gc cr block build time", 'FM999,999,999.99')

            "gc cr block build tm(ms)",

         TO_CHAR ("gc cr block flush time", 'FM999,999,999.99')

            "gc cr block flush tm(ms)",

         TO_CHAR ("gc current block flush time", 'FM999,999,999.99')

            "gc current block flush tm(ms)",

         TO_CHAR ("gc cr block receive time", 'FM999,999,999.99')

            "gc cr block receive tm(ms)",

         TO_CHAR ("gc current block receive time", 'FM999,999,999.99')

            "gc current block receiv tm(ms)",

         TO_CHAR ("gc cr block send time", 'FM999,999,999.99')

            "gc cr block send tm(ms)",

         TO_CHAR ("gc current block send time", 'FM999,999,999.99')

            "gc current block send tm(ms)",

         TO_CHAR ("gc current block pin time", 'FM999,999,999.99')

            "gc current block pin tm(ms)",

         TO_CHAR ("Blocks Served Time", 'FM999,999,999.99')

            "Blocks Served tm(ms)",

         TO_CHAR ("Blocks Served", 'FM999,999,999.9') "Blocks Served",

         TO_CHAR ("Blocks Receive Time", 'FM999,999,999.99')

            "Blocks Receive tm(ms)",

         TO_CHAR ("Blocks Received", 'FM999,999,999.9') "Blocks Received"

    FROM (SELECT SNAP_TIME,

                 SNAP_TIME_RANGE,

                 "gc cr blocks served",

                 "gc current blocks served",

                 "gc cr blocks received",

                 "gc current blocks received",

                 "gcs messages sent",

                 "ges messages sent",

                 "gcs msgs received",

                 "ges msgs received",

                 "gc blocks lost",

                 "gc cr block build time" * 10 "gc cr block build time",

                 "gc cr block flush time" * 10 "gc cr block flush time",

                 "gc current block flush time" * 10

                    "gc current block flush time",

                 "gc cr block send time" * 10 "gc cr block send time",

                 "gc current block send time" * 10 "gc current block send time",

                 "gc current block pin time" * 10 "gc current block pin time",

                 ( (  "gc cr blocks served"

                    + "gc current blocks served"

                    + "gc cr blocks received"

                    + "gc current blocks received")

                  * DB_BLOCK_SIZE

                  + (  "gcs msgs received"

                     + "ges msgs received"

                     + "gcs messages sent"

                     + "ges messages sent")

                    * 200)

                 / 1024

                    "Estd.Interconnect Traffic(KB)",

                 (  "gc cr block build time"

                  + "gc cr block flush time"

                  + "gc current block flush time"

                  + "gc cr block send time"

                  + "gc current block send time"

                  + "gc current block pin time")

                 * 10

                    "Blocks Served Time",

                 "gc current blocks served" + "gc cr blocks served"

                    "Blocks Served",

                 ("gc cr block receive time" + "gc current block receive time")

                 * 10

                    "Blocks Receive Time",

                 "gc cr blocks received" + "gc current blocks received"

                    "Blocks Received",

                 "gc cr block receive time" "gc cr block receive time",

                 "gc current block receive time"

                    "gc current block receive time"

            FROM (  SELECT SNAP_TIME,

                           SNAP_TIME_RANGE,

                           SUM (DECODE (STAT_NAME, 'gc cr blocks served', VALUE))

                              "gc cr blocks served",

                           SUM (

                              DECODE (STAT_NAME,

                                      'gc current blocks served', VALUE))

                              "gc current blocks served",

                           SUM (

                              DECODE (STAT_NAME, 'gc cr blocks received', VALUE))

                              "gc cr blocks received",

                           SUM (

                              DECODE (STAT_NAME,

                                      'gc current blocks received', VALUE))

                              "gc current blocks received",

                           SUM (DECODE (STAT_NAME, 'gcs messages sent', VALUE))

                              "gcs messages sent",

                           SUM (DECODE (STAT_NAME, 'ges messages sent', VALUE))

                              "ges messages sent",

                           SUM (DECODE (STAT_NAME, 'gcs msgs received', VALUE))

                              "gcs msgs received",

                           SUM (DECODE (STAT_NAME, 'ges msgs received', VALUE))

                              "ges msgs received",

                           SUM (DECODE (STAT_NAME, 'gc blocks lost', VALUE))

                              "gc blocks lost",

                           SUM (

                              DECODE (STAT_NAME, 'gc cr block build time', VALUE))

                              "gc cr block build time",

                           SUM (

                              DECODE (STAT_NAME, 'gc cr block flush time', VALUE))

                              "gc cr block flush time",

                           SUM (

                              DECODE (STAT_NAME,

                                      'gc current block flush time', VALUE))

                              "gc current block flush time",

                           SUM (

                              DECODE (STAT_NAME, 'gc cr block send time', VALUE))

                              "gc cr block send time",

                           SUM (

                              DECODE (STAT_NAME,

                                      'gc current block send time', VALUE))

                              "gc current block send time",

                           SUM (

                              DECODE (STAT_NAME,

                                      'gc current block pin time', VALUE))

                              "gc current block pin time",

                           SUM (

                              DECODE (STAT_NAME,

                                      'gc cr block receive time', VALUE))

                              "gc cr block receive time",

                           SUM (

                              DECODE (STAT_NAME,

                                      'gc current block receive time', VALUE))

                              "gc current block receive time",

                           MIN (P.PVALUE) DB_BLOCK_SIZE

                      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,

                                                        (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)))

                                                        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 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 DI.DBID,

                                                                         DI.INSTANCE_NUMBER,

                                                                         MAX (

                                                                            DI.STARTUP_TIME)

                                                                            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)  --변경

                                                                GROUP BY DI.DBID,

                                                                         DI.INSTANCE_NUMBER) 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

                                                                      ('gc blocks lost',

                                                                       'gc cr block build time',

                                                                       'gc cr block flush time',

                                                                       'gc current block flush time',

                                                                       'gc cr block send time',

                                                                       'gc current block send time',

                                                                       'gc current block pin time',

                                                                       'gc cr blocks served',

                                                                       'gc current blocks served',

                                                                       'gc cr blocks received',

                                                                       'gc current blocks received',

                                                                       'messages sent',

                                                                       'messages received',

                                                                       'gcs messages sent',

                                                                       'ges messages sent',

                                                                       'gc cr block receive time',

                                                                       'gc current block receive time')

                                                      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,

                                   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 SNAP.END_INTERVAL_TIME

                                                                  SNAP_TIME_C1,

                                                               LEAD (

                                                                  SNAP.END_INTERVAL_TIME)

                                                               OVER (

                                                                  PARTITION BY DBI.INSTANCE_NUMBER,

                                                                               NAME

                                                                  ORDER BY

                                                                     SNAP.SNAP_ID)

                                                                  SNAP_TIME_C2,

                                                               STAT.NAME STAT_NAME,

                                                               STAT.VALUE VALUE_1,

                                                               LEAD (

                                                                  STAT.VALUE)

                                                               OVER (

                                                                  PARTITION BY DBI.INSTANCE_NUMBER,

                                                                               NAME

                                                                  ORDER BY

                                                                     SNAP.SNAP_ID)

                                                                  VALUE_2,

                                                               SNAP.SNAP_ID,

                                                               DBI.INSTANCE_NUMBER

                                                          FROM (  SELECT DI.DBID,

                                                                         DI.INSTANCE_NUMBER,

                                                                         MAX (

                                                                            DI.STARTUP_TIME)

                                                                            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)  --변경

                                                                GROUP BY DI.DBID,

                                                                         DI.INSTANCE_NUMBER) DBI,

                                                               DBA_HIST_SNAPSHOT SNAP,

                                                               DBA_HIST_DLM_MISC STAT

                                                         WHERE DBI.DBID = SNAP.DBID

                                                               AND DBI.INSTANCE_NUMBER =

                                                                      SNAP.INSTANCE_NUMBER

                                                               AND DBI.DBID =

                                                                      SNAP.DBID

                                                               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.NAME IN

                                                                      ('gcs msgs received',

                                                                       'ges msgs received')

                                                      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)

                            ORDER BY STAT_NAME, SNAP_TIME) V,

                           (SELECT                             /*+ NO_MERGE */

                                  VALUE PVALUE

                              FROM DBA_HIST_PARAMETER DHP, DBA_HIST_SNAPSHOT SNAP

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

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

                                   AND SNAP.SNAP_ID = :11

                                   AND SNAP.DBID = DHP.DBID

                                   AND SNAP.INSTANCE_NUMBER = DHP.INSTANCE_NUMBER

                                   AND SNAP.SNAP_ID = DHP.SNAP_ID

                                   AND DHP.PARAMETER_NAME = 'db_block_size') P

                  GROUP BY SNAP_TIME, SNAP_TIME_RANGE))

ORDER BY SNAP_TIME

set pages 80

set lines 130

col c1 heading 'Average Waits for|Full Scan Read I/O' format 999999.999

col c2 heading 'Average Waits for|Index Read I/O' format 999999.999

col c3 heading 'Percent of| I/O Waits|for scattered|Full Scans' format 999.99

col c4 heading 'Percent of| I/O Waits|for sequential|Index Scans' format 999.99

col c5 heading 'Starting|Value|for|optimizer|index|cost|adj' format 99999

select a.snap_id "Snap",

       sum(a.time_waited_micro)/sum(a.total_waits)/10000 c1,

       sum(b.time_waited_micro)/sum(b.total_waits)/10000 c2,

       (sum(a.total_waits) / sum(a.total_waits + b.total_waits)) * 100 c3,

       (sum(b.total_waits) / sum(a.total_waits + b.total_waits)) * 100 c4,

       (sum(b.time_waited_micro)/sum(b.total_waits)) /

(sum(a.time_waited_micro)/sum(a.total_waits)) * 100 c5

from 

   dba_hist_system_event a, 

   dba_hist_system_event b

where a.snap_id = b.snap_id

and a.event_name = 'db file scattered read'

and b.event_name = 'db file sequential read'

group by a.snap_id

order by 1

/

set echo off

set lines 132

set pages 5000

set scan on

set verify off

set feedback off

set head on

prompt

accept owner prompt 'Table owner: '

accept table_name prompt 'Table name: '

col owner for a15

col synonym_name for a15

col table_owner for a15

col db_link for a15

col table_name for a30

col tablespace_name for a15

col mb for 999,990

col num_rows for 999,999,990

col blocks for 999,999,990

col empty_blocks for 999,990

col avg_space for 9,990

col chain_cnt for 990

col avg_row_len for 999,990

col avg_col_len for 990

col column_name for a30

col nullable for a4

col num_distinct for 999,999,990

col density for 9.999999

col index_name for a30

col uniq for a4

col blev for 90

col leaf_blocks for 9,999,990

col distinct_keys for 999,999,990

col key_lblocks for 99,990

col key_dblocks for 9,999,990

col clustering_factor for 999,999,990

col column_position format 999

col col for a25

col column_length for 990

col num_buckets for 990

col num_nulls for 999,999,990

select  t.table_name,

        t.tablespace_name,

        t.num_rows,

        t.blocks,

        s.bytes/1048576 mb,

        t.empty_blocks,

        t.chain_cnt,

        t.avg_row_len,

        t.last_analyzed

from    dba_tables t, dba_segments s

where   t.owner=upper(NVL('&&owner',USER)) and t.table_name=upper('&&table_name')

  and   s.owner=t.owner and s.segment_name=t.table_name

  and   s.segment_type <> 'TABLE PARTITION'

union all

select  p.partition_name||' (P)' table_name,

        p.tablespace_name,

        p.num_rows,

        p.blocks,

        s.bytes/1048576 mb,

        p.empty_blocks,

        p.chain_cnt,

        p.avg_row_len,

        p.last_analyzed

from    dba_segments s, dba_tab_partitions p

where   s.segment_type='TABLE PARTITION'

  and   p.table_owner=upper(NVL('&&owner',USER)) and p.table_name=upper('&&table_name')

  and   s.owner=p.table_owner and s.segment_name=p.table_name and s.partition_name=p.partition_name

order by table_name

/