Developer’s Description
As an oracle developer or DBA You may feel boring about using Tkprof command to collect SQL information from oracle trace file, you know SQL server has a windows tool named profiler to sniffer the live SQL. TkprofPlus is a windows gui software that has the same function. When oracle generate new trace content, it can auto detect the changes happened to the oracle trace files and put it to the list window.
The quickest way to capture the SQL being processed by a session is to switch on SQL trace or set the 10046 event for a representative period of time. The resulting trace files can be read in their raw state or translated using the tkprof utility. Explaining the contents of the trace file is beyond the scope of this article, but the following sections explain how trace files can be created and processed.
Using Application Tracing Tools – 11g Release 2 (11.2)
-
Performance Tuning Basics 5 : Trace and TKPROF – Part 1
24-Nov-2017 — For SQL Trace obtained using the Profile Option method or SQL*Plus, the trace file identifier explicitly set (using ALTER SESSION SET …
Using SQL Trace and TKPROF
The SQL Trace facility and TKPROF
are two basic performance diagnostic tools that can help you monitor and tune applications running against the Oracle Server.
This chapter contains the following sections:
- Understanding SQL Trace and TKPROF
- Using the SQL Trace Facility and TKPROF
- Avoiding Pitfalls in TKPROF Interpretation
- Sample TKPROF Output
Understanding SQL Trace and TKPROF
The SQL Trace facility and TKPROF
let you accurately assess the efficiency of the SQL statements an application runs. For best results, use these tools with EXPLAIN
PLAN
rather than using EXPLAIN
PLAN
alone.
Understanding the SQL Trace Facility
The SQL Trace facility provides performance information on individual SQL statements. It generates the following statistics for each statement:
- Parse, execute, and fetch counts
- CPU and elapsed times
- Physical reads and logical reads
- Number of rows processed
- Misses on the library cache
- Username under which each parse occurred
- Each commit and rollback
You can enable the SQL Trace facility for a session or for an instance. When the SQL Trace facility is enabled, performance statistics for all SQL statements executed in a user session or in the instance are placed into trace files.
The additional overhead of running the SQL Trace facility against an application with performance problems is normally insignificant compared with the inherent overhead caused by the application’s inefficiency.
Understanding TKPROF
You can run the TKPROF
program to format the contents of the trace file and place the output into a readable output file. Optionally, TKPROF
can also:
- Determine the execution plans of SQL statements
- Create a SQL script that stores the statistics in the database
TKPROF
reports each statement executed with the resources it has consumed, the number of times it was called, and the number of rows which it processed. This information lets you easily locate those statements that are using the greatest resource. With experience or with baselines available, you can assess whether the resources used are reasonable given the work done.
Using the SQL Trace Facility and TKPROF
Follow these steps to use the SQL Trace facility and TKPROF
:
- Set initialization parameters for trace file management.
See “Step 1: Setting Initialization Parameters for Trace File Management”.
- Enable the SQL Trace facility for the desired session, and run the application. This step produces a trace file containing statistics for the SQL statements issued by the application.
- Run
TKPROF
to translate the trace file created in Step 2 into a readable output file. This step can optionally create a SQL script that can be used to store the statistics in a database. - Interpret the output file created in Step 3.
- Optionally, run the SQL script produced in Step 3 to store the statistics in the database.
In the following sections, each of these steps is discussed in depth.
Step 1: Setting Initialization Parameters for Trace File Management
When the SQL Trace facility is enabled for a session, Oracle generates a trace file containing statistics for traced SQL statements for that session. When the SQL Trace facility is enabled for an instance, Oracle creates a separate trace file for each process. Before enabling the SQL Trace facility:
- Check the settings of the
TIMED_STATISTICS
,MAX_DUMP_FILE_SIZE
, andUSER_DUMP_DEST
initialization parameters. See Table 10-1.
Table 10-1 Initialization Parameters to Check Before Enabling SQL Trace
- Devise a way of recognizing the resulting trace file.
Be sure you know how to distinguish the trace files by name. Oracle writes them to the user dump destination specified by
USER_DUMP_DEST
. However, this directory can soon contain many hundreds of files, usually with generated names. It might be difficult to match trace files back to the session or process that created them. You can tag trace files by including in your programs a statement likeSELECT
program_name
FROM
DUAL
. You can then trace each file back to the process that created it. - If the operating system retains multiple versions of files, then be sure that the version limit is high enough to accommodate the number of trace files you expect the SQL Trace facility to generate.
- The generated trace files can be owned by an operating system user other than yourself. This user must make the trace files available to you before you can use
TKPROF
to format them.See Also: “Setting the Level of Statistics Collection” for information about
STATISTICS_LEVEL
settings
Step 2: Enabling the SQL Trace Facility
Enable the SQL Trace facility for the session by using one of the following:
You can enable SQL Trace in another session by using the DBMS_SYSTEM
.SET_SQL_TRACE_IN_SESSION
procedure.
To disable the SQL Trace facility for the session, enter:
ALTER SESSION SET SQL_TRACE = FALSE;
The SQL Trace facility is automatically disabled for the session when the application disconnects from Oracle.
You can enable the SQL Trace facility for an instance by setting the value of the SQL_TRACE
initialization parameter to TRUE
in the initialization file.
SQL_TRACE = TRUE
After the instance has been restarted with the updated initialization parameter file, SQL Trace is enabled for the instance and statistics are collected for all sessions. If the SQL Trace facility has been enabled for the instance, you can disable it for the instance by setting the value of the SQL_TRACE
parameter to FALSE
.
Setting |
Step 3: Formatting Trace Files with TKPROF
TKPROF
accepts as input a trace file produced by the SQL Trace facility, and it produces a formatted output file. TKPROF
can also be used to generate execution plans.
After the SQL Trace facility has generated a number of trace files, you can:
- Run
TKPROF
on each individual trace file, producing a number of formatted output files, one for each session. - Concatenate the trace files, and then run
TKPROF
on the result to produce a formatted output file for the entire instance.
TKPROF
does not report COMMITs
and ROLLBACKs
that are recorded in the trace file.
Sample TKPROF Output
Sample output from TKPROF
is as follows:
SELECT * FROM emp, dept WHERE emp.deptno = dept.deptno; call count cpu elapsed disk query current rows ---- ------- ------- --------- -------- -------- ------- ------ Parse 1 0.16 0.29 3 13 0 0 Execute 1 0.00 0.00 0 0 0 0 Fetch 1 0.03 0.26 2 2 4 14 Misses in library cache during parse: 1 Parsing user id: (8) SCOTT Rows Execution Plan ------- --------------------------------------------------- 14 MERGE JOIN 4 SORT JOIN 4 TABLE ACCESS (FULL) OF 'DEPT' 14 SORT JOIN 14 TABLE ACCESS (FULL) OF 'EMP'
For this statement, TKPROF
output includes the following information:
- The text of the SQL statement
- The SQL Trace statistics in tabular form
- The number of library cache misses for the parsing and execution of the statement.
- The user initially parsing the statement.
- The execution plan generated by
EXPLAIN
PLAN
.
TKPROF
also provides a summary of user level statements and recursive SQL calls for the trace file.
Syntax of TKPROF
TKPROF::=
Text description of the illustration sqltracea.gif
If you invoke TKPROF
without arguments, then online help is displayed. Use the arguments in Table 10-2 with TKPROF
.
Table 10-2 TKPROF Arguments
Argument | Description |
---|---|
|
Specifies the input file, a trace file containing statistics produced by the SQL Trace facility. This file can be either a trace file produced for a single session, or a file produced by concatenating individual trace files from multiple sessions. |
|
Specifies the file to which |
|
Specifies whether to record summary for any wait events found in the trace file. Values are |
|
Sorts traced SQL statements in descending order of specified sort option before listing them into the output file. If more than one option is specified, then the output is sorted in descending order by the sum of the values specified in the sort options. If you omit this parameter, then TKPROF lists statements into the output file in order of first use. Sort options are listed as follows: |
Number of times parsed. |
|
CPU time spent parsing. |
|
Elapsed time spent parsing. |
|
Number of physical reads from disk during parse. |
|
Number of consistent mode block reads during parse. |
|
Number of current mode block reads during parse. |
|
Number of library cache misses during parse. |
|
Number of executes. |
|
CPU time spent executing. |
|
Elapsed time spent executing. |
|
Number of physical reads from disk during execute. |
|
Number of physical reads from disk during execute. |
|
Number of consistent mode block reads during execute. |
|
Number of current mode block reads during execute. |
|
Number of rows processed during execute. |
|
Number of library cache misses during execute. |
|
Number of fetches. |
|
CPU time spent fetching. |
|
Elapsed time spent fetching. |
|
Number of physical reads from disk during fetch. |
|
Number of consistent mode block reads during fetch. |
|
Number of current mode block reads during fetch. |
|
Number of rows fetched. |
|
|
Lists only the first integer sorted SQL statements from the output file. If you omit this parameter, then |
|
If you specify |
|
Creates a SQL script that stores the trace file statistics in the database. |
|
Enables and disables the listing of SQL statements issued by the user |
|
Specifies the schema and name of the table into which The specified user must be able to issue This option allows multiple individuals to run If you use the If no plan table exists, |
|
Determines the execution plan for each SQL statement in the trace file and writes these execution plans to the output file. |
|
Creates a SQL script with the specified filename with all of the nonrecursive SQL in the trace file. This can be used to replay the user events from the trace file. |
|
An integer that controls the output line width of some TKPROF output, such as the explain plan. This parameter is useful for post-processing of TKPROF output. |
Examples of TKPROF Statement
This section provides two brief examples of TKPROF
usage. For an complete example of TKPROF
output, see “Sample TKPROF Output”.
TKPROF Example 1
If you are processing a large trace file using a combination of SORT
parameters and the PRINT
parameter, then you can produce a TKPROF
output file containing only the highest resource-intensive statements. For example, the following statement prints the 10 statements in the trace file that have generated the most physical I/O:
TKPROF ora53269.trc ora53269.prf SORT = (PRSDSK, EXEDSK, FCHDSK) PRINT = 10
TKPROF Example 2
This example runs TKPROF
, accepts a trace file named dlsun12_jane_fg_sqlplus_007
.trc
, and writes a formatted output file named outputa
.prf
:
TKPROF dlsun12_jane_fg_sqlplus_007.trc OUTPUTA.PRF EXPLAIN=scott/tiger TABLE=scott.temp_plan_table_a INSERT=STOREA.SQL SYS=NO SORT=(EXECPU,FCHCPU)
This example is likely to be longer than a single line on the screen, and you might need to use continuation characters, depending on the operating system.
Note the other parameters in this example:
- The
EXPLAIN
value causesTKPROF
to connect as the userscott
and use theEXPLAIN
PLAN
statement to generate the execution plan for each traced SQL statement. You can use this to get access paths and row source counts. - The
TABLE
value causesTKPROF
to use the tabletemp_plan_table_a
in the schemascott
as a temporary plan table. - The
INSERT
value causesTKPROF
to generate a SQL script namedSTOREA
.SQL
that stores statistics for all traced SQL statements in the database. - The
SYS
parameter with the value ofNO
causesTKPROF
to omit recursive SQL statements from the output file. In this way, you can ignore internal Oracle statements such as temporary table operations. - The
SORT
value causesTKPROF
to sort the SQL statements in order of the sum of the CPU time spent executing and the CPU time spent fetching rows before writing them to the output file. For greatest efficiency, always useSORT
parameters.
Step 4: Interpreting TKPROF Output
This section provides pointers for interpreting TKPROF
output.
- Tabular Statistics in TKPROF
- Library Cache Misses in TKPROF
- Statement Truncation in SQL Trace
- Identification of User Issuing the SQL Statement in TKPROF
- Execution Plan in TKPROF
- Deciding Which Statements to Tune
While TKPROF
provides a very useful analysis, the most accurate measure of efficiency is the actual performance of the application in question. At the end of the TKPROF
output is a summary of the work done in the database engine by the process during the period that the trace was running.
Tabular Statistics in TKPROF
TKPROF
lists the statistics for a SQL statement returned by the SQL Trace facility in rows and columns. Each row corresponds to one of three steps of SQL statement processing. Statistics are identified by the value of the CALL
column. See Table 10-3.
Table 10-3 CALL Column Values
The other columns of the SQL Trace facility output are combined statistics for all parses, all executes, and all fetches of a statement. The sum of query
and current
is the total number of buffers accessed, also called Logical I/Os (LIOs). See Table 10-4.
Table 10-4 SQL Trace Statistics for Parses, Executes, and Fetches.
Statistics about the processed rows appear in the ROWS
column. See Table 10-5.
Table 10-5 SQL Trace Statistics for the ROWS Column
SQL Trace Statistic | Meaning |
---|---|
|
Total number of rows processed by the SQL statement. This total does not include rows processed by subqueries of the SQL statement. |
For SELECT
statements, the number of rows returned appears for the fetch step. For UPDATE
, DELETE
, and INSERT
statements, the number of rows processed appears for the execute step.
The row source counts are displayed when a cursor is closed. In SQL*Plus, there is only one user cursor, so each statement executed causes the previous cursor to be closed; therefore, the row source counts are displayed. PL/SQL has its own cursor handling and does not close child cursors when the parent cursor is closed. Exiting (or reconnecting) causes the counts to be displayed. |
Interpreting the Resolution of Statistics
Timing statistics have a resolution of one hundredth of a second; therefore, any operation on a cursor that takes a hundredth of a second or less might not be timed accurately. Keep this in mind when interpreting statistics. In particular, be careful when interpreting the results from simple queries that execute very quickly.
Understanding Recursive Calls
Sometimes, in order to execute a SQL statement issued by a user, Oracle must issue additional statements. Such statements are called recursive calls or recursive SQL statements. For example, if you insert a row into a table that does not have enough space to hold that row, then Oracle makes recursive calls to allocate the space dynamically. Recursive calls are also generated when data dictionary information is not available in the data dictionary cache and must be retrieved from disk.
If recursive calls occur while the SQL Trace facility is enabled, then TKPROF
produces statistics for the recursive SQL statements and marks them clearly as recursive SQL statements in the output file. You can suppress the listing of Oracle internal recursive calls (for example, space management) in the output file by setting the SYS
command-line parameter to NO
. The statistics for a recursive SQL statement are included in the listing for that statement, not in the listing for the SQL statement that caused the recursive call. So, when you are calculating the total resources required to process a SQL statement, consider the statistics for that statement as well as those for recursive calls caused by that statement.
Recursive SQL statistics are not included for SQL-level operations. However, recursive SQL statistics are included for operations done under the SQL level, such as triggers. For more information, see “Avoiding the Trigger Trap”. |
Library Cache Misses in TKPROF
TKPROF
also lists the number of library cache misses resulting from parse and execute steps for each SQL statement. These statistics appear on separate lines following the tabular statistics. If the statement resulted in no library cache misses, then TKPROF
does not list the statistic. In “Sample TKPROF Output”, the statement resulted in one library cache miss for the parse step and no misses for the execute step.
Statement Truncation in SQL Trace
The following SQL statements are truncated to 25 characters in the SQL Trace file:
SET ROLE GRANT ALTER USER ALTER ROLE CREATE USER CREATE ROLE
Identification of User Issuing the SQL Statement in TKPROF
TKPROF
also lists the user ID of the user issuing each SQL statement. If the SQL Trace input file contained statistics from multiple users and the statement was issued by more than one user, then TKPROF
lists the ID of the last user to parse the statement. The user ID of all database users appears in the data dictionary in the column ALL_USERS
.USER_ID
.
Execution Plan in TKPROF
If you specify the EXPLAIN
parameter on the TKPROF
statement line, then TKPROF
uses the EXPLAIN
PLAN
statement to generate the execution plan of each SQL statement traced. TKPROF
also displays the number of rows processed by each step of the execution plan.
Trace files generated immediately after instance startup contain data that reflects the activity of the startup process. In particular, they reflect a disproportionate amount of I/O activity as caches in the system global area (SGA) are filled. For the purposes of tuning, ignore such trace files. |
See Also:
Chapter 9, “Using EXPLAIN PLAN” for more information on interpreting execution plans |
Deciding Which Statements to Tune
You need to find which SQL statements use the most CPU or disk resource. If the TIMED_STATISTICS
parameter is on, then you can find high CPU activity in the CPU
column. If TIMED_STATISTICS
is not on, then check the QUERY
and CURRENT
columns.
See Also:
“Examples of TKPROF Statement” for examples of finding resource intensive statements |
With the exception of locking problems and inefficient PL/SQL loops, neither the CPU time nor the elapsed time is necessary to find problem statements. The key is the number of block visits, both query (that is, subject to read consistency) and current (that is, not subject to read consistency). Segment headers and blocks that are going to be updated are acquired in current mode, but all query and subquery processing requests the data in query mode. These are precisely the same measures as the instance statistics CONSISTENT
GETS
and DB
BLOCK
GETS
. You can find high disk activity in the disk column.
The following listing shows TKPROF
output for one SQL statement as it appears in the output file:
SELECT * FROM emp, dept WHERE emp.deptno = dept.deptno; call count cpu elapsed disk query current rows ---- ------- ------- --------- -------- -------- ------- ------ Parse 11 0.08 0.18 0 0 0 0 Execute 11 0.23 0.66 0 3 6 0 Fetch 35 6.70 6.83 100 12326 2 824 ------------------------------------------------------------------ total 57 7.01 7.67 100 12329 8 826 Misses in library cache during parse: 0
If it is acceptable to have 7.01 CPU seconds and to retrieve 824 rows, then you need not look any further at this trace output. In fact, a major use of TKPROF
reports in a tuning exercise is to eliminate processes from the detailed tuning phase.
You can also see that 10 unnecessary parse call were made (because there were 11 parse calls for this one statement) and that array fetch operations were performed. You know this because more rows were fetched than there were fetches performed. A large gap between CPU
and elapsed
timings indicates Physical I/Os (PIOs).
Step 5: Storing SQL Trace Facility Statistics
You might want to keep a history of the statistics generated by the SQL Trace facility for an application, and compare them over time. TKPROF
can generate a SQL script that creates a table and inserts rows of statistics into it. This script contains:
- A
CREATE
TABLE
statement that creates an output table namedTKPROF_TABLE
. INSERT
statements that add rows of statistics, one for each traced SQL statement, to theTKPROF_TABLE
.
After running TKPROF
, you can run this script to store the statistics in the database.
Generating the TKPROF Output SQL Script
When you run TKPROF
, use the INSERT
parameter to specify the name of the generated SQL script. If you omit this parameter, then TKPROF
does not generate a script.
Editing the TKPROF Output SQL Script
After TKPROF
has created the SQL script, you might want to edit the script before running it. If you have already created an output table for previously collected statistics and you want to add new statistics to this table, then remove the CREATE
TABLE
statement from the script. The script then inserts the new rows into the existing table.
If you have created multiple output tables, perhaps to store statistics from different databases in different tables, then edit the CREATE
TABLE
and INSERT
statements to change the name of the output table.
Querying the Output Table
The following CREATE
TABLE
statement creates the TKPROF_TABLE
:
CREATE TABLE TKPROF_TABLE ( DATE_OF_INSERT DATE, CURSOR_NUM NUMBER, DEPTH NUMBER, USER_ID NUMBER, PARSE_CNT NUMBER, PARSE_CPU NUMBER, PARSE_ELAP NUMBER, PARSE_DISK NUMBER, PARSE_QUERY NUMBER, PARSE_CURRENT NUMBER, PARSE_MISS NUMBER, EXE_COUNT NUMBER, EXE_CPU NUMBER, EXE_ELAP NUMBER, EXE_DISK NUMBER, EXE_QUERY NUMBER, EXE_CURRENT NUMBER, EXE_MISS NUMBER, EXE_ROWS NUMBER, FETCH_COUNT NUMBER, FETCH_CPU NUMBER, FETCH_ELAP NUMBER, FETCH_DISK NUMBER, FETCH_QUERY NUMBER, FETCH_CURRENT NUMBER, FETCH_ROWS NUMBER, CLOCK_TICKS NUMBER, SQL_STATEMENT LONG);
Most output table columns correspond directly to the statistics that appear in the formatted output file. For example, the PARSE_CNT
column value corresponds to the count statistic for the parse step in the output file.
The columns in Table 10-6 help you identify a row of statistics.
Table 10-6 TKPROF_TABLE Columns for Identifying a Row of Statistics
The output table does not store the statement’s execution plan. The following query returns the statistics from the output table. These statistics correspond to the formatted output shown in the section “Sample TKPROF Output”.
SELECT * FROM TKPROF_TABLE;
Oracle responds with something similar to:
DATE_OF_INSERT CURSOR_NUM DEPTH USER_ID PARSE_CNT PARSE_CPU PARSE_ELAP -------------- ---------- ----- ------- --------- --------- ---------- 21-DEC-1998 1 0 8 1 16 22 PARSE_DISK PARSE_QUERY PARSE_CURRENT PARSE_MISS EXE_COUNT EXE_CPU ---------- ----------- ------------- ---------- --------- ------- 3 11 0 1 1 0 EXE_ELAP EXE_DISK EXE_QUERY EXE_CURRENT EXE_MISS EXE_ROWS FETCH_COUNT -------- -------- --------- ----------- -------- -------- ----------- 0 0 0 0 0 0 1 FETCH_CPU FETCH_ELAP FETCH_DISK FETCH_QUERY FETCH_CURRENT FETCH_ROWS --------- ---------- ---------- ----------- ------------- ---------- 2 20 2 2 4 10 SQL_STATEMENT --------------------------------------------------------------------- SELECT * FROM EMP, DEPT WHERE EMP.DEPTNO = DEPT.DEPTNO
Avoiding Pitfalls in TKPROF Interpretation
This section describes some fine points of TKPROF
interpretation:
- Avoiding the Argument Trap
- Avoiding the Read Consistency Trap
- Avoiding the Schema Trap
- Avoiding the Time Trap
- Avoiding the Trigger Trap
Avoiding the Argument Trap
If you are not aware of the values being bound at run time, then it is possible to fall into the argument trap. EXPLAIN
PLAN
cannot determine the type of a bind variable from the text of SQL statements, and it always assumes that the type is varchar
. If the bind variable is actually a number or a date, then TKPROF
can cause implicit data conversions, which can cause inefficient plans to be executed. To avoid this, experiment with different data types in the query.
To avoid this problem, perform the conversion yourself.
See Also:
“EXPLAIN PLAN Restrictions” for information about |
Avoiding the Read Consistency Trap
The next example illustrates the read consistency trap. Without knowing that an uncommitted transaction had made a series of updates to the NAME
column, it is very difficult to see why so many block visits would be incurred.
Cases like this are not normally repeatable: if the process were run again, it is unlikely that another transaction would interact with it in the same way.
SELECT name_id FROM cq_names WHERE name = 'FLOOR'; call count cpu elapsed disk query current rows ---- ----- --- ------- ---- ----- ------- ---- Parse 1 0.10 0.18 0 0 0 0 Execute 1 0.00 0.00 0 0 0 0 Fetch 1 0.11 0.21 2 101 0 1 Misses in library cache during parse: 1 Parsing user id: 01 (USER1) Rows Execution Plan ---- --------- ---- 0 SELECT STATEMENT 1 TABLE ACCESS (BY ROWID) OF 'CQ_NAMES' 2 INDEX (RANGE SCAN) OF 'CQ_NAMES_NAME' (NON_UNIQUE)
Avoiding the Schema Trap
This example shows an extreme (and thus easily detected) example of the schema trap. At first, it is difficult to see why such an apparently straightforward indexed query needs to look at so many database blocks, or why it should access any blocks at all in current mode.
SELECT name_id FROM cq_names WHERE name = 'FLOOR'; call count cpu elapsed disk query current rows -------- ------- -------- --------- ------- ------ ------- ---- Parse 1 0.06 0.10 0 0 0 0 Execute 1 0.02 0.02 0 0 0 0 Fetch 1 0.23 0.30 31 31 3 1 Misses in library cache during parse: 0 Parsing user id: 02 (USER2) Rows Execution Plan ------- --------------------------------------------------- 0 SELECT STATEMENT 2340 TABLE ACCESS (BY ROWID) OF 'CQ_NAMES' 0 INDEX (RANGE SCAN) OF 'CQ_NAMES_NAME' (NON-UNIQUE)
Two statistics suggest that the query might have been executed with a full table scan. These statistics are the current mode block visits, plus the number of rows originating from the Table Access row source in the execution plan. The explanation is that the required index was built after the trace file had been produced, but before TKPROF
had been run.
Generating a new trace file gives the following data:
-- -------- ----- ------ ------- -----
Parse 1 0.01
0.02 0 0 0 0
1 0.00 0.00 0 0 0 0
Fetch 1 0.00 0.00 0 2 0 1
Misses in library cache during parse: 0
Parsing user id: 02 (
Execute USER2)
Rows Execution Plan
------- ---------------------------------------------------
0 SELECT STATEMENT
1 TABLE ACCESS (BY ROWID) OF 'CQ_NAMES'
2 INDEX (RANGE SCAN) OF 'CQ_NAMES_NAME' (NON-UNIQUE)
One of the marked features of this correct version is that the parse call took 10 milliseconds of CPU time and 20 milliseconds of elapsed time, but the query apparently took no time at all to execute and perform the fetch. These anomalies arise because the clock tick of 10 milliseconds is too long relative to the time taken to execute and fetch the data. In such cases, it is important to get lots of executions of the statements, so that you have statistically valid numbers.
Avoiding the Time Trap
Sometimes, as in the following example, you might wonder why a particular query has taken so long.
UPDATE cq_names SET ATTRIBUTES = lower(ATTRIBUTES) WHERE ATTRIBUTES = :att call count cpu elapsed disk query current rows -------- ------- -------- --------- -------- -------- ------- ---------- Parse 1 0.06 0.24 0 0 0 0 Execute 1 0.62 19.62 22 526 12 7 Fetch 0 0.00 0.00 0 0 0 0 Misses in library cache during parse: 1 Parsing user id: 02 (USER2) Rows Execution Plan ------- --------------------------------------------------- 0 UPDATE STATEMENT 2519 TABLE ACCESS (FULL) OF 'CQ_NAMES'
Again, the answer is interference from another transaction. In this case, another transaction held a shared lock on the table cq_names
for several seconds before and after the update was issued. It takes a fair amount of experience to diagnose that interference effects are occurring. On the one hand, comparative data is essential when the interference is contributing only a short delay (or a small increase in block visits in the previous example). On the other hand, if the interference is contributing only a modest overhead, and the statement is essentially efficient, then its statistics might not need to be analyzed.
Avoiding the Trigger Trap
The resources reported for a statement include those for all of the SQL issued while the statement was being processed. Therefore, they include any resources used within a trigger, along with the resources used by any other recursive SQL (such as that used in space allocation). With the SQL Trace facility enabled, TKPROF
reports these resources twice. Avoid trying to tune the DML statement if the resource is actually being consumed at a lower level of recursion.
If a DML statement appears to be consuming far more resources than you would expect, then check the tables involved in the statement for triggers and constraints that could be greatly increasing the resource usage.
This section provides an extensive example of TKPROF
output. Portions have been edited out for the sake of brevity.
How To Install?
Run the system and open PC properties.Get the latest Software.
Go to the activation menu too.
After that, download the code and the crack from the link below.
Enter this key to activate.