查询Oracle正在执行的sql语句及执行该语句的用户

SELECT b.sid oracleID,

    b.username 登录Oracle用户名,

    b.serial#,

    spid 操作系统ID,

    paddr,

    sql_text 正在执行的SQL,

    b.machine 计算机名

FROM v$process a, v$session b, v$sqlarea c

WHERE a.addr = b.paddr

  AND b.sql_hash_value = c.hash_value
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

或者

select a.username, a.sid,b.SQL_TEXT, b.SQL_FULLTEXT

 from v$session a, v$sqlarea b

where a.sql_address = b.address
  • 1
  • 2
  • 3
  • 4

查询Oracle执行过的sql语句及执行该语句的用户

---执行过的

select a.USERNAME        登录Oracle用户名,

       a.MACHINE         计算机名,

       SQL_TEXT,

       b.FIRST_LOAD_TIME,

       b.SQL_FULLTEXT

  from v$sqlarea b, v$session a

 where a.sql_hash_value = b.hash_value

   and b.FIRST_LOAD_TIME between '2016-11-01/09:24:47' and

       '2016-11-31/09:24:47'

 order by b.FIRST_LOAD_TIME desc;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

查看正在执行sql的发起者的发放程序

SELECT OSUSER 电脑登录身份,

    PROGRAM 发起请求的程序,

    USERNAME 登录系统的用户名,

    SCHEMANAME,

    B.Cpu_Time 花费cpu的时间,

    STATUS,

    B.SQL_TEXT 执行的sql

FROM V$SESSION A

LEFT JOIN V$SQL B ON A.SQL_ADDRESS = B.ADDRESS

          AND A.SQL_HASH_VALUE = B.HASH_VALUE

ORDER BY b.cpu_time DESC
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
 v$sql、v$sqlarea 、v$sqltext
  • 1

这三哥视图都可以用于查询共享池中已经解析过的SQL语句及其相关信息。

  • V$SQL中列出了共享SQL区中所有语句的信息，它不包含GROUP BY字句，并且为每一条SQL语句中单独存放一条记录；
  • V$SQLAREA中一条记录显示了一条共享SQL区中的统计信息。它提供了有在内存中、解析过的和准备运行的SQL语句的统计信息；
  • V$SQLTEXT包含了库缓存中所有共享游标对应的SQL语句。它将SQL语句分片显示。

查出oracle当前的被锁对象

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#;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

kill掉当前的锁对象可以为

alter system kill session 'sid， s.serial#‘;
  • 1

查看占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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

查询碎片程度高

（实际使用率小于30%）的表，也就是可以收缩的表

条件为什么block>100，因为一些很小的表，只有几行数据实际大小很小，但是block一次性分配就是5个（11g开始默认一次性分配1M的block大小了，见create table storged的NEXT参数），5个block相对于几行小表数据来说就相差太大了

算法中/0.9是因为块的pfree一般为10%，所以一个块最多只用了90%，而且一行数据大于8KB时容易产生行链接，把一行分片存储，一样的一个块连90%都用不满

AVG_ROW_LEN还是比较准的，比如个人实验情况一表6个字段，一个number，其他5个都是char(100)但是实际数据都是’1111111’7位，AVG_ROW_LEN显示依然为513

SELECT TABLE_NAME,(BLOCKS*8192/1024/1024)"理论大小M",

(NUM_ROWS*AVG_ROW_LEN/1024/1024/0.9)"实际大小M",

round((NUM_ROWS*AVG_ROW_LEN/1024/1024/0.9)/(BLOCKS*8192/1024/1024),3)*100||'%' "实际使用率%"

FROM USER_TABLES where blocks>100 and (NUM_ROWS*AVG_ROW_LEN/1024/1024/0.9)/(BLOCKS*8192/1024/1024)<0.3

order by (NUM_ROWS*AVG_ROW_LEN/1024/1024/0.9)/(BLOCKS*8192/1024/1024) desc
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

查询索引碎片的比例

（索引删除行数除以索引总行数的百分比>30%即认为索引碎片大），也就是需要重建的索引

select name,

       del_lf_rows,

       lf_rows,

       round(del_lf_rows / decode(lf_rows, 0, 1, lf_rows) * 100, 0) || '%' frag_pct

  from index_stats

 where round(del_lf_rows / decode(lf_rows, 0, 1, lf_rows) * 100, 0) > 30;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

集群因子clustering_factor高的表

集群因子越接近块数越好，接近行数则说明索引列的列值相等的行分布极度散列，可能不走索引扫描而走全表扫描

select tab.table_name,tab.blocks,tab.num_rows,ind.index_name,ind.clustering_factor,

round(nvl(ind.clustering_factor,1)/decode(tab.num_rows,0,1,tab.num_rows),3)*100||'%' "集群因子接近行数"

from user_tables tab, user_indexes ind where tab.table_name=ind.table_name

and tab.blocks>100

and nvl(ind.clustering_factor,1)/decode(tab.num_rows,0,1,tab.num_rows) between 0.35 and 3
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

或

select tab.owner,tab.table_name,tab.blocks,tab.num_rows,ind.index_name,ind.clustering_factor,

