oracle db perfmon

時間 2019-11-17

原文原文鏈接

/*當前正在使用何種sql優化方式:
用explain plan產生explain plan，檢查plan_table中id=0的position列的值。*/linux

select decode(nvl(position,-1),-1,'rbo',1,'cbo') from plan_table where id=0;

--查看還沒提交的事務sql

select * from v$locked_object;
select * from v$transaction;

--監控事例的等待數據庫

select event,sum(decode(wait_time,0,0,1)) "prev",sum(decode(wait_time,0,1,0)) "curr",count(*) "tot" 
from v$session_wait 
group by event 
order by 4;

--查看段(表段、索引段)所使用空間的大小，替換<>中的內容。c#

select owner,segment_name,sum(bytes)/1024/1024
from dba_segments
where owner=&v_owner
and segment_name=&v_segment_name
group by owner,segment_name
order by 3 desc;

--oracle全部回滾段狀態的檢查：windows

select segment_name,owner,tablespace_name,initial_extent,next_extent,dba_rollback_segs.status 
from dba_rollback_segs,v$datafile 
where file_id=file#;

--oracle回滾段擴展信息的檢查:緩存

col name format a10
set linesize 140 
select substr(name,1,40) name,extents,rssize,optsize,aveactive,extends,wraps,shrinks,hwmsize
from v$rollname rn,v$rollstat rs 
where (rn.usn=rs.usn);

/*extents:回滾段中的盤區數量。
rssize:以字節爲單位的回滾段的尺寸。
optsize：爲optimal參數設定的值。
aveactive:從回滾段中刪除盤區時釋放的以字節爲單位的平均空間的大小。
extends:系統爲回滾段增長的盤區的次數。
shrinks:系統從回滾段中清除盤區（即回滾段收縮）的次數。回滾段每次清除盤區時，系統可能會從這個回滾段中消除一個或多個盤區。
hwmsize:回滾段尺寸的上限，即回滾段曾經達到的最大尺寸。
(若是回滾段平均尺寸接近optimal的值，那麼說明optimal的值設置正確，若是回滾段動態增加次數或收縮次數很高，
那麼須要提升optimal的值)*/服務器

--查看回滾段的使用狀況，哪一個用戶正在使用回滾段的資源:網絡

select s.username,u.name 
from v$transaction t,v$rollstat r,v$rollname u,v$session s 
where s.taddr=t.addr 
and t.xidusn=r.usn 
and r.usn=u.usn 
order by s.username;

--回滾段查看session

select rownum,sys.dba_rollback_segs.segment_name name,v$rollstat.extents extents,
v$rollstat.rssize size_in_bytes,v$rollstat.xacts xacts,v$rollstat.gets gets,
v$rollstat.waits waits,v$rollstat.writes writes,sys.dba_rollback_segs.status status 
from v$rollstat,sys.dba_rollback_segs,v$rollname 
where v$rollname.name=sys.dba_rollback_segs.segment_name 
and v$rollstat.usn=v$rollname.usn 
order by rownum

--查看回滾段名稱及大小併發

select segment_name,tablespace_name,r.status,(initial_extent/1024) initialextent,(next_extent/1024) nextextent,
max_extents,v.curext curextent
from dba_rollback_segs r,v$rollstat v
where r.segment_id=v.usn
order by segment_name ;

--查看回滾段:

col name format a10
set linesize 100
select rownum,sys.dba_rollback_segs.segment_name name,v$rollstat.extents extents,v$rollstat.rssize size_in_bytes,
v$rollstat.xacts xacts,v$rollstat.gets gets,v$rollstat.waits waits,v$rollstat.writes writes,
sys.dba_rollback_segs.status status 
from v$rollstat,sys.dba_rollback_segs,v$rollname 
where v$rollname.name(+)= sys.dba_rollback_segs.segment_name 
and v$rollstat.usn(+)= v$rollname.usn 
order by rownum;

/*數據庫回滾段性能檢查:
檢查ratio執行*/

select sum(waits) * 100 /sum(gets) "ratio",sum(waits) "waits",sum(gets) "gets" from v$rollstat;

--檢查count/value執行:

select class,count from v$waitstat where class like '%undo%';
select value from v$sysstat where name='consistent gets';

--(二者的value值相除)

--查看哪些session正在使用哪些回滾段:

col 回滾段名 format a10
col sid format 9990
col 用戶名 format a10
col 操做程序 format a80
col status format a6 trunc
select r.name 回滾段名,s.sid,s.serial#,s.username 用戶名,t.status,t.cr_get,t.phy_io,
t.used_ublk,t.noundo,substr(s.program,1,78) 操做程序
from sys.v_$session s,sys.v_$transaction t,sys.v_$rollname r
where t.addr = s.taddr 
and t.xidusn = r.usn
order by t.cr_get,t.phy_io;

--回滾段的爭用狀況

select name,waits,gets,waits/gets "ratio" from v$rollstat a,v$rollname b where a.usn = b.usn;

--判斷回滾段競爭的sql語句：（當ratio大於2時存在回滾段競爭，須要增長更多的回滾段）

select rn.name,rs.gets,rs.waits,(rs.waits/rs.gets)*100 ratio from v$rollstat rs,v$rollname rn where rs.usn = rn.usn

--判斷恢復日誌競爭的sql語句：（immediate_contention或wait_contention的值大於1時存在競爭）

select name,(t.immediate_misses/ 
decode((t.immediate_gets+t.immediate_misses),0,-1,
(t.immediate_gets+t.immediate_misses)))*100 immediate_contention,
(t.misses/decode((t.gets+t.misses),0,-1,(t.gets+t.misses)))*100 wait_contention
from v$latch t
where name in ('redo copy','redo allocation')

--查看數據文件的大小及頭大小（hwm）（能夠resize的最小空間）和文件頭大小:

select v1.file_name,v1.file_id,num1 totle_space,num3 free_space,num1-num3 "used_space(hwm)",
nvl(num2,0) data_space,num1-num3-nvl(num2,0) file_head
from 
(select file_name,file_id,sum(bytes) num1 from dba_data_files group by file_name,file_id) v1,
(select file_id,sum(bytes) num2 from dba_extents group by file_id) v2,
(select file_id,sum(bytes) num3 from dba_free_space group by file_id) v3
where v1.file_id=v2.file_id(+)
and v1.file_id=v3.file_id(+);

/*(運行以上查詢，咱們能夠以下信息：
totle_pace:該數據文件的總大小，字節爲單位
free_space:該數據文件的剩於大小，字節爲單位
used_space:該數據文件的已用空間，字節爲單位
data_space:該數據文件中段數據佔用空間，也就是數據空間，字節爲單位
file_head:該數據文件頭部佔用空間，字節爲單位)*/

--查看數據文件的實際使用狀況：

select ceil(max_block * block_size / 1024)
from (select max(block_id) max_block from dba_extents where file_id in (
select file_id from dba_data_files d where d.tablespace_name = 'users')) m,
(select value / 1024 block_size from v$parameter where name = 'db_block_size') b

--監控文件系統的 i/o 比例

