一键获取数据库整体信息脚本

Posted duwamish

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了一键获取数据库整体信息脚本相关的知识,希望对你有一定的参考价值。

一键获取数据库整体信息脚本
将脚本内容放spooldb.sql中,在sqlplus中执行,相关信息会自动生成5个文件,其中addm是最近一小时文件,ash是最近半小时文件,而awr文件是最近一小时和最近7天的两个文件。

SET markup html ON spool ON pre off entmap off

set term off
set heading on
set verify off
set feedback off

set linesize 2000
set pagesize 30000
set long 999999999
set longchunksize 999999

column index_name format a30
column table_name format a30
column num_rows format 999999999
column index_type format a24
column num_rows format 999999999
column status format a8
column clustering_factor format 999999999
column degree format a10
column blevel format 9
column distinct_keys format 9999999999
column leaf_blocks format   9999999
column last_analyzed    format a10
column column_name format a25
column column_position format 9
column temporary format a2
column partitioned format a5
column partitioning_type format a7
column partition_count format 999
column program  format a30
column spid  format a6
column pid  format 99999
column sid  format 99999
column serial# format 99999
column username  format a12
column osuser    format a12
column logon_time format  date
column event    format a32
column JOB_NAME        format a30
column PROGRAM_NAME    format a32
column STATE           format a10
column window_name           format a30
column repeat_interval       format a60
column machine format a30
column program format a30
column osuser format a15
column username format a15
column event format a50
column seconds format a10
column sqltext format a100

SET markup html off
column dbid new_value spool_dbid
column inst_num new_value spool_inst_num
select dbid from v$database where rownum = 1;
select instance_number as inst_num from v$instance where rownum = 1;
column spoolfile_name new_value spoolfile
select ‘spool_‘||(select name from v$database where rownum=1) ||‘_‘|| (select instance_number from v$instance where rownum=1)||‘_‘||to_char(sysdate,‘yy-mm-dd_hh24.mi‘) as spoolfile_name from dual;
spool &&spoolfile..html