round(nvl(ind.clustering_factor,1)/decode(tab.num_rows,0,1,tab.num_rows),3)*100||'%' "集群因子接近行数"

from dba_tables tab, dba_indexes ind where tab.table_name=ind.table_name and tab.owner

not in ('SYS','SYSTEM','WMSYS','DBSNMP','CTXSYS','XDB','ORDDATA','SYSMAN','CATALOG','APEX_030200','MDSYS','OLAPSYS','EXFSYS')

and tab.blocks>100

and nvl(ind.clustering_factor,1)/decode(tab.num_rows,0,1,tab.num_rows) between 0.35 and 3
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

根据sid查spid或根据spid查sid

select s.sid, s.serial#, s.LOGON_TIME, s.machine, p.spid, p.terminal

  from v$session s, v$process p

 where s.paddr = p.addr

   and s.sid = XX

    or p.spid = YY
  • 1
  • 2
  • 3
  • 4
  • 5

根据sid查看具体的sql语句

select username, sql_text, machine, osuser

  from v$session a, v$sqltext_with_newlines b

 where DECODE(a.sql_hash_value, 0, prev_hash_value, sql_hash_value) =

       b.hash_value

   and a.sid = &sid

 order by piece;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

根据spid查询具体的sql语句

select ss.SID,

       ss.SERIAL#,

       ss.LOGON_TIME,

       pr.SPID,

       ss.action,

       sa.SQL_FULLTEXT,

       ss.machine,

       ss.TERMINAL,

       ss.PROGRAM,

       ss.USERNAME,

       ss.STATUS,

       ss.OSUSER,

       ss.last_call_et

  from v$process pr, v$session ss, v$sqlarea sa

 where ss.status = 'ACTIVE'

   and ss.username is not null

   and pr.ADDR = ss.PADDR

   and ss.SQL_ADDRESS = sa.ADDRESS

   and ss.SQL_HASH_VALUE = sa.HASH_VALUE

   and pr.spid = XX
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

查看历史session_id的SQL来自哪个IP

(当然这是个误解，都是历史的了，怎么可能还查到spid，其实查看trace文件名就可以知道spid,trace文件里面有sid和具体sql，如果trace存在incident，那trace就看不到具体sql，但是可以在incident文件中看到具体的sql，如DW_ora_17751.trc中17751就是spid，里面有这样的内容Incident 115 created, dump file: /XX/incident/incdir_115/DW_ora_17751_i115.trc，那么在DW_ora_17751_i115.trc就可以看到具体的sql语句)

DB_ora_29349.trc中出现如下

* SESSION ID:(5057.12807) 2016-10-26 14:45:52.726

通过表V$ACTIVE_SESSION_HISTORY来查，如下

select a.sql_id, a.machine, a.*

  from V$ACTIVE_SESSION_HISTORY a

 where a.session_id = 5057

   and a.SESSION_SERIAL# = 12807
  • 1
  • 2
  • 3
  • 4
  • 5

查询上面的machine的IP是多少

select s.sid, s.serial#, s.LOGON_TIME, s.machine, p.spid, p.terminal

  from v$session s, v$process p

 where s.paddr = p.addr

   and s.machine = 'localhost'
  • 1
  • 2
  • 3
  • 4
  • 5

通过上面的spid在oracle服务器上执行netstat -anp |grep spid即可

[oracle@dwdb trace]$ netstat -anp |grep 17630

tcp      210      0 192.168.64.228:11095        192.168.21.16:1521          ESTABLISHED 17630/oracleDB

tcp        0      0 ::ffff:192.168.64.228:1521  ::ffff:192.168.64.220:59848 ESTABLISHED 17630/oracleDB
  • 1
  • 2
  • 3
  • 4
  • 5

出现两个，说明来自220，连接了228数据库服务器，但是又通过228服务器的dblink去连接了16服务器

查询DML死锁会话sid

（对象锁被释放的等待者），及引起死锁的堵塞者会话blocking_session（对象加锁者）

select sid,

       blocking_session,

       LOGON_TIME,

       sql_id,

       status,

       event,

       seconds_in_wait,

       state,

       BLOCKING_SESSION_STATUS

  from v$session

 where event like 'enq%'

   and state = 'WAITING'

   and BLOCKING_SESSION_STATUS = 'VALID'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

BLOCKING_SESSION:Session identifier of the blocking session. This column is valid only if BLOCKING_SESSION_STATUS has the value VALID.

可以在v$session.LOGON_TIME上看到引起死锁的堵塞者会话比等待者要早

如果遇到RAC环境，一定要用gv$来查，并且执行alter system kill session ‘sid,serial#’要到RAC对应的实例上去执行

或如下也可以

select

           (select username from v$session where sid=a.sid) blocker,

         a.sid,

         a.id1,

         a.id2,

       ' is blocking ' "IS BLOCKING",

         (select username from v$session where sid=b.sid) blockee,

             b.sid

    from v$lock a, v$lock b

   where a.block = 1

     and b.request > 0

     and a.id1 = b.id1

     and a.id2 = b.id2;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

查询DDL锁的sql

查询x开头的动态性能视图，只能用sys用户

SELECT sid, event, p1raw, seconds_in_wait, wait_time

  FROM sys.v_$session_wait

 WHERE event like 'library cache %'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