select substr(a.file#,1,2) "#",substr(a.name,1,30) "name",a.status,a.bytes,b.phyrds,b.phywrts 
from v$datafile a,v$filestat b
where a.file#=b.file#;

--查看數據表的參數信息

select partition_name,high_value,high_value_length,tablespace_name,pct_free,pct_used,ini_trans,max_trans,
initial_extent,next_extent,min_extent,max_extent,pct_increase,freelists,freelist_groups,logging,
buffer_pool,num_rows,blocks,empty_blocks,avg_space,chain_cnt,avg_row_len,sample_size,last_analyzed
from dba_tab_partitions
--where table_name = :tname and table_owner = :towner
order by partition_position

--查看錶是不是分區表：
--例子：

select table_name,partitioned from user_tables where table_name='localusage';

table_name par
------------------------------ --- ---------
localusage yes

--查看分區表的分區名和相應的表空間名：

select table_name,partition_name,tablespace_name from user_tab_partitions where table_name like '%usage%';

--查看索引是不是分區索引：

select index_name,table_name,status,partitioned from user_indexes where table_name like '%usage';

--若是返回的patitioned爲yes，請再執行以下語句來查詢分區索引的類型：

select index_name,table_name,locality from user_part_indexes;

--dual是oracle中的一個實際存在的表，任何用戶都可讀取，經常使用在沒有目標表的select中.

--查看索引段中extent的數量：

select segment_name,count(*) from dba_extents where segment_type='index' and owner='scott' group by segment_name;

--查看系統表中的用戶索引（用來檢查在system表空間內其餘用戶索引的存在）：

select count(*) from dba_indexes where tablespace_name='system' and owner not in ('sys','system');

--在某個用戶下找全部的索引

select user_indexes.table_name,user_indexes.index_name,uniqueness,column_name 
from user_ind_columns,user_indexes 
where user_ind_columns.index_name=user_indexes.index_name 
and user_ind_columns.table_name=user_indexes.table_name 
order by user_indexes.table_type,user_indexes.table_name,user_indexes.index_name,column_position;

--表、索引的存儲狀況檢查

select segment_name,sum(bytes),count(*) ext_quan 
from dba_extents 
where tablespace_name='&tablespace_name'
and segment_type='table'
group by tablespace_name,segment_name;

select segment_name,count(*) from dba_extents where segment_type='index' and owner='&owner' group by segment_name;

--查看一下哪一個用戶在用臨時段:

select username,sid,serial#,sql_address,machine,program,tablespace,segtype,contents 
from v$session se,v$sort_usage su 
where se.saddr=su.session_addr;

--查詢oracle的鏈接數

select count(*) from v$session;

--查詢oracle的併發鏈接數

select count(*) from v$session where status='active';

--查看不一樣用戶的鏈接數

select username,count(username) from v$session where username is not null group by username;

--當前的鏈接數

select count(*) from v$process

--查看oracle最大鏈接

show parameter processes

select value from v$parameter where name ='processes'

--修改最大鏈接數:

alter system set processes = &value scope = spfile;

--例如：

alter system set processes = 300 scope = spfile;

--主機產生的鏈接數

select username,machine,program,status,count(machine) as connect_num
from v$session
group by username,machine,program,status
order by machine;

--按主機名查詢鏈接

select count(*) from v$session where machine ='hostname';

--按機器名分組查

select username,machine,count(username) from v$session where username is not null group by username,machine;

--查看鏈接的進程 sid,serial#

select sid,serial#,username,status,osuser from v$session;

--查看客戶端登錄的ip地址:

select sys_context('userenv','ip_address') from dual;

--在生產數據庫中建立一個追蹤客戶端ip地址的觸發器：

create or replace trigger on_logon_trigger
after logon on database
begin
dbms_application_info.set_client_info(sys_context('userenv','ip_address'));
end;

--查詢當前日期

select to_char(sysdate,'yyyy-mm-dd,hh24:mi:ss') from dual;

--查看有哪些用戶鏈接

select s.osuser os_user_name,decode(sign(48 - command),1,to_char(command),'action code #'||to_char(command)) action,
p.program oracle_process,status session_status,s.terminal terminal,s.program program,s.username user_name,
s.fixed_table_sequence activity_meter,'' query,0 memory,0 max_memory,0 cpu_usage,s.sid,s.serial# serial_num
from v$session s,v$process p
where s.paddr=p.addr
and s.type='user'
order by s.username,s.osuser

--查看當前有哪些用戶正在使用數據

select osuser,a.username,cpu_time/executions/1000000||'s',sql_fulltext,machine
from v$session a,v$sqlarea b
where a.sql_address=b.address 
order by cpu_time/executions desc;

--監控當前數據庫誰在運行什麼sql語句:

select osuser,username,sql_text from v$session a,v$sqltext b where a.sql_address=b.address order by address,piece;

--如何查看數據庫中某用戶，正在運行什麼sql語句

select sql_text 
from v$sqltext t,v$session s 
where t.address=s.sql_address
and t.hash_value=s.sql_hash_value 
and s.machine='&v_hostname'
or username='wacos';

--如何查出前臺正在發出的sql語句:

select user_name,sql_text 
from v$open_cursor 
where sid 
in (select sid from (
select sid,serial# from v$session where status='active'));

--查詢當前所執行的sql語句：

select program ,sql_address 
from v$session where paddr 
in (select addr from v$process where spid=3556);

program sql_address
------------------------------------------------ ----------------
sqlplus@ctc20(tns v1-v3) 000000038fcb1a90

select sql_text from v$sqlarea where address='000000038fcb1a90';

--根據sid查看對應鏈接正在運行的sql

select /* push_subq */ command_type,sql_text,sharable_mem,persistent_mem,runtime_mem,sorts,version_count,
loaded_versions,open_versions,users_opening,executions,users_executing,loads,first_load_time,invalidations,
parse_calls,disk_reads,buffer_gets,rows_processed,sysdate start_time,sysdate finish_time,
'>'||address sql_address,'n' status
from v$sqlarea 
where address =(
select sql_address from v$session where sid = &v_sid);

--根據sid查看對應鏈接的資源佔用等狀況

select n.name,v.value,n.class,n.statistic# 
from v$statname n,v$sesstat v
where v.sid=&v_sid
and v.statistic#=n.statistic#
order by n.class,n.statistic#

--根據sid查是哪臺電腦的連接

column osuser format a15
column username format a10
column machine format a30
select osuser,machine,username,sid,serial# from v$session where sid='&v_sid';

--根據sid查對應的sql

select sid,sql_text from v$open_cursor where sid=&v_sid;

--根據sid找oracle的某個進程:

select pro.spid from v$session ses,v$process pro where ses.sid=&v_sid and ses.paddr=pro.addr;

--當前會話的sid，serial#

select sid,serial# from v$session where audsid = sys_context('userenv','sessionid');

--找到與所鏈接的會話有關的當前等待事件：

select sw.sid,s.username,sw.event,sw.wait_time,sw.state,sw.seconds_in_wait sec_in_wait
from v$session s,v$session_wait sw 
where s.username is not null 
and sw.sid=s.sid
and sw.event not like '%sql*net%'
order by sw.wait_time desc;

--等待時間最多的5個系統等待事件的獲取：

select * from (
select * from v$system_event where event not like 'sql%' order by total_waits desc)
where rownum<=5;

--查看當前等待事件的會話:

col username format a10
set line 120
col event format a30
select se.sid,s.username,se.event,se.total_waits,se.time_waited,se.average_wait
from v$session s,v$session_event se 
where s.username is not null 
and se.sid=s.sid
and s.status='active'
and se.event not like '%sql*net%';

select sid,event,p1,p2,p3,wait_time,seconds_in_wait,state 
from v$session_wait 
where event not like '%message%'
and event not like 'sql*net%'
and event not like '%timer%'
and event!='wakeup time manager';

查會話的阻塞

col user_name format a32
select /* rule */ lpad('',decode(l.xidusn,0,3,0))||l.oracle_username user_name,o.owner,o.object_name,s.sid,s.serial#
from v$locked_object l,dba_objects o,v$session s
where l.object_id=o.object_id
and l.session_id=s.sid
order by o.object_id,xidusn desc;

col username format a15
col lock_level format a8
col owner format a18
col object_name format a32
select /* rule */ s.username,decode(l.type,'tm','table lock','tx','row lock',null) lock_level,
o.owner,o.object_name,s.sid,s.serial#
from v$session s,v$lock l,dba_objects o
where l.sid=s.sid
and l.id1=o.object_id
and s.username is not null;

--求等待的事件及會話信息/求會話的等待及會話信息

select se.sid,s.username,se.event,se.total_waits,se.time_waited,se.average_wait
from v$session s,v$session_event se
where s.username is not null
and se.sid=s.sid
and s.status='active'
and se.event not like '%sql*net%'
order by s.username;

select s.sid,s.username,sw.event,sw.wait_time,sw.state,sw.seconds_in_wait
from v$session s,v$session_wait sw
where s.username is not null
and sw.sid=s.sid
and sw.event not like '%sql*net%'
order by s.username;

--求會話等待的file_id/block_id

col event format a24
col p1text format a12
col p2text format a12
col p3text format a12
select sid,event,p1text,p1,p2text,p2,p3text,p3
from v$session_wait where event not like '%sql%' and event not like '%rdbms%' and event not like '%mon%' order by event;

select name,wait_time 
from v$latch l 
where exists(
select 1 from (
select sid,event,p1text,p1,p2text,p2,p3text,p3
from v$session_wait
where event not like '%sql%'
and event not like '%rdbms%'
and event not like '%mon%') x
where x.p1 = l.latch#);

--求會話等待的對象

col owner format a18
col segment_name format a32
col segment_type format a32
select owner, segment_name, segment_type
from dba_extents
where file_id = &file_id
and &block_id between block_id and block_id + blocks - 1;

--殺會話的腳本:

select a.sid,b.spid,a.serial#,a.lockwait,a.username,a.osuser,a.logon_time,a.last_call_et/3600 last_hour,a.status,
'orakill'||sid||''||spid host_command,'alter system kill session'''||a.sid||','||a.serial#||'''' sql_command
from v$session a,v$process b 
where a.paddr=b.addr 
and sid>6;

--鎖相關的表

select * from v$lock;
select * from v$sqlarea;
select * from v$session;
select * from v$process ;
select * from v$locked_object;
select * from all_objects;
select * from v$session_wait;

--查看數據庫中的表鎖
--查找某個表被哪一個session鎖定

select a.owner,a.object_name,b.xidusn,b.xidslot,b.xidsqn,b.session_id,b.oracle_username,b.os_user_name,b.process,
b.locked_mode,c.machine,c.status,c.server,c.sid,c.serial#,c.program
from all_objects a,v$locked_object b,sys.gv_$session c
where(a.object_id = b.object_id)
and(b.process = c.process)
order by 1,2;

--數據庫的鎖表與解鎖

select /*+ rule */ s.username,decode(l.type,'tm','table lock','tx','row lock',null) lock_level,
o.owner,o.object_name,o.object_type,s.sid,s.serial#,s.terminal,s.machine,s.program,s.osuser
from v$session s,v$lock l,dba_objects o
where l.sid = s.sid
and l.id1 = o.object_id(+)
and s.username is not null

--kill session語句
alter system kill session'50,492';

--分步

--1.查出鎖定object的session的信息以及被鎖定的object名
select l.session_id sid, s.serial#, l.locked_mode,l.oracle_username,
l.os_user_name,s.machine, s.terminal, o.object_name, s.logon_time
from v$locked_object l, all_objects o, v$session s
where l.object_id = o.object_id
and l.session_id = s.sid
order by sid, s.serial# ;
--2.查出鎖定表的session的sid, serial#,os_user_name, machine name, terminal和執行的語句
--比上面那段多出sql_text和action
select l.session_id sid, s.serial#, l.locked_mode, l.oracle_username, s.user#,
l.os_user_name,s.machine, s.terminal,a.sql_text, a.action
from v$sqlarea a,v$session s, v$locked_object l
where l.session_id = s.sid
and s.prev_sql_addr = a.address
order by sid, s.serial#;
--3.查出鎖定表的sid, serial#,os_user_name, machine_name, terminal，鎖的type,mode
select s.sid, s.serial#, s.username, s.schemaname, s.osuser, s.process, s.machine,
s.terminal, s.logon_time, l.type
from v$session s, v$lock l
where s.sid = l.sid
and s.username is not null
order by sid;

/*這個語句將查找到數據庫中全部的dml語句產生的鎖，還能夠發現，
任何dml語句其實產生了兩個鎖，一個是表鎖，一個是行鎖。
殺鎖命令*/

/*若是發生了鎖等待，咱們可能更想知道是誰鎖了表而引發誰的等待
如下的語句能夠查詢到誰鎖了表，而誰在等待。
以上查詢結果是一個樹狀結構，若是有子節點，則表示有等待發生。
若是想知道鎖用了哪一個回滾段，還能夠關聯到v$rollname，其中xidusn就是回滾段的usn*/

col user_name format a10
col owner format a10
col object_name format a10
col object_type format a10
select /*+ rule */ lpad(' ',decode(l.xidusn ,0,3,0))||l.oracle_username user_name,
o.owner,o.object_name,o.object_type,s.sid,s.serial#
from v$locked_object l,dba_objects o,v$session s
where l.object_id=o.object_id
and l.session_id=s.sid
order by o.object_id,xidusn desc

--分步

--１.查哪一個過程被鎖:
--查v$db_object_cache視圖:
select * from v$db_object_cache a where a.owner='gseoprod' and a.locks != '0';

--2. 查是哪個sid,經過sid可知道是哪一個session:
--查v$access視圖:
select * from v$access where owner='過程的所屬用戶' and name='剛纔查到的過程名';

--3. 查出sid和serial#：
--查v$session視圖:
select sid,serial#,paddr from v$session where sid='剛纔查到的sid';
--查v$process視圖:
select spid from v$process where addr='剛纔查到的paddr';

--4. 殺進程：
--(1)先殺oracle進程:
alter system kill session '&v_sid,&v_serial#';
--(2)再殺操做系統進程:
--kill -9 剛纔查出的spid或orakill 剛纔查出的sid 剛纔查出的spid。

--查看是否有鎖表的sql

select 'blocker('||lb.sid||':'||sb.username||')-sql:'|| qb.sql_text blockers, 
'waiter ('||lw.sid||':'||sw.username||')-sql:'|| qw.sql_text waiters 
from v$lock lb, v$lock lw, v$session sb, v$session sw, v$sql qb, v$sql qw 
where lb.sid=sb.sid 
and lw.sid=sw.sid 
and sb.prev_sql_addr=qb.address 
and sw.sql_address=qw.address 
and lb.id1=lw.id1 
and sw.lockwait is not null 
and sb.lockwait is null 
and lb.block=1 ;

/*
session_id擁有鎖的session_id,username擁有鎖的username,mode_held鎖的執行模式mode_held,
mode_requested鎖的請求mode_requested,object_name鎖所在的數據庫對象名
,lock_type鎖的類型,lock_id鎖的id
*/

select s.sid session_id, s.username,
decode(lmode, 0, 'none', 1, 'null', 2, 'row-s (ss)', 3, 'row-x (sx)', 
4, 'share', 5, 's/row-x (ssx)', 6, 'exclusive', to_char(lmode)) mode_held, 
decode(request, 0, 'none', 1, 'null', 2, 'row-s (ss)', 3, 'row-x (sx)', 
4, 'share', 5, 's/row-x (ssx)', 6, 'exclusive', to_char(request)) mode_requested, 
o.owner||'.'||o.object_name||' ('||o.object_type||')', s.type lock_type, l.id1 lock_id1, l.id2 lock_id2 
from v$lock l, sys.dba_objects o, v$session s 
where l.sid = s.sid and l.id1 = o.object_id;

--查看被鎖的表

select p.spid,a.serial#,c.object_name,
b.session_id,b.oracle_username,b.os_user_name 
from v$process p,v$session a, v$locked_object b,all_objects c 
where p.addr=a.paddr 
and a.process=b.process 
and c.object_id=b.object_id ;

--處理存儲過程被鎖
--查找鎖定過程的sid

select * from v$access where owner=<object owner> and object=<procedure name>;

--查看鎖（lock）狀況:

select /*+ rule */ ls.osuser os_user_name,ls.username user_name,
decode(ls.type,'rw','row wait enqueue lock','tm','dml enqueue lock','tx','transaction enqueue lock',
'ul','user supplied lock') lock_type,o.object_name object,
decode(ls.lmode,1,null,2,'row share',3,'row exclusive',4,'share',5,'share row exclusive',6,
'exclusive',null) lock_mode,o.owner,ls.sid,ls.serial# serial_num,ls.id1,ls.id2 
from sys.dba_objects o,(
select s.osuser,s.username,l.type,l.lmode,s.sid,s.serial#,l.id1,l.id2 
from v$session s,v$lock l 
where s.sid=l.sid) ls 
where o.object_id=ls.id1 
and o.owner<>'sys'
order by o.owner,o.object_name;

select sys.v_$session.osuser,sys.v_$session.machine,v$lock.sid,sys.v_$session.serial#,
decode(v$lock.type,'mr','media recovery','rt','redo thread','un','user name','tx','transaction','tm','dml','ul',
'pl/sql user lock','dx','distributed xaction','cf','control file','is','instance state','fs','file set','ir',
'instance recovery','st','disk space transaction','ts','temp segment','iv','library cache invalida-tion','ls',
'log start or switch','rw','row wait','sq','sequence number','te','extend table','tt','temp table','unknown'
) locktype,rtrim(object_type)||''||rtrim(owner)||'.'||object_name object_name,
decode(lmode,0,'none',1,'null',2,'row-s',3,'row-x',4,'share',5,'s/row-x',6,'exclusive','unknown') lockmode,
decode(request,0,'none',1,'null',2,'row-s',3,'row-x',4,'share',5,'s/row-x',6,'exclusive','unknown') requestmode,
ctime,block b 
from v$lock,all_objects,sys.v_$session 
where v$lock.sid > 6 
and sys.v_$session.sid = v$lock.sid 
and v$lock.id1 = all_objects.object_id;

--查看那個用戶那個進程形成死鎖，鎖的級別

select b.owner,b.object_name,l.session_id,l.locked_mode 
from v$locked_object l, dba_objects b
where l.object_id=b.object_id

--查看是哪一個session引發的死鎖

select b.username,b.sid,b.serial#,logon_time 
from v$locked_object a,v$session b 
where a.session_id = b.sid 
order by b.logon_time;

--殺掉進程

alter system kill session 'sid,serial#';

--若是有ora-00031錯誤，則在後面加immediate;
alter system kill session '29,5497' immediate；

--形成等待的lock的信息，好比lock類型等：

col event format a30 
set line 160 
col machine format a10 
col username format a15 
select b.sid,b.serial#,b.username,machine,a.event,a.wait_time,
chr(bitand(a.p1,-16777216)/16777215)||chr(bitand(b.p1,16711680)/65535) "enqueue type" 
from v$session_wait a,v$session b 
where a.event not like 'sql*n%'
and a.event not like 'rdbms%'
and a.sid=b.sid 
and b.sid>8 
and a.event='enqueue'
order by username;

--數據庫鎖對象

set line 120
column object_name format a32
column os_user_name format a12
column orauser format a12
column sql_text format a32
column serial# format 999999
column sid format 99999
select os_user_name,oracle_username as orauser,s.sid,o.object_name,o.object_type,s.serial#,a.sql_text
from v$locked_object l,dba_objects o,v$session s,v$sqlarea a
where l.object_id=o.object_id
and s.sql_address=a.address
and l.session_id=s.sid;

select'alter system kill session'''||to_char(s.sid)||','||to_char(s.serial#)||''';' as "statement to kill"
from v$locked_object l,dba_objects o,v$session s
where l.object_id=o.object_id
and l.session_id=s.sid;

--以dba角色,查看當前數據庫裏鎖的狀況能夠用以下sql語句：

col owner for a12 
col object_name for a16 
select b.owner,b.object_name,l.session_id,l.locked_mode from v$locked_object l,dba_objects b where b.object_id=l.object_id;

select t2.username,t2.sid,t2.serial#,t2.logon_time 
from v$locked_object t1,v$session t2 
where t1.session_id=t2.sid 
order by t2.logon_time;

select sql_address from v$session where sid=&v_sid;
select * from v$sqltext where address=&v_address;
select command_type,piece,sql_text from v$sqltext where address=(select sql_address from v$session a where sid=&v_sid); 
select object_id from v$locked_object;
select object_name,object_type from dba_objects where object_id=&v_object_id;

--若是有長期出現的一列，多是沒有釋放的鎖。咱們能夠用下面sql語句殺掉長期沒有釋放非正常的鎖：

alter system kill session'sid,serial#';

--以dba角色,查看當前數據庫裏鎖的狀況：

select object_id,session_id,locked_mode from v$locked_object;

select t2.username,t2.sid,t2.serial#,t2.logon_time 
from v$locked_object t1,v$session t2
where t1.session_id=t2.sid 
order by t2.logon_time;

--查看lock，並殺掉會話：

set linesize 132 pagesize 66
break on kill on username on terminal
column kill heading'kill string'format a13
column res heading'resource type'format 999	
column id1 format 999999	
column id2 format 9999990
column lmode beading'lock held'format a20
column request heading'lock requested'format a20
column serial# format 99999
column username format a10 heading "username"
column terminal heading term format a6
column tab format a35 heading "table name"
column owner format a9
column address format a18
select nvl(s.username,'internal') username,nvl(s.terminal,'none') terminal,l.sid||','||s.serial# kill,
u1.name||','||substr(t1.name,1,20) tab,
decode(l.lmode,1,'no lock',2,'row share',3,'row exclusive',4,'share',5,'share row exclusive',6,'exclusive',null) lmode,
decode(l.request,1,'no lock',2,'row share',3,'row exclusive',4,'share',5,'share row exclusive',6,'exclusive',null) request
from v$lock l,v$session s,sys.user$ u1,sys.obj$ t1
where l.sid=s.sid
and t1.obj#=decode(l.id2,0,l.id1,l.id2)
and u1.user#=t1.owner#
and s.type!='background'
order by 1,2,5;

--alter system kill session',';

column username format a15
column sid format 9990 heading sid
column type format a4
column lmode format 990 heading'held'
column request format 990 heading'req'
column id1 format 9999990
column id2 format 9999990
break on id1 skip 1 dup
spool tfslckwt.lst
select sn.username,m.sid,m.type,
decode(m.lmode,0,'none',1,'null',2,'row share',3,'row excl.',4,'share',5,'s/row excl.',
6,'exclusive',lmode,ltrim(to_char(lmode,'990'))) lmode,
decode(m.request,0,'none',1,'null',2,'row share',3,'row excl.',4,'share',5,'s/row excl.',6,'exclusive',request,
ltrim(to_char(m.request,'990'))) request,m.id1,m.id2
from v$session sn,v$lock m
where (sn.sid = m.sid and m.request!= 0)
or (sn.sid = m.sid and m.request=0 and lmode!=4 and (id1 ,id2) 
in (select s.id1,s.id2 from v$lock s where request != 0 and s.id1 = m.id1 and s.id2 = m.id2)
)
order by id1,id2,m.request;
spool off
clear breaks

--查看等待（wait）狀況

select ws.class,ws.count count,sum(ss.value)sum_value
from v$waitstat ws,v$sysstat ss
where ss.name in ('db block gets','consistent gets')
group by ws.class,ws.count;

--檢查average_wait執行:

select event,total_waits,time_waited,average_wait from v$system_event where event like '%undo%';

--求process/session的狀態

select p.pid,p.spid,s.program,s.sid,s.serial# from v$process p,v$session s where s.paddr=p.addr;

--求誰阻塞了某個session(10g)

select sid,username,event,blocking_session,seconds_in_wait,wait_time
from v$session
where state in ('waiting')
and wait_class!='idle';

--如何查看一下某個shared_server正在忙什麼:

select a.username,a.machine,a.program,a.sid,a.serial#,a.status,c.piece,c.sql_text
from v$session a,v$process b,v$sqltext c
where b.spid=13161 
and b.addr=a.paddr
and a.sql_address=c.address(+)
order by c.piece;

--查看當前sga值：

select * from v$sga

--查看各項sga相關參數：sga，sgastat

select substr(name,1,10) name,substr(value,1,10) value from v$parameter where name='log_buffer';
select * from v$sgastat ;
select * from v$sga;

show parameters area_size --查看各項區域內存參數，其中sort_area爲排序參數用；
--各項視圖建議參數值：v$db_cache_advice、v$shared_pool_advice），關於pga也有相關視圖v$pga_target_advice 等。

--監控 sga 的命中率

select a.value+b.value "logical_reads",c.value "phys_reads",
round(100*((a.value+b.value)-c.value)/(a.value+b.value)) "buffer hit ratio" 
from v$sysstat a,v$sysstat b,v$sysstat c 
where a.statistic#=38 
and b.statistic#=39 
and c.statistic#=40;

--監控 sga 中字典緩衝區的命中率

select parameter,gets,getmisses,getmisses/(gets+getmisses)*100 "miss ratio",
(1-(sum(getmisses)/(sum(gets)+sum(getmisses))))*100 "hit ratio" 
from v$rowcache 
where gets+getmisses<>0 
group by parameter,gets,getmisses;

--監控字典緩衝區

select (sum(pins-reloads))/sum(pins) "lib cache" from v$librarycache;
select (sum(gets-getmisses-usage-fixed))/sum(gets) "row cache" from v$rowcache;
select sum(pins) "executions",sum(reloads) "cache misses while executing" from v$librarycache;

--(後者除之前者,此比率小於1%,接近0%爲好)

select sum(gets) "dictionary gets",sum(getmisses) "dictionary cache get misses" from v$rowcache;

--監控 sga 中共享緩存區的命中率，應該小於1%

select sum(pins) "total pins",sum(reloads) "total reloads",sum(reloads)/sum(pins)*100 libcache from v$librarycache;

select sum(pinhits-reloads)/sum(pins) "hit radio",sum(reloads)/sum(pins) "reload percent" from v$librarycache;

--監控 sga 中重作日誌緩存區的命中率，應該小於1%

select name,gets,misses,immediate_gets,immediate_misses,decode(gets,0,0,misses/gets*100) ratio1,
decode(immediate_gets+immediate_misses,0,0,immediate_misses/(immediate_gets+immediate_misses)*100) ratio2 
from v$latch 
where name in ('redo allocation','redo copy');

--監控 mts

select busy/(busy+idle) "shared servers busy" from v$dispatcher;--(此值大於0.5時，參數需加大)
select sum(wait)/sum(totalq) "dispatcher waits" from v$queue where type='dispatcher';
select count(*) from v$dispatcher;
select servers_highwater from v$mts;
--(servers_highwater接近mts_max_servers時，參數需加大)

--db_cache建議

select size_for_estimate,buffers_for_estimate,estd_physical_read_factor,estd_physical_reads
from v$db_cache_advice
where name='default'
and block_size =(select value from v$parameter where name='db_block_size')
and advice_status ='on';

/*內存使用鎖定在物理內存：
aix 5l（aix 4.3.3 以上）
logon aix as root
cd /usr/samples/kernel
./vmtune(信息以下)v_pingshm已是1
./vmtune -s 1
而後oracle用戶修改initsid.ora 中 lock_sga = true
從新啓動數據庫

hp unix
root身份登錄
create the file "/etc/privgroup": vi /etc/privgroup
add line "dba mlock" to file
as root,run the command "/etc/setprivgrp -f /etc/privgroup":
$/etc/setprivgrp -f /etc/privgroup
oracle用戶修改initsid.ora中lock_sga=true
從新啓動數據庫

solaris(solaris2.6以上)
8i版本以上數據庫默認使用隱藏參數 use_ism = true ，自動鎖定sga於內存中,不用設置
lock_sga,若是設置 lock_sga =true 使用非 root 用戶啓動數據庫將返回錯誤。

windows （做用不大）
不能設置lock_sga=true,能夠經過設置pre_page_sga=true,使得數據庫啓動的時候就把全部內
存頁裝載，這樣可能起到必定的做用。

數據庫的硬件配置：cpu、內存、網絡條件
1.cpu：在任何機器中cpu的數據處理能力每每是衡量計算機性能的一個標誌，而且oracle是一個提供並行能力的數據庫系統，在cpu方面的要求就更高了，若是運行隊列數目超過了cpu處理的數目，性能就會降低，咱們要解決的問題就是要適當增長cpu的數量了，固然咱們還能夠將須要許多資源的進程kill掉；
2.內存：衡量機器性能的另一個指標就是內存的多少了，在oracle中內存和咱們在建數據庫中的交換區進行數據的交換，讀數據時，磁盤i/o必須等待物*/

--共享內存的使用率

select round(bytes/1024/1024,2)||'m' free_memory,round(total/1024/1024,2)||'m' as total_memory,
(1-round(bytes/total,2))*100||'%' as used_ratio
from v$sgastat,
(select pool,sum(bytes) as total from v$sgastat where pool='shared pool' group by pool) b
where name='free memory'
and b.pool=v$sgastat.pool
and v$sgastat.pool='shared pool';

--分步執行獲取使用率
--共享內存的大小：

select round(sum(bytes)/1024/1024,2) from v$sgastat where pool='shared pool';

--查詢空閒的共享池內存:

select * from v$sagstat where name ='free memory' and pool ='shared pool';

--共享池內存使用率

select (1-round(bytes/(&tsp_in_m * 1024 * 1024),2))*100||'%'
from v$sgastat
where name='free memory'
and pool='shared pool';

--其中: &tsp_in_m是你的總的共享池的size(m)
--共享池內存使用率，應該穩定在75%-90%間，過小浪費內存，太大則內存不足。

--肯定高速緩衝區命中率：（若是命中率低於70％，則應該加大init.ora參數中的db_block_buffer的值）

select 1-sum(decode(name,'physical reads',value,0))/
(sum(decode(name,'db block gets',value,0))+sum(decode(name,'consistent gets',value,0))) hit_ratio
from v$sysstat t
where name in ('physical reads','db block gets','consistent gets')

--數據庫共享池性能檢查:

select namespace,gets,gethitratio,pins,pinhitratio,reloads,invalidations 
from v$librarycache 
where namespace in ('sqlarea','table/procedure','body','trigger');

--library cache的命中率計算
--計算公式:
--library cache hit ratio = sum(pinhits)/sum(pins)
--select sum(pinhits)/sum(pins) from v$librarycache;

--一般在98%以上，不然，須要要考慮加大共享池，綁定變量，修改cursor_sharing等參數。

/*共享池的命中率（若是ratio1大於1時，須要加大共享池，若是ratio2大於10％時，須要加大共享池shared_pool_size）
假如共享池的命中率低於95%,就要考慮調整應用（一般是沒使用bind var ）或者增長內存*/
select sum(pinhits-reloads)/sum(pins)*100 "hit radio" from v$librarycache;

--假如共享池的命中率低於95%,就要考慮調整應用（一般是沒使用bind var ）或者增長內存；

select sum(pinhits)/sum(pins)*100 "hit radio" from v$librarycache;
select sum(pins)pins,sum(reloads)reloads,(sum(reloads)/sum(pins))*100 ratio1 from v$librarycache
select sum(gets)gets,sum(getmisses)getmisses,(sum(getmisses)/sum(gets))*100 ratio2 from v$rowcache

--查詢init.ora參數：

select * from v$parameter

--db buffer cache命中率
--計算公式:
--hit ratio = 1-[physical reads/(block gets+consistent gets)]

select name,physical_reads,db_block_gets,consistent_gets,1-(physical_reads/(db_block_gets+consistent_gets)) "hit ratio"
from v$buffer_pool_statistics
where name='default';

--一般應在90%以上，不然，須要調整,加大db_cache_size。

--另一種buffer cache計算命中率的方法：

/*命中率的計算公式爲:
hit ratio=1-((physical reads-physical reads direct-physical reads direct(lob))/
(db block gets+consistent gets-physical reads direct-physical reads direct(lob))*/

select round((1-((physica_reads-physical_reads_direct-physical_reads_direct_lob)/ 
(db_block_gets+consistent_gets-physical_reads_direct-physical_reads_direct_lob)))*100,2)||'%' as hit_ratio
from (
select
sum(case name when 'session logical reads' then value else null end) session_logical_reads,
sum(case name when 'db block gets' then value else null end) db_block_gets,
sum(case name when 'consistent gets' then value else null end) consistent_gets,
sum(case name when 'physical reads' then value else null end) physica_reads,
sum(case name when 'physical reads direct' then value else null end) physical_reads_direct,
sum(case name when 'physical reads direct(lob)' then value else null end) physical_reads_direct_lob
from v$sysstat
where name in ('session logical reads','physical reads','physical reads direct','physical reads direct(lob)',
'db block gets','consistent gets')
)

--分步執行獲取命中率

select name,value
from v$sysstat
where name in ('session logical reads','physical reads','physical reads direct',
'physical reads direct(lob)','db block gets','consistent gets');

--數據緩衝區命中率

select value from v$sysstat where name='physical reads';
select value from v$sysstat where name='physical reads direct';
select value from v$sysstat where name='physical reads direct(lob)';
select value from v$sysstat where name='consistent gets';
select value from v$sysstat where name='db block gets';

--這裏命中率的計算應該是令 x=physical reads direct+physical reads direct(lob)
--命中率=100-(physical reads-x)/(consistent gets+db block gets-x)*100
--一般若是發現命中率低於90%,則應該調整應用可能夠考慮是否增大數據緩衝區

--檢查rbs header get ratio執行:

select n.name,s.usn,s.wraps,decode(s.waits,0,1,1- s.waits/s.gets) "rbs header get ratio" 
from v$rollstat s,v$rollname n 
where s.usn=n.usn;

--(正常時ratio應該小於1%,count/value應該小於0.01%,average_wait最好爲0，該值越小越好,rbs header get ratio應該大於95%)

--監控內存和硬盤的排序比率，最好使它小於 .10，增長 sort_area_size
select name,value from v$sysstat where name in ('sorts(memory)','sorts(disk)');

--命中排序域的次數：

select t.name,t.value from v$sysstat t where t.name like 'sort%'

--假如咱們發現sorts(disk)/(sorts(memory)sorts(disk))的比例太高，則一般意味着sort_area_size 部份內存較小，可考慮調整相應的參數。

--查看排序段的性能:

select name,value from v$sysstat where name in ('sorts(memory)','sorts(disk)');

--查看排序多的sql

select sql_text,sorts,parsing_schema_name from v$sqlarea order by sorts desc;

--查看執行次數多的sql

select sql_text,executions,parsing_schema_name from v$sqlarea order by executions desc;

/*說明：單純從v$sqlarea中是沒法查出每一個sql消耗的內存量的，但咱們能夠藉助磁盤讀次數間接反映可能的消耗內存量較大的sql語句，
而後再借助執行計劃（如v$sql_plan視圖）具體查看。
利用系統視圖v$sqlarea，其中disk_reads是磁盤讀次數，也是主要字段，剩餘字段均爲參考字段。
其中，buffer_gets是內存讀次數，parsing_schema_name是首次編譯者模式名（通常與user名相同），executions是語句執行次數。
須要注意的是，v$sqlarea中sql_text可能不完整，若須要完整的則須要藉助hash_value或sql_id結合v$sqltext來查看分析。*/

--根據pid查找相應的sql語句:

select a.username,a.machine,a.program,a.sid,a.serial#,a.status,c.piece,c.sql_text 
from v$session a,v$process b,v$sqltext c 
where b.spid='orcl'
and b.addr=a.paddr 
and a.sql_address=c.address(+)
order by c.piece

--log_buffer

select name,value from v$sysstat where name in ('redo entries','redo buffer allocation retries');

--假如 redo buffer allocation retries/ redo entries 的比例超過1%咱們就能夠考慮增大log_buffer

--查詢消耗資源的進程（top session）

select s.schemaname schema_name,decode(sign(48 - command),1,to_char(command),'action code #'||to_char(command)) action,
status session_status,s.osuser os_user_name,s.sid,p.spid,s.serial# serial_num,
nvl(s.username,'[oracle process]') user_name,s.terminal terminal,s.program program,st.value criteria_value
from v$sesstat st,v$session s,v$process p
where st.sid = s.sid
and st.statistic# = to_number('38')
and ('all'='all'or s.status ='all')
and p.addr = s.paddr
order by st.value desc,p.spid asc,s.username asc,s.osuser asc

--求出某個進程，並對它進行跟蹤

select s.sid,s.serial# from v$session s,v$process p where s.paddr = p.addr and p.spid = &1;
exec dbms_system.set_sql_trace_in_session(&1,&2,true);
exec dbms_system.set_sql_trace_in_session(&1,&2,false);

--求當前session的跟蹤文件

select p1.value||'/'||p2.value||'_ora_'||p.spid||'.ora' filename
from v$process p,v$session s,v$parameter p1,v$parameter p2
where p1.name='user_dump_dest'
and p2.name='instance_name'
and p.addr=s.paddr
and s.audsid=userenv('sessionid')
and p.background is null
and instr(p.program,'cjq')=0;

--查詢session的os進程id

select p.spid "os thread",b.name "name-user",s.program,s.sid,s.serial#,s.osuser,s.machine
from v$process p,v$session s,v$bgprocess b
where p.addr=s.paddr
and p.addr=b.paddr 
and(s.sid=&1 or p.spid=&1)
union all
select p.spid "os thread",s.username "name-user",s.program,s.sid,s.serial#,s.osuser,s.machine
from v$process p,v$session s
where p.addr=s.paddr
and(s.sid=&1 or p.spid=&1)
and s.username is not null;

--查找object爲哪些進程所用

select p.spid,s.sid,s.serial# serial_num,s.username user_name,a.type object_type,s.osuser os_user_name,a.owner,
a.object object_name,decode(sign(48 - command),1,to_char(command),'action code #'||to_char(command)) action,
p.program oracle_process,s.terminal terminal,s.program program,s.status session_status
from v$session s,v$access a,v$process p
where s.paddr=p.addr
and s.type='user'
and a.sid=s.sid
and a.object='&obj'
order by s.username,s.osuser

--查看object_catched

select owner,name,db_link,namespace,type,sharable_mem,loads,executions,locks,pins,kept from v$db_object_cache

--求出鎖定的對象

select do.object_name,session_id,process,locked_mode 
from v$locked_object lo,dba_objects do
where lo.object_id=do.object_id;

--檢查誰lock了什麼對象:

set line 200 
col "o/s-user" format a10 
col "ora-user" format a10 
col "obj locked" format a30 
select /*+rule*/s.machine,s.osuser "o/s-user",s.username "ora-user",s.sid "session-id",s.serial# "serial",
s.process "process-id",s.status "status",l.name "obj locked",l.mode_held "lock mode" 
from v$session s,dba_dml_locks l,v$process p 
where l.session_id=s.sid 
and p.addr=s.paddr

--查看數據庫庫對象

select owner,object_type,status,count(*) count# from all_objects group by owner,object_type,status;

--顯示全部數據庫對象的類別和大小

select count(name) num_instances ,type,sum(source_size) source_size,sum(parsed_size) parsed_size ,sum(code_size) code_size ,
sum(error_size) error_size,sum(source_size)+sum(parsed_size)+sum(code_size)+sum(error_size) size_required 
from dba_object_size 
group by type 
order by 2;

--查詢disk_reads大於100000的sql查詢

select b.username username,a.disk_reads reads,
a.executions exec,a.disk_reads/decode(a.executions,0,1,a.executions) rds_exec_ratio,
a.sql_text statement
from v$sqlarea a,dba_users b
where a.parsing_user_id=b.user_id
and a.disk_reads>100000
order by a.disk_reads desc;

--運行時間長的的sql

column username format a12
column opname format a16
column progress format a8
select username,sid,opname,round(sofar*100/totalwork,0)||'%' as progress,time_remaining,sql_text
from v$session_longops,v$sql
where time_remaining<>0
and sql_address=address
and sql_hash_value=hash_value

--耗內存的sql語句

select b.username username,a.buffer_gets buffer_gets,a.executions exec,a.sql_text statement
from v$sqlarea a,dba_users b
where a.parsing_user_id=b.user_id
order by a.buffer_gets desc;

--v$sql是內存共享sql區域中已經解析的sql語句。查出使用頻率最高的5個查詢：

select sql_text,executions
from (select sql_text,executions,rank() over(order by executions desc) exec_rank from v$sql)
where exec_rank <=5;

--消耗磁盤讀取最多的sql top5：

select disk_reads,sql_text
from (select sql_text,disk_reads,dense_rank() over(order by disk_reads desc) disk_reads_rank from v$sql)
where disk_reads_rank <=5;

select * from (
select parsing_user_id,executions,sorts,command_type,disk_reads,sql_text from v$sqlarea 
order by disk_reads) d
where rownum<10

--找出須要大量緩衝讀取（邏輯讀）操做的查詢：

select buffer_gets,sql_text
from (select sql_text,buffer_gets,dense_rank() over(order by buffer_gets desc) buffer_gets_rank from v$sql)
where buffer_gets_rank<=5;

--經過v$session_wait這個視圖查看性能問題的成因，看系統的這些session在等什麼，使用了多少的io。

--查看佔io較大的正在運行的session

select se.sid,se.serial#,pr.spid,se.username,se.status,se.terminal,se.program,se.module,
se.sql_address,st.event,st.p1text,si.physical_reads,si.block_changes 
from v$session se,v$session_wait st,v$sess_io si,v$process pr 
where st.sid=se.sid 
and st.sid=si.sid 
and se.paddr=pr.addr 
and se.sid>6 
and st.wait_time=0 
and st.event not like '%sql%'
order by physical_reads desc

/*對檢索出的結果的幾點說明：
一、我是按每一個正在等待的session已經發生的物理讀排的序，由於它與實際的io相關。
二、你能夠看一下這些等待的進程都在忙什麼，語句是否合理？ */
select sql_address from v$session where sid=&v_sid;
select * from v$sqltext where address=&v_address;

--執行以上兩個語句即可以獲得這個session的語句。 kill進程
alter system kill session'sid,serial#';

/*三、應觀注一下event這列，這是咱們調優的關鍵一列，下面對常出現的event作以簡要的說明：
a、buffer busy waits，free buffer waits這兩個參數所標識是dbwr是否夠用的問題，與io很大相關的，
當v$session_wait中的free buffer wait的條目很小或沒有的時侯，說明你的系統的dbwr進程決對夠用，不用調整；
free buffer wait的條目不少，你的系統感受起來必定很慢，這時說明你的dbwr已經不夠用了，它產生的wio已經成爲你的數據庫性能的瓶頸，這時的解決辦法以下：
a、1增長寫進程，同時要調整db_block_lru_latches參數
示例：修改或添加以下兩個參數
db_writer_processes=4
db_block_lru_latches=8
2開異步io，ibm這方面簡單得多，hp則麻煩一些，能夠與hp工程師聯繫。
b、db file sequential read，指的是順序讀，即全表掃描，這也是咱們應該儘可能減小的部分，
解決方法就是使用索引、sql調優，同時能夠增大db_file_multiblock_read_count這個參數。
c、db file scattered read,這個參數指的是經過索引來讀取，一樣能夠經過增長db_file_multiblock_read_count這個參數來提升性能。
d、latch free,與栓相關的了，須要專門調節。
e、其餘參數能夠不特別觀注。
*/

/*計算cpu消耗首先要藉助linux的top命令尋找cpu使用量高的session，找到高佔用的pid。
而後藉助v$process的addr字段跟v$session的paddr找到sql_id、hash_value，
而後結合v$sqltext而後找相應的sql語句，找到以後分析執行計劃，進行相應調優。*/

--前30條平均cpu時間超過10秒的sql

select a.address address,b.cpu_time/1000000/b.executions averagecputime,b.cpu_time/1000000 cputime,
b.elapsed_time/1000000 elapsedtime,b.executions executions,a.sql_text sqltext
from v$sqltext a,v$sqlarea b
where a.address=b.address 
and a.hash_value=b.hash_value 
and b.executions>0 
and(b.address,b.hash_value)
in (select address,hash_value 
from (
select address,hash_value 
from v$sqlarea
where executions>0 
and cpu_time/1000000>10*executions
order by cpu_time desc)
where rownum<31)
group by a.address,a.sql_text,a.piece,b.cpu_time,b.elapsed_time,b.executions
order by averagecputime desc,a.address,a.piece;

--找出消耗cpu最高的進程對應的sql語句（這裏輸入佔用cpu最高的進程對應的pid）：

set line 240
set verify off
column sid format 999
column pid format 999
column s_# format 999
column username format a9 heading "ora user"
column program format a29
column sql format a60
column osname format a9 heading "os user"
select p.pid pid,s.sid sid,p.spid spid,s.username username,s.osuser osname,p.serial# s_#,p.terminal,p.program program,
p.background,s.status,rtrim(substr(a.sql_text,1,80)) sql
from v$process p,v$session s,v$sqlarea a 
where p.addr=s.paddr
and s.sql_address=a.address(+)
and p.spid like'%&v_pid%';

set termout off
spool maxcpu.txt
select '++'||s.username username,rtrim(replace(a.sql_text,chr(10),''))||';'
from v$process p,v$session s, v$sqlarea a 
where p.addr=s.paddr 
and s.sql_address=a.address(+)
and p.spid like'%&v_pid%';

--enter value for 1: pid（這裏輸入佔用cpu最高的進程對應的pid）
--spool off(這句放在最後執行)

--找使用cpu多的用戶session

select a.sid,spid,status,substr(a.program,1,40) prog,a.terminal,osuser,value/60/100 value 
from v$session a,v$process b,v$sesstat c 
where c.statistic#=12 
and c.sid=a.sid 
and a.paddr=b.addr 
order by value desc;

--(12是cpu used by this session)

--cpu用率最高的2條sql語句的獲取
--執行：top，經過top得到cpu佔用率最高的進程的pid。

select sql_text,spid,v$session.program,process 
from v$sqlarea,v$session,v$process 
where v$sqlarea.address=v$session.sql_address 
and v$sqlarea.hash_value=v$session.sql_hash_value
and v$session.paddr=v$process.addr 
and v$process.spid in (&v_pid);

col machine format a30 
col program format a40 
set line 200 
select sid,serial#,username,osuser,machine,program,process,to_char(logon_time,'yyyy/mm/dd hh24:mi:ss') 
from v$session 
where paddr 
in (select addr from v$process where spid in (&spid));

select sql_text 
from v$sqltext_with_newlines 
where hash_value=(select sql_hash_value from v$session where sid=&sid)
order by piece;

--查找消耗資源的sql語句

select se.username,se.sid,su.extents,su.blocks*to_number(rtrim(p.value)) as space,tablespace,segtype,sql_text
from v$sort_usage su,v$parameter p,v$session se,v$sql s
where p.name='db_block_size'
and su.session_addr=se.saddr
and s.hash_value=su.sqlhash
and s.address=su.sqladdr
order by se.username,se.sid

--查找消耗資源多的sql 操做系統pid

select sql_text,spid,v$session.program,process 
from v$sqlarea,v$session,v$process
where v$sqlarea.address=v$session.sql_address
and v$sqlarea.hash_value=v$session.sql_hash_value
and v$session.paddr=v$process.addr
and v$process.spid in (&v_pid);

----------------------------------------
--查看v$sqlarea

select sql_text,sharable_mem,persistent_mem,runtime_mem,sorts,version_count,loaded_versions,open_versions,users_opening,
executions,users_executing,loads,first_load_time,invalidations,parse_calls,disk_reads,buffer_gets,rows_processed 
from v$sqlarea

--------------------------------------------------------------------------------
/*v$sqlarea
v$sql和v$sqlarea基本相似，而v$sqlarea更經常使用，故僅對v$sqlarea經常使用字段進行說明，以下（我的參考oracle官方文檔翻譯的，因是最新版本，因此會跟網絡上的有些出入）：

sql_text：sql語句的前1000個字符；
sql_fulltext：sql語句的全部字符；
sql_id：緩存在高速緩衝區（library cache）中的sql父遊標的惟一標識id（注，相似於hash_value，不過hash_value是4bytes而sql_id是8bytes，sql_id更精確後期可能會替代hash_value）；
sharable_mem：sql語句及其子游標占用的共享內存大小；
persistent_mem：打開sql語句的生命週期內所佔用的固定內存大小（包含子游標）；
runtime_mem：遊標執行期間所佔用的固定內存大小；
sorts：語句執行致使的排序次數；
version_count：在緩存中以該語句爲父語句的子游標總數；
loaded_versions：緩存中載入了這條語句上下文堆（kgl heap 6）的子游標數；
open_versions：父遊標下打開的子游標個數；
users_opening：打開子游標的用戶個數；
fetches：sql語句的fetch數；
executions：包含全部子游標在內該sql語句共執行次數；
users_executing：執行過該語句全部子游標的用戶總數；
loads：語句被載入的總次數；
first_load_time：父遊標被首次載入（編譯）的時間；
parse_calls：父遊標下全部子游標解析調用次數；
disk_reads：該語句經過全部子游標緻使的讀磁盤次數；
direct_writes：該語句經過全部子游標緻使的直接寫入次數；
buffer_gets：該語句經過全部子游標緻使的讀緩存次數；
application_wait_time：應用等待時間；
user_io_wait_time：用戶i/o等待時間；
plsql_exec_time：plsql執行時間；
rows_processed：該sql語句處理的總行數；
optimizer_cost：此查詢優化給出的成本數；
parsing_user_id：第一次解析該父語句的用戶id；
parsing_schema_id：第一次解析該語句schema的id；
parsing_schema_name：解析該語句的schema的name；
kept_versions：指出是否當前子游標被使用dbms_shared_pool包標記爲常駐內存；
address：當前遊標父句柄（惟一指向該遊標的一種地址編號）；
hash_value：該語句在library cache中hash值；
plan_hash_value：執行計劃的hash值，可依此肯定兩個執行計劃是否相同（取代每行每字符進行比較的方式）；
cpu_time：該語句解析、執行和fetch（取值）所消耗的cpu時間；
elapsed_time：該語句解析、執行和fetch（取值）所通過的時間；
last_active_time：查詢計劃最後一次執行的時間；
locked_total：全部子游標被鎖的次數；
v$sqltext

address：當前遊標父句柄（惟一指向該遊標的一種地址編號）；
hash_value：該遊標（子游標）在library cache中惟一hash值；
sql_id：緩存遊標中該sql的一個惟一標識值；
command_type：sql語句類型，如select、insert、update等；
piece：排序sql文本的碎片數；
sql_text：包含一個完整sql中的某一小塊sql文本字符（要完整的sql語句須要把這些碎片組合起來）；
v$session

saddr：session地址；sid：session標識值，常跟serial#聯合惟一肯定一個session（在殺進程時，有時sid會重用，形成誤殺。而serial會增長但不會重複，sid 在同一個instance的當前session中是一個unique key，而sid ,serial#則是在整個instance生命期內的全部session中是unique key）；serial#：會話序列號，用於在一個會話結束而另外一個會話重用這該會話的sid時，惟一肯定一個會話；audsid：審計會話id，能夠經過audsid查詢當前session的sid，select sid from v$session where audsid=userenv('sessionid')；paddr：進程地址，關聯v$process的addr字段，經過這個能夠查詢到進程對應的session；user#：同於dba_users中的user_id，oracle內部進程user#爲0；username：會話擁有者用戶名，等於dba_users中的username，oracle內部進程的username爲空；command：正在執行的sql語句類型，如1爲create table、3爲select等；ownerid：若是該列值爲2147483644則值無效，不然值用於會話遷移、並行等；taddr：address of transaction state object；lockwait：標識當前查詢是否處於鎖等待狀態，爲空則表示無等待；status：標識session狀態，active正執行sql語句，inactive等待操做，killed被標註爲殺死；server：服務器類型，dedicated專用、shared共享等；schema#：schema標識id值，oracle內部進程的schema#爲0；schemaname：schema用戶名，oracle內部進程的爲sys；osuser：客戶端操做系統用戶名；process：客戶端操做系統進程id；machine：操做系統機器名；terminal：操做系統終端名；program：操做系統應用程序名，如exe或sqlplus.exe；type：會話類型，如background或user；sql_address：和sql_hash_value一塊兒使用標識正在執行的sql語句；sql_hash_value：和sql_address一塊兒使用標識正在執行的sql語句；sql_id：正在執行的sql語句的標識id；sql_child_number：正在執行的sql語句的子id；fixed_table_sequence：當session完成一個user call後就會增長的一個數值，也就是說，若是session掛起，它就不會增長。所以能夠根據這個字段來監控某個時間點以來的session性能狀況。例如，一個小時前某個session的此字段數值爲10000，而如今是20000，則代表一個小時內其user call較頻繁，能夠重點關注此session的performance statistics。row_wait_obj#：被鎖定行所在table的object_id，和dba_object中的object_id關聯能夠獲得被鎖定的table name；row_wait_file#：被鎖定行所在的datafile id，和v$datafile中的file#關聯能夠獲得datafile name；row_wait_block#：被鎖定的塊id；row_wait_row#：被鎖定的當前行；logon_time：登陸時間；*/

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。