SET markup html off
set serveroutput on;
exec dbms_output.enable(9999999999);
exec dbms_output.put_line(‘<html>‘);
exec dbms_output.put_line(‘<style>‘);
exec dbms_output.put_line(‘th {font:bold 8pt Arial,Helvetica,Geneva,sans-serif; color:White; background:#0066CC;padding-left:4px; padding-right:4px;padding-bottom:2px}‘);
exec dbms_output.put_line(‘</style>‘);
exec dbms_output.put_line(‘<head>‘);
exec dbms_output.put_line(‘</head>‘);
exec dbms_output.put_line(‘<body>‘);

SET markup html on

prompt <p>VERSION
select * from v$version;
select * from dba_registry_history;

prompt <p>Last startup time, version, and whether RAC
select * from
 (select name db_name from v$database),
 (select instance_name from v$instance),
 (select archiver from v$instance),
 (select snap_interval awr_interval, retention awr_retention FROM DBA_HIST_WR_CONTROL),
 (select flashback_on from v$database),
 (select parallel from v$instance),
 (select startup_time from v$instance),
 (select decode(name,null,‘NOT ASM‘,‘ASM‘) IS_ASM from (select null name from dual union all (select name IS_ASM from v$datafile where name like ‘+%‘ and rownum = 1))),
 (select max(end_time) rman_lastcompleted from v$rman_status where status = ‘COMPLETED‘ and object_type like ‘DB FULL‘)
;

prompt <p>CPU or wait for the longest in 30 minutes
select t.*, s.sid, s.serial#, s.machine, s.program, s.osuser
  from (select c.USERNAME,
               a.event,
               to_char(a.cnt) as seconds,
               a.sql_id
               --,dbms_lob.substr(b.sql_fulltext,50,1) sqltext
          from (select rownum rn, t.*
                  from (select decode(s.session_state,
                                      ‘WAITING‘,
                                      s.event,
                                      ‘Cpu + Wait For Cpu‘) Event,
                               s.sql_id,
                               s.user_id,
                               count(*) CNT
                          from v$active_session_history s
                         where sample_time > sysdate - 30 / 1440
                         group by s.user_id,
                                  decode(s.session_state,
                                         ‘WAITING‘,
                                         s.event,
                                         ‘Cpu + Wait For Cpu‘),
                                  s.sql_id
                         order by CNT desc) t
                 where rownum < 20) a,
               v$sqlarea b,
               dba_users c
         where a.sql_id = b.sql_id
           and a.user_id = c.user_id
         order by CNT desc) t,
       v$session s
where t.sql_id = s.sql_id(+)
;

prompt <p>Recent load status (based on AWR snapshot
select s.snap_date,
       decode(s.redosize, null, ‘--shutdown or end--‘, s.currtime) "TIME",
       to_char(round(s.seconds/60,2)) "elapse(min)",
       round(t.db_time / 1000000 / 60, 2) "DB time(min)",
       s.redosize redo,
       round(s.redosize / s.seconds, 2) "redo/s",
       s.logicalreads logical,
       round(s.logicalreads / s.seconds, 2) "logical/s",
       physicalreads physical,
       round(s.physicalreads / s.seconds, 2) "phy/s",
       s.executes execs,
       round(s.executes / s.seconds, 2) "execs/s",
       s.parse,
       round(s.parse / s.seconds, 2) "parse/s",
       s.hardparse,
       round(s.hardparse / s.seconds, 2) "hardparse/s",
       s.transactions trans,
       round(s.transactions / s.seconds, 2) "trans/s"
  from (select curr_redo - last_redo redosize,
               curr_logicalreads - last_logicalreads logicalreads,
               curr_physicalreads - last_physicalreads physicalreads,
               curr_executes - last_executes executes,
               curr_parse - last_parse parse,
               curr_hardparse - last_hardparse hardparse,
               curr_transactions - last_transactions transactions,
               round(((currtime + 0) - (lasttime + 0)) * 3600 * 24, 0) seconds,
               to_char(currtime, ‘yy/mm/dd‘) snap_date,
               to_char(currtime, ‘hh24:mi‘) currtime,
               currsnap_id endsnap_id,
               to_char(startup_time, ‘yyyy-mm-dd hh24:mi:ss‘) startup_time
          from (select a.redo last_redo,
                       a.logicalreads last_logicalreads,
                       a.physicalreads last_physicalreads,
                       a.executes last_executes,
                       a.parse last_parse,
                       a.hardparse last_hardparse,
                       a.transactions last_transactions,
                       lead(a.redo, 1, null) over(partition by b.startup_time order by b.end_interval_time) curr_redo,
                       lead(a.logicalreads, 1, null) over(partition by b.startup_time order by b.end_interval_time) curr_logicalreads,
                       lead(a.physicalreads, 1, null) over(partition by b.startup_time order by b.end_interval_time) curr_physicalreads,
                       lead(a.executes, 1, null) over(partition by b.startup_time order by b.end_interval_time) curr_executes,
                       lead(a.parse, 1, null) over(partition by b.startup_time order by b.end_interval_time) curr_parse,
                       lead(a.hardparse, 1, null) over(partition by b.startup_time order by b.end_interval_time) curr_hardparse,
                       lead(a.transactions, 1, null) over(partition by b.startup_time order by b.end_interval_time) curr_transactions,
                       b.end_interval_time lasttime,
                       lead(b.end_interval_time, 1, null) over(partition by b.startup_time order by b.end_interval_time) currtime,
                       lead(b.snap_id, 1, null) over(partition by b.startup_time order by b.end_interval_time) currsnap_id,
                       b.startup_time
                  from (select snap_id,
                               dbid,
                               instance_number,
                               sum(decode(stat_name, ‘redo size‘, value, 0)) redo,
                               sum(decode(stat_name,
                                          ‘session logical reads‘,
                                          value,
                                          0)) logicalreads,
                               sum(decode(stat_name,
                                          ‘physical reads‘,
                                          value,
                                          0)) physicalreads,
                               sum(decode(stat_name, ‘execute count‘, value, 0)) executes,
                               sum(decode(stat_name,
                                          ‘parse count (total)‘,
                                          value,
                                          0)) parse,
                               sum(decode(stat_name,
                                          ‘parse count (hard)‘,
                                          value,
                                          0)) hardparse,
                               sum(decode(stat_name,
                                          ‘user rollbacks‘,
                                          value,
                                          ‘user commits‘,
                                          value,
                                          0)) transactions
                          from dba_hist_sysstat
                         where stat_name in
                               (‘redo size‘,
                                ‘session logical reads‘,
                                ‘physical reads‘,
                                ‘execute count‘,
                                ‘user rollbacks‘,
                                ‘user commits‘,
                                ‘parse count (hard)‘,
                                ‘parse count (total)‘)
                         group by snap_id, dbid, instance_number) a,
                       dba_hist_snapshot b
                 where a.snap_id = b.snap_id
                   and a.dbid = b.dbid
                   and a.instance_number = b.instance_number
                   and a.dbid = &&spool_dbid
                   and a.instance_number = &&spool_inst_num
                 order by end_interval_time)) s,
       (select lead(a.value, 1, null) over(partition by b.startup_time order by b.end_interval_time) - a.value db_time,
               lead(b.snap_id, 1, null) over(partition by b.startup_time order by b.end_interval_time) endsnap_id
          from dba_hist_sys_time_model a, dba_hist_snapshot b
         where a.snap_id = b.snap_id
           and a.dbid = b.dbid
           and a.instance_number = b.instance_number
           and a.stat_name = ‘DB time‘
           and a.dbid = &&spool_dbid
           and a.instance_number = &&spool_inst_num) t
 where s.endsnap_id = t.endsnap_id
order by s.snap_date desc ,time asc
;

prompt <p>逻辑读最多
select *
  from (select sql_id,
               s.EXECUTIONS,
               s.LAST_LOAD_TIME,
               s.FIRST_LOAD_TIME,
               s.DISK_READS,
               s.BUFFER_GETS
          from v$sql s
         where s.buffer_gets > 300
         order by buffer_gets desc)
where rownum <= 10
;

prompt <p>Logical read most
select * from (select sql_id,
       s.EXECUTIONS,
       s.LAST_LOAD_TIME,
       s.FIRST_LOAD_TIME,
       s.DISK_READS,
       s.BUFFER_GETS,
       s.PARSE_CALLS
  from v$sql s
where s.disk_reads > 300
order by disk_reads desc)
where rownum<=10
;

prompt <p>Maximum number of executions
select *
  from (select sql_id,
               s.EXECUTIONS,
               s.LAST_LOAD_TIME,
               s.FIRST_LOAD_TIME,
               s.DISK_READS,
               s.BUFFER_GETS,
               s.PARSE_CALLS
          from v$sql s
         order by s.EXECUTIONS desc)
where rownum <= 10
;

prompt <p>SQL parsing most
select *
  from (select sql_id,
               s.EXECUTIONS,
               s.LAST_LOAD_TIME,
               s.FIRST_LOAD_TIME,
               s.DISK_READS,
               s.BUFFER_GETS,
               s.PARSE_CALLS
          from v$sql s
         order by s.PARSE_CALLS desc)
where rownum <= 10
;

prompt <p>The disk is sorted most
select sess.username, sql.address, sort1.blocks
  from v$session sess, v$sqlarea sql, v$sort_usage sort1
where sess.serial# = sort1.session_num
   and sort1.sqladdr = sql.address
   and sort1.sqlhash = sql.hash_value
   and sort1.blocks > 200
order by sort1.blocks desc
;

prompt <p>Commits more than 10,000 session
select t1.sid, t1.value, t2.name
  from v$sesstat t1, v$statname t2
 where t2.name like ‘%user commits%‘
   and t1.STATISTIC# = t2.STATISTIC#
   and value >= 10000
 order by value desc
;

prompt <p>SQL with a length of more than 100
SELECT SQL_ID, COUNT(*) line_count
  FROM V$SQLTEXT
 GROUP BY SQL_ID
HAVING COUNT(*) >= 100
 ORDER BY COUNT(*) DESC
;

prompt <p>Query shared memory share
select count(*),round(sum(sharable_mem)/1024/1024,2)
  from v$db_object_cache a
;

prompt <p>Table with parallelism
select t.owner, t.table_name, degree
  from dba_tables t
where  trim(t.degree) <>‘1‘
   and trim(t.degree)<>‘0‘
   and owner not in (‘SYSTEM‘,‘SYSMAN‘,‘SYS‘,‘CTXSYS‘,‘MDSYS‘,‘OLAPSYS‘,‘WMSYS‘,‘EXFSYS‘,‘LBACSYS‘,‘WKSYS‘,‘XDB‘,‘ORDSYS‘,‘DBSNMP‘,‘OUTLN‘,‘TSMSYS‘)
   and owner not like ‘FLOWS%‘
   and owner not like ‘WK%‘
;

prompt <p>Index with parallelism
select t.owner, t.table_name, index_name, degree, status
  from dba_indexes t
where  trim(t.degree) <>‘1‘
   and trim(t.degree)<>‘0‘
   and owner not in (‘SYSTEM‘,‘SYSMAN‘,‘SYS‘,‘CTXSYS‘,‘MDSYS‘,‘OLAPSYS‘,‘WMSYS‘,‘EXFSYS‘,‘LBACSYS‘,‘WKSYS‘,‘XDB‘,‘ORDSYS‘,‘DBSNMP‘,‘OUTLN‘,‘TSMSYS‘)
   and owner not like ‘FLOWS%‘
   and owner not like ‘WK%‘
;

prompt <p>Invalid index
select t.index_name,
       t.table_name,
       blevel,
       t.num_rows,
       t.leaf_blocks,
       t.distinct_keys
  from dba_indexes t
  where status = ‘UNUSABLE‘
  and  table_owner not in (‘SYSTEM‘,‘SYSMAN‘,‘SYS‘,‘CTXSYS‘,‘MDSYS‘,‘OLAPSYS‘,‘WMSYS‘,‘EXFSYS‘,‘LBACSYS‘,‘WKSYS‘,‘XDB‘)
  and  table_owner not like ‘FLOWS%‘
;
select t2.owner,
       t1.blevel,
       t1.leaf_blocks,
       t1.INDEX_NAME,
       t2.table_name,
       t1.PARTITION_NAME,
       t1.STATUS
  from dba_ind_partitions t1, dba_indexes t2
where t1.index_name = t2.index_name
   and t1.STATUS = ‘UNUSABLE‘
;

prompt <p>Invalid object
select t.owner,
       t.object_type,
       t.object_name
  from dba_objects t
 where STATUS=‘INVALID‘
order by 1, 2
;

prompt <p>Bitmap index and function index, reverse key index
select t.owner,
       t.table_name,
       t.index_name,
       t.index_type,
       t.status,
       t.blevel,
       t.leaf_blocks
  from dba_indexes t
 where index_type in (‘BITMAP‘, ‘FUNCTION-BASED NORMAL‘, ‘NORMAL/REV‘)
   and owner not in (‘SYSTEM‘,‘SYSMAN‘,‘SYS‘,‘CTXSYS‘,‘MDSYS‘,‘OLAPSYS‘,‘WMSYS‘,‘EXFSYS‘,‘LBACSYS‘,‘WKSYS‘,‘XDB‘,‘ORDSYS‘,‘DBSNMP‘,‘OUTLN‘,‘TSMSYS‘)
   and owner not like ‘FLOWS%‘
   and owner not like ‘WK%‘
;

prompt <p>The combination of index columns is more than four
select table_owner,table_name, index_name, count(*)
  from dba_ind_columns
where  table_owner not in (‘SYSTEM‘,‘SYSMAN‘,‘SYS‘,‘CTXSYS‘,‘MDSYS‘,‘OLAPSYS‘,‘WMSYS‘,‘EXFSYS‘,‘LBACSYS‘,‘WKSYS‘,‘XDB‘,‘ORDSYS‘,‘DBSNMP‘,‘OUTLN‘,‘TSMSYS‘)
   and table_owner not like ‘FLOWS%‘
   and table_owner not like ‘WK%‘
 group by table_owner,table_name, index_name
having count(*) >= 4
 order by count(*) desc
;

prompt <p>Indexed more than 5 numbers
select owner,table_name, count(*) cnt
  from dba_indexes
where  owner not in (‘SYSTEM‘,‘SYSMAN‘,‘SYS‘,‘CTXSYS‘,‘MDSYS‘,‘OLAPSYS‘,‘WMSYS‘,‘EXFSYS‘,‘LBACSYS‘,‘WKSYS‘,‘XDB‘,‘ORDSYS‘,‘DBSNMP‘,‘OUTLN‘,‘TSMSYS‘)
   and owner not like ‘FLOWS%‘
   and owner not like ‘WK%‘
 group by owner,table_name
having count(*) >= 5
order by cnt desc
;

prompt <p>Never indexed a large table
select segment_name,
       bytes / 1024 / 1024 / 1024 "GB",
       blocks,
       tablespace_name
  from dba_segments
 where segment_type = ‘TABLE‘
   and segment_name not in (select table_name from dba_indexes)
   and bytes / 1024 / 1024 / 1024 >= 0.5
 order by GB desc
;
select segment_name, sum(bytes) / 1024 / 1024 / 1024 "GB", sum(blocks)
  from dba_segments
 where segment_type = ‘TABLE PARTITION‘
   and segment_name not in (select table_name from dba_indexes)
 group by segment_name
having sum(bytes) / 1024 / 1024 / 1024 >= 0.5
 order by GB desc
;

prompt <p>There is a cross between the combined index of the table and the single column index

select table_name, trunc(count(distinct(column_name)) / count(*),2) cross_idx_rate
  from dba_ind_columns
 where table_owner not in (‘SYSTEM‘,‘SYSMAN‘,‘SYS‘,‘CTXSYS‘,‘MDSYS‘,‘OLAPSYS‘,‘WMSYS‘,‘EXFSYS‘,‘LBACSYS‘,‘WKSYS‘,‘XDB‘,‘ORDSYS‘,‘DBSNMP‘,‘OUTLN‘,‘TSMSYS‘)
   and table_owner not like ‘FLOWS%‘
   and table_owner not like ‘WK%‘
 group by table_name
having count(distinct(column_name)) / count(*) < 1 
order by cross_idx_rate desc
;

prompt <p>Object is built on the system tablespace
select * from (
select owner, segment_name, tablespace_name, count(*) num
  from dba_segments
 where tablespace_name in(‘SYSTEM‘,‘SYSAUX‘)
group by owner, segment_name, tablespace_name)
where  owner not in (‘SYSTEM‘,‘SYSMAN‘,‘SYS‘,‘CTXSYS‘,‘MDSYS‘,‘OLAPSYS‘,‘WMSYS‘,‘EXFSYS‘,‘LBACSYS‘,‘WKSYS‘,‘XDB‘,‘ORDSYS‘,‘DBSNMP‘,‘OUTLN‘,‘TSMSYS‘)
   and owner not like ‘FLOWS%‘
   and owner not like ‘WK%‘
;

prompt <p>Check whether the statistics are collected
select t.job_name,t.program_name,t.state,t.enabled
  from dba_scheduler_jobs t
where job_name = ‘GATHER_STATS_JOB‘
;
select client_name,status
  from dba_autotask_client
;
select window_next_time,autotask_status
  from DBA_AUTOTASK_WINDOW_CLIENTS
;

prompt <p>Check the object that was not collected or collected for a long time
select owner, count(*)
  from dba_tab_statistics t
where (t.last_analyzed is null or t.last_analyzed < sysdate - 100)
   and table_name not like ‘BIN$%‘
group by owner
order by owner
;

prompt <p>Temporary table for collecting statistical information
select owner, table_name, t.last_analyzed, t.num_rows, t.blocks
  from dba_tables t
where t.temporary = ‘Y‘
   and last_analyzed is not null
;

prompt <p>Log switching frequency analysis
select *
  from (select thread#, sequence#, to_char(first_time, ‘MM/DD/RR HH24:MI:SS‘)
          from v$log_history
         order by first_time desc)
 where rownum <= 50
;

prompt <p>The amount of log switch every day in the last 10 days
SELECT SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH:MI:SS‘),1,5) Day,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘00‘,1,0)) H00,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘01‘,1,0)) H01,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘02‘,1,0)) H02,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘03‘,1,0)) H03,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘04‘,1,0)) H04,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘05‘,1,0)) H05,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘06‘,1,0)) H06,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘07‘,1,0)) H07,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘08‘,1,0)) H08,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘09‘,1,0)) H09,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘10‘,1,0)) H10,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘11‘,1,0)) H11,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘12‘,1,0)) H12,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘13‘,1,0)) H13,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘14‘,1,0)) H14,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘15‘,1,0)) H15,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘16‘,1,0)) H16,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘17‘,1,0)) H17,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘18‘,1,0)) H18,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘19‘,1,0)) H19,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘20‘,1,0)) H20,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘21‘,1,0)) H21,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘22‘,1,0)) H22 ,
       SUM(DECODE(SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH24:MI:SS‘),10,2),‘23‘,1,0)) H23,
       COUNT(*) TOTAL