p1raw结果为’0000000453992440’

SELECT s.sid, kglpnmod "Mode", kglpnreq "Req", s.LOGON_TIME

FROM x$kglpn p, v$session s

WHERE p.kglpnuse=s.saddr

AND kglpnhdl='0000000453992440';
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

结果为671 0 3 2011-11-1 12:00:00

  525 2 0 2011-11-4 12:00:00

查询锁住的DDL对象

select d.session_id, s.SERIAL#, d.name

  from dba_ddl_locks d, v$session s

 where d.owner = 'CC'

   and d.SESSION_ID = s.sid
  • 1
  • 2
  • 3
  • 4
  • 5

查询当前正在执行的sql

SELECT s.sid,

       s.serial#,

       s.username,

       spid,

       v$sql.sql_id,

       machine,

       s.terminal,

       s.program,

       sql_text

  FROM v$process, v$session s, v$sql

 WHERE addr = paddr

   and s.sql_id = v$sql.sql_id

   AND sql_hash_value = hash_value
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

查询正在执行的SCHEDULER_JOB

select owner, job_name, sid, b.SERIAL#, b.username, spid

  from ALL_SCHEDULER_RUNNING_JOBS, v$session b, v$process

 where session_id = sid

   and paddr = addr
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

查询正在执行的dbms_job

select job,b.sid,b.SERIAL#,b.username,spid from DBA_JOBS_RUNNING a ,v$session b,v$process  where a.sid=b.sid and paddr=addr
  • 1

查询一个会话session、process平均消耗多少内存，查看下面avg_used_M值

select round(sum(pga_used_mem) / 1024 / 1024, 0) total_used_M,

       round(sum(pga_used_mem) / count(1) / 1024 / 1024, 0) avg_used_M,

       round(sum(pga_alloc_mem) / 1024 / 1024, 0) total_alloc_M,

       round(sum(pga_alloc_mem) / count(1) / 1024 / 1024, 0) avg_alloc_M

  from v$process;
  • 1
  • 2
  • 3
  • 4
  • 5

TOP 10 执行次数排序

select *

from (select executions,username,PARSING_USER_ID,sql_id,sql_text  

   from v$sql,dba_users where user_id=PARSING_USER_ID order by executions desc)

where rownum <=5;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

TOP 10 物理读排序（消耗IO排序，即最差性能SQL、低效SQL排序）

select *

from (select DISK_READS,username,PARSING_USER_ID,sql_id,ELAPSED_TIME/1000000,sql_text  

   from v$sql,dba_users where user_id=PARSING_USER_ID order by DISK_READS desc)

where rownum <=5;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

（不要使用DISK_READS/ EXECUTIONS来排序，因为任何一条语句不管执行几次都会耗逻辑读和cpu，可能不会耗物理读（遇到LRU还会耗物理读，LRU规则是执行最不频繁的且最后一次执行时间距离现在最久远的就会被交互出buffer cache），是因为buffer cache存放的是数据块，去数据块里找行一定会消耗cpu和逻辑读的。Shared pool执行存放sql的解析结果，sql执行的时候只是去share pool中找hash value，如果有匹配的就是软解析。所以物理读逻辑读是在buffer cache中，软解析硬解析是在shared pool）

TOP 10 逻辑读排序（消耗内存排序）

select *

from (select BUFFER_GETS,username,PARSING_USER_ID,sql_id,ELAPSED_TIME/1000000,sql_text  

   from v$sql,dba_users where user_id=PARSING_USER_ID order by BUFFER_GETS desc)

where rownum <=5;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

（不要使用BUFFER_GETS/ EXECUTIONS来排序，因为任何一条语句不管执行几次都会耗逻辑读和cpu，可能不会耗物理读（遇到LRU还会耗物理读，LRU规则是执行最不频繁的且最后一次执行时间距离现在最久远的就会被交互出buffer cache），是因为buffer cache存放的是数据块，去数据块里找行一定会消耗cpu和逻辑读的。Shared pool执行存放sql的解析结果，sql执行的时候只是去share pool中找hash value，如果有匹配的就是软解析。所以物理读逻辑读是在buffer cache中，软解析硬解析是在shared pool）

TOP 10 CPU排序(单位秒=cpu_time/1000000)

select *

from (select CPU_TIME/1000000,username,PARSING_USER_ID,sql_id,ELAPSED_TIME/1000000,sql_text  

   from v$sql,dba_users where user_id=PARSING_USER_ID order by CPU_TIME/1000000 desc)

where rownum <=5;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

（不要使用CPU_TIME/ EXECUTIONS来排序，因为任何一条语句不管执行几次都会耗逻辑读和cpu，可能不会耗物理读（遇到LRU还会耗物理读，LRU规则是执行最不频繁的且最后一次执行时间距离现在最久远的就会被交互出buffer cache），是因为buffer cache存放的是数据块，去数据块里找行一定会消耗cpu和逻辑读的。Shared pool执行存放sql的解析结果，sql执行的时候只是去share pool中找hash value，如果有匹配的就是软解析。所以物理读逻辑读是在buffer cache中，软解析硬解析是在shared pool）

查询等待事件

