㈠ 如何使用AWR报告来诊断数据库性能问题
一般来说，当检测到性能问题时，我们会收集覆盖了发生问题的时间段的AWR报告-但是最好只收集覆盖1个小时时间段的AWR报告-如果时间过长，那么AWR报告就不能很好的反映出问题所在。还应该收集一份没有性能问题的时间段的AWR报告，作为一个参照物来对比有问题的时间段的AWR报告。这两个AWR报告的时间段应该是一致的，比如都是半个小时的，或者都是一个小时的。
Interpretation
在处理性能问题时，我们最关注的是数据库正在等待什么。
当进程因为某些原因不能进行操作时，它需要等待。花费时间最多的等待事件是我们最需要关注的，因为降低它，我们能够获得最大的好处。
AWR报告中的"Top 5 Timed Events"部分就提供了这样的信息，可以让我们只关注主要的问题。
Top 5 Timed Events
正如前面提到的，"Top 5 Timed Events"是AWR报告中最重要的部分。它指出了数据库的sessions花费时间最多的等待事件，如下：
Top 5 Timed Events Avg %Total
~~~~~~~~~~~~~~~~~~ wait Call
Event Waits Time (s) (ms) Time Wait Class
------------------------------ ------------ ----------- ------ ------ ----------
db file scattered read 10,152,564 81,327 8 29.6 User I/O
db file sequential read 10,327,231 75,878 7 27.6 User I/O
CPU time 56,207 20.5
read by other session 4,397,330 33,455 8 12.2 User I/O
PX Deq Credit: send blkd 31,398 26,576 846 9.7 Other
-------------------------------------------------------------
Top 5 Events部分包含了一些跟Events（事件）相关的信息。它记录了这期间遇到的等待的总次数，等待所花费的总时间，每次等待的平均时间；这一部分是按照每个Event占总体call time的百分比来进行排序的。
根 据Top 5 Events部分的信息的不同，接下来我们需要检查AWR报告的其他部分，来验证发现的问题或者做定量分析。等待事件需要根据报告期的持续时间和当时数据 库中的并发用户数进行评估。如：10分钟内1000万次的等待事件比10个小时内的1000万等待更有问题；10个用户引起的1000万次的等待事件比 10,000个用户引起的相同的等待要更有问题。
就像上面的例子，将近60%的时间是在等待IO相关的事件。
其他20%的时间是花在使用或等待CPU time上。过高的CPU使用经常是性能不佳的sql引起的（或者这些SQL有可能用更少的资源完成同样的操作）；对于这样的SQL，过多的IO操作也是一个症状。关于CPU使用方面，我们会在之后讨论。
在以上基础上，我们将调查是否这个等待事件是有问题的。若有问题，解决它；若是正常的，检查下个等待事件。
过多的IO相关的等待一般会有两个主要的原因：
Top 5 Events部分的显示的信息会帮助我们检查：
需要注意，接下来的分析步骤取决于我们在TOP 5部分的发现。在上面的例子里，3个top wait event表明问题可能与SQL语句执行计划不好有关，所以接下来我们要去分析"SQL Statistics"部分。
同样的，因为我们并没有看到latch相关的等待，latch在我们这个例子里并没有引发严重的性能问题；那么我们接下来就完全不需要分析latch相关的信息。
一 般来讲，如果数据库性能很慢，TOP 5等待事件里"CPU"， "db file sequential read" 和"db file scattered read" 比较明显（不管它们之间的顺序如何），我们总是需要检查Top SQL (by logical and physical reads)部分；调用SQL Tuning Advisor或者手工调优这些SQL来确保它们是有效率的运行。
是否数据库做了大量的读操作：
上面的图显示了在这段时间里两类读操作都分别大于1000万，这些操作是否过多取决于报告的时间是1小时或1分钟。我们可以检查AWR报告的elapsed time如果这些读操作确实是太多了，接下来我们需要检查AWR报告中 SQL Statistics 部分的信息，因为读操作都是由SQL语句发起的。
是否是每次的IO读操作都很慢：
上面的图显示了在这段时间里两类读操作平均的等待时间是小于8ms的
至于8ms是快还是慢取决于底层的硬件设备；一般来讲小于20ms的都可以认为是可以接受的。
我们还可以在AWR报告"Tablespace IO Stats"部分得到更详细的信息
Tablespace IO Stats DB/Inst: VMWREP/VMWREP Snaps: 1-15
-> ordered by IOs (Reads + Writes) desc
Tablespace
------------------------------
Av Av Av Av Buffer Av Buf
Reads Reads/s Rd(ms) Blks/Rd Writes Writes/s Waits Wt(ms)
-------------- ------- ------ ------- ------------ -------- ---------- ------
TS_TX_DATA
14,246,367 283 7.6 4.6 145,263,880 2,883 3,844,161 8.3
USER
204,834 4 10.7 1.0 17,849,021 354 15,249 9.8
UNDOTS1
19,725 0 3.0 1.0 10,064,086 200 1,964 4.9
AE_TS
4,287,567 85 5.4 6.7 932 0 465,793 3.7
TEMP
2,022,883 40 0.0 5.8 878,049 17 0 0.0
UNDOTS3
1,310,493 26 4.6 1.0 941,675 19 43 0.0
TS_TX_IDX
1,884,478 37 7.3 1.0 23,695 0 73,703 8.3
>SYSAUX
346,094 7 5.6 3.9 112,744 2 0 0.0
SYSTEM
101,771 2 7.9 3.5 25,098 0 653 2.7
如上图，我们关心Av Rd(ms)的指标。如果它高于20ms并且同时有很多读操作的，我们可能要开始从OS的角度调查是否有潜在的IO问题。
注：对于一些比较空闲的tablespace/files,我们可能会得到一个比较大的Av Rd(ms)值；对于这样的情况，我们应该忽略这样的tablespace/files;因为这个很大的值可能是由于硬盘自旋(spin)引起的，没有太大的参考意义。比如对
于一个有1000万次读操作而且很慢的系统，引起问题的基本不可能是一个只有10次read的tablespace/file.
虽 然高"db file scattered read"和"db file sequential read"等待可以是I / O相关的问题，但是很多时候这些等待也可能是正常的；实际上，对一个已经性能很好的数据库系统，这些等待事件往往在top 5等待事件里，因为这意味着您的数据库没有那些真正的“问题”。
诀窍是能够评估引起这些等待的语句是否使用了最优的访问路径。如果"db file scattered read"比较高，那么相关的SQL语句可能使用了全表扫描而没有使用索引（也许是没有创建索引，也许是没有合适的索引）；相应的，如果"db file sequential read"过多，则表明也许是这些SQL语句使用了selectivity不高的索引从而导致访问了过多不必要的索引块或者使用了错误的索引。这些等待可 能说明SQL语句的执行计划不是最优的。
接下来就需要通过AWR来检查这些top SQL是否可以进一步的调优，我们可以查看AWR报告中 SQL Statistics 的部分.
上面的例子显示了20%的时间花在了等待或者使用CPU上，我们也需要检查 SQL statistics 部分来进一步的分析。
数据库做了太多的读操作
每次的IO读操作都很慢
事件"db file scattered read"一般表明正在做由全表扫描或者index fast full scan引起的多块读。
事件"db file sequential read"一般是由不能做多块读的操作引起的单块读（如读索引）
SQL Statistics
AWR包含了一些不同的SQL统计值：
根据Top 5 部分的Top Wait Event不同，我们需要检查不同的SQL statistic。
在我们这个例子里，Top Wait Event是"db file scattered read"，"db file sequential read"和CPU；我们最需要关心的是SQL ordered by CPU Time, Gets and Reads。
我们会从"SQL ordered by gets"入手，因为引起高buffer gets的SQL语句一般是需要调优的对象。
SQL ordered by Gets
-> Resources reported for PL/SQL code includes the resources used by all SQL
statements called by the code.
-> Total Buffer Gets: 4,745,943,815
-> Captured SQL account for 122.2% of Total
Gets CPU Elapsed
Buffer Gets Executions per Exec %Total Time (s) Time (s) SQL Id
-------------- ------------ ------------ ------ -------- --------- -------------
1,228,753,877 168 7,314,011.2 25.9 8022.46 8404.73 5t1y1nvmwp2
SELECT ADDRESSID",CURRENT$."ADDRESSTYPEID",CURRENT$URRENT$."ADDRESS3",
CURRENT$."CITY",CURRENT$."ZIP",CURRENT$."STATE",CURRENT$."PHONECOUNTRYCODE",
CURRENT$."PHONENUMBER",CURRENT$."PHONEEXTENSION",CURRENT$."FAXCOU
1,039,875,759 62,959,363 16.5 21.9 5320.27 5618.96 grr4mg7ms81
Mole: DBMS_SCHEDULER
INSERT INTO "ADDRESS_RDONLY" ("ADDRESSID","ADDRESSTYPEID","CUSTOMERID","
ADDRESS1","ADDRESS2","ADDRESS3","CITY","ZIP","STATE","PHONECOUNTRYCODE","PHONENU
854,035,223 168 5,083,543.0 18.0 5713.50 7458.95 4at7cbx8hnz
SELECT "CUSTOMERID",CURRENT$."ISACTIVE",CURRENT$."FIRSTNAME",CURRENT$."LASTNAME",CU<
RRENT$."ORGANIZATION",CURRENT$."DATEREGISTERED",CURRENT$."CUSTOMERSTATUSID",CURR
ENT$."LASTMODIFIEDDATE",CURRENT$."SOURCE",CURRENT$."EMPLOYEEDEPT",CURRENT$.
对这些Top SQL,可以手工调优，也可以调用SQL Tuning Advisor。
分析：
Other SQL Statistic Sections
就像之前提到的那样，AWR报告中有很多不同的部分用来分析各种不同的问题。如果特定的问题并没有出现，那么分析AWR报告的这些部分并不能有很大的帮助。
下面提到了一些可能的问题：
Waits for 'Cursor: mutex/pin' 如 果发现了一些像"Cursor: pin S wait on X" 或"Cursor: mutex X" 类的mutex等待，那么可能是由于parsing引起的问题。检查"SQL ordered by Parse Calls" 和"SQL ordered by Version Count"部分的Top SQL，这些SQL可能引起这类的问题。
单次执行buffer gets过多
SQL_ID为'5t1y1nvmwp2'和'4at7cbx8hnz'的SQL语句总共被执行了168次，但是每次执行引起的buffer gets超过500万。这两个SQL应该是主要的需要调优的候选者。
执行次数过多
SQL_ID 'grr4mg7ms81' 每次执行只是引起16次buffer gets,减少这条SQL每次执行的buffer get可能并不能显着减少总共的buffer gets。这条语句的问题是它执行的太频繁了，6500万次。
改变这条SQL的执行次数可能会更有意义。这个SQL看起来是在一个循环里面被调用，如果可以让它一次处理的数据更多也许可以减少它执行的次数。
-> Total Buffer Gets: 4,745,943,815
假设这是一个一个小时的AWR报告，4,745,943,815是一个很大的值；所以需要进一步分析这个SQL是否使用了最优的执行计划
Indivial Buffer Gets
上面的例子里单个的SQL的buffer get非常多，最少的那个都是8亿5千万。这三个SQL指向了两个不同的引起过多buffers的原因：
注意：对于某些非常繁忙的系统来讲，以上的数字可能都是正常的。这时候我们需要把这些数字跟正常时段的数字作对比，如果没有什么太大差别，那么这些SQL并不是引起问题的元兇（虽然通过调优这些SQL我们仍然可以受益）
Load Profile
根据Top 5等待事件的不同，"Load Profile"可以提供一些有用的背景资料或潜在问题的细节信息。
Load Profile
~~~~~~~~~~~~ Per Second Per Transaction
--------------- ---------------
Redo size: 4,585,414.80 3,165,883.14
Logical reads: 94,185.63 65,028.07
Block changes: 40,028.57 27,636.71
Physical reads: 2,206.12 1,523.16
Physical writes: 3,939.97 2,720.25
User calls: 50.08 34.58
Parses: 26.96 18.61
Hard parses: 1.49 1.03
Sorts: 18.36 12.68
Logons: 0.13 0.09
Executes: 4,925.89 3,400.96
Transactions: 1.45
% Blocks changed per Read: 42.50 Recursive Call %: 99.19
Rollback per transaction %: 59.69 Rows per Sort: 1922.64
在这个例子里，Top 5 Events部分显示问题可能跟SQL的执行有关，那么我们接下来检查load profile部分。
如果您检查AWR report是为了一般性的性能调优，那么可以看到有比较多的redo activity和比较高的physical writes. Physical writes比physical read要高，并且有42%的块被更改了.
此外，hard parse的次数要少于soft parse.
如果mutex等待事件比较严重，如"library cache: mutex X"，那么查看所有parse的比率会更有用。
当然，如果把Load Profile部分跟正常时候的AWR报告做比较会更有用，比如，比较redo size, users calls, 和 parsing这些性能指标。
Instance Efficiency
Instance Efficiency部分更适用于一般性的调优，而不是解决某个具体问题（除非等待事件直接指向这些指标）。
Instance Efficiency Percentages (Target 100%)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Buffer Nowait %: 99.91 Redo NoWait %: 100.00
Buffer Hit %: 98.14 In-memory Sort %: 99.98
Library Hit %: 99.91 Soft Parse %: 94.48
Execute to Parse %: 99.45 Latch Hit %: 99.97
Parse CPU to Parse Elapsd %: 71.23 % Non-Parse CPU: 99.00
从我们的这个例子来看，最有用的信息是%Non-Parse CPU，它表明几乎所有的CPU都消耗在了Execution而不是Parse上，所以调优SQL会对性能有改善。
㈡ 如何进行数据库性能分析
使用RichAPM可以直接针对不同类型的数据库性能进行分析，包括MySQL、Oracle、SQL Server三类关系型数据库及Memcache、redis两类非关系型数据库。
㈢ 如何使用AWR报告来诊断数据库性能问题 第3页
当进程因为某些原因不能进行操作时，它需要等待。花费时间最多的等待事件是我们最需要关注的，因为降低它，我们能够获得最大的好处。
AWR报告中的"Top 5 Timed Events"部分就提供了这样的信息，可以让我们只关注主要的问题。
㈣ 如何使用awr报告来诊断数据库性能问题
您好，很高兴为您解答。
过程参考：http://blog.itpub.net/12798004/viewspace-1262538/
如若满意，请点击右侧【采纳答案】，如若还有问题，请点击【追问】
希望我的回答对您有所帮助，望采纳！
~ O(∩_∩)O~
㈤ 如何检查oracle数据库性能
这种问题要回答好要求知识比较全面。
1 从操作系统层次上看
看CPU 内存 swqp（交换分区）等使用率
2 从磁盘上看
主要看磁盘读写。可以用dd测磁盘读写的速度 也可以在业务高峰期检测磁盘的速率。
3 从数据库本身来看。
先要看数据库各个参数的值 。 如sga的大小，process的大小，redo日志的个数与大小等这些关系到性能的参数是否设置合理。
长期观察的方式就是看各个时期的AWR报告。里面有各种性能指标，以及按执行时间或资源排列的sql ，以及各种等待时间的排名。从这里面可以掌握数据库的长期的性能变化。
即时观察的方式就是利用各种sql 查询 数据库在当前时间的各个性能指标(AWR报告里面的各种指标也都是通过sql查询出来的)
还有对数据库整体的一个检查：
如 表的大小，表是否需要分区而没有分区，索引是否创建，索引是否失效，开发人员写的sql是否正确使用到了索引，频繁使用的sql是否有绑定变量，有频繁大批量增删改的表是否存在高水位。。。
额 总之，这个话题涉及的知识非常多，尽可能多的学习一些东西，祝你好运。
㈥ mysql 性能测试报告怎么写
给你看个范例：
测试环境：
DELL2.4Gmemory512M
RH9.0MySQL3.23.54
测试使用的是mysql缺省参数，用mysql提供的API用C编写测试程序
测试程序共启动40个线程进行数据库操作，查找、插入、修改、删除各10个，每个线程独立与SqlServer连接。
数据库结构，单表，表结构如下：
toheader100byte主键
contactheader100byte
called50byte
cseq100byte
hashvalint
timestampint次键
对主次键分别建了索引。分别在5万、10万、50万用户环境做测试，结果如下：
查找100次
插入100次
修改100次
删除100次
5万
100－300ms
100－300ms
100－300ms
100－300ms
10万
500ms-1s
500ms-1s
500ms-1s
500ms-1s
50万
3s-5s
3s-5s
3s-5s
3s-5s
从此数据看性能是很不错的，因为mysql能保证每个操作是原子的，所以不用考虑线程间的同步。
但有一个问题：即mysql的每个操作是原子的，所以做每个操作时，其它线程是阻塞的，在大数据量查询时，花的时间较长，会对其它线程有影响。我在保持其它线程工作不变的情况下，将每个查找线程改为做一次对所有记录的查询，在5万和10万记录时表现不错，分别为250ms和450ms，但在50万记录时，这个数值达到了22秒。而且在50万用户时，通过条件查找部分数据也很慢，如查询结果为10万记录时用11秒。
怀疑是sqlserver的参数影响，按数据库说明修改了几个缓冲区的参数，但没有效果。
由于首次同步发生的频率很低，象250ms和450ms这样的数据还是可以接受的，但22秒太离谱了。支持50万用户在线，需要考虑一个解决办法，现在有一个办法是建一个备份表，写备份表的请求放到一个队列里由一个单独线程处理，这样阻塞不会影响正常业务处理了。但这个线程的缓冲区要足够容纳30秒内发生的操作。
本来担心数据量大了mysql的缓冲区不够会出错或丢数据，但测试发现，一次查询最多读了50M数据，没有出现问题，经测算我们首次同步的数据不会超过10M。
在MySQL中启动了innoDB引擎后，可以实现真正的行级锁，select和update操作可以并发，这样在全表查询进行中间可以进行其它的select和update操作，但insert和delete不行。
性能也有很大提高，50万记录时100次操作300ms，全表查询11秒多
常用参数[options]详细说明：--auto-generate-sql,
-a自动生成测试表和数据，表示用mysqlslap工具自己生成的SQL脚本来测试并发压力。
--auto-generate-sql-load-type=type测试语句的类型。代表要测试的环境是读操作还是写操作还是两者混合的。取值包括：read，key，write，update和mixed(默认)。
--auto-generate-sql-add-auto-increment代表对生成的表自动添加auto_increment列，从5.1.18版本开始支持。--number-char-cols=N,
-xN自动生成的测试表中包含多少个字符类型的列，默认1--number-int-cols=N,-yN自动生成的测试表中包含多少个数字类型的列，默认1--number-of-queries=N总的测试查询次数(并发客户数×每客户查询次数)
--query=name,-q使用自定义脚本执行测试，例如可以调用自定义的一个存储过程或者sql语句来执行测试。--create-schema代表自定义的测试库名称，测试的schema，MySQL中schema也就是database。--commint=N多少条DML后提交一次。
--compress,-C如果服务器和客户端支持都压缩，则压缩信息传递。--concurrency=N,-cN表示并发量，也就是模拟多少个客户端同时执行select。可指定多个值，以逗号或者--delimiter参数指定的值做为分隔符。例如：
--concurrency=100,200,500。
--engine=engine_name,-eengine_name代表要测试的引擎，可以有多个，用分隔符隔开。例如：--engines=myisam,innodb。--iterations=N,-iN测试执行的迭代次数，代表要在不同并发环境下，各自运行测试多少次。
--only-print只打印测试语句而不实际执行。--detach=N执行N条语句后断开重连。--debug-info,-T打印内存和CPU的相关信息。说明：测试的过程需要生成测试表，插入测试数据，这个mysqlslap可以自动生成，默认生成一个mysqlslap的schema，如果已经存在则先删除。可以用--only-print来打印实际的测试过程，整个测试完成后不会在数据库中留下痕迹。各种测试参数实例（-p后面跟的是mysql的root密码）：单线程测试。测试做了什么。
#mysqlslap-a-uroot-p123456多线程测试。使用–concurrency来模拟并发连接。#mysqlslap-a-c100-uroot-p123456迭代测试。用于需要多次执行测试得到平均值。#mysqlslap-a-i10-uroot-p123456#mysqlslap---auto-generate-sql-add-autoincrement-a-uroot-p123456#mysqlslap-a--auto-generate-sql-load-type=read-uroot-p123456#mysqlslap-a--auto-generate-secondary-indexes=3-uroot-p123456#mysqlslap-a--auto-generate-sql-write-number=1000-uroot-p123456#mysqlslap--create-schemaworld-q"selectcount(*)fromCity"-uroot-p123456#mysqlslap-a-einnodb-uroot-p123456#mysqlslap-a--number-of-queries=10-uroot-p123456测试同时不同的存储引擎的性能进行对比：#mysqlslap-a--concurrency=50,100--number-of-queries1000--iterations=5--engine=myisam,innodb--debug-info-uroot-p123456执行一次测试，分别50和100个并发，执行1000次总查询：#mysqlslap-a--concurrency=50,100--number-of-queries1000--debug-info-uroot-p12345650和100个并发分别得到一次测试结果(Benchmark)，并发数越多，执行完所有查询的时间越长。为了准确起见，可以多迭代测试几次:#mysqlslap-a--concurrency=50,100--number-of-queries1000--iterations=5--debug-info-uroot-p123456
㈦ 如何在性能测试中手工生成AWR报告完成数据库性能分析
如何在性能测试中手工生成AWR报告完成数据库性能分析
网络文库：http://wenku..com/link?url=_X91Ua_9wnwZJ42hazbEDNOtAocN8GFsN-
㈧ 如何使用AWR报告来诊断数据库性能问题
Interpretation
在处理性能问题时，我们最关注的是数据库正在等待什么。
当进程因为某些原因不能进行操作时，它需要等待。花费时间最多的等待事件是我们最需要关注的，因为降低它，我们能够获得最大的好处。
AWR报告中的"Top 5 Timed Events"部分就提供了这样的信息，可以让我们只关注主要的问题。
•
Top 5 Timed Events
正如前面提到的，"Top 5 Timed Events"是AWR报告中最重要的部分。它指出了数据库的sessions花费时间最多的等待事件，如下：
Top 5 Timed Events Avg %Total
~~~~~~~~~~~~~~~~~~ wait Call
Event Waits Time (s) (ms) Time Wait Class
------------------------------ ------------ ----------- ------ ------ ----------
db file scattered read 10,152,564 81,327 8 29.6 User I/O
db file sequential read 10,327,231 75,878 7 27.6 User I/O
CPU time 56,207 20.5
read by other session 4,397,330 33,455 8 12.2 User I/O
PX Deq Credit: send blkd 31,398 26,576 846 9.7 Other
-------------------------------------------------------------
Top 5 Events部分包含了一些跟Events（事件）相关的信息。它记录了这期间遇到的等待的总次数，等待所花费的总时间，每次等待的平均时间；这一部分是按照每个Event占总体call time的百分比来进行排序的。
根 据Top 5
Events部分的信息的不同，接下来我们需要检查AWR报告的其他部分，来验证发现的问题或者做定量分析。等待事件需要根据报告期的持续时间和当时数据
库中的并发用户数进行评估。如：10分钟内1000万次的等待事件比10个小时内的1000万等待更有问题；10个用户引起的1000万次的等待事件比
10,000个用户引起的相同的等待要更有问题。
就像上面的例子，将近60%的时间是在等待IO相关的事件。
• 事件"db file scattered read"一般表明正在做由全表扫描或者index fast full scan引起的多块读。
• 事件"db file sequential read"一般是由不能做多块读的操作引起的单块读（如读索引）
其他20%的时间是花在使用或等待CPU time上。过高的CPU使用经常是性能不佳的SQL引起的（或者这些SQL有可能用更少的资源完成同样的操作）；对于这样的SQL，过多的IO操作也是一个症状。关于CPU使用方面，我们会在之后讨论。
在以上基础上，我们将调查是否这个等待事件是有问题的。若有问题，解决它；若是正常的，检查下个等待事件。
过多的IO相关的等待一般会有两个主要的原因：
• 数据库做了太多的读操作
• 每次的IO读操作都很慢
Top 5 Events部分的显示的信息会帮助我们检查：
• 是否数据库做了大量的读操作：
上面的图显示了在这段时间里两类读操作都分别大于1000万，这些操作是否过多取决于报告的时间是1小
时或1分钟。我们可以检查AWR报告的elapsed time如果这些读操作确实是太多了，接下来我们需要检查AWR报告中 SQL
Statistics 部分的信息，因为读操作都是由SQL语句发起的。
• 是否是每次的IO读操作都很慢：
上面的图显示了在这段时间里两类读操作平均的等待时间是小于8ms的
至于8ms是快还是慢取决于底层的硬件设备；一般来讲小于20ms的都可以认为是可以接受的。
我们还可以在AWR报告"Tablespace IO Stats"部分得到更详细的信息
Tablespace IO Stats DB/Inst: VMWREP/VMWREP Snaps: 1-15
-> ordered by IOs (Reads + Writes) desc
Tablespace
------------------------------
Av Av Av Av Buffer Av Buf
Reads Reads/s Rd(ms) Blks/Rd Writes Writes/s Waits Wt(ms)
-------------- ------- ------ ------- ------------ -------- ---------- ------
TS_TX_DATA
14,246,367 283 7.6 4.6 145,263,880 2,883 3,844,161 8.3
USER
204,834 4 10.7 1.0 17,849,021 354 15,249 9.8
UNDOTS1
19,725 0 3.0 1.0 10,064,086 200 1,964 4.9
AE_TS
4,287,567 85 5.4 6.7 932 0 465,793 3.7
TEMP
2,022,883 40 0.0 5.8 878,049 17 0 0.0
UNDOTS3
1,310,493 26 4.6 1.0 941,675 19 43 0.0
TS_TX_IDX
1,884,478 37 7.3 1.0 23,695 0 73,703 8.3
>SYSAUX
346,094 7 5.6 3.9 112,744 2 0 0.0
SYSTEM
101,771 2 7.9 3.5 25,098 0 653 2.7
如上图，我们关心Av Rd(ms)的指标。如果它高于20ms并且同时有很多读操作的，我们可能要开始从OS的角度调查是否有潜在的IO问题。
㈨ 衡量数据库性能的重要指标
具体来说，本文包括以下内容:
事务
查询性能
用户和查询冲突
容量
配置
NoSQL 数据库
- 图1-基于基线评估当前事务响应时间
事务
事务可以观察真实用户的行为：能够在应用交互时捕获实时性能。众所周知，测量事务的性能包括获取整个事务的响应时间和组成事务的各个部分的响应时间。通常我们可以用这些响应时间与满足事务需求的基线对比，来确定当前事务是否处于正常状态。
如果你只想衡量应用的某个方面，那么可以评估事务的行为。所以，尽管容器指标能够提供更丰富的信息，并且帮助你决定何时对当前环境进行自动测量，但你的事务就足以确定应用性能。无需向应用程序服务器获取 CPU 的使用情况，你更应该关心用户是否完成了事务，以及该事务是否得到了优化。
补充一个小知识点，事务是由入口点决定的，通过该入口点可以启动事务与应用进行交互。
一旦定义了事务，会在整个应用生态系统中对其性能进行测量，并将每个事务与基线进行比对。例如，我们可能会决定当事务的响应时间与基线相比，一旦慢于平均响应时间的两个标准差是否就应该判定为异常，如图1所示。
用于评估事务的基线与正在进行的事务活动在时间上是一致的，但事务会由每个事务执行来完善。例如，当你选定一个基线，在当前事务结束之后，将事务与平均响应时间按每天的小时数和每周的天数进行对比，所有在那段时间内执行的事务都将会被纳入下周的基线中。通过这种机制，应用程序可以随时间而变化，而无需每次都重建原始基线；你可以将其看作是一个随时间移动的窗口。
总之，事务最能反映用户体验的测量方法，所以也是衡量性能状况最重要的指标。
查询性能
最容易检测到查询性能是否正常的指标就是查询本身。由查询引起的问题可能会导致时间太长而无法识别所需数据或返回数据。所以不妨在查询中排查以下问题。
1. 选择过多冗余数据
编写查询语句来返回适当的数据是远远不够的，很可能你的查询语句会返回太多列，从而导致选择行和检索数据变得异常缓慢。所以，最好是列出所需的列，而不是直接用 SELECT*。当需要在特定字段中查询时，该计划可能会确定一个覆盖索引从而加快结果返回。覆盖索引通常会包含查询中使用的所有字段。这意味着数据库可以仅从索引中产生结果，而不需要通过底层表来构建。
另外，列出结果中所需的列不仅可以减少传输的数据，还能进一步提高性能。
2. 表之间的低效联接
联接会导致数据库将多组数据带到内存中进行比较，这会产生多个数据库读取和大量 CPU。根据表的索引，联接还可能需要扫描两个表的所有行。如果写不好两个大型表之间的联接，就需要对每个表进行完整扫描，这样的计算量将会非常大。其他会拖慢联接的因素包括联接列之间存在不同的数据类型、需要转换或加入包含 LIKE 的条件，这样就会阻止使用索引。另外，还需注意避免使用全外联接；在恰当的时候使用内部联接只返回所需数据。
3. 索引过多或过少
如果查询优化没有可用的索引时，数据库会重新扫描表来产生查询结果，这个过程会生成大量的磁盘输入/输出（I/O）。适当的索引可以减少排序结果的需要。虽然非唯一值的索引在生成结果时，不能像唯一索引那样方便。如果键越大，索引也会变大，并通过它们创建更多的磁盘 I/O。大多数索引是为了提高数据检索的性能，但也需要明白索引本身也会影响数据的插入和更新，因为所有相关联的指标都必须更新。
4. 太多的SQL导致争用解析资源
任何 SQL 查询在执行之前都必须被解析，在生成执行计划之前需要对语法和权限进行检查。由于解析非常耗时，数据库会保存已解析的 SQL 来重复利用，从而减少解析的耗时。因为 WHERE 语句不同，所以使用文本值的查询语句不能被共享。这将导致每个查询都会被解析并添加到共享池中，由于池的空间有限，一些已保存的查询会被舍弃。当这些查询再次出现时，则需要重新解析。
用户和查询冲突
数据库支持多用户，但多用户活动也可能造成冲突。
1. 由慢查询导致的页/行锁定
为了确保查询产生精确的结果，数据库必须锁定表以防止在运行读取查询时再发生其他的插入和更新行为。如果报告或查询相当缓慢，需要修改值的用户可能需要等待至更新完成。锁提示能帮助数据库使用最小破坏性的锁。从事务数据库中分离报表也是一种可靠的解决方法。
2. 事务锁和死锁
当两个事务被阻塞时会出现死锁，因为每一个都需要使用被另一个占用的资源。当出现一个普通锁时，事务会被阻塞直到资源被释放。但却没有解决死锁的方案。数据库会监控死锁并选择终止其中一个事务，释放资源并允许该事务继续进行，而另一个事务则回滚。
3. 批处理操作造成资源争夺
批处理过程通常会执行批量操作，如大量的数据加载或生成复杂的分析报告。这些操作是资源密集型的，但可能影响在线用户的访问应用的性能。针对此问题最好的解决办法是确保批处理在系统使用率较低时运行，比如晚上，或用单独的数据库进行事务处理和分析报告。
容量
并不是所有的数据库性能问题都是数据库问题。有些问题也是硬件不合适造成的。
1. CPU 不足或 CPU 速度太慢
更多 CPU 可以分担服务器负载，进一步提高性能。数据库的性能不仅是数据库的原因，还受到服务器上运行其他进程的影响。因此，对数据库负载及使用进行审查也是必不可少的。由于 CPU 的利用率时时在变，在低使用率、平均使用率和峰值使用率的时间段分别检查该指标可以更好地评估增加额外的 CPU 资源是否有益。
2. IOPS 不足的慢磁盘
磁盘性能通常以每秒输入/输出操作（IOPS）来计。结合 I/O 大小，该指标可以衡量每秒的磁盘吞吐量是多少兆。同时，吞吐量也受磁盘的延迟影响，比如需要多久才能完成请求，这些指标主要是针对磁盘存储技术而言。传统的硬盘驱动器（HDD）有一个旋转磁盘，通常比固态硬盘（SSD）或闪存更慢。直到近期，SSD 虽然仍比 HDD 贵，但成本已经降了下来，所以在市场上也更具竞争力。
3. 全部或错误配置的磁盘
众所周知，数据库会被大量磁盘访问，所以不正确配置的磁盘可能带来严重的性能缺陷。磁盘应该适当分区，将系统数据目录和用户数据日志分开。高度活跃的表应该区分以避免争用，通过在不同磁盘上存放数据库和索引增加并行放置，但不要将操作系统和数据库交换空间放置在同一磁盘上。
4. 内存不足
有限或不恰当的物理内存分配会影响数据库性能。通常我们认为可用的内存更多，性能就越好。监控分页和交换,在多个非繁忙磁盘中建立多页面空间，进一步确保分页空间分配足够满足数据库要求；每个数据库供应商也可以在这个问题上提供指导。
5. 网速慢
网络速度会影响到如何快速检索数据并返回给终端用户或调用过程。使用宽带连接到远程数据库。在某些情况下，选择 TCP/IP 协议而不是命名管道可显着提高数据库性能。
配置
每个数据库都需设置大量的配置项。通常情况下，默认值可能不足以满足数据库所需的性能。所以，检查所有的参数设置，包括以下问题。
1. 缓冲区缓存太小
通过将数据存储在内核内存，缓冲区缓存可以进一步提高性能同时减少磁盘 I/O。当缓存太小时，缓存中的数据会更频繁地刷新。如果它再次被请求，就必须从磁盘重读。除了磁盘读取缓慢之外，还给 I/O 设备增添了负担从而成为瓶颈。除了给缓冲区缓存分配足够的空间，调优 SQL 查询可以帮助其更有效地利用缓冲区缓存。
2. 没有查询缓存
查询缓存会存储数据库查询和结果集。当执行相同的查询时，数据会在缓存中被迅速检索，而不需要再次执行查询。数据会更新失效结果，所以查询缓存是唯一有效的静态数据。但在某些情况下，查询缓存却可能成为性能瓶颈。比如当锁定为更新时，巨大的缓存可能导致争用冲突。
3. 磁盘上临时表创建导致的 I/O 争用
在执行特定的查询操作时，数据库需要创建临时表，如执行一个 GROUP BY 子句。如果可能，在内存中创建临时表。但是，在某些情况下，在内存中创建临时表并不可行，比如当数据包含 BLOB 或 TEXT 对象时。在这些情况下，会在磁盘上创建临时表。大量的磁盘 I / O 都需要创建临时表、填充记录、从表中选择所需数据并在查询完成后舍弃。为了避免影响性能，临时数据库应该从主数据库中分离出来。重写查询还可以通过创建派生表来减少对临时表的需求。使用派生表直接从另一个 SELECT 语句的结果中选择，允许将数据加到内存中而不是当前磁盘上。
NoSQL 数据库
NoSQL 的优势在于它处理大数据的能力非常迅速。但是在实际使用中，也应该综合参考 NoSQL 的缺点，从而决定是否适合你的用例场景。这就是为什么NoSQL通常被理解为 “不仅仅是 SQL”，说明了 NoSQL 并不总是正确的解决方案，也没必要完全取代 SQL，以下分别列举出五大主要原因。
1. 挑剔事务
难以保持 NoSQL 条目的一致性。当访问结构化数据时，它并不能完全确保同一时间对不同表的更改都生效。如果某个过程发生崩溃，表可能会不一致。一致事务的典型代表是复式记账法。相应的信贷必须平衡每个借方，反之亦然。如果双方数据不一致则不能输入。NoSQL 则可能无法保证“收支平衡”。
2. 复杂数据库
NoSQL 的支持者往往以高效代码、简单性和 NoSQL 的速度为傲。当数据库任务很简单时，所有这些因素都是优势。但当数据库变得复杂，NoSQL 会开始分解。此时，SQL 则比 NoSQL 更好地处理复杂需求，因为 SQL 已经成熟，有符合行业标准的接口。而每个 NoSQL 设置都有一个唯一的接口。
3. 一致联接
当执行 SQL 的联接时，由于系统必须从不同的表中提取数据进行键对齐，所以有一个巨大的开销。而 NoSQL 似乎是一个空想，因为缺乏联接功能。所有的数据都在同一个表的一个地方。当检索数据时，它会同时提取所有的键值对。问题在于这会创建同一数据的多个副本。这些副本也必须更新，而这种情况下，NoSQL 没有功能来确保更新。
4. Schema设计的灵活性
由于 NoSQL 不需要 schema，所以在某些情况下也是独一无二的。在以前的数据库模型中，程序员必须考虑所有需要的列能够扩展，能够适应每行的数据条目。在 NoSQL 下，条目可以有多种字符串或者完全没有。这种灵活性允许程序员迅速增加数据。但是，也可能存在问题，比如当有多个团体在同一项目上工作时，或者新的开发团队接手一个项目时。开发人员能够自由地修改数据库，也可能会不断实现各种各样的密钥对。
5. 资源密集型
NoSQL 数据库通常比关系数据库更加资源密集。他们需要更多的 CPU 储备和 RAM 分配。出于这个原因，大多数共享主机公司都不提供 NoSQL。你必须注册一个 VPS 或运行自己的专用服务器。另一方面，SQL 主要是在服务器上运行。初期的工作都很顺利，但随着数据库需求的增加，硬件必须扩大。单个大型服务器比多个小型服务器昂贵得多，价格呈指数增长。所以在这种企业计算场景下，使用 NoSQL 更为划算，例如那些由谷歌和 Facebook 使用的服务器。
㈩ 如何检查oracle数据库性能
oracle的性能判断需要综合数据库的多个运行指标来判断：
1、进程数量和占用cpu：这个主要看有没有长时间占用cpu的进行。通常会判断大出sql，需要优化；这个可以用执行计划或者awr报告查看；
2、内存占用：主要用系统命令查看ora_占用和系统总内存的比例，swap的使用率；通常swap使用率低就没事；这个主要使用系统命令；
3、磁盘占用率：防止磁盘空间不足，需要的主要在系统和用户表空间、RMAN等操作上；这个主要使用系统命令；RMAN命令查看