FROM v$log_history  a
   where first_time>=to_char(sysdate-11)
GROUP BY SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH:MI:SS‘),1,5)
ORDER BY SUBSTR(TO_CHAR(first_time, ‘MM/DD/RR HH:MI:SS‘),1,5) DESC
;

prompt <p>Log group size
select group#,bytes,status
  from v$log
;

prompt <p>show recovery_file_dest usage
 select substr(name, 1, 30) name,
        space_limit as quota,
        space_used as used,
        space_reclaimable as reclaimable,
        number_of_files as files
   from v$recovery_file_dest
;
select * from V$FLASH_RECOVERY_AREA_USAGE
;

prompt <p>Check if the sequence is less than 20
select sequence_owner,
       count(*) CNT,
       sum(case when t.cache_size <= 20 then 1 else 0 end ) CNT_LESS_20,
       sum(case when t.cache_size > 20 then 1 else 0 end ) CNT_MORE_20
  from dba_sequences t
 group by sequence_owner
;

prompt <p>Table space usage
set markup html off
prompt <p>
declare
  type NUMBER_ARRAY is table of number(15) index by varchar2(30);
  ts_free_mb NUMBER_ARRAY;
  cursor c1 is
    select tablespace_name, sum(free_mb) + sum(expired_mb) free_mb
      from (SELECT tablespace_name,
                   round(sum(nvl(bytes, 0)) / 1024 / 1024, 2) free_mb,
                   0 expired_mb
              FROM dba_free_space
             GROUP BY tablespace_name
            union all
            select tablespace_name,
                   0 free_mb,
                   round(sum(nvl(bytes, 0)) / 1024 / 1024, 2) expired_mb
              from dba_undo_extents d
             where tablespace_name =
                   (select value
                      from v$parameter
                     where name = ‘undo_tablespace‘)
               and status = ‘EXPIRED‘
             group by tablespace_name)
     group by tablespace_name;
  cursor c2 is
    SELECT /*+ rule */
     tablespace_name, round(sum(bytes) / 1024 / 1024, 2) total_mb
      FROM dba_data_files
     where tablespace_name not in
           (select tablespace_name
              from dba_data_files
             where upper(AUTOEXTENSIBLE) = ‘YES‘)
     GROUP BY tablespace_name;
  ts_name  varchar2(30);
  ts_total number(15);
  ts_used  number(15);
  ts_free  number(15);
  ts_rate  varchar2(5);