select event,

       sum(decode(wait_time, 0, 0, 1)) "之前等待次数",

       sum(decode(wait_time, 0, 1, 0)) "正在等待次数",

       count(*)

  from v$session_wait

 group by event

 order by 4 desc
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

查询当前正在消耗temp空间的sql语句

Select distinct se.username,

         se.sid,

         su.blocks * to_number(rtrim(p.value))/1024/1024 as space_G,

         su.tablespace,

         sql_text

    from V$TEMPSEG_USAGE su, v$parameter p, v$session se, v$sql s

   where p.name = 'db_block_size'

     and su.session_addr=se.saddr

     and su.sqlhash=s.hash_value

     and su.sqladdr=s.address
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

查询需要使用绑定变量的sql,10G以后推荐第二种

（任何一条执行过的语句不管执行了几次在V$SQL中都只有一条记录，V$SQL中会记录执行了几次。两条一模一样的语句但是在不同的schema下执行的两种结果，如select * from t1.test在sye、system下执行则V$SQL只有一条记录(谁先执行则PARSING_SCHEMA_NAME显示谁)。如在sys和system都执行select * from test则V$SQL中有两条记录，两条记录的CHILD_NUMBER和PARSING_SCHEMA_NAME不一样。同一个用户下执行一样的语句如果大小写不一样或加了hint的话则会出现多个V$SQL记录，说明V$SQL对应的sql语句必须一模一样，如果alter system flush shared_pool（主站慎用）后再执行一样的语句，发现语句在V$SQL中的SQL_ID和HASH_VALUE与之前的一样，说明SQL_ID和HASH_VALUE应该是oracle自己的一套算法来的，只是根据sql语句内容来进行转换，sql语句不变则SQL_ID和HASH_VALUE也不变。）

第一种

select * from (

select count(*),sql_id, substr(sql_text,1,40)

from v$sql

group by sql_id, substr(sql_text,1,40) having count(*) > 10 order by count(*) desc) where rownum<10
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

第二种

count(1)>10表示类语句运行了10次以上

select sql_id, FORCE_MATCHING_SIGNATURE, sql_text

from v$SQL

where FORCE_MATCHING_SIGNATURE in

(select /*+ unnest */

FORCE_MATCHING_SIGNATURE

from v$sql

where FORCE_MATCHING_SIGNATURE > 0

and FORCE_MATCHING_SIGNATURE != EXACT_MATCHING_SIGNATURE

group by FORCE_MATCHING_SIGNATURE

having count(1) > 10)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

查看数据文件可用百分比

select b.file_id,b.tablespace_name,b.file_name,b.AUTOEXTENSIBLE,

ROUND(b.bytes/1024/1024/1024,2) ||'G'  "文件总容量",

ROUND((b.bytes-sum(nvl(a.bytes,0)))/1024/1024/1024,2)||'G' "文件已用容量",

ROUND(sum(nvl(a.bytes,0))/1024/1024/1024,2)||'G' "文件可用容量",

ROUND(sum(nvl(a.bytes,0))/(b.bytes),2)*100||'%' "文件可用百分比"

from dba_free_space a,dba_data_files b

where a.file_id=b.file_id

group by b.tablespace_name,b.file_name,b.file_id,b.bytes,b.AUTOEXTENSIBLE

order by b.tablespace_name;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

查看数据文件可用百分比（文件自增长的情况下）

select b.file_id,b.tablespace_name,b.file_name,b.AUTOEXTENSIBLE,

ROUND(b.MAXBYTES/1024/1024/1024,2) ||'G'  "文件最大可用总容量",

ROUND((b.bytes-sum(nvl(a.bytes,0)))/1024/1024/1024,2)||'G' "文件已用容量",

ROUND(((b.MAXBYTES/1024/1024/1024)-((b.bytes-sum(nvl(a.bytes,0)))/1024/1024/1024))/(b.MAXBYTES/1024/1024/1024),2)*100||'%' "文件可用百分比"

from dba_free_space a,dba_data_files b

where a.file_id=b.file_id and b.file_id>4

group by b.tablespace_name,b.file_name,b.file_id,b.bytes,b.AUTOEXTENSIBLE,b.MAXBYTES

order by b.tablespace_name;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

查看表空间可用百分比

select b.tablespace_name,a.total,b.free,round((b.free/a.total)*100) "% Free" from

(select tablespace_name, sum(bytes/(1024*1024)) total from dba_data_files group by tablespace_name) a,

(select tablespace_name, round(sum(bytes/(1024*1024))) free from dba_free_space group by tablespace_name) b

WHERE a.tablespace_name = b.tablespace_name

order by "% Free";
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

查看临时表空间使用率（临时文件是AUTOEXTENSIBLE的情况下可能空闲率是0）

SELECT temp_used.tablespace_name,total,used,

           total - used as "Free",

           round(nvl(total-used, 0) * 100/total,3) "Free percent"

      FROM (SELECT tablespace_name, SUM(bytes_used)/1024/1024 used

              FROM GV_$TEMP_SPACE_HEADER

             GROUP BY tablespace_name) temp_used,

           (SELECT tablespace_name, SUM(bytes)/1024/1024 total

              FROM dba_temp_files

             GROUP BY tablespace_name) temp_total

     WHERE temp_used.tablespace_name = temp_total.tablespace_name
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

