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：登陆时间；*/