begin
  for rec1 in c1 loop
    ts_free_mb(rec1.tablespace_name) := rec1.free_mb;
  end loop;
  dbms_output.put_line(‘<table border="1" width="90%" align="center" summary="Script output">‘);
  dbms_output.put_line(‘<tr><th>ts_name</th><th>ts_total</th><th>ts_used</th><th>ts_free</th><th>ts_rate</th></tr>‘);
  for rec2 in c2 loop
    ts_name  := null;
    ts_total := null;
    ts_used  := null;
    ts_free  := null;
    ts_rate  := null;
    ts_name  := rec2.tablespace_name;
    ts_total := rec2.total_mb;
    ts_free  := nvl(ts_free_mb(ts_name), 0);
    ts_used  := nvl(ts_total - ts_free, 0);
    ts_rate  := to_char(round((ts_total - ts_free) / ts_total * 100, 2),
                        ‘fm990.99‘);
    dbms_output.put_line(‘<tr><td>‘ || ts_name || ‘</td><td>‘ || ts_total ||
                         ‘</td><td>‘ || ts_used || ‘</td><td>‘ || ts_free ||
                         ‘</td><td>‘ || ts_rate || ‘</td></tr>‘);
  end loop;
  dbms_output.put_line(‘</table>‘);
end;
/
prompt <p>
set markup html on