查询undo表空间使用情况

select tablespace_name, status, sum(bytes) / 1024 / 1024 M

  from dba_undo_extents

 group by tablespace_name, status
  • 1
  • 2
  • 3
  • 4

查看ASM磁盘组使用率

select name,

       round(total_mb / 1024) "总容量",

       round(free_mb / 1024) "空闲空间",

       round((free_mb / total_mb) * 100) "可用空间比例"

  from gv$asm_diskgroup
  • 1
  • 2
  • 3
  • 4
  • 5

统计每个用户使用表空间率

SELECT c.owner                                  "用户",

       a.tablespace_name                        "表空间名",

       total/1024/1024                          "表空间大小M",

       free/1024/1024                           "表空间剩余大小M",

       ( total - free )/1024/1024               "表空间使用大小M",

       Round(( total - free ) / total, 4) * 100 "表空间总计使用率   %",

       c.schemas_use/1024/1024                  "用户使用表空间大小M",

       round((schemas_use)/total,4)*100         "用户使用表空间率  %"

FROM   (SELECT tablespace_name,

               Sum(bytes) free

        FROM   DBA_FREE_SPACE

        GROUP  BY tablespace_name) a,

       (SELECT tablespace_name,

               Sum(bytes) total

        FROM   DBA_DATA_FILES

        GROUP  BY tablespace_name) b,

       (Select owner ,Tablespace_Name,

                Sum(bytes) schemas_use

        From Dba_Segments

        Group By owner,Tablespace_Name) c

WHERE  a.tablespace_name = b.tablespace_name

and a.tablespace_name =c.Tablespace_Name

order by "用户","表空间名"
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

查看闪回区\快速恢复区空间使用率

select sum(percent_space_used) || '%' "已使用空间比例"

  from V$RECOVERY_AREA_USAGE
  • 1
  • 2

或

select round(100 * (a.space_used / space_limit), 2) || '%' "已使用空间比例",

       a.*

  from v$recovery_file_dest a;
  • 1
  • 2
  • 3
  • 4

查看僵死进程，分两种（一种是会话不在的，另一种是会话标记为killed的但是会话还在的）

alter system kill session一执行则session即标记为KILLED，但是如果会话产生的数据量大则这个kill可能会比较久，在这个过程中session标记为KILLED但是这个会话还在V$session中，则V$session.paddr还在，所以可以匹配到V$process.addr，所以process进程还在；当kill过程执行完毕，则这个会话即不在V$session中

会话不在的

select *

  from v$process

 where addr not in (select paddr from v$session)

   and pid not in (1, 17, 18)
  • 1
  • 2
  • 3
  • 4
  • 5

会话还在的，但是会话标记为killed

select *

  from v$process

 where addr in (select paddr from v$session where status = 'KILLED')
  • 1
  • 2
  • 3

再根据上述结果中的SPID通过如下命令可以查看到process的启动时间

ps auxw|head -1;ps auxw|grep SPID
  • 1

查看行迁移或行链接的表

select * From dba_tables where nvl(chain_cnt, 0) <> 0
  • 1

chain_cnt ：Number of rows in the table that are chained from one data block to another or that have migrated to a new block, requiring a link to preserve the old rowid. This column is updated only after you analyze the table.

数据缓冲区命中率（百分比小于90就要加大db_cache_size）

查询V$SYSSTAT视图可以查看从内存中读取数据的频率。它提供了数据库中设置的数据块缓存区的命中率。这个信息可以帮助您判断系统何时需要更多的数据缓存(DB_CACHE_SIZE)，或者系统的状态何时调整得不佳(二者均将导致较低的命中率)。

通常情况下，您应当确保读数据的命中率保持在95%以上。将系统的命中率从98%提高到99%，可能意味着性能提高了100%(取决于引起磁盘读操作的语句)。

SELECT a.VALUE + b.VALUE logical_reads,

       c.VALUE phys_reads,

       round(100 * (1 - c.value / (a.value + b.value)), 2) || '%' hit_ratio

  FROM v$sysstat a, v$sysstat b, v$sysstat c

 WHERE a.NAME = 'db block gets'

   AND b.NAME = 'consistent gets'

   AND c.NAME = 'physical reads';
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

或

SELECT DB_BLOCK_GETS + CONSISTENT_GETS Logical_reads,

       PHYSICAL_READS phys_reads,

       round(100 *

             (1 - (PHYSICAL_READS / (DB_BLOCK_GETS + CONSISTENT_GETS))),

             2) || '%' "Hit Ratio"

  FROM V$BUFFER_POOL_STATISTICS

 WHERE NAME = 'DEFAULT';
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

或

SELECT 1 - (SUM(DECODE(NAME, 'physical reads', VALUE, 0)) /

       (SUM(DECODE(NAME, 'db block gets', VALUE, 0)) +

       (SUM(DECODE(NAME, 'consistent gets', VALUE, 0))))) "Read Hit Ratio"

  FROM v$sysstat;
  • 1
  • 2
  • 3
  • 4

或者

