In this Document
| Purpose |
| Troubleshooting Steps |
| Diagnostics/Remedies |
| 1. Poorly tuned SQL |
| 2. Poor disk performance/disk contention |
| 3. Unnecessary sorting |
| 4. Late row elimination |
| 5. Over parsing |
| 6. Missing indexes/use of 'wrong' indexes |
| 7. Wrong plan or join order selected |
| 8. Import estimating statistics on tables |
| 9. Insufficiently high sample rate for CBO |
| 10. Skewed data |
| 11. New features forcing use of CBO |
| 12. ITL contention |
| References |
APPLIES TO:
Oracle Database - Enterprise Edition - Version 9.0.1.0 and laterInformation in this document applies to any platform.
***Checked for relevance on 14-SEP-2010***
PURPOSE
This document contains a number of potentially useful pointers for use when attempting to tune an individual SQL statement. This is a vast topic and this is just a drop in the ocean.
TROUBLESHOOTING STEPS
Diagnostics/Remedies
1. Poorly tuned SQL
Often, part of the problem is finding the SQL causing performance degradation. If you are seeing problems on a system, it is usually a good idea to start
by eliminating database setup issues by using the statspack(8i,9i,10g), or AWR (recommended for 10g and higher). (For versions earlier than 8i use UTLBSTAT & UTLESTAT reports) See:
Document 276103.1 PERFORMANCE TUNING USING 10g ADVISORS AND MANAGEABILITY
Document 62161.1Tuning using BSTAT/ESTAT
for much more on this.
Once the database has been tuned to a reasonable level then the most resource hungry selects can be determined by using Statspack and AWR reports focusing on the following sections:
SQL ordered by Buffer Gets
SQL ordered by Physical Reads
SQL ordered by Executions
SQL ordered by Parse Calls (not in 8i)
SQL ordered by CPU (AWR only)
See:
It is also possible to find resource hungry SQL interactively as follows (a very similar report can be found in the Enterprise Manager Tuning Pack):
buffer_gets/executions AVG
FROM v$sqlarea
WHERE executions > 0
AND buffer_gets > 100000
ORDER BY 5;
Remember that the 'buffer_gets' value of > 100000 needs to be varied for the individual system being tuned. On some systems no queries will read more than 100000 buffers, while on others most of them will. This value allows you to control how many rows you see returned from the select.
The ADDRESS value retrieved above can then be used to lookup the whole statement in the v$sqltext view:
Once the whole statement has been identified it can be tuned to reduce resource usage.
If the problem relates to CPU bound applications then CPU information for each session can be examined to determine the culprits. The v$sesstat view can be queried to find high cpu using sessions and then SQL can be listed as before. Steps:
1. Verify the reference number for the 'CPU used by this session' statistic:
FROM v$statname
WHERE name LIKE '%CPU%session';
NAME STATISTIC#
----------------------------------- ----------
CPU used by this session 12
2. Then determine which session is using most of the cpu:
SID STATISTIC# VALUE
---------- ---------- ----------
1 12 0
2 12 0
3 12 0
4 12 0
5 12 0
6 12 0
7 12 0
8 12 0
9 12 0
10 12 0
11 12 0
12 12 0
16 12 1930
3. Lookup details for this session:
buffer_gets/executions AVG
FROM v$sqlarea a, v$session s
WHERE sid = 16
AND s.sql_address = a.address
AND executions > 0
ORDER BY 5;
4. Use v$sqltext to extract the whole SQL text.
5. Explain the queries and examine their access paths. Autotrace is
a useful tool for examining access paths. See
2. Poor disk performance/disk contention
Use of Statspack or AWR and focusing on "Tablespace IO Statistics", and/or operating system i/o reports can help in this area. Remember that you may be able to capture the activity of a single statement by running the report around the run of your statement with no other activity.
Another good way of monitoring IO is to run a 10046 Level 8 trace to capture all the waits for a particular session. 10046 can be turned on at the session level using:
Excessing i/o can be found by examining the resultant trace file and looking for i/o related waits such as:
'db file scattered read' (Multi-Block i/o - Full table Scan).
Remember to set TIMED_STATISTICS = TRUE to capture timing information otherwise comparisons will be meaningless. See:
If you are also interested in viewing bind variable values then a level 12 trace may be used with Event 10046.
3. Unnecessary sorting
The first question to ask is 'Does the data REALLY need to be sorted?' If sorting does need to be done then try to allocate enough memory to prevent the sorts from spilling to disk an causing i/o problems.
Sorting is a very expensive operation:
- High CPU usage
- Potentially large disk usage
Try to make the query sort the data as late in the access path as possible. The idea behind this is to make sure that the smallest number of rows possible are sorted.
Remember that:
- Indexes may be used to provided presorted data.
- Sort merge joins inherently need to do a sort.
- Some sorts don't actually need a sort to be performed. In this case the explain plan should show NOSORT for this operation.
In summary:
- Increase sort area size to promote in memory sorts.
- Modify the query to process less rows -> Less to sort
- Use an index to retrieve the rows in order and avoid the sort.
- use sort_direct_writes to avoid flooding the buffer cache with sort blocks.
- If Pro*C use release_cursor=yes as this will free up any temporary segments held open.
4. Late row elimination
Queries are more likely to be performant if the bulk of the rows can be eliminated early in the plan. If this does happen then unnecessary comparisons may be made on rows that are simply eliminated later. This tends to increase CPU usage with no performance benefits.
If these rows can be eliminated early in the access path using a selective predicate then this may significantly enhance the query performance.
5. Over parsing
Over parsing implies that cursors are not being shared.
If statements are referenced multiple times then it makes sense to share then rather than fill up the shared pool with multiple copies of essentially the same statement. See:
Document 70075.1 Use of bind variables with CBO
6. Missing indexes/use of 'wrong' indexes
If indexes are missing on key columns then queries will have to use Full Table Scans to retrieve data. Usually indexes for performance should be added to support selective predicates included in queries.
If an unselective index is chosen in preference to a selective one then potential solutions are:
RBO
- indexes have an equal ranking so row cache order is used. See .
Document 73167.1 Handling of equally ranked (RBO) or costed (CBO) indexes
CBO
- reanalyze with a higher sample size
- add histograms if column data has an uneven distribution of values
- add hints to force use of the index you require
Remember that index usage on join can be affected by the join type and join order chosen. For more information on the use of indexes see:
7. Wrong plan or join order selected
If the wrong plan has been selected then you may want to force the correct one.
If the problem relates to an incorrect join order, then it ofter helps to draw out the tables linking them together to show how they join e.g.:
|
E-F
This can help with visualisation of the join order and identifications of missing joins. When tuning a plan, try different join orders examining number of rows returned to get an idea of how good they may be.
8. Import estimating statistics on tables
Pre 8i, import performs an analyze estimate statistics on all tables that were analyzed when the tables were exported. This can result in different performance after an export/import.
Introduced in 8i, more sampling functionality has been introduced including the facility to extract statistics on export.
9. Insufficiently high sample rate for CBO
If the CBO does not have the correct statistical information then it cannot be expected to produce accurate results. Usually a sample size of
5% will be sufficient, however in some cases it may be necessary to have more accurate statistics at its' disposal. Please see:
for Analysis recommendations.
10. Skewed data
If column data distribution is non uniform, then the use of column statistics in the form of histograms should be considered. Histogram statistics do not help with uniformly distributed data or where no information about the column predicate is available such as with bind variables.
11. New features forcing use of CBO
A number of new features are not implemented in the RBO and their presence in queries will force the use of the CBO. These include:
- Degree of parallelism set on any table in the query
- Index-only tables
- Partition Tables
- Materialised views
See:
for a more extensive list.
12. ITL contention
ITL contention can occur when there is not enough Interested Transaction Lists in each block to support the update volume required. This can often occur after an export and import especially when no update space has been left in the blocks and the ITLs have not been increased.
See:
REFERENCES
NOTE:228913.1 - Systemwide Tuning using STATSPACK ReportsNOTE:276103.1 - Performance Tuning Using Advisors and Manageability Features: AWR, ASH, ADDM and Sql Tuning Advisor
NOTE:39817.1 - Interpreting Raw SQL_TRACE output
NOTE:43214.1 - AUTOTRACE Option in SQL*Plus
NOTE:44961.1 - Statistics Gathering: Frequency and Strategy Guidelines
NOTE:50256.1 - RDBMS V7.0.X - V7.3.X Locking Issues on Oracle Server
NOTE:62143.1 - Troubleshooting: Tuning the Shared Pool and Tuning Library Cache Latch Contention
NOTE:62161.1 - Systemwide Tuning using UTLESTAT Reports in Oracle7/8
NOTE:66484.1 - Which Optimizer is Being Used ?
NOTE:67522.1 - * Diagnosing Why a Query is Not Using an Index
NOTE:70075.1 - Use of bind variables in queries (Pre 9i)
NOTE:73167.1 - Handling of equally ranked (RBO) or costed (CBO) indexes
NOTE:94224.1 - FAQ- Statspack Complete Reference
NOTE:151473.1 - INITRANS Relationship with DB_BLOCK_SIZE.
NOTE:21154.1 - EVENT: 10046 "enable SQL statement tracing (including binds/waits)"
145
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