prompt <p>The size of the entire database
select owner, round(sum(bytes) / 1024 / 1024 / 1024, 2) "GB"
  from dba_segments
 group by owner
 order by 2 desc
;

prompt <p>Object size TOP10
select *
  from (select owner,
               segment_name,
               segment_type,
               round(sum(bytes) / 1024 / 1024) object_size
          from DBA_segments
         group by owner, segment_name, segment_type
         order by object_size desc)
where rownum <= 10
;

prompt <p>Recycle Bin situation (size and quantity)
select *
  from (select SUM(BYTES) / 1024 / 1024 / 1024 as recyb_size
          from DBA_SEGMENTS
         WHERE SEGMENT_NAME LIKE ‘BIN$%‘) a,
       (select count(*) as recyb_cnt from dba_recyclebin)
;

prompt <p>Check who took up the undo tablespace

SELECT r.name "roll_segment_name", rssize/1024/1024/1024 "RSSize(G)",
  s.sid,
  s.serial#,
  s.username,
  s.status,
  s.sql_hash_value,
  s.SQL_ADDRESS,
  s.MACHINE,
  s.MODULE,
  substr(s.program, 1, 78) program,
  r.usn,
  hwmsize/1024/1024/1024, shrinks ,xacts
FROM sys.v_$session s,sys.v_$transaction t,sys.v_$rollname r, v$rollstat rs
WHERE t.addr = s.taddr and t.xidusn = r.usn and r.usn=rs.USN
Order by rssize desc
;