在Oracle 10g中，也可以直接获得V$SYSMETRIC中的 AWR 信息:

select metric_name, value

  from v$sysmetric

 where metric_name = 'Buffer Cache Hit Ratio';
  • 1
  • 2
  • 3
  • 4

测定数据字典的命中率(V$ROWCACHE)

可以使用V$ROWCACHE视图来发现对数据字典的调用是否有效地利用了通过init.ora参数SHARED_POOL_SIZE分配的内存缓存.

如果字典的命中率不高，系统的综合性能将大受影响。推荐的命中率是95%或者更高。如果命中率低于这个百分比，说明可能需要增加init.ora参数SHARED_POOL_SIZE。

但要记住，在V$SGASTAT视图中看到的共享池包括多个部分，而这里仅仅就是其中之一。注意：在大幅度使用公共同名的环境中，字典命中率可能难以超过75%，即使共享池的尺寸很大。这是因为Oracle必须经常检查不存在的对象是否依旧存在。

SQL> select sum(gets),sum(getmisses),(1 - (sum(getmisses) / (sum(gets)+ sum(getmisses)))) * 100 HitRate from v$rowcache;

 SUM(GETS) SUM(GETMISSES)    HITRATE

---------- -------------- ----------

  35555492         186408 99.4784608
  • 1
  • 2
  • 3
  • 4
  • 5

在Oracle 10g中，也可以直接获得V$SYSMETRIC中的AWR信息:

SQL> select metric_name, value from v$sysmetric where metric_name ='Library Cache Hit Ratio';

METRIC_NAME                                           VALUE

---------------------------------------------------------------- ----------

Library Cache Hit Ratio                        98.7987987

Library Cache Hit Ratio                               100
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

测定共享SQL和PL/SQL的命中率(V$LIBRARYCACHE)

访问V$LIBRARYCACHE视图可以显示实际使用的语句(SQL和PL/SQL)访问内存的情况。如果init.ora的参数SHARED_POOL_SIZE设置得太小，内存中就没有足够的空间来存储所有的语句。固定命中率通常应该是95%或更高，而重载的次数不应该超过1%。查询V$SQL_BIND_CAPTURE视图，看看每个SQL绑定是否太高，是否需要CURSOR_SHARING。

SQL> select sum(pinhits)/sum(pins)*100 from v$librarycache;

SUM(PINHITS)/SUM(PINS)*100

--------------------------

          98.2787413813059
  • 1
  • 2
  • 3
  • 4
  • 5
SQL> select sum(pinhits-reloads)/sum(pins)*100 from v$librarycache;

SUM(PINHITS-RELOADS)/SUM(PINS)

------------------------------

              98.0597157838185
  • 1
  • 2
  • 3
  • 4
  • 5

最好的方式：

select sum(pins) "Executions",

       sum(pinhits) "Hits",

       ((sum(pinhits) / sum(pins)) * 100) "PinHitRatio",

       sum(reloads) "Misses",

       ((sum(pins) / (sum(pins) + sum(reloads))) * 100) "RelHitRatio"

  from v$librarycache;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

查询 v$sql_bind_capture，看看 average binds 是否大于15 (issue):

select sql_id, count(*) bind_count

  from v$sql_bind_capture

 where child_number = 0

 group by sql_id

having count(*) > 20 order by count(*);
  • 1
  • 2
  • 3
  • 4
  • 5

确定需要固定的PL/SQL对象

的可用空间均成为许多零散的片段，而没有足够大的连续空间，这是共享池中的普遍现象。消除共享池错误的关键是理解哪些对象会引起问题。一旦知道了会引起潜在问题的PL/SQL对象，就可以在数据库启动时固定这个代码(这时共享池是完全连续的)。

select name, sharable_mem

  from v$db_object_cache

 where sharable_mem > 100000

   and type in ('PACKAGE', 'PACKAGE BODY', 'FUNCTION', 'PROCEDURE')

   and kept = 'NO';
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

通过V$SQLAREA查找有问题的查询

V$SQLAREA视图提供了一种识别有潜在问题或者需要优化的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.command_type,

       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;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

检查用户的当前操作及其使用的资源

将V$SESSION和V$SQLTEXT连接就可以显示目前每一个会话正在执行的SQL语句。这在有些时候是极为有用的，例如DBA希望查看某一个给定的时间点上系统究竟执行了哪些操作。

select a.sid, a.username, s.sql_text

  from v$session a, v$sqltext s

 where a.sql_address = s.address

   and a.sql_hash_value = s.hash_value

 order by a.username, a.sid, s.piece;
  • 1
  • 2
  • 3
  • 4
  • 5
select a.username,

       b.block_gets,

       b.consistent_gets,

       b.physical_reads,

       b.block_changes,

       b.consistent_changes

  from v$session a, v$sess_io b

 where a.sid = b.sid

 order by a.username;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

查找磁盘I/O问题

视图V$DATAFILE、V$FILESTAT和V$DBA_DATA_FILES提供了数据库中所有数据文件和磁盘的文件I/O活动信息。理想情况下，物理的读和写应当平均分布。如果没有合理的配置系统，其综合性能就会受到影响。