prompt <p>Check who took up the temp tablespace

select sql.sql_id,
       t.Blocks * 16 / 1024 / 1024,
       s.USERNAME,
       s.SCHEMANAME,
       t.tablespace,
       t.segtype,
       t.extents,
       s.PROGRAM,
       s.OSUSER,
       s.TERMINAL,
       s.sid,
       s.SERIAL#
  from v$sort_usage t, v$session s , v$sql sql
where t.SESSION_ADDR = s.SADDR
  and t.SQLADDR=sql.ADDRESS
  and t.SQLHASH=sql.HASH_VALUE
;

prompt <p>Observe the rollback segment, the temporary segment and the general segment No is automatically expanded
select t2.contents, t1.*
  from (select file_name, tablespace_name, bytes, maxbytes, autoextensible
          from dba_temp_files
        union all
        select file_name, tablespace_name, bytes, maxbytes, autoextensible
          from dba_data_files) t1,
       dba_tablespaces t2
 where t1.tablespace_name = t2.tablespace_name
;

prompt <p>Table size of more than 10GB did not build the partition table
select owner,
       segment_name,
       segment_type,
       round(sum(bytes) / 1024 / 1024 / 1024,2) object_size
  from dba_segments
where segment_type = ‘TABLE‘
  and bytes > 10*1024*1024*1024
group by owner, segment_name, segment_type
order by object_size desc
;

prompt <p>The top 10 partitions are the most
select *
  from (select table_owner, table_name, count(*) cnt
          from dba_tab_partitions
         group by table_owner, table_name
         order by cnt desc)
where rownum <= 10
;

prompt <p>Partitioned uneven table
select *
  from (select table_owner,
               table_name,
               max(num_rows) max_num_rows,
               trunc(avg(num_rows), 0) avg_num_rows,
               sum(num_rows) sum_num_rows,
               case
                 when sum(num_rows) = 0 then
                  0
                 else
                  trunc(max(num_rows) / trunc(avg(num_rows), 0), 2)
               end rate,
               count(*) part_count
          from dba_tab_partitions
         group by table_owner, table_name)
 where rate > 5;

prompt <p>A table with a column larger than 100 or less than 2
select *
  from (select owner, table_name, count(*) col_count
          from dba_tab_cols
         group by owner, table_name)
 where col_count > 100
    or col_count <= 2
 and  owner not in (‘SYSTEM‘,‘SYSMAN‘,‘SYS‘,‘CTXSYS‘,‘MDSYS‘,‘OLAPSYS‘,‘WMSYS‘,‘EXFSYS‘,‘LBACSYS‘,‘WKSYS‘,‘XDB‘)
 and  owner not like ‘FLOWS%‘
;

prompt <p>The table property is NOLOGGING
select owner, table_name, tablespace_name, logging
  from dba_tables
 where logging = ‘NO‘
 and  owner not in (‘SYSTEM‘,‘SYSMAN‘,‘SYS‘,‘CTXSYS‘,‘MDSYS‘,‘OLAPSYS‘,‘WMSYS‘,‘EXFSYS‘,‘LBACSYS‘,‘WKSYS‘,‘XDB‘)
 and  owner not like ‘FLOWS%‘
 ;

prompt <p>Table properties, containing COMPRESSION
select owner, table_name, tablespace_name, COMPRESSION
  from dba_tables
 where COMPRESSION = ‘ENABLED‘
 and  owner not in (‘SYSTEM‘,‘SYSMAN‘,‘SYS‘,‘CTXSYS‘,‘MDSYS‘,‘OLAPSYS‘,‘WMSYS‘,‘EXFSYS‘,‘LBACSYS‘,‘WKSYS‘,‘XDB‘)
 and  owner not like ‘FLOWS%‘
;

prompt <p>The index property contains COMPRESSION
select owner, index_name, table_name, COMPRESSION
  from dba_indexes
 where COMPRESSION = ‘ENABLED‘
 and  owner not in (‘SYSTEM‘,‘SYSMAN‘,‘SYS‘,‘CTXSYS‘,‘MDSYS‘,‘OLAPSYS‘,‘WMSYS‘,‘EXFSYS‘,‘LBACSYS‘,‘WKSYS‘,‘XDB‘)
 and  owner not like ‘FLOWS%‘
;

prompt <p>Trigger
select OWNER, TRIGGER_NAME, TABLE_NAME, STATUS
  from dba_triggers
 where owner not in (‘SYSTEM‘,‘SYSMAN‘,‘SYS‘,‘CTXSYS‘,‘MDSYS‘,‘OLAPSYS‘,‘WMSYS‘,‘EXFSYS‘,‘LBACSYS‘,‘WKSYS‘,‘XDB‘)
 and  owner not like ‘FLOWS%‘;
 
prompt <p>The foreign key is not indexed
select *
  from (select pk.owner PK_OWNER,
               pk.constraint_name PK_NAME,
               pk.table_name PK_TABLE_NAME,
               fk.owner FK_OWNER,
               fk.constraint_name FK_NAME,
               fk.table_name FK_TABLE_NAME,
               fk.delete_rule FK_DELETE_RULE,
               ind_col.INDEX_NAME FK_INDEX_NAME,
               ind.index_type FK_INDEX_TYPE,
               con_col.COLUMN_NAME FK_INDEX_COLUMN_NAME,
               con_col.POSITION FK_INDEX_COLUMN_POSITION,
               decode(ind_col.INDEX_NAME,
                      NULL,
                      NULL,
                      NVL(x_ind.status, ‘VALID‘)) IS_IND_VALID,
               decode(ind_col.INDEX_NAME,
                      NULL,
                      NULL,
                      NVL(x_ind_part.status, ‘VALID‘)) IS_IND_PART_VALID
          from (select * from dba_constraints where constraint_type = ‘R‘) fk,
               (select * from dba_constraints where constraint_type = ‘P‘) pk,
               dba_cons_columns con_col,
               dba_ind_columns ind_col,
               dba_indexes ind,
               (select index_owner, index_name, status
                  from dba_ind_partitions
                 where status <> ‘VALID‘) x_ind_part,
               (select owner as index_owner, index_name, status
                  from dba_indexes
                 where status <> ‘VALID‘) x_ind
         where fk.r_constraint_name = pk.constraint_name
           and pk.owner = fk.owner
           and fk.owner = con_col.owner
           and fk.table_name = con_col.table_name
           and fk.constraint_name = con_col.CONSTRAINT_NAME
           and con_col.owner = ind_col.TABLE_OWNER(+)
           and con_col.TABLE_NAME = ind_col.TABLE_NAME(+)
           and con_col.COLUMN_NAME = ind_col.COLUMN_NAME(+)
           and ind_col.INDEX_OWNER = ind.owner(+)
           and ind_col.INDEX_NAME = ind.index_name(+)
           and ind_col.INDEX_OWNER = x_ind.index_owner(+)
           and ind_col.INDEX_NAME = x_ind.index_name(+)
           and ind_col.INDEX_OWNER = x_ind_part.index_owner(+)
           and ind_col.INDEX_NAME = x_ind_part.index_name(+))
 where FK_INDEX_NAME is null
 order by FK_OWNER ASC
;

/* Bad performance
prompt <p>Hot block (summary)
SELECT *+ rule *
         e.owner, e.segment_name, e.segment_type, sum(b.tch) tch
          FROM dba_extents e,
               (SELECT *
                  FROM (SELECT addr, ts#, file#, dbarfil, dbablk, tch
                          FROM x$bh
                         ORDER BY tch DESC)
                 WHERE ROWNUM <= 10) b
         WHERE e.relative_fno = b.dbarfil
           AND e.block_id <= b.dbablk
           AND e.block_id + e.blocks > b.dbablk
           group by e.owner, e.segment_name, e.segment_type
order by tch desc
;
prompt <p>Hot block (unfolded, not summary)
SELECT *+ rule *
        distinct e.owner, e.segment_name, e.segment_type, dbablk,b.tch
          FROM dba_extents e,
               (SELECT *
                  FROM (SELECT addr, ts#, file#, dbarfil, dbablk, tch
                          FROM x$bh
                         ORDER BY tch DESC)
                 WHERE ROWNUM <= 10) b
         WHERE e.relative_fno = b.dbarfil
           AND e.block_id <= b.dbablk
           AND e.block_id + e.blocks > b.dbablk
order by tch desc
;
*/

prompt <p>Appendix: check the parameter settings of session_cached_cursors and increase the parameter value if the usage rate is 100%
SELECT ‘session_cached_cursors‘ PARAMETER,  
         LPAD(VALUE, 5) VALUE,  
         DECODE(VALUE, 0, ‘ n/a‘, TO_CHAR(100 * USED / VALUE, ‘990‘) || ‘%‘) USAGE  
   FROM (SELECT MAX(S.VALUE) USED  
            FROM V$STATNAME N, V$SESSTAT S  
           WHERE N.NAME = ‘session cursor cache count‘  
             AND S.STATISTIC# = N.STATISTIC#),  
         (SELECT VALUE FROM V$PARAMETER WHERE NAME = ‘session_cached_cursors‘)  
  UNION ALL  
SELECT ‘open_cursors‘,  
         LPAD(VALUE, 5),  
         TO_CHAR(100 * USED / VALUE, ‘990‘) || ‘%‘  
   FROM (SELECT MAX(SUM(S.VALUE)) USED  
            FROM V$STATNAME N, V$SESSTAT S  
           WHERE N.NAME IN  
                 (‘opened cursors current‘, ‘session cursor cache count‘)  
             AND S.STATISTIC# = N.STATISTIC#  
           GROUP BY S.SID),  
         (SELECT VALUE FROM V$PARAMETER WHERE NAME = ‘open_cursors‘);  


prompt <p>Appendix: all parameters of Oracle for reference
show parameter

set markup html off
exec dbms_output.put_line(‘</body>‘);
exec dbms_output.put_line(‘</html>‘);

spool off


/* Obtain awr、addm、ash */
--HTML tags are not used below
SET markup html off spool ON pre off entmap off

set trim on
set trimspool on
set heading off

--select dbid、instance_number
column dbid new_value awr_dbid
column instance_number new_value awr_inst_num
select dbid from v$database;
select instance_number from v$instance;

--Ash report in half an hour
column ashbegintime new_value ashbegin_str
column ashendtime new_value ashend_str
select to_char(sysdate-3/144,‘yyyymmddhh24miss‘) as ashbegintime, to_char(sysdate,‘yyyymmddhh24miss‘) as ashendtime from dual;

column ashfile_name new_value ashfile
select ‘ashrpt_‘ || to_char(&&awr_inst_num) || ‘_‘ || to_char(&&ashbegin_str) || ‘_‘ || to_char(&&ashend_str) ashfile_name from dual;
spool &&ashfile..html
select * from table(dbms_workload_repository.ash_report_html(to_char(&&awr_dbid),to_char(&&awr_inst_num),to_date(to_char(&&ashbegin_str),‘yyyymmddhh24miss‘),to_date(to_char(&&ashend_str),‘yyyymmddhh24miss‘)));
spool off;

--Create AWR snapshot
column begin_snap new_value awr_begin_snap
column end_snap new_value awr_end_snap
select max(snap_id) begin_snap
  from dba_hist_snapshot
 where snap_id < (select max(snap_id) from dba_hist_snapshot);
select max(snap_id) end_snap from dba_hist_snapshot;
declare
  snap_maxtime date;
  snap_mintime date;
begin
  select max(end_interval_time) + 0
    into snap_maxtime
    from dba_hist_snapshot
   where snap_id = to_number(&&awr_end_snap);
  select max(end_interval_time) + 0
    into snap_mintime
    from dba_hist_snapshot
   where snap_id = to_number(&&awr_begin_snap);
  if sysdate - snap_maxtime > 10/1445 then
    dbms_workload_repository.create_snapshot();
  end if;
end;
/

--The latest two AWR reports between snap_id
column begin_snap new_value awr_begin_snap
column end_snap new_value awr_end_snap
select max(snap_id) begin_snap
  from dba_hist_snapshot
 where snap_id < (select max(snap_id) from dba_hist_snapshot);
select max(snap_id) end_snap from dba_hist_snapshot;
column awrfile_name new_value awrfile
select ‘awrrpt_‘ || to_char(&&awr_inst_num) || ‘_‘ || to_char(&&awr_begin_snap) || ‘_‘ || to_char(&&awr_end_snap) awrfile_name from dual;

spool &&awrfile..html
select output from table(dbms_workload_repository.awr_report_html(&&awr_dbid,&&awr_inst_num,&&awr_begin_snap,&&awr_end_snap));
spool off;


--The longest AWR report available (all analyses since a week)
column begin_snap new_value awr_begin_snap
column end_snap new_value awr_end_snap
select a.begin_snap, a.end_snap
  from (select startup_time, min(snap_id) begin_snap, max(snap_id) end_snap
          from dba_hist_snapshot
         group by startup_time) a,
       (select max(startup_time) startup_time from dba_hist_snapshot) b
 where a.startup_time = b.startup_time
   and rownum = 1;
column awrfile_name new_value awrfile
select ‘awrrpt_‘ || to_char(&&awr_inst_num) || ‘_‘ || to_char(&&awr_begin_snap) || ‘_‘ || to_char(&&awr_end_snap) ||‘_all‘ awrfile_name from dual;

spool &&awrfile..html
select output from table(dbms_workload_repository.awr_report_html(&&awr_dbid,&&awr_inst_num,&&awr_begin_snap,&&awr_end_snap));
spool off;


--Latest ADDM Report
column addmfile_name new_value addmfile
select ‘addmrpt_‘ || to_char(&&awr_inst_num) || ‘_‘ || to_char(&&awr_begin_snap) || ‘_‘ || to_char(&&awr_end_snap) addmfile_name from dual;
set serveroutput on
spool &&addmfile..txt
declare
  id          number;
  name        varchar2(200) := ‘‘;
  descr       varchar2(500) := ‘‘;
  addmrpt     clob;
  v_ErrorCode number;
BEGIN
  name := ‘&&addmfile‘;
  begin
    dbms_advisor.create_task(‘ADDM‘, id, name, descr, null);
    dbms_advisor.set_task_parameter(name, ‘START_SNAPSHOT‘, &&awr_begin_snap);
    dbms_advisor.set_task_parameter(name, ‘END_SNAPSHOT‘, &&awr_end_snap);
    dbms_advisor.set_task_parameter(name, ‘INSTANCE‘, &&awr_inst_num);
    dbms_advisor.set_task_parameter(name, ‘DB_ID‘, &&awr_dbid);
    dbms_advisor.execute_task(name);
  exception
    when others then
      null;
  end;
  select dbms_advisor.get_task_report(name, ‘TEXT‘, ‘TYPICAL‘)
    into addmrpt
    from sys.dual;
  dbms_output.enable(20000000000);
  for i in 1 .. (DBMS_LOB.GETLENGTH(addmrpt) / 2000 + 1) loop
    dbms_output.put_line(substr(addmrpt, 1900 * (i - 1) + 1, 1900));
  end loop;
  dbms_output.put_line(‘‘);
  begin
    dbms_advisor.delete_task(name);
  exception
    when others then
      null;
  end;
end;
/
spool off;

exit;

 

以上是关于一键获取数据库整体信息脚本的主要内容,如果未能解决你的问题,请参考以下文章

常用python日期日志获取内容循环的代码片段

脚本一键启动zk,kafka集群

SVN到Git的一键迁移脚本(保留所有分支、Tag及提交记录)

一键获取测试脚本,轻松验证“TSBS 时序数据库性能基准测试报告”

lastInsertId() 是不是获取该脚本或整体插入的最后一个 id?

lamp脚本一键搭建