select a.file#, a.name, a.status, a.bytes, b.phyrds, b.phywrts

  from v$datafile a, v$filestat b

 where a.file# = b.file#;
  • 1
  • 2
  • 3

查询归档日志切换频率

select sequence#,to_char(first_time,'yyyymmdd_hh24:mi:ss')

firsttime,round((first_time-lag(first_time) over(order by first_time))*24*60,2) minutes from

v$log_history where first_time > sysdate - 3 order by first_time,minutes;
  • 1
  • 2
  • 3
  • 4
  • 5

或

select sequence#,to_char(first_time,'yyyy-mm-dd hh24:mi:ss') First_time,First_change#,switch_change# from

v$loghist where first_time>sysdate-3 order by 1;
  • 1
  • 2
  • 3

或

SELECT TO_CHAR(first_time, 'MM/DD') DAY,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '00', 1, 0)) H00,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '01', 1, 0)) H01,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '02', 1, 0)) H02,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '03', 1, 0)) H03,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '04', 1, 0)) H04,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '05', 1, 0)) H05,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '06', 1, 0)) H06,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '07', 1, 0)) H07,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '08', 1, 0)) H08,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '09', 1, 0)) H09,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '10', 1, 0)) H10,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '11', 1, 0)) H11,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '12', 1, 0)) H12,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '13', 1, 0)) H13,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '14', 1, 0)) H14,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '15', 1, 0)) H15,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '16', 1, 0)) H16,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '17', 1, 0)) H17,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '18', 1, 0)) H18,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '19', 1, 0)) H19,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '20', 1, 0)) H20,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '21', 1, 0)) H21,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '22', 1, 0)) H22,

SUM(DECODE(TO_CHAR(first_time, 'HH24'), '23', 1, 0)) H23,

COUNT(*) TOTAL

FROM (SELECT ROWNUM RN, FIRST_TIME FROM V$LOG_HISTORY WHERE first_time>sysdate-18

and FIRST_TIME>ADD_MONTHS(SYSDATE,-1) ORDER BY FIRST_TIME)

GROUP BY TO_CHAR(first_time, 'MM/DD')

ORDER BY MIN(RN);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59

查询lgwr进程写日志时每执行一次lgwr需要多少秒，在state是waiting的情况下，某个等待编号seq#下，seconds_in_wait达多少秒，就是lgwr进程写一次IO需要多少秒

select event, state, seq#, seconds_in_wait, program

  from v$session

 where program like '%LGWR%'

   and state = 'WAITING'
  • 1
  • 2
  • 3
  • 4

查询没有索引的表

Select table_name

  from user_tables

 where table_name not in (select table_name from user_indexes)
  • 1
  • 2
  • 3
Select table_name

  from user_tables

 where table_name not in (select table_name from user_ind_columns)
  • 1
  • 2
  • 3

查询7天的db time（db time=db cpu+io time+wait time不包含空闲等待）

WITH sysstat AS

 (select sn.begin_interval_time begin_interval_time,

         sn.end_interval_time end_interval_time,

         ss.stat_name stat_name,

         ss.value e_value,

         lag(ss.value, 1) over(order by ss.snap_id) b_value

    from dba_hist_sysstat ss, dba_hist_snapshot sn

   where trunc(sn.begin_interval_time) >= sysdate - 7

     and ss.snap_id = sn.snap_id

     and ss.dbid = sn.dbid

     and ss.instance_number = sn.instance_number

     and ss.dbid = (select dbid from v$database)

     and ss.instance_number = (select instance_number from v$instance)

     and ss.stat_name = 'DB time')

select to_char(BEGIN_INTERVAL_TIME, 'mm-dd hh24:mi') ||

       to_char(END_INTERVAL_TIME, ' hh24:mi') date_time,

       stat_name,

       round((e_value - nvl(b_value, 0)) /

             (extract(day from(end_interval_time - begin_interval_time)) * 24 * 60 * 60 +

             extract(hour from(end_interval_time - begin_interval_time)) * 60 * 60 +

             extract(minute from(end_interval_time - begin_interval_time)) * 60 +

             extract(second from(end_interval_time - begin_interval_time))),

             0) per_sec

  from sysstat

 where (e_value - nvl(b_value, 0)) > 0

   and nvl(b_value, 0) > 0
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

查询产生热块较多的对象

x$bh .tch(Touch)表示访问次数越高，热点快竞争问题就存在

SELECT e.owner, e.segment_name, e.segment_type

FROM dba_extents e,

(SELECT *

FROM (SELECT addr,ts#,file#,dbarfil,dbablk,tch

FROM x$bh

ORDER BY tch DESC)

WHERE ROWNUM < 11) b

WHERE e.relative_fno = b.dbarfil

AND e.block_id <= b.dbablk

AND e.block_id + e.blocks > b.dbablk;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

导出AWR报告的SQL语句

select * from dba_hist_snapshot
  • 1
select * from table(dbms_workload_repository.awr_report_html(DBID, INSTANCE_NUMBER, startsnapid,endsnapid))
  • 1
select * from TABLE(DBMS_WORKLOAD_REPOSITORY.awr_diff_report_html(DBID, INSTANCE_NUMBER, startsnapid,endsnapid, DBID, INSTANCE_NUMBER, startsnapid,endsnapid));
  • 1

查询某个SQL的执行计划

select a.hash_value,a.* from v$sql a where sql_id='0n4qfzbqfsjm3'
  • 1
select * from table(dbms_xplan.display_cursor(v$sql.hash_value,0,'advanced'));
  • 1

含顺序的

select * from table(xplan.display_cursor('v$sql.sql_id',0,'advanced'));
  • 1

不过要先创建xplan包，再执行

SQL> CREATE PUBLIC SYNONYM XPLAN FOR SYS.XPLAN;

SQL> grant execute on sys.xplan to public;

ORACLE常用性能监控SQL（二）的更多相关文章

  1. ORACLE常用性能监控SQL【一】

    目录(?)[+] 系列 ORACLE常用性能监控SQL[一] ORACLE常用性能监控SQL[二] Oracle-动态性能视图解读 系列 死锁后的解决办法 生成Kill Session语句 查看导致死 ...

  2. ORACLE常用性能监控SQL

    Temp表空间上进程的查询 select a.tablespace, b.sid, b.serial#, a.blocks,c.sql_text from v$sort_usage a,v$sessi ...

  3. Oracle 常用性能监控SQL语句

    1.  --查看表锁     SELECT * FROM SYS.V_$SQLAREA WHERE DISK_READS > 100; 2.  --监控事例的等待     SELECT EVEN ...

  4. Oracle种常用性能监控SQL语句

    --Oracle常用性能监控SQL语句 --1 SELECT * FROM SYS.V_$SQLAREA WHERE DISK_READS > 100; --2 监控事例的等待 SELECT E ...

  5. Oracle常用性能监控语句解析

    转:http://www.cnblogs.com/preftest/archive/2010/11/14/1876856.html 1.监控等待事件select event,sum(decode(wa ...

  6. oracle常用函数总结（二）

    之前也有写过“oracle常用函数总结(一)”,为了尽量找全常见oracle函数,笔者特意查找了相关资料来作为参考,下边给大家罗列出来,部分和之前有重复的,希望能帮到大家! 列举了31个函数和1个分组 ...

  7. oracle AWR性能监控报告生成方法

    目前相当一部分公司会用到oracle,在做性能测试的时候,对数据库的监控很重要,那么这里先介绍下如何生成oracle自带的awr监控报告,而具体报告的内容分析会放在后续的博客中 oracle性能分析入 ...

  8. Oracle常用系统查询SQL

    以user1身份登录oracle,然后执行:select table_name from user_tables;或select table_name from tabs; 常用SQL --1.查询o ...

  9. centos性能监控系列二：Collectl初解

    对于一个 Linux 系统管理员来说确保自己管理的系统处于一个良好的状态是其首要责任. Linux 系统管理员可以找到有很多工具来帮助自己监控和显示系统中的进程,例如 top 和 htop 今天介绍一 ...

随机推荐

  1. JSON简述

    JSON(JavaScript Object Notation) JavaScript 对象表示法,是一种轻量级的数据交换格式.类似于XML. 基础结构 JSON基于两种结构(即由两种结构组成:对象( ...

  2. 使用randA()生成randB()

    randA()表示可以随机生成1--A的整数 rand7()生成rand5() int Rand5(){ int x = ~(1<<31); // max int while(x > ...

  3. HIBERNATE与 MYBATIS的对比，在这里做一下总结

    我是一名java开发人员,hibernate以及mybatis都有过学习,在java面试中也被提及问道过,在项目实践中也应用过,现在对hibernate和mybatis做一下对比,便于大家更好的理解和 ...

  4. spring mvc 3.0 实现文件上传功能

    http://club.jledu.gov.cn/?uid-5282-action-viewspace-itemid-188672 —————————————————————————————————— ...

  5. SQL宝典

    SQL Server 数据库的高级操作 (1) 批处理 (2) 变量 (3) 逻辑控制 (4) 函数 (5) 高级查询 */ (1)批处理 将多条SQL语句作为一个整体去编译,生成一个执行计划,然后, ...

  6. VS2010之– Web Development(四)-将WebApplication打包发布到IIS

    下面将介绍怎样将一个WebApplication在VisualStudio中直接打包发布到IIS上去.  首先需要使用Administrator的身份运行Visual Studio. Task 1 – ...

  7. ListView setOnItemClickListener无效原因具体分析

    前言 近期在做项目的过程中,在使用listview的时候遇到了设置item监听事件的时候在没有回调onItemClick 方法的问题. 我的情况是在item中有一个Buttonbutton. 所以不会 ...

  8. （转）Unity笔记之编辑器（CurveField、DoubleField、EnumMaskField、EnumPopup） ... ...

    1. CurveField创建的是一个类型为AnimationCurve的曲线变量,看代码: [code]csharpcode: using UnityEngine; using System.Col ...

  9. poj 3414(简单bfs)

    题目链接:http://poj.org/problem?id=3414 思路:bfs简单应用,增对瓶A或者瓶B进行分析就可以了,一共6种状态. #include<iostream> #in ...

  10. wpf的MVVM框架

    http://www.cnblogs.com/KnightsWarrior/archive/2010/11/01/1866641.html 框架名字的介绍在 文章的后面