9i DBA Performance Tuning R2 V2 - D37163

Oracle9i Database Performance
Tuning
y
l
n
Student Guide Volume Two
O
e
I
A
&
l
a
n
r
te
n
I
e
D11299GC20
Edition 2.0
August 2002
D37163
r
O
l
c
a
s
U
Copyright Oracle Corporation, 2002. All rights reserved.
Authors
Peter Kilpatrick
This documentation contains proprietary information of Oracle Corporation. It is

provided under a license agreement containing restrictions on use and disclosure and
is also protected by copyright law. Reverse engineering of the software is prohibited.
If this documentation is delivered to a U.S. Government Agency of the Department of
Defense, then it is delivered with Restricted Rights and the following legend is
applicable:
Shankar Raman
Jim Womack
Technical Contributors and
Reviewers
Mirza Ahmad
Restricted Rights Legend
David Austin
Use, duplication or disclosure by the Government is subject to restrictions for

commercial computer software and shall be deemed to be Restricted Rights software
under Federal law, as set forth in subparagraph (c)(1)(ii) of DFARS 252.227-7013,
Rights in Technical Data and Computer Software (October 1988).
Ruth Baylis
Howard Bradley
This material or any portion of it may not be copied in any form or by any means
without the express prior written permission of Oracle Corporation. Any other copying
is a violation of copyright law and may result in civil and/or criminal penalties.
Pietro Colombo
Michele Cyran
If this documentation is delivered to a U.S. Government Agency not within the

Department of Defense, then it is delivered with Restricted Rights, as defined in
FAR 52.227-14, Rights in Data-General, including Alternate III (June 1987).
Benoit Dagerville
Connie Dialeris
Joel Goodman
The information in this document is subject to change without notice. If you find any
problems in the documentation, please report them in writing to Education Products,
Oracle Corporation, 500 Oracle Parkway, Box SB-6, Redwood Shores, CA 94065.
Oracle Corporation does not warrant that this document is error-free.
Scott Gossett
Lilian Hobbs
Alexander Hunold
Oracle and all references to Oracle and Oracle products are trademarks or registered
trademarks of Oracle Corporation.
Sushil Kumar
Roderick Manalac
All other products or company names are used for identification purposes only, and
may be trademarks of their respective owners.
Howard Ostrow
y
l
n
Sander Rekveld
Maria Senise
O
e
Ranbir Singh
Janet Stern
Wayne Stokes
Tracy Stollberg
I
A
Harald Van Breederode

John Watson
&
l
a
Publisher
John B Dawson
n
r
te
r
O
l
c
a
n
I
e
s
U
Contents
Overview of Oracle9i Database Performance Tuning

Objectives 1-2
Tuning Questions 1-3
Tuning Phases 1-5
Tuning Goals 1-6
Common Performance Problems 1-7
Tuning Steps During Development 1-8
Collect a Baseline Set of Statistics 1-9
Tuning Steps for a Production Database 1-10
Database Server Tuning Methodology 1-12
Performance Versus Safety Trade-Offs 1-14
Summary 1-15
Diagnostic and Tuning Tools

Objectives 2-2
Maintenance of the Alert Log File 2-3
Tuning Components of the Alert Log File 2-4
Background Processes Trace Files 2-5
User Trace Files 2-6
Views, Utilities, and Tools 2-7
Oracle Enterprise Manager Console 2-9
Performance Manager 2-10
Overview of Oracle Expert Tuning Methodology 2-12
Tuning Using Oracle Expert 2-13
Statspack 2-15
Statspack Output 2-17
Dictionary and Special Views 2-20
Displaying Systemwide Statistics 2-21
Displaying Session-Related Statistics 2-24
Oracle Wait Events 2-26
The v$event_name View 2-27
Statistics Event Views 2-28
The v$session_event View 2-29
The v$session_wait View 2-30
The v$system_event View 2-32
Dynamic Troubleshooting and Performance Views 2-33
Troubleshooting and Tuning Views 2-34
utlbstat and utlestat Scripts 2-36
DBA-Developed Tools 2-37
Level of Statistics Collection 2-38
Summary 2-40
I
A
&
l
a
n
r
te
l
c
a
r
O
3
n
I
e
Database Configuration and I/O Issues

Objectives 3-2
Oracle Processes and Files 3-3
Performance Guidelines 3-4
iii
y
l
n
s
U
O
e
Distributing Files Across Devices 3-5

IO Topology Support 3-6
Tablespace Usage 3-7
Locally Managed system Tablespace 3-8
Diagnostic Tools for Checking I/O Statistics 3-9
Using the v$filestat View 3-10
Performance Manager: I/O Statistics 3-11
I/O Statistics 3-12
File Striping 3-13
Tuning Full Table Scan Operations 3-15
Table Scan Statistics 3-17
Monitoring Full Table Scan Operations 3-18
Checkpoints 3-20
Full Checkpoints 3-21
Performance Manager: Response Time 3-22
Regulating the Checkpoint Queue 3-23
Defining and Monitoring Fast Start Checkpointing 3-24
Redo Log Groups and Members 3-26
Online Redo Log File Configuration 3-27
Increasing the Performance of Archiving 3-29
Diagnostic Tools 3-30
Summary 3-31
4
Sizing the Shared Pool

Objectives 4-2
Shared Pool Contents 4-3
Shared Pool 4-4
The Library Cache 4-5
Important Shared Pool Latches 4-7
Shared Pool and Library Cache Latches 4-8
Tuning the Library Cache 4-9
Terminology 4-11
Diagnostic Tools for Tuning the Library Cache 4-12
Are Cursors Being Shared? 4-13
Sharing Cursors 4-14
Guidelines: Library Cache Reloads 4-15
Library Cache Guidelines Statspack Report 4-16
Invalidations 4-17
Sizing the Library Cache 4-19
Shared Pool Advisory 4-20
Oracle Enterprise Manager Shared Pool Size Advisor 4-22
Cached Execution Plans 4-23
Views to Support Cached Execution Plans 4-24
Support For Cached Execution Plans 4-25
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
iv
s
U
O
e
y
l
n
Global Space Allocation 4-26

Large Memory Requirements 4-28
Tuning the Shared Pool Reserved Space 4-30
Keeping Large Objects 4-32
Anonymous PL/SQL Blocks 4-34
Other Parameters Affecting the Library Cache 4-36
Tuning The Data Dictionary Cache 4-38
Diagnostic Tools for Tuning the Data Dictionary Cache 4-39
Measuring the Dictionary Cache Statistics 4-40
Tuning the Data Dictionary Cache 4-42
Guidelines: Dictionary Cache Misses 4-43
Performance Manager: Shared Pool Statistics 4-44
UGA and Oracle Shared Server 4-45
Determining the User Global Area Size 4-46
Large Pool 4-47
Summary 4-48
5
Sizing the Buffer Cache

Objectives 5-2
Overview 5-3
Buffer Cache Sizing Parameters 5-5
Dynamic Buffer Cache Advisory Parameter 5-6
View to Support Buffer Cache Advisory 5-7
Using the v$db_cache_advice View 5-8
Using the Buffer Cache Advisory 5-9
Managing the Database Buffer Cache 5-10
Tuning Goals and Techniques 5-12
Buffer Cache Performance Indicators 5-17
More Buffer Cache Performance Indicators 5-18
Measuring the Cache Hit Ratio 5-20
Guidelines for Using the Cache Hit Ratio 5-21
Buffer Cache Hit Ratio Isnt Everything 5-22
Guidelines to Increase the Cache Size 5-23
Using Multiple Buffer Pools 5-25
Defining Multiple Buffer Pools 5-26
Enabling Multiple Buffer Pools 5-28
KEEP Buffer Pool Guidelines 5-29
RECYCLE Buffer Pool Guidelines 5-30
Calculating the Hit Ratio for Multiple Pools 5-33
Identifying Candidate Pool Segments 5-34
Dictionary Views with Buffer Pool Information 5-35
Caching Tables 5-36
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
y
l
n
s
U
O
e
Automatic Segment Space Management 5-37

Auto-Management of Free Space 5-38
Free Lists 5-39
Diagnosing Free List Contention 5-40
Resolving Free List Contention 5-41
Multiple DBWn Processes 5-43
Multiple I/O Slaves 5-44
Tuning DBWn I/O 5-45
Summary 5-46
6
Dynamic Instance Resizing

Objectives 6-2
Dynamic SGA Feature 6-3
Unit of Allocation in the Dynamic SGA 6-4
Granule 6-5
Allocating Granules at Startup 6-6
Adding Granules to Components 6-7
Dynamic Buffer Cache Size Parameters 6-8
Example: Increasing the Size of a SGA Component 6-9
Summary 6-10
Sizing Other SGA Structures

Objectives 7-2
The Redo Log Buffer 7-3
Sizing the Redo Log Buffer 7-4
Diagnosing Redo Log Buffer Inefficiency 7-5
Using Dynamic Views to Analyze Redo Log Buffer Efficiency 7-6
Redo Log Buffer Tuning Guidelines 7-9
Reducing Redo Operations 7-11
Monitoring Java Pool Memory 7-13
Sizing the SGA for Java 7-14
Summary 7-15
I
A
&
l
a
n
r
te
Tuning the Oracle Shared Server

Objectives 8-2
Overview 8-3
Oracle Shared Server Characteristics 8-4
Monitoring Dispatchers 8-5
Monitoring Shared Servers 8-7
Monitoring Process Usage 8-9
Shared Servers and Memory Usage 8-10
Troubleshooting 8-11
Obtaining Dictionary Information 8-12
Summary 8-13
n
I
e
r
O
l
c
a
vi
s
U
O
e
y
l
n
Optimizing Sort Operations

Objectives 9-2
Automatic Sort Area Management 9-3
PGA Management Resources 9-4
Work Area Groups and PGA Cache Hit Percentages 9-5
Determining PGA Workload 9-6
Other Views for Work Areas 9-7
Querying v$pga_target_advice 9-8
Understanding v$pga_target_advice 9-9
PGA Sizing Advisor Output in Oracle Enterprise Manager 9-10
Overview 9-11
The Sorting Process 9-12
Sort Area and Parameters 9-13
Tuning Sorts 9-17
The Sorting Process and Temporary Space 9-18
Temporary Space Segments 9-19
Operations Requiring Sorts 9-20
Avoiding Sorts 9-22
Diagnostics and Guidelines 9-26
Performance Manager: Sorts 9-27
Monitoring Temporary Tablespaces 9-28
Temporary Tablespace Configuration 9-29
Summary 9-31
s
U
10 Tuning Undo Segments

Objectives 10-2
Undo Segments: Usage 10-3
Using Less Undo Space Per Transaction 10-4
Using Less Undo Space 10-5
Automatic Undo Management 10-6
Automatic Undo Management Tablespaces 10-7
Altering an Undo Tablespace 10-8
Switching Undo Tablespaces 10-9
Dropping an Undo Tablespace 10-10
Setting UNDO_RETENTION 10-11
Other Parameters for Automatic Undo Management 10-13
Monitoring Automatic Undo Management 10-15
Using v$undostat 10-16
Performance Manager: Rollback/Undo 10-17
Overview 10-18
Rollback Segment Activity 10-19
Rollback Segment Header Activity 10-20
Growth of Rollback Segments 10-21
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
vii
O
e
y
l
n
Tuning Manually Managed Rollback Segments 10-22

Diagnosing Contention for Manual Rollback Segment Header 10-24
Guidelines: Number of Manual Rollback Segments (RBSs) 10-26
Guidelines: Sizing Manual Rollback Segments 10-28
Sizing Transaction Rollback Data 10-29
Possible Problems Caused by Small Rollback Segments 10-32
Summary 10-33
11 SQL Statement Tuning
Objectives 11-2
Overview 11-3
Optimizer Modes 11-4
Setting the Optimizer Mode 11-5
Using Hints in a SQL Statement 11-7
Optimizer Plan Stability 11-8
Plan Equivalence 11-9
Creating Stored Outlines 11-10
Using Stored Outlines 11-11
Using Private Outlines 11-12
Editing Stored Outlines 11-13
Maintaining Stored Outlines 11-15
Oracle Enterprise Manager: Maintaining Stored Outlines 11-16
Overview of Diagnostic Tools 11-17
SQL Reports in Statspack 11-18
Performance Manager: Top SQL 11-19
Generate the Execution Plan 11-20
Query the plan_table Table 11-21
Using SQL Trace and TKPROF 11-22
Enabling and Disabling SQL Trace 11-24
Formatting the Trace File with TKPROF 11-25
TKPROF Statistics 11-27
SQL*Plus Autotrace 11-28
Summary 11-29
I
A
&
l
a
n
r
te
12 Managing Statistics
Objectives 12-2
Managing Statistics 12-3
Table Statistics 12-5
Collecting Segment-Level Statistics 12-6
Querying Segment-Level Statistics 12-7
Using Dynamic Sampling 12-8
Enabling Dynamic Sampling 12-9
Index Statistics 12-10
n
I
e
r
O
l
c
a
viii
s
U
O
e
y
l
n
Index Tuning Wizard 12-11

Column Statistics 12-12
Histograms 12-13
Generating Histogram Statistics 12-14
Gathering Statistic Estimates 12-15
Automatic Statistic Collecting 12-17
Optimizer Cost Model 12-18
Using System Statistics 12-20
Gathering System Statistics 12-21
Automatic Gathering of System Statistics 12-22
Manual Gathering of System Statistics 12-23
Import System Statistics Example 12-24
Copying Statistics Between Databases 12-25
Example: Create the Statistics Table 12-26
Example: Copy the Statistics to a Table 12-27
Example: Import the Statistics 12-28
Summary 12-29
13 Using Oracle Blocks Efficiently
Objectives 13-2
Database Storage Hierarchy 13-3
Allocation of Extents 13-4
Avoiding Dynamic Allocation 13-5
Locally Managed Extents 13-6
Pros and Cons of Large Extents 13-7
The High-Water Mark 13-9
Table Statistics 13-11
The dbms_space Package 13-12
Recovering Space 13-14
Database Block Size 13-15
The DB_BLOCK_SIZE Parameter 13-16
Small Block Size: Pros and Cons 13-17
Large Block Size: Pros and Cons 13-18
PCTFREE and PCTUSED 13-19
Guidelines for PCTFREE and PCTUSED 13-21
Migration and Chaining 13-22
Detecting Migration and Chaining 13-24
Selecting Migrated Rows 13-25
Eliminating Migrated Rows 13-26
Index Reorganization 13-28
Monitoring Index Space 13-29
Deciding Whether to Rebuild or Coalesce an Index 13-30
Monitoring Index Usage 13-32
Identifying Unused Indexes 13-33
Summary 13-34
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
ix
y
l
n
s
U
O
e
14 Using Oracle Data Storage Structures Efficiently

Objectives 14-2
Data Storage Structures 14-3
Selecting the Physical Structure 14-4
Data Access Methods 14-6
Clusters 14-7
Cluster Types 14-8
Situations Where Clusters Are Useful 14-9
Partitioning Methods 14-10
Range Partitioning Example 14-12
Hash Partitioning Overview 14-13
List Partitioning Example 14-14
Default Partition for List Partitioning 14-15
Composite Partitioned Table Overview 14-16
Partitioned Indexes for Scalable Access 14-17
Partition Pruning 14-19
Statistics Collection for Partitioned Objects 14-22
Summary 14-25
15 Application Tuning
Objectives 15-2
The Role of the Database Administrator 15-3
Moving Tables Using ALTER TABLE 15-4
Redefining a Table Online 15-5
B-Tree Indexes 15-7
Rebuilding Indexes 15-8
Compressed Indexes 15-9
Bitmap Indexes 15-10
Creating and Maintaining Bitmap Indexes 15-12
B-Tree Indexes and Bitmap Indexes 15-13
Reverse Key Index 15-14
Creating Reverse Key Indexes 15-15
Oracle Enterprise Manager: Index Management 15-16
Index-Organized Tables 15-17
Index-Organized Tables and Heap Tables 15-18
Creating Index-Organized Tables 15-19
IOT Row Overflow 15-20
Querying dba_tables for IOT Information 15-21
Querying dba_indexes and dba_segments for IOT information 15-22
Using a Mapping Table 15-23
Maintaining a Mapping Table 15-24
The ANALYZE Statement 15-25
Oracle Enterprise Manager: Collect Statistics 15-26
OLTP Systems 15-27
O
e
y
l
n
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
s
U
OLTP Requirements 15-28

OLTP Application Issues 15-30
Decision Support Systems (Data Warehouses) 15-31
Data Warehouse Requirements 15-32
Further Data Warehouse Requirements 15-33
Data Warehouse Application Issues 15-34
Hybrid Systems 15-35
Summary 15-36
16 Using Materialized Views
Objectives 16-2
Materialized Views 16-3
Creating Materialized Views 16-4
Refreshing Materialized Views 16-5
Materialized Views: Manual Refreshing 16-7
Nested Materialized View Example 16-8
Union All Materialized Views 16-10
Query Rewrite Overview 16-12
Query Rewrites 16-13
Creating a Materialized View 16-14
Materialized Views and Query Rewrites: Example 16-15
Enabling and Controlling Query Rewrites 16-16
Disabling Query Rewrites: Example 16-18
Union All Query Rewrite 16-19
Using the dbms_mview Package 16-20
Summary 16-21
17 Monitoring and Detecting Lock Contention
Objectives 17-2
Locking Mechanism 17-3
Data Concurrency 17-4
Two Types of Locks 17-6
DML Locks 17-8
Enqueue Mechanism 17-9
Table Lock Modes 17-10
Manually Locking a Table 17-12
DML Locks in Blocks 17-14
DDL Locks 17-15
Possible Causes of Lock Contention 17-17
Diagnostic Tools for Monitoring Locking Activity 17-18
Guidelines for Resolving Contention 17-20
Performance Manager: Locks 17-22
Deadlocks 17-23
Summary 17-26
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
xi
y
l
n
s
U
O
e
18 Using Resource Manager

Objectives 18-2
Overview 18-3
Database Resource Management Concepts 18-4
Using Sub-Plans to Limit CPU Utilization 18-5
Resource Allocation Methods 18-6
The Initial Plan: SYSTEM_PLAN 18-8
Administering the Database Resource Manager 18-9
Oracle Enterprise Manager: Resource Manager 18-11
Assigning the Resource Manager Privilege 18-12
Creating Database Resource Manager Objects 18-13
Active Session Pool 18-15
Active Session Pool Mechanism 18-16
Active Session Pool Parameters 18-17
Setting the Active Session Pool 18-18
Maximum Estimated Execution Time 18-19
Automatic Consumer Group Switching 18-20
Undo Quota 18-21
Creating Database Resource Manager Objects 18-22
Assigning Users to Consumer Groups 18-24
Setting the Resource Plan for an Instance 18-25
Changing a Consumer Group Within a Session 18-26
Changing Consumer Groups for Sessions 18-27
Database Resource Manager Information 18-28
Resource Plan Directives 18-29
Resource Consumer Groups and Privileges 18-30
Current Database Resource Manager Settings 18-32
Summary 18-33
19 Tuning the Operating System
Objectives 19-2
Operating System Tuning 19-3
System Architectures 19-4
Virtual and Physical Memory 19-6
Paging and Swapping 19-7
Tuning Memory 19-8
Tuning I/O 19-9
Understanding Different I/O System Calls 19-10
CPU Tuning 19-11
Process versus Thread 19-13
Summary 19-14
&
l
a
n
r
te
n
I
e
r
O
l
c
a
xii
I
A
y
l
n
s
U
O
e
20 Workshop Overview
Objectives 20-2
Approach to Workshop 20-3
Company Information 20-4
Physical Workshop Configuration 20-5
Workshop Database Configuration 20-6
Workshop Procedure 20-7
Choosing a Scenario 20-8
Workshop Scenarios 20-9
Collecting Information 20-10
Generating a Workshop Load 20-11
Results 20-12
Summary 20-13
A Appendix A: Practice Solutions Using SQL Plus
B Appendix B: Practice Solutions Using Enterprise Manager
C Appendix C: Tuning Workshop
y
l
n
D Appendix D: Example of a Statspack Report
O
e
E Appendix E: Redundant Arrays of Inexpensive Disks Technology (RAID)
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
xiii
s
U
y
l
n
O
e
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
xiv
s
U
Using Oracle Blocks Efficiently
O
e
I
A
&
l
a
n
r
te
r
O
l
c
a
n
I
e
y
l
n
s
U
Objectives
After completing this lesson, you should be able to do

the following:
Use automatic segment space management
Use manual segment space management
Manage extents and Oracle blocks
Ensure effective use of space
Determine the high-water mark
Describe the use of Oracle block parameters

Recover space from sparsely populated segments
Describe and detect chaining and migration of
Oracle blocks
Perform index reorganization
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Oracle9i Database Performance Tuning 13-2
y
l
n
Database Storage Hierarchy
Tablespace
Segments
Extents
Extents
Extents
y
l
n
Blocks
O
e
s
U
Space Management
The efficient management of space in the database is important to its performance. This
section of the lesson examines how to manage extents and blocks in the database.
Blocks
In an Oracle database, the block is the smallest unit of data file I/O and the smallest unit of
space that can be allocated. An Oracle block consists of one or more contiguous operating
system blocks.
Extents
An extent is a logical unit of database storage space allocation consisting of a number of
contiguous data blocks. One or more extents make up a segment. When the existing space in
a segment is completely used, the Oracle server allocates a new extent for the segment.
Segments
A segment is a set of extents that contains all the data for a specific logical storage structure
within a tablespace. For example, for each table, the Oracle server allocates one or more
extents to form data segments for that table. For indexes, the Oracle server allocates one or
more extents to form its index segment.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Allocation of Extents
To avoid the disadvantages of dynamic extent

allocation:
Create locally managed tablespaces.
Size the segments appropriately.
Monitor segments ready to extend.
O
e
y
l
n
s
U
Allocation of Extents
When database operations cause the data to grow and exceed the space that is allocated, the
Oracle server extends the segment. Dynamic extension or extending the segment when
executing an INSERT or UPDATE statement reduces performance because the server
executes several recursive SQL statements to find free space and add the extent to the data
dictionary. However, this is not the case for locally managed tablespaces that avoid
recursive space management operations.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Avoiding Dynamic Allocation
To display segments with less than 10% free blocks:

SQL> SELECT owner, table_name, blocks, empty_blocks
2 FROM dba_tables
3 WHERE empty_blocks/(blocks+empty_blocks) < .1;
OWNER TABLE_NAME
BLOCKS EMPTY_BLOCKS
------ ---------- ---------- -----------HR
EMPLOYEES
1450
50
HR
COUNTRIES
460
40
To avoid dynamic allocation:

SQL> ALTER TABLE hr.employees ALLOCATE EXTENT;
Table altered.
O
e
y
l
n
s
U
Avoid Dynamic Extension

Size the segment appropriately by:
Determining the maximum size of your object
Choosing storage parameters that allocate extents large enough to accommodate all of
your data when you create the object
When determining the segment size, the DBA should allow for the growth of data. For
example, allocate enough space for the current data and for any data that will be inserted
into the segment over the next year. For formulas to predict how much space to allow for a
table see the Oracle9i Database Administrator's Guide Release 2 (9.2) manual part number
A96521-01.
Monitor the database for segments that are about to extend dynamically and extend them
with an ALTER TABLE/INDEX/CLUSTER command.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Locally Managed Extents
Create a locally managed tablespace:

SQL>
2
3
4
5
6
CREATE TABLESPACE user_data_1

DATAFILE
/oracle9i/oradata/db1/lm_1.dbf
SIZE 100M
EXTENT MANAGEMENT LOCAL
UNIFORM SIZE 2M;
With the Oracle database the default extent

management is local.
O
e
y
l
n
s
U
Locally Managed Extents

Create locally managed tablespaces for the objects that extend continuously.
A locally managed tablespace manages its own extents and maintains a bitmap in each data
file to keep track of the free or used status of blocks in that data file. Each bit in the bitmap
corresponds to a block or a group of blocks. When an extent is allocated or freed for reuse,
the bitmap values change to show the new status of the blocks. These changes do not
generate rollback information because they do not update tables in the data dictionary.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Pros and Cons of Large Extents
Pros
Are less likely to extend dynamically
Deliver small performance benefit
Enable you to read the entire extent map with a
single I/O operation
Cons
Free space may not be available
Unused space
O
e
y
l
n
s
U
Advantages of Large Extents

To ease space management, the DBA should create objects with appropriately sized extents.
As a general rule, larger extents are preferred over smaller extents.
Large extents avoid dynamic extent allocation, because segments with larger extents
are less likely to need to be extended.
Larger extents can have a small performance benefit because the Oracle server can
read one large extent from disk with fewer multi-block reads than would be required to
read many small extents. To avoid partial multi-block reads, set the extent size to a
multiple of 5 DB_FILE_MULTIBLOCK_READ_COUNT. Multiply by five because
the Oracle server tries to allocate extents on five-block boundaries. By matching extent
sizes to the I/O and space allocation sizes, the performance cost of having many
extents in a segment is minimized. However, for a table that never has a full table scan
operation, it makes no difference in terms of query performance whether the table has
one extent or multiple extents.
The performance of searches using an index is not affected by the index having one
extent or multiple extents.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Advantages of Large Extents (continued)

Extent maps list all the extents for a certain segment. When MAXEXTENTS is set to
UNLIMITED, these maps are in multiple blocks. For best performance, you should be
able to read the extent map with a single I/O. Performance degrades if multiple I/Os
are necessary for a full table scan to get the extent map. Also, a large number of
extents can degrade data dictionary performance, because each extent uses space in the
dictionary cache.
Disadvantages of Large Extents
Large extents require more contiguous blocks, therefore the Oracle server may have
difficulty finding enough contiguous space to store them.
The DBA sizes the segment to allow for growth, so some of the space allocated to the
segment will not be used initially.
To determine whether to allocate a few large extents or many small extents, consider how
the benefits and drawbacks of each would affect your plans for the growth and use of your
tables.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
The High-Water Mark
Highwater
mark
Extent 1
Empty blocks
(rows deleted)
Extent 2
Segment header block
Empty blocks (never used)
O
e
y
l
n
s
U
The High-Water Mark

Note the use of empty blocks to describe two different types of blocks.
Empty Blocks (Rows Deleted) Shown in Extent 1 and Extent 2:
These empty blocks contain data that has been deleted from the table. These blocks,
assigned to the free list of the table, are to be used by INSERT statements.
Empty Blocks (Never Used) Shown in Extent 2 Only
Empty blocks in this region are those blocks assigned to the table but which have not
yet been used by the table and thus are found above the high-water mark.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
The High-Water Mark
The high-water mark is:

Recorded in the segment header block
Set to the beginning of the segment on creation
Incremented in five-block increments as rows
are inserted
Reset by the TRUNCATE command
Never reset by using DELETE statements
y
l
n
O
e
s
U
The High-Water Mark

Space above the high-water mark can be reclaimed at the table level by using the following
command:
I
A
ALTER TABLE <table_name> DEALLOCATE UNUSED...
In a full table scan, the Oracle server reads in all blocks below the high-water mark. Empty
blocks above the high-water mark may waste space, but should not degrade performance;
however, underused blocks below the high-water mark may degrade performance.
Clusters
In clusters, space is allocated for all cluster keys, whether they contain data or not. The
amount of space allocated depends on the value of the SIZE parameter specified when
creating the cluster and the type of cluster:
In a hash cluster, because the number of hash keys is specified in the create cluster
statement, there is space allocated below the high-water mark for every hash key.
In an index cluster, there is space allocated for every entry into the cluster index.
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Table Statistics
Populate the table statistics using the dbms_stats

package and then query the values in dba_tables:
SQL> EXECUTE dbms_stats.gather_table_stats >
('HR','EMPLOYEES');
PL/SQL procedure successfully completed.
SQL> SELECT num_rows, blocks, empty_blocks as empty,
2
avg_space, chain_cnt, avg_row_len
3 FROM
dba_tables
4 WHERE
owner = 'HR'
5 AND
table_name = 'EMPLOYEES';
NUM_ROWS BLOCKS EMPTY AVG_SPACE CHAIN_CNT AVG_ROW_LEN
-------- ------ ----- --------- --------- ----------13214
615
35
1753
0
184
O
e
y
l
n
s
U
Table Statistics
Using the dbms_stats package you can analyze the storage characteristics of tables,
indexes, and clusters to gather statistics, which are then stored in the data dictionary. You
can use these statistics to determine whether a table or index has unused space.
Query the dba_tables view to see the resulting statistics:
num_rows: Number of rows in the table
blocks: Number of blocks below the high-water mark of the table
empty_blocks: Number of blocks above the high-water mark of the table
avg_space: Average free space in bytes in the blocks below the high-water mark
avg_row_len: Average row length, including row overhead
chain_cnt: Number of chained or migrated rows in the table
avg_space_freelist_blocks: The average freespace of all blocks on a free list
num_freelist_blocks: The number of blocks on the free list
empty_blocks represents blocks that have not yet been used, rather than blocks that were
full and are now empty.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
The dbms_space Package

DECLARE
owner
VARCHAR2(30);
table_name VARCHAR2(30);
seg_type
VARCHAR2(30);
tblock
NUMBER;
...
BEGIN
dbms_space.unused_space
('&owner','&table_name','TABLE',
tblock,tbyte,ublock,ubyte,lue_fid,
lue_bid,lublock);
dbms_output.put_line(...
END;
/
O
e
The dbms_space Package
I
A
y
l
n
s
U
You can also use this supplied package to obtain information about space use in segments. It
contains two procedures:
unused_space returns information about unused space in an object (table, index, or
cluster). Its specification is:
&
l
a
unused_space (segment_owner IN
VARCHAR2,
segment_name
IN
VARCHAR2,
segment_type
IN
VARCHAR2,
total_blocks
OUT NUMBER,
total_bytes
OUT NUMBER,
unused_blocks
OUT NUMBER,
unused_bytes
OUT NUMBER,
last_used_extent_file_id
OUT NUMBER,
last_used_extent_block_id
OUT NUMBER,
last_used_block
OUT NUMBER);
n
r
te
n
I
e
r
O
l
c
a
The dbms_space Package (continued)

FREE_BLOCKS returns information about free blocks in an object (table, index, or
cluster). Its specification is:
free_blocks (segment_owner IN
VARCHAR2,
segment_name
IN
VARCHAR2,
segment_type
IN
VARCHAR2,
freelist_group_id IN
NUMBER,
free_blks
OUT NUMBER,
scan_limit
IN
NUMBER DEFAULT NULL);
These procedures are created by and documented in the dbmsutil.sql script that is run
by catproc.sql. When running this package, you must provide a value for the
FREE_LIST_GROUP_ID. Use a value of 1, unless you are using Oracle Parallel Server.
The following script prompts the user for the table owner and table name, executes
dbms_space.unused_space, and displays the space statistics:
DECLARE
owner
varchar2(30);
name
varchar2(30);
seg_type varchar2(30);
tblock
number;
tbyte
number;
uBlock
number;
ubyte
number;
lue_fid number;
lue_bid number;
lublock number;
y
l
n
O
e
BEGIN
dbms_space.unused_space('&owner','&table_name','TABLE',
tblock,tbyte,ublock,ubyte,lue_fid,lue_bid,lublock);
dbms_output.put_line ('Total blocks allocated to table = '
||to_char(tblock));
dbms_output.put_line('Total bytes allocated to table = '
||to_char(tbyte));
dbms_output.put_line('Unused blocks(above HWM) = '
||to_char(ublock));
dbms_output.put_line('Unused bytes(above HWM) = '
||to_char(ubyte));
dbms_output.put_line('Last extent used file id = '
||to_char(lue_fid));
dbms_output.put_line ('Last extent used beginning block
id = ' ||to_char(lue_bid));
dbms_output.put_line('Last used block in last extent = '
||to_char(lublock));
END;
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Recovering Space
Below the high-water mark:

Use the Export and Import utilities to:
Export the table
Drop or truncate the table
Import the table
Or use the Alter Table Employees Move

command to move the table.
Above the high-water mark, use the Alter Table
Employees Deallocate Unused; command.
O
e
y
l
n
s
U
Recovering Space
Dropping or Truncating the Table
When deciding whether to drop or truncate the table, consider the following:
Both actions have the same result: no data in the table.
The DROP command removes all information regarding this table from the data
dictionary. For example, the extents used by the table will be deallocated.
The TRUNCATE command has the option to keep all allocated space, by specifying
reuse storage.
If you use the DROP TABLE command then careful consideration must be given to
using the COMPRESS option, because there might not be a single contiguous area large
enough for the entire space allocated to the table when importing.
If the table is stored in a dictionary-managed tablespace, then the deallocation from the
DROP or TRUNCATE (if using the default setting) and the allocation (at the import
stage) of extents could be a major time factor, depending on the number of extents (not
the size).
Move the Table
After the table is moved, all indexes are marked unusable and must be rebuilt.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Database Block Size
Minimize block visits by:
Using a larger block size
Packing rows tightly
Preventing row migration

Tablespace
Segments
Extents
y
l
n
Blocks
O
e
s
U
Minimizing the Number of Block Visits

One of the database tuning goals is to minimize the number of blocks visited. The developer
contributes to this goal by tuning the application and SQL statements. The DBA reduces
block visits by:
Using a larger block size
Packing rows as closely as possible into blocks
Preventing row migration
Unfortunately for the DBA, the last two goals conflict: as more data is packed into a block
the likelihood of migration increases.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
The DB_BLOCK_SIZE Parameter
The database block size:

Is defined by the DB_BLOCK_SIZE parameter
Is set when the database is created

Is the minimum I/O unit for data file reads
Is 2 KB or 4 KB by default, but up to 64 KB
is allowed
Cannot be changed easily
Should be an integer multiple of the OS block size
Should be less than or equal to the OS I/O size
O
e
y
l
n
s
U
Characteristics
When the database is created, the block size is determined by the value of the
DB_BLOCK_SIZE parameter.
It is the minimum I/O unit for data file reads.
The default block size on most Oracle platforms is either 2 or 4 KB.
Some operating systems allow block sizes of up to 64 KB. Check your operating
systemspecific documentation, specifically the Oracle database installation and
configuration guides, to determine the maximum Oracle block size for your platform.
The size cannot be changed without re-creating or duplicating the database. This
makes it difficult to test applications with different block sizes. The Oracle database
can have multiple block sizes. However, the base block size (that of the system
tablespace) cannot be changed.
The database block size should be an integer multiple of the operating system block
size.
If your operating system reads the next block during sequential reads and your
application performs many full table scans, then the database block size should be
large, but not exceeding the operating system I/O size.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Small Block Size: Pros and Cons
Pros
Reduces block contention
Is good for small rows
Is good for random access
Cons
Has a relatively large overhead
Has a small number of rows per block
Can cause more index blocks to be read
O
e
y
l
n
s
U
Small Oracle Blocks

Advantages
Small blocks reduce block contention, because there are fewer rows per block.
Small blocks are good for small rows.
Small blocks are good for random access. If it is unlikely that a block will be reused
after it is read into memory, then a smaller block size makes more efficient use of the
buffer cache. This is especially important when memory resources are scarce, because
the size of the database buffer cache is limited.
Disadvantages
Small blocks have relatively large overhead.
Depending on the size of the row you may end up storing only a small number of rows
per block,. This can cause additional I/Os.
Small blocks can cause more index blocks to be read.
Performance
For random access to a large object, as in an OLTP environment, small blocks are favored.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Large Block Size: Pros and Cons
Pros
Less overhead
Good for sequential access
Good for very large rows
Better performance of index reads
Cons
Increases block contention
Uses more space in the buffer cache
O
e
y
l
n
s
U
Large Oracle Blocks

Advantages
There is less overhead and thus more room to store useful data.
Large blocks are good for sequential reads.
Large blocks are good for very large rows.
Larger blocks improve the performance of index reads. The larger blocks can hold
more index entries in each block, which reduces the number of levels in large indexes.
Fewer index levels mean fewer I/Os when traversing the index branches.
Disadvantages
A large block size is not good for index blocks used in an OLTP environment, because
they increase block contention on the index leaf blocks.
Space in the buffer cache is wasted if you randomly access small rows and have a large
block size. For example, with an 8 KB block size and a 50 byte row size, you waste
7,950 bytes in the buffer cache when doing a random access.
Performance
Sequential access to large amounts of data, as in a DSS environment, prefers large blocks.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
PCTFREE and PCTUSED
Inserts
Inserts
Inserts
Inserts
O
e
y
l
n
s
U
How PCTFREE and PCTUSED Work Together

You use two space management parameters, PCTFREE and PCTUSED, to control the use of
free space within all the data blocks of a segment. You specify these parameters when
creating or altering a table or cluster (which has its own data segment).
If you are using Automatic Segment Space Management the value of PCTUSED has no
meaning because there is no free list. Instead the space management is handled by way of a
bitmap. However, PCTFREE does still have meaning and should be set appropriately.
The PCTFREE parameter sets the minimum percentage of a data block to be reserved as free
space for possible updates to rows that already exist in that block.
The PCTUSED parameter sets the minimum percentage of a block that can be used for row
data plus overhead before new rows are added to the block.
As an example, if you issue a CREATE TABLE statement with PCTFREE set to 20, the
Oracle server reserves 20% of each data block in the data segment of this table for updates
to the existing rows in each block. The used space in the block can grow (1) until the row
data and overhead total 80% of the total block size. Then the block is removed from the free
list to prevent additional inserts (2).
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
How PCTFREE and PCTUSED Work Together (continued)

DML Statements and PCTFREE
After you issue a DELETE or UPDATE statement, the Oracle server processes the statement
and checks to see whether the space being used in the block is now less than PCTUSED. If it
is, the block goes to the beginning of the freelist. When the transaction is committed, free
space in the block becomes available for other transactions (3).
After a data block is filled to the PCTFREE limit again (4), the Oracle server again considers
the block unavailable for the insertion of new rows until the percentage of that block falls
below the PCTUSED parameter.
DML Statements, PCTFREE, and PCTUSED
Two types of statements can increase the free space of one or more data blocks:
DELETE statements
UPDATE statements which update existing values to values that use less space
Released space in a block may not be contiguous; for example, when a row in the middle of
the block is deleted. The Oracle server coalesces the free space of a data block only when:
An INSERT or UPDATE statement attempts to use a block that contains enough free
space to contain a new row piece
The free space is fragmented so that the row piece cannot be inserted in a contiguous
section of the block
The Oracle server performs this compression only when required, because otherwise the
performance of a database system would decrease due to the continuous compression of the
free space in data blocks.
Setting PCTFREE for an Index
You can also specify the PCTFREE storage parameter when creating or altering an index.
Setting PCTFREE for an index specifies how much of a block to fill when the index is
created or during a block split. It does not keep space available for updates as is done with
data blocks.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Guidelines for PCTFREE and PCTUSED
PCTFREE
Default is 10
Zero if no UPDATE activity
PCTFREE = 100 UPD / (Average row length)

PCTUSED
Default is 40
Set if rows are deleted
PCTUSED = 100 PCTFREE 100 Rows
(Average row length) / Block size
O
e
y
l
n
s
U
Guidelines for Setting the Values of PCTFREE and PCTUSED

PCTFREE = 100 UPD / (Average row length)
PCTUSED = 100 PCTFREE 100 Rows (Average row length) / block size
where:
UPD = Average amount added by updates, in bytes. This is determined by subtracting
the average row length of the insert from the current average row length.
Average row length = After analyzing the table get this value from the
avg_row_len column of dba_tables.
Rows = Number of rows to be deleted before free list maintenance occurs
The space between PCTFREE and PCTUSED should provide enough space in the
block for row updates and for at least one more row.
PCTUSED is relevant only in tables that undergo deletes. In many tables you may be able to
pack rows into blocks more tightly by setting PCTUSED to be higher than the default.
Choose a value for PCTUSED that balances between two different kinds of performance
concerns. For tables with many DELETE and INSERT statements, changing PCTUSED can
improve block storage performance. Blocks that are densely populated can cause free list
contention, but fewer blocks are required, tables are smaller, and read operations are faster.
If you change PCTFREE and PCTUSED for existing tables, there is no immediate impact on
blocks. However, future DML activity uses the new rules for tables.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Migration and Chaining

Migration
Chaining
Index
Table
O
e
y
l
n
s
U
Migration and Chaining

In two circumstances accessing a row requires more than one block to be read. This is
caused by:
Migration: An UPDATE statement increases the amount of data in a row so that the
row no longer fits in its data block. The Oracle server tries to find another block with
enough free space to hold the entire row. If such a block is available, the Oracle server
moves the entire row to the new block. The Oracle server keeps the original row piece
of a migrated row to point to the new block containing the actual row; the rowid of a
migrated row does not change. Indexes are not updated; they continue to point to the
original row location.
Chaining: The row is too large to fit into an empty data block. The Oracle server
stores the data for the row in a chain of two or more data blocks. Chaining can occur
when the row is inserted or updated. Row chaining usually occurs with large rows,
such as rows that contain a large object (LOB). Row chaining in these cases is
unavoidable, unless a larger block size is used.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Migration and Chaining (continued)

Migration and chaining have a negative affect on performance:
INSERT and UPDATE statements that cause migration and chaining perform poorly
because they perform additional processing.
Queries that use an index to select migrated or chained rows must perform additional
I/Os.
Migration is caused by PCTFREE being set too low; there is not enough room in the block
kept for updates. To avoid migration, all tables that are updated should have their PCTFREE
set so that there is enough space within the block for updates.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Detecting Migration and Chaining
Use the ANALYZE command to detect migration

and chaining:
SQL> ANALYZE TABLE oe.orders COMPUTE STATISTICS;
PL/SQL procedure successfully completed.
SQL> SELECT num_rows, chain_cnt FROM dba_tables
2
WHERE table_name='ORDERS';
NUM_ROWS CHAIN_CNT
--------- --------168
102
Detect migration and chaining by using Statspack:

Statistic
Total Per transaction ...
------------------------- ----- --------------- ...
table fetch continued row
495
.02
O
e
Detecting Migration and Chaining

The ANALYZE Command
I
A
y
l
n
s
U
You can identify the existence of migrated and chained rows in a table or cluster by using
the ANALYZE command. This command will count the number of migrated and chained
rows and place this information into the chain_cnt column of dba_tables.
The num_rows column provides the number of rows stored in the analyzed table or cluster.
Compute the ratio of chained and migrated rows to the number of rows to decide whether
migrated rows need to be eliminated.
The Table Fetch Continued Row Statistic
You can also detect migrated or chained rows by checking the Table Fetch Continued Row
statistic in v$sysstat or in the Statspack report under Instance Activity Stats for DB.
&
l
a
n
r
te
n
I
e
l
c
a
Guidelines
Increase PCTFREE to avoid migrated rows. If you leave more free space available in the
block for updates, the row has room to grow. You can also reorganize (re-create) tables and
indexes with a high deletion rate.
r
O
Selecting Migrated Rows
SQL> ANALYZE TABLE oe.orders LIST CHAINED ROWS;

Table analyzed.
SQL> SELECT owner_name, table_name, head_rowid
2
FROM chained_rows
3
WHERE table_name = 'ORDERS';
OWNER_NAME TABLE_NAME HEAD_ROWID
---------- ---------- -----------------SALES
ORDER_HIST AAAAluAAHAAAAA1AAA
SALES
ORDER_HIST AAAAluAAHAAAAA1AAB
y
l
n
...
O
e
ANALYZE ... LIST CHAINED ROWS
I
A
s
U
You can identify migrated and chained rows in a table or cluster by using the ANALYZE
command with the LIST CHAINED ROWS option. This command collects information
about each migrated or chained row and places this information into a specified output table.
To create the table that holds the chained rows, execute the utlchain.sql script:
SQL>
2
3
4
5
6
7
&
l
a
CREATE TABLE chained_rows (

owner_name
VARCHAR2(30),
table_name
VARCHAR2(30),
cluster_name
VARCHAR2(30),
partition_name
VARCHAR2(30),
head_rowid
ROWID,
analyze_timestamp DATE );
n
r
te
n
I
e
l
c
a
If you create this table manually, it must have the same column names, data types, and sizes
as the chained_rows table.
r
O
Eliminating Migrated Rows
Export/Import
Export the table.
Drop or truncate the table.
Import the table.
Move table command:

Alter Table Employees Move
Copying migrated rows

Find migrated rows using ANALYZE.
Copy migrated rows to new table.
Delete migrated rows from original table.
Copy rows from new table to original table.
O
e
s
U
Eliminating Migrated Rows

You can eliminate migrated rows by using this SQL*Plus script:
I
A
y
l
n
/* Get the name of the table with migrated rows */

ACCEPT table_name PROMPT 'Enter the name of the table with
migrated rows: '
&
l
a
/* Clean up from last execution */

SET ECHO OFF
DROP TABLE migrated_rows;
DROP TABLE chained_rows;
n
r
te
n
I
e
/* Create the CHAINED_ROWS table */

@?/rdbms/admin/utlchain
SET ECHO ON
SPOOL fix_mig
/* List the chained & migrated rows */
ANALYZE TABLE &table_name LIST CHAINED ROWS;
r
O
l
c
a
Eliminating Migrated Rows (continued)

/* Copy the chained/migrated rows to another table */
CREATE TABLE migrated_rows AS
SELECT orig.*
FROM &table_name orig, chained_rows cr
WHERE orig.rowid = cr.head_rowid
AND cr.table_name = upper('&table_name');
/* Delete the chained/migrated rows from the original
table */
DELETE FROM &table_name
WHERE rowid IN (
SELECT head_rowid
FROM chained_rows);
/* Copy the chained/migrated rows back into the original
table */
INSERT INTO &table_name
SELECT *
FROM migrated_rows;
SPOOL OFF
When using this script, you must disable any foreign key constraints that would be violated
when the rows are deleted.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Index Reorganization
Indexes on volatile tables are a performance

problem.
Only entirely empty index blocks go to the
free list.
If a block contains only one entry,
it must be maintained.
You may need to rebuild indexes.
O
e
y
l
n
s
U
Index Reorganization
Indexes on volatile tables can also present a performance problem.
In data blocks, the Oracle server replaces deleted rows with inserted ones; however, in index
blocks, the Oracle server orders entries sequentially. Values must go in the correct block,
together with others in the same range.
Many applications insert in ascending index order and delete older values. But even if a
block contains only one entry, it must be maintained. In this case, you may need to rebuild
your indexes regularly.
If you delete all the entries from an index block, the Oracle server puts the block back on the
free list.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Monitoring Index Space
To collect usage statistics regarding an index:

SQL> EXECUTE dbms_stats.gather_index_stats >
('OE','CUSTOMERS_PK');
To view statistics collected:

SQL> SELECT name,
2
(DEL_LF_ROWS_LEN/LF_ROWS_LEN) * 100 AS wastage
3 FROM index_stats;
Rebuild indexes with wastage greater than 20%:

SQL> ALTER INDEX oe.customers_pk REBUILD;
y
l
n
SQL>
ALTER INDEX
oe.customers_pk
To
coalesce
indexes
(alternative toCOALESCE;
REBUILD):
O
e
s
U
Monitoring Index Space

You can monitor the space used by indexes by using the dbms_stats package.
After gathering statistics you can query the index_stats view to obtain the following
values:
lf_rows
Number of values currently in the index
lf_rows_len
Sum of all the length of values, in bytes
del_lf_rows
Number of values deleted from the index
del_lf_rows_len
Length of all deleted values
Note: The INDEX_STATS view contains the last analyzed index. The view is sessionspecific. If you connect to another session under the same user, the view is populated with
the index analyzed by the session querying the view.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Deciding Whether to Rebuild

or Coalesce an Index
Rebuild
Coalesce
Quickly moves index to

another tablespace
Cannot move index to

another tablespace
Higher costs: requires more

disk space
Lower costs: does not

require more disk space
Creates new tree, shrinks

height if applicable
Coalesces leaf blocks within

same branch of tree
Enables you to quickly change

storage and tablespace
parameters without having to
drop the original index.
Quickly frees up index

leaf blocks for use.
O
e
y
l
n
s
U
Rebuilding Indexes
You may decide to rebuild an index if the deleted entries represent 20% or more of the
current entries, although this depends on your application and priorities. You can use the
query in the previous slide to find the ratio. Use the ALTER INDEX REBUILD statement
to reorganize or compact an existing index or to change its storage characteristics. The
REBUILD statement uses the existing index as the basis for the new index. All index storage
commands are supported, such as STORAGE (for extent allocation), TABLESPACE (to move
the index to a new tablespace), and INITRANS (to change the initial number of entries).
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Rebuilding Indexes (continued)

When building an index, you can also use the following keywords to reduce the time it takes
to rebuild:
PARALLEL or NOPARALLEL (NOPARALLEL is the default)
RECOVERABLE or UNRECOVERABLE (RECOVERABLE is the default):
- UNRECOVERABLE is faster because it does not write redo log entries during the
index creation or rebuild.
- This clause does not set a permanent attribute of the object, but is only effective
during the creation operation; thus this setting does not appear in the data
dictionary.
- This attribute cannot be updated.
- This attribute is usable only at object creation or rebuild.
- This attribute implies LOGGING by default, which means that further inserts are
logged.
- The index is not recoverable if it needs to be re-created during a recover
operation.
LOGGING or NOLOGGING
- NOLOGGING is faster because it does not write any redo log entries during the
index life until NOLOGGING is changed to LOGGING.
- It is a permanent attribute and thus appears in the data dictionary.
- It can be updated with the ALTER INDEX NOLOGGING/LOGGING command
at any time.
Note: UNRECOVERABLE and LOGGING are not compatible.
The UNRECOVERABLE option can be used but it is kept for backwards compatibility only.
To duplicate the semantics of UNRECOVERABLE clause, create an object with the
NOLOGGING option and then alter it, specifying LOGGING. To duplicate the semantics of a
RECOVERABLE clause, create an object with the LOGGING option.
ALTER INDEX REBUILD is usually faster than dropping and re-creating an index because
it uses the fast full scan feature. It thus reads all the index blocks, using multi-block I/O,
then discards the branch blocks. The Oracle database allows the creation of an index or the
re-creation of an existing index while allowing concurrent operations on the base table. This
helps achieve demanding availability goals by allowing maintenance operations to be
performed online with no down time.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Monitoring Index Usage
Gathering statistics using an Oracle supplied

package:
SQL> EXECUTE
dbms_stats.gather_index_stats
(HR,LOC_COUNTRY_IX);
Gathering statistics at index creation:
SQL> CREATE INDEX hr.loc_country_ix

2
5 COMPUTE STATISTICS;
Gathering statistics when rebuilding an index:
SQL> ALTER INDEX hr.loc_country_ix REBUILD

2 COMPUTE STATISTICS;
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
l
c
a
r
O
y
l
n
Identifying Unused Indexes
To start monitoring the usage of an index:
To query the usage of the index:
SQL> ALTER INDEX hr.emp_name_ix

2 MONITORING USAGE;
SQL> SELECT index_name, used

2 FROM v$object_usage;
To stop monitoring the usage of an index:
SQL> ALTER INDEX hr.emp_name_ix

2
NOMONITORING USAGE;
O
e
y
l
n
s
U
Identifying Unused Indexes

The statistics about the usage of an index can be gathered and displayed in
v$object_usage. If the information gathered indicates that an index is never used, the
index can be dropped. In addition, eliminating unused indexes cuts down on the overhead
for DML operations, thus improving performance. Each time the MONITORING USAGE
clause is specified, v$object_stats is reset for the specified index. The previous
information is cleared and a new start time is recorded.
v$object_usage Columns
index_name
The index name
table_name
The corresponding table
monitoring
Indicates whether monitoring is On or Off
used
Indicates (Yes or No) the index has been used during the
monitoring time
start_monitoring
Time at which monitoring began on index
stop_monitoring
Time at which monitoring stopped on index
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Summary
In this lesson, you should have learned to do the

following:
Use automatic segment space management
Use manual segment space management
Manage extents and Oracle blocks
Ensuring effective use of space
Determine the high-water mark
Describe the use of Oracle Block parameters

Recover space from sparsely populated segments
Describe and detect chaining and migration of
Oracle blocks
Perform index reorganization
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
l
c
a
r
O
y
l
n
Practice 13
Throughout this practice Oracle Enterprise Manager can be used if desired. SQL Worksheet
can be used instead of SQL*Plus and there are many uses for the Oracle Enterprise Manager
console. (Solutions for Oracle Enterprise Manager can be found in Appendix B).
1. Connect using sys/oracle AS sysdba and query the tablespace_name and
extent_management columns of dba_tablespaces to determine which
tablespaces are locally managed and which are dictionary managed. Record which
tablespaces are dictionary managed.
2. Alter the hr user to have the tools tablespace as the default.
3. Examine the v$system_event view and note the total waits for the statistic
enqueue.
Note: On a production system you would be more likely to pick up the contention
through the Statspack report.
4. Also examine the v$enqueue_stat view for eq_type 'ST' to determine the
total_wait# for the ST enqueue, which is the space management enqueue.
5. Exit out of the SQL*Plus session and change the directory to
$HOME/STUDENT/LABS. Run the lab13_04.sh script (lab13_04.bat for
Enterprise Manager) from the operating system prompt. This script will log five users
onto the database simultaneously and then each user creates and drops tables. The
tables each have many extents. The script must be run from the
$HOME/STUDENT/LABS directory or it will fail.
y
l
n
O
e
s
U
6. Connect as system/oracle and again examine the v$enqueue_stat view for

eq_type 'ST' to determine if the value of total_wait# for the ST enqueue, which
is the space management enqueue.
I
A
Note: Record the difference in the number of waits for the ST enqueue for extent
management using a dictionary managed tablespace. This value is found by subtracting
the first wait value (from practice 13-04) from the second wait value (from practice 1306).
&
l
a
n
r
te
7. Create a new locally managed tablespace test, name the data file test01.dbf,
and place it in the $HOME/ORADATA/u06 directory. Set the size to 120 MB and a
uniform extent size of 20 KB.
n
I
e
l
c
a
8. Alter the default tablespace of the hr user to test.
r
O
Note: The same steps are covered again. This time you are looking for the number of
waits for the ST enqueue caused by locally managed tablespaces.
Practice 13 (continued)
9. Examine and record the initial total_wait# for 'ST' in the v$enqueue_stat
view.
10. Exit out of the SQL*Plus session and change directory to $HOME/STUDENT/LABS.
Run the script lab13_04.sh (lab13_04.bat for Enterprise Manager) from the
operating system prompt. This script will log five users onto the database
simultaneously and then each user creates and drops tables. The tables each have many
extents. The script must be run from the $HOME/STUDENT/LABS directory or it will
fail.
11. Again examine and record the final total_wait# for 'ST' in the
v$enqueue_stat view.
Note: Record the difference in the total_wait# for the ST enqueue for extent
management using a locally managed tablespace. This value is found by subtracting
the first wait value (from practice 13-09) from the second wait value (from practice 1311). Compare the two results for the different tablespaces. The locally managed
tablespace would be far less contentious with extent management because it is
managing the space within the tablespace itself.
y
l
n
12. Connect as the hr/hr user and run the $HOME/STUDENT/LABS/lab13_12.sql

script. This will create a similar table (new_emp) as the employees table but with
PCTFREE = 0. The table is then populated with data from the employees table.
O
e
s
U
13. Run analyze on the new_emp table and query the dba_tables view to determine
the value of chain_cnt for the new_emp table. Record this value.
I
A
14. Create an index called new_emp_name_idx on the last_name column of the

new_emp table. Place the index in the tablespace indx. Then confirm the index's
status in the user_indexes view.
&
l
a
15. Run the $HOME/STUDENT/LABS/lab13_15.sql script, which will update the

rows of the new_emp table. Analyze the new_emp table again and query the
user_tables view to get the new value of chain_cnt Record this value. Also
check the status of the new_emp_name_idx index.
n
r
te
n
I
e
16. Resolve the migration caused by the previous update, by using the ALTER TABLE
MOVE command. This will cause the index to become unusable and should be rebuilt
using the ALTER INDEX REBUILD command before reanalyzing the new_emp
table. Confirm that the migration has been resolved by querying chain_cnt column
in the user_tables view and confirm that the index is valid by querying the
user_indexes view.
r
O
l
c
a
Using Oracle Data Storage

Structures Efficiently
O
e
I
A
&
l
a
n
r
te
r
O
l
c
a
n
I
e
y
l
n
s
U
Objectives
After completing this lesson, you should be able to

do the following:
Compare and evaluate the different storage
structures
Examine different data access methods
Implement different partitioning methods
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
y
l
n
Data Storage Structures
Heap table
Cluster
Indexorganized
table
Organization by value
Heap
Clustered
Sorted
Partitioned
table
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
y
l
n
Selecting the Physical Structure
Factors affecting the selection:

Rows read in groups
SELECT or DML statements
Table size
Row size, row group, and block size
Small or large transactions
Using parallel queries to load or for SELECT
statements
O
e
y
l
n
s
U
Selecting the Physical Structure

The DBAs goal is to enable reads and writes to happen as fast as possible. To achieve this
goal, the following factors must be taken into account:
Rows Read in Groups: If the application uses rows in groups then you should
investigate storing the rows in clusters. Also, because clusters do not perform well with
high DML activity, you should look at the level of DML activity.
To distribute the workload among the disks and controllers, you should know which
tables will have a high number of reads and which tables will have a high number of
writes. Avoid having highly accessed tables on the same drive or controller.
Because queries can hit any portion of the table, look for specific hot spots. DML is
more likely to have the active extent as the hot spot.
Table Size: Consider using a separate tablespace for large tables. For very large
partitioned tables, multiple tablespaces can be used. This arrangement assists in
managing and distributing the workload evenly among disks.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Selecting the Physical Structure (continued)

Row Size, Row Groups, and Block Size
The Oracle9i database allows multiple block sizes within the same database; thus
tables that have a larger row size can have a larger block size. A larger block size can
also assist if the application uses full table scans or if the table is clustered.
Small or Large Transactions
Small transactions require less undo space to store rollback information. Larger
transactions require more undo space.
Larger transactions add more data, therefore more available free space is required
within the tablespace.
Parallel Queries
If large queries are occurring, you should investigate having multiple server processes
distribute the workload between them. Using multiple server processes to distribute the
table between disks and controllers will lessen contention and therefore enhance
performance.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Data Access Methods
To enhance performance, you can use the following

data access methods:
Clusters
Indexes
B-tree (normal or reverse key)
Bitmap
Function based
Index-organized tables
Materialized views
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
y
l
n
Clusters
ORD_NO
----101
102
102
102
101
101
PROD
QTY
------ -----A4102
20
A2091
11
G7830
20
N9587
26
A5675
19
W0824
10
ORD_NO
-----101
102
...
ORD_DT
CUST_CD
----------05-JAN-97
R01
07-JAN-97
N45
Cluster Key
(ORD_NO)
101 ORD_DT
CUST_CD
05-JAN-97
R01
PROD
QTY
A4102
20
A5675
19
W0824
10
102
ORD_DT
CUST_CD
07-JAN-97
N45
PROD
QTY
A2091
11
G7830
20
N9587
26
Unclustered orders and

order_item tables
Clustered orders and

order_item tables
O
e
y
l
n
s
U
Definition of Clusters
A cluster is a group of one or more tables that share the same data blocks because they share
common columns and are often used together in join queries. Storing tables in clusters offers
the DBA a method to denormalize data. Clusters are transparent to the end user and
programmer.
Performance Benefits of Clusters
Disk I/O is reduced and access time improved for joins of clustered tables.
Each cluster key value is stored only once for all the rows of the same key value; it
therefore uses less storage space.
Performance Consideration
Full table scans are generally slower on clustered tables than on nonclustered tables.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Cluster Types
Index cluster
Hash cluster
Hash function
O
e
y
l
n
s
U
Cluster Types
Index Clusters
An index cluster uses an index, known as the cluster index, to maintain the data within the
cluster. The cluster index must be available to store, access, or maintain data in an index
cluster.
The cluster index is used to point to the block that contains the rows with a given key value.
The structure of a cluster index is similar to that of a normal index.
Although a normal index does not store null key values, cluster indexes store null keys.
There is only one entry for each key value in the cluster index. Therefore, a cluster index is
likely to be smaller than a normal index on the same set of key values.
Hash Clusters
A hash cluster uses a hash algorithm (either user-defined or system-generated) to calculate
the location of a row, both for retrieval and for DML operations.
For equality searches that use the cluster key, a hash cluster can provide greater performance
gains than an index cluster, because there is only one segment to scan (no index access is
needed).
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Situations Where Clusters Are Useful
Criterion
Index
Hash
Uniform key distribution

Evenly distributed key values
Rarely updated key
Often joined master-detail tables
Predictable number of key values
Queries using equality predicate on key
O
e
y
l
n
s
U
Situations Where Clusters Are Useful

When Not to Use Clusters
If a full scan is executed often on one of the clustered tables: This table is stored on
more blocks than if it had been created alone.
If the data for all rows of a cluster key value exceeds one or two Oracle blocks: To
access an individual row in a clustered key table, the Oracle server reads all blocks
containing rows with the same value.
When Not to Use Hash Clusters
If the table is constantly growing and if it is impractical to rebuild a new, larger hash
cluster.
If your application often performs full table scans and you must allocate a great deal of
space to the hash cluster in anticipation of the table growing.
Hash and index clusters require a lot of planning before being used. There may be more
performance overhead involved for major operations like bulk (direct path) inserts and
rebuilds.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Partitioning Methods
The following partitioning methods are available:

Range
Hash
List
Composite
Range
partitioning
Hash
partitioning
List
partitioning
Composite
partitioning
O
e
y
l
n
s
U
Partitioning Methods
A major driving force for supporting partitioned tables and indexes is the dramatic increase
in the size of these database objects. This capability reduces down time (because of
scheduled maintenance or data failures), improves performance through partition pruning,
and improves manageability and ease of configuration.
Range Partitioning
Range partitioning uses ranges of column values to map rows to partitions. Partitioning by
range is well suited for historical databases. However, it is not always possible to know
beforehand how much data will map to a given range and in some cases sizes of partitions
may differ quite substantially, resulting in sub-optimal performance for certain operations
like parallel DML.
Hash Partitioning
This method uses a hash function on the partitioning columns to stripe data into partitions. It
controls the physical placement of data across a fixed number of partitions and gives you a
highly tunable method of data placement.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Partitioning Methods (continued)

List Partitioning
The list method allows explicit control over how rows map to partitions. This is done by
specifying a list of discrete values for the partitioning column in the description for each
partition.
List partitioning is different from range partitioning where a range of values is associated
with a partition, and from hash partitioning where the user has no control of the row-topartition mapping. This partitioning method allows the modeling of data-distributions that
follow discrete values and are not ordered. The sets of data can be unrelated. These can be
grouped and organized together very naturally by using list partitioning.
Composite Partitioning
This method partitions data by using a combination of the three types of partitioning. This
type of partitioning supports historical operations data at the partition level and parallelism
(parallel DML) and data placement at the subpartition level.
The following two types of composite partitioning are allowed:
Range-Hash Composite Partitioning: First the table is partitioned according to the
range method and then, each partition is further subpartition by using the hash method.
Range-List Composite Partitioning: First the table is partitioned according to the
range method and then, each partition is further subpartition by using the list method.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Range Partitioning Example
CREATE TABLE sales

(acct_no
NUMBER(5),
person
VARCHAR2(30),
sales_amount NUMBER(8),
1
week_no
NUMBER(2))
3
PARTITION BY RANGE (week_no) 2
(PARTITION P1 VALUES LESS THAN (4) TABLESPACE data0,
PARTITION P2 VALUES LESS THAN (8) TABLESPACE data1,
...
PARTITION P13 VALUES LESS THAN (53)TABLESPACE data12
);
The partition key is week_no.

2 VALUES LESS THAN must be specified as a literal.
3 Physical attributes can be set per partition.
1
O
e
y
l
n
s
U
Range Partitioning Example

Range partitioning maps rows to partitions based on ranges of column values. The partition
key can be a composite key of up to 16 columns. In each partition, all rows have partition
keys that are less than the partition bound for that partition. You cannot have gaps in the
ranges; for example, 13, 56, 810 is not allowed.
In the VALUES LESS THAN specification, you must either use a literal, the TO_DATE, or
the RPAD function with constant arguments. If a table or index is partitioned on a column
that has the DATE data type, you must specify the century with the year in the TO_DATE
format mask or in the NLS format mask. The NLS date format is determined implicitly by
NLS_TERRITORY or explicitly by NLS_DATE_FORMAT.
If you attempt to insert a row into a table such as the sales table example in the slide and
the rows partitioning key binary value is greater than or equal to the highest partition bound
in the table, the insert fails with the ORA-14400 error message.
To avoid this, use MAXVALUE as the highest bound of the last partition to allow for all
possible values to be inserted including NULL which is greater than any other value except
MAXVALUE.
Note: Partitioned tables support any data types except LONG and LONG RAW. You can
specify up to 64K-1 partitions.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Hash Partitioning Overview
Easy to Implement
Enables better performance for PDML and
partition-wise joins
Inserts rows into partitions automatically based on
the hash of the partition key
Supports (hash) local indexes
Does not support (hash) global indexes
O
e
y
l
n
s
U
Hash Partitioning Concept

Although range partitioning is interesting for historical databases, it may not be the best
choice for other purposes. Hash partitioning is a partitioning method introduced in the
Oracle8i database release that uses a hash function on the partitioning columns to stripe data
into partitions. Hash partitioning enables data to be easily partitioned for performance
reasons such as parallel DML when sizes of range partitions would differ substantially.
Due to internal algorithms, the number of partitions should be a power of two (2, 4, 8, and so
on) to obtain the most even data distribution.
Cardinality is important for the partition keys choice. The partition key should be unique or
near unique.
The other consideration for choosing the partition key is the application. Hash partitioning
can improve the performance of single-key lookups, but it does not improve range lookups.
More importantly, hash partitioning can enable partition-wise joins and this should be the
primary performance consideration when choosing a hash-partition key.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
List Partitioning Example

SQL> CREATE TABLE locations
2
(location_id, street_address,
3
postal_code, city, state_province,
4
country_id)
5
STORAGE(INITIAL 10K NEXT 20K)
6
TABLESPACE users
7
PARTITION BY LIST (state_province)
8
(PARTITION region_east
9
VALUES('MA','NY','CT','ME','MD'),
10
PARTITION region_west
11
VALUES('CA','AZ','NM','OR','WA'),
12
PARTITION region_south
13
VALUES('TX','KY','TN','LA','MS'),
14
PARTITION region_central
15
VALUES('OH','ND','SD','MO','IL'));
O
e
y
l
n
s
U
List Partitioning Example

The details of list partitioning can best be described with an example. In this case you want
to partition the locations table by region; that is, you want to group states together
according to their geographical location.
A row is mapped to a partition by checking whether the value of the partitioning column for
a row falls within the set of values that describes the partition.
For example, the following rows will be inserted as follows:
(1500,'2011 Interiors Blvd', '99236','South San Francisco', 'CA', 'US') maps to partition
region_west.
(5000,'Chemin de la Fanee','13840','ROGNES','BR','FR') will not map to any partitions
in the table and thus will fail with an ORA-14400 error. This partitioning method is
useful when the partitioning column consists of bounded set of discrete values.
The partitions can be specified with physical attributes that will override the table-level
defaults. Any partition with unspecified attributes inherits their physical attributes from the
table-level defaults.
Note: For formatting reasons, the column data types are not specified and neither is the
complete list of States present. Refer to the Oracle9i Sample Schema definition for complete
details.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Default Partition for List Partitioning
Create a DEFAULT list partition for all values not

covered by other partitions:
CREATE TABLE customer
...
PARTITION BY LIST (state)
(PARTITION p1 VALUES ('CA','CO'),
PARTITION p2 VALUES ('FL','TX'),
PARTITION p3 VALUES (DEFAULT)
);
y
l
n
O
e
s
U
Default Partition for List Partitioning

List partitioning allows the specification of a default partition. Adding this partition provides
a catch-all partition for rows that are not allocated to a partition. In concept, setting a
DEFAULT value for a list partition is similar to setting a MAXVALUE value for a partition in
range partitioning.
As an example, in the table shown in the slide, if an entry has the value of 'NY' for the
state, then the entry would be allocated to partition p3, the default one.
Adding a New Partition
If a table has a default partition then the table cannot have a new partition added to it; the
Oracle9i database will report an error if this occurs. To add a partition it is required to split
the default partition. When splitting the default partition, the Oracle9i database ensures that
any rows matching the values of the new partition are moved.
To split the default partition use:
I
A
&
l
a
n
r
te
n
I
e
l
c
a
r
O
SQL> ALTER TABLE customer

2 SPLIT PARTITION p3 VALUES ('ND','SD')
3 INTO (PARTITION p3, PARTITION p4);
This command will split the default partition into two partitions, p3 with values ND and
SD and p4 as the new default partition holding all values not covered by any partition.
Composite Partitioned Table Overview
Ideal for both historical data and data placement

Provides high availability and manageability, like
range partitioning
Improves performance for parallel DML and
supports partition-wise joins
Allows more granular
partition elimination
Supports composite local indexes
Does not support composite
global indexes
O
e
y
l
n
s
U
Composite Partitioned Tables

There is a need for partitioning methods that are both well suited for historical data and
simplifies management for support of parallelism. One method is composite partitioning.
Under composite partitioning, an object consists of one or more partitions each of which in
turn consists of one or more subpartitions.
The Oracle server supports two types of composite partitioning:
Range-Hash partitioning
Range-List partitioning
Partitions (not subpartitions) using the composite partitioning method have a logical
meaning defined by their partition bounds but no physical presence, because all data mapped
to a partition resides in segments of subpartitions associated with it.
This type of partitioning supports historical operations data at the partition level and
parallelism (PDML) and data placement at the subpartition level.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Partitioned Indexes for Scalable Access

Global
Nonpartitioned index
Global Partitioned Index
Table
partition
Table
partition
Table
partition
Table
partition
y
l
n
Local partitioned index
O
e
s
U
Partitioned Indexes for Scalable Access

Prefixed Partitioned Indexes
An index is prefixed if it is partitioned on the left prefix of the index columns. Prefixed
indexes can be unique or non-unique.
Non-prefixed Partitioned Indexes
An index is non-prefixed if it is not partitioned on a left prefix of the index columns.
Non-prefixed indexes can be unique only if their partitioning key is a subset of the index
key.
Local Partitioned Indexes
In a local index, all keys in a particular index fragment refer only to rows stored in a single
underlying table fragment. Specifying the LOCAL attribute creates a local index. The Oracle
server constructs the local index so that it is equipartitioned with the underlying table. To
ensure that the index remains equipartitioned with the table, the Oracle server also maintains
the index partitioning automatically when partitions in the underlying table are added,
dropped, merged, or split or when hash partitions or subpartitions are added or coalesced.
A bitmap index on a partitioned table must be a local index.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Partitioned Indexes for Scalable Access (continued)

Global Partitioned Indexes
In a global partitioned index, the keys in a particular index partition may refer to rows stored
in more than one underlying table partition or subpartition. A global index can only be
range-partitioned, but it can be defined on any type of partitioned table. Specifying the
GLOBAL attribute creates a global index. The highest partition bound of a global index must
be MAXVALUE. This insures that all rows in the underlying table can be represented in the
index.
The database administrator is responsible for defining the initial partitioning of a global
index at creation and for maintaining the partitioning over time. Index partitions can be
merged or split as necessary.
A global index can be equipartitioned with the underlying table, but the Oracle server does
not take advantage of the equipartitioning when generating query plans or executing
partition maintenance operations. An index that is equipartitioned with the underlying table
should be created as LOCAL.
Non-prefixed global indexes are not supported because they have no application in reality.
Nonpartitioned Indexes
Nonpartitioned indexes are treated as global prefixed non-partitioned indexes.
Guidelines for Partitioned Indexes
When deciding how to partition indexes on a table, consider the mix of applications that
need to access the table. There is a trade-off between performance on the one hand and
availability and manageability on the other. You should create local indexes on partitioned
tables unless there is a justified performance requirement for a global index. Most of the
maintenance operations on partitioned tables invalidate all global index partitions; this
implies a complete rebuild.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Partition Pruning
99-Jan
Partition pruning: Only the relevant

partitions are accessed.
99-Feb
SQL>
2
3
4
5
6
7
99-Mar
99-Apr
99-May
99-Jun
SELECT SUM(sales_amount)
FROM sales
WHERE sales_date BETWEEN
TO_DATE(01-MAR-1999,
DD-MON-YYYY) AND
TO_DATE(31-MAY-1999,
DD-MON-YYYY);
y
l
n
sales
O
e
s
U
Partition Pruning
Depending on the SQL statement, the Oracle server can explicitly recognize partitions and
subpartitions (of tables and indexes) that need to be accessed and the ones that can be
eliminated. This optimization is called partition pruning. This can result in substantial
improvements in query performance. However, the optimizer cannot prune partitions if the
SQL statement applies a function to the partitioning column.
If you partition the index and table on different columns (with a global, partitioned index),
partition pruning also eliminates index partitions even when the underlying tables partitions
cannot be eliminated. However, the optimizer cannot use an index if the SQL statement
applies a function to the indexed column, unless it is a function-based index.
The Oracle server considers only the relevant partitions for such predicates as c in (10,30) or
c=10 or c=30
For hash partitioning, partition pruning is limited to using equality or IN-list predicates.
The optimizer can also performs partition pruning when subquery predicates are used.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Partition-Wise Join
3
1
Full partition-wise join
Nonpartition-wise join
Partial partition-wise join

Query slave
Partitioned table
Partition
O
e
y
l
n
s
U
Partition-Wise Joins
Partition-wise joins minimize the amount of data exchanged among parallel slaves during
parallel joins execution by taking into account data distribution. This significantly reduces
response time and resource utilization, both in terms of CPU and memory. In Oracle Parallel
Server environments the data traffic over the interconnect (if the relevant partitions are colocated) can limit the performance of massive join operations.
Full Partition-Wise Join
A full partition-wise join is a join performed on two tables that are equipartitioned in
advance on their join keys. The Oracle server performs the joins sequentially if the query is
executed serially or in parallel if a separate query slave joins each pair. The Oracle server
can join the results of each parallel scan without the need to redistribute data. The number of
partitions limits partition-wise joins.
Note: The Oracle server supports partition-wise joins on range, hash, composite, or list
partitioned tables.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Partition-Wise Joins (continued)

Partial Partition-Wise Join
A partial partition-wise join is a join that can be performed on two tables when only one of
the tables is partitioned on their join keys. Other must be dynamically repartitioned to meet
the partitioning scheme of the first one. It is implemented only when joins are run in
parallel.
Example
Consider the following typical query: Find the records of all customers who bought more
than 100 articles in quarter 3 of 1994.
SQL>
2
3
4
5
6
7
SELECT c_customer_name, COUNT (*)

FROM sales, customer
WHERE s_customerid = c_customerid
AND s_saledate
BETWEEN TO_DATE (01-jul-1994, DD-MON-YYYY)
AND TO_DATE (01-oct-1994, DD-MON-YYYY)
GROUP BY c_customer_name HAVING COUNT (*) > 100;
Suppose that the optimizer uses a hash join in this case. You can reduce the processing time
for this join if both tables are partitioned correctly because this enables a partition-wise join.
Multiple partitioning methods can be used, but not all of them activate the partition-wise
join:
Hash-Hash: The customer and sales tables are equipartitioned by hash on
s_customerid and c_customerid respectively. In this case, the technique used
by the Oracle server to make this join parallel is number 3 in the partition-wise join
slide. This is the most efficient. It can become even better in a cluster or MPP
environment if each corresponding hash-partition is co-located (placed on the same
local disk).
Composite-Hash: The sales table is partitioned by range on s_saledate (each
partition representing a quarter) and subpartitioned by hash on s_customerid. The
customer table is partitioned by hash on c_customerid so that both tables are
equipartitioned on the hash dimension. In this case, because the pruning on the sales
table restricts the scan to the subpartitions corresponding to quarter 3 of 1994, the same
technique as in the previous example can be used.
Range-Hash: However, if the sales table is partitioned by range on s_saledate
and the customer table is partitioned by hash on c_customerid, then the
technique used by the Oracle server in this case is number 2 in the partition-wise join
slide. Only a partial partition-wise join can be used.
Range-Range: If both tables are range partitioned, then the only available technique is
number 1 in the partition-wise join slide. This is probably the worst case.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Statistics Collection for

Partitioned Objects
You can gather object-, partition-, or subpartition

level statistics.
There are GLOBAL or NON-GLOBAL statistics.
The dbms_stats package can gather global
statistics at any level for tables only.
It is not possible to gather:
Global histograms
Global statistics for indexes
O
e
y
l
n
s
U
Cost-Based Optimization and Partitioned Objects Statistics

Statistics can be gathered by partition or subpartition by using the dbms_stats package.
The cost-based optimizer is always used for SQL statement accessing partitioned tables or
indexes.
For partitioned objects, the Oracle server maintains separate sets of statistics: at the object
level, the partition level and the subpartition level. If a SQL statement accesses only one
fragment, then the Oracle server uses the fragment levels statistics. If a SQL statement
accesses multiple fragments, the Oracle server uses a single access path for all of these
fragments and uses the statistics from the next higher level. (Here, a fragment can be a
subpartition or a partition of a non-composite object; subpartition is considered the lowest
level, partition is the next level, and object is the last.)
The dbms_stats package always collects global statistics (except histograms and
indexes) at any level and never merges them. Global statistics are obtained by considering
multiple fragments as only one.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Some dbms_stats Examples
CALL dbms_stats.gather_table_stats (
ownname => o901,
tabname => sales,
partname => feb99,
granularity => partition);
CALL dbms_stats.gather_index_stats (
ownname => o901,
indname => isales,
partname => s1);
O
e
The dbms_stats.gather_table_stats Procedure
y
l
n
s
U
The following is a list of some important arguments of this procedure:

OWNNAME: Schema of table to analyze
TABNAME: Name of table
PARTNAME: Name of partition or subpartition depending on granularity
METHOD_OPT: Equivalent to the FOR clause of the ANALYZE command for
histograms
DEGREE: Degree of parallelism (NULL means use table default value.)
GRANULARITY: Granularity of statistics to collect (pertinent for partitioned tables)
- Default: Gather table- and partition-level statistics
- Subpartition: Gather subpartition-level statistics
- Partition: Gather partition-level statistics
- Global: Gather object-level statistics
- All: Gather all (subpartition-, partition-, and object-level) statistics
CASCADE: Gather statistics on the indexes for this table. Index statistics gathering is
not made parallel.
Note: Except for indexes and histograms, gathered statistics are always global.
For a complete description of the dbms_stats package refer to the Oracle9i Supplied
PL/SQL Packages and Types Reference Release 2 (9.2) manual part number A96612-01.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
The dbms_stats.gather_index_stats Procedure

This procedure gathers index statistics. It is equivalent to running ANALYZE INDEX. It
does not execute in parallel:
OWNNAME: Schema of index to analyze
INDNAME: Name of index
PARTNAME: Name of partition or subpartition
ESTIMATE_PERCENT: Percentage of rows to estimate (NULL means compute.)
STATTAB: User statistics table identifier describing where to save the original
statistics
STATID: Identifier (optional) to associate with these statistics within stattab
STATOWN: Schema containing stattab (if different than ownname)
Note: The last four parameters are also available with the
dbms_stats.gather_table_stats procedure.
There are two other procedures that can also be used:
gather_schema_stats
This procedure gathers statistics for all objects in a schema.
gather_database_stats
This procedure gathers statistics for all objects in the database.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Summary
In this lesson, you should have learned how to do the

following:
Compare and evaluate the different storage
structures
Examine different data access methods
Implement different partitioning methods
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
l
c
a
r
O
y
l
n
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Application Tuning
O
e
I
A
&
l
a
n
r
te
r
O
l
c
a
n
I
e
y
l
n
s
U
Objectives

the following:
Explain the role of the DBA in tuning applications
Move tables using the ALTER TABLE command
Redefine a table online

Create different types of indexes
Build and manage index-organized tables
Explain and plan OLTP, DSS, and hybrid systems
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
y
l
n
The Role of the Database Administrator
Application tuning is the most important part of

tuning.
DBAs are not always directly involved in
application tuning.
However, DBAs must be familiar with the impact
that poorly written SQL statements can have upon
database performance.
O
e
y
l
n
s
U
Database Administrator Tasks

Application design and application tuning provide the greatest performance benefits.
However, the method in which data is selected and the amount of data that is selected has
serious implications for application performance if the statements that execute those
operations are not properly written.
As a database administrator (DBA), you are not always directly involved in the tuning of an
application; application developers are often responsible for developing applications and
writing SQL statements. However, as a DBA you must be aware of the impact that poorly
written SQL statements can have on the database environment. You should be able to
provide assistance with application tuning and identify inefficient SQL statements. You
should also be aware of optimizer plan stability, implemented through stored outlines and
query rewrites using materialized views and dimensions.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Moving Tables Using ALTER TABLE
Tables can be moved using the ALTER TABLE

command. This allows:
Privileges and constraints to be kept
The table structure to be changed
Movement to another tablespace
The command to be parallelized
SQL> ALTER TABLE hr.employees
2 MOVE
3 TABLESPACE users;
O
e
Moving Tables Using ALTER TABLE
I
A
y
l
n
s
U
Tables can be moved by:

Using export and import: The problem with this method is that for a period of time the
table is unavailable to users and the table must be dropped from the database before
the import starts.
Using the CREATE TABLE AS SELECT command: This command will copy
across to the new table all the data, but the constraints, triggers, and so on will not be
transferred to the new table.
Using the ALTER TABLE MOVE command to move the table can:
- Move the table
- Keep the constraints, triggers, and so on valid
- Move the table using parallelization
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Redefining a Table Online
Online table redefinition enables you to:

Modify the storage parameters of the table
Move the table to a different tablespace in the
same schema
Add support for parallel queries
Add or drop partitioning support
Re-create the table to reduce fragmentation
Change the organization of a normal table (heap
organized) to an index-organized table and
vice versa
Add or drop a column
y
l
n
O
e
s
U
Redefining a Table Online

Use the dbms_redefinition package to redefine a table online. This package will
redefine a table without taking the table offline, except for a short period that is not
determined by the size of the table.
In addition to having execute privileges on the dbms_redefinition package, you also
require the following privileges:
CREATE ANY TABLE
ALTER ANY TABLE
DROP ANY TABLE
LOCK ANY TABLE
SELECT ANY TABLE
I
A
&
l
a
n
r
te
n
I
e
To perform an online redefinition of a table you must perform the following steps:
1. Choose one of the following two methods of redefinition:
- Use the primary keys to perform the redefinition. This is the default and preferred
method. The pre-redefinition and the post-redefinition versions of the tables have
the same primary key columns.
- Use the rowids. This method is used if the primary key method cannot be used.
Index-organized tables should not be redefined with this method.
r
O
l
c
a
Redefining a Table Online (continued)

2. Use the dbms_redefinition.can_redef_table() procedure to verify that
the table can be redefined online using the redefining method selected.
3. Create an empty interim table (in the same schema as the table to be redefined) with all
of the desired attributes. This table must contain the redefined columns, triggers,
indexes, grants and constraints. Any referential constraints involving the interim table
must be created disabled.
4. Start the redefinition process by calling the
dbms_redefinition.start_redef_table() procedure, providing the
following information:
- The table to be redefined
- The interim table name
- The column mapping
List the columns that are to be included in the interim table. If the column
mapping information is not supplied, then it is assumed all the columns (with
their names unchanged) are to be included in the interim table.
- The method of redefinition
5. Execute the dbms_redefinition.finish_redef_table() procedure to
complete the redefinition of the table. This procedure performs the following tasks:
- The original table is redefined such that it has all the attributes, indexes,
constraints, grants and triggers of the interim table
- The referential constraints involving the interim table now involve the postredefined table and are enabled.
- Optionally, rename any indexes, triggers, and constraints that were created on the
interim table and that are now defined on the redefined table. If the redefinition
was done using rowids, then the post-redefined table will have a hidden
column (m_row$$). It is recommended that this column be labeled as unused
and then dropped.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
B-Tree Indexes
Index entry
Root
Branch
Index entry header

Key column length
Key column value
Row ID
Leaf
O
e
y
l
n
s
U
B-Tree Indexes
When to Create B-Tree Indexes
B-tree indexes typically improve the performance of queries that select a small percentage
of rows from a table. As a general guideline, you should create indexes on tables that are
often queried for less than 5% of the tables rows. If you select 5% or more of the data it
may mean visiting just about every portion of the table anyway, making it less efficient than
a full scan. On the other hand, an index can be used to eliminate a potentially expensive sort
when many rows are selected, if all data can be retrieved from an index, or where the
indexed columns can be used for joining to other tables.
How Indexes Grow
Indexes are always balanced and they grow from the bottom up. As rows are added, the leaf
block fills. When the leaf block is full, the Oracle server splits it into two blocks and puts
50% of the blocks contents into the original leaf block and 50% into a new leaf block.
If another block is added to the index, this newly added block must be added to the directory
entry in the parent branch block. If this parent branch block is full, the parent branch block is
split in a similar way to the leaf block, with 50% of the existing contents being divided
between the existing and new branch blocks. If required, this pattern is repeated until the
place where the root block becomes a branch block and a new root block is added.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Rebuilding Indexes
To assist in the rebuilding of indexes use:

ONLINE: Keeps the index available during the
rebuild operation
COMPUTE STATISTICS: Collects the statistics
while rebuilding the index
y
l
n
O
e
s
U
Rebuilding Indexes
The more levels an index has, the less efficient it may be. Additionally, an index with many
rows deleted might not be efficient. Typically, if 15% of the index data is deleted, then you
should consider rebuilding the index.
You should rebuild your indexes regularly. However, this can be a time-consuming task,
especially if the base table is very large. In the Oracle database, you can create and rebuild
indexes online. Parallelization is possible as well. While the index is being rebuilt, the
associated base table remains available for queries and DML operations.
I
A
&
l
a
n
r
te
SQL> ALTER INDEX i_name REBUILD ONLINE;
The ONLINE keyword specifies that DML operations on the table or partition be allowed
during rebuilding of the index.
Restriction: Parallel DML is not supported during online index building. If you specify
ONLINE and then issue parallel DML statements, an error is returned.
n
I
e
l
c
a
r
O
You can also compute statistics for the cost-based optimizer while rebuilding the index.
Adding the compute statistics procedure has very little effect on the performance of the
rebuild because the entire index is being accessed anyway. The command is:
SQL> ALTER INDEX I_name REBUILD COMPUTE STATISTICS;
You can combine the ONLINE and COMPUTE STATISTICS clauses into one statement.
Compressed Indexes
When creating the index:

SQL>
2
3
4
CREATE INDEX emp_last_name_idx

ON hr.employees
(last_name, first_name)
COMPRESS;
When rebuilding the index:

SQL> ALTER INDEX emp_last_name_idx
2 REBUILD COMPRESS;
Specify NOCOMPRESS (the default) to disable key

compression.
O
e
y
l
n
s
U
Key Compression
Specify COMPRESS to enable key compression, which eliminates the repeated occurrence of
key column values and may substantially reduce storage. Use an integer to specify the prefix
length (the number of prefix columns to compress).
For unique indexes, the valid range of prefix length values is from 1 to the number of key
columns minus 1 (the default value). In a unique index with a single attribute key, key
compression is not possible due to the unique piece there are no grouping pieces to share.
For nonunique indexes, the valid range of prefix length values is from 1 to the number of
key columns. The default prefix length is the number of key columns.
Key compression is useful in many different scenarios, such as:
In a nonunique regular index, the Oracle database stores duplicate keys with the
rowid appended to the key to break the duplicate rows. If key compression is used,
then the duplicate key is stored as a prefix entry on the index block without the
rowid. The rest of the rows are suffix entries that consist of only the rowid.
This same behavior can be seen in a unique index that has a key of the form (item,
time stamp), for example, stock_ticker or transaction_time.
Thousands of rows can have the same stock_ticker value, with
transaction_time preserving uniqueness.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Bitmap Indexes
File 3
Table
Block 10
Block 11
Block 12
Index
Block 13
Start
End
Key ROWID ROWID
Bitmap
<Blue, 10.0.3, 12.8.3, 1000100100010010100>

<Green, 10.0.3, 12.8.3, 0001010000100100000>
<Red, 10.0.3, 12.8.3, 0100000011000001001>
<Yellow, 10.0.3, 12.8.3, 0010001000001000010>
O
e
y
l
n
s
U
Bitmap Indexes
With bitmap indexes, you can store data that has few distinct values within the column, such
as gender or job_title. The index consists of a range of rows stored in the index and
then a map of binary values for each key. The value is on, that is 1, if the key is true for
that row. In the example on the slide, the value in the bitmap is on for only one color. If the
row item is blue, then the value is a 1 for blue and 0 for all other combinations.
Bitmap indexes perform best when there are few variations for the value, but millions of
rows. Bitmap indexes also help resolve Boolean type constraints; for example, if the user
requires all items that are blue and yellow or if the green or red items are wanted.
DML statements do not perform well with bitmap indexes, so for high DML activity, do not
use a bitmap index.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Bitmap Indexes
Used for low-cardinality columns

Good for multiple predicates
Uses minimal storage space
Best for read-only systems
Good for very large tables
y
l
n
O
e
s
U
Bitmap Indexes
When to Create Bitmapped Indexes
Bitmap indexes are intended for low-cardinality columns that contain a limited number
of values.
If you use a query with multiple WHERE conditions, the Oracle server can use logical
bit-AND or bit-OR operations to combine this bitmap with bitmaps for other columns.
I
A
&
l
a
Performance Considerations
Bitmap indexes use little storage space: one entry per distinct key value, stored in a
compressed form. Each bitmap is divided into bitmap segments (up to one-half block).
They work very fast with multiple predicates on low-cardinality columns.
They are particularly suited to large, read-only systems such as decision support
systems.
DML statements slow down performance:
- They are not suited for OLTP applications.
- Locking is at the bitmap-segment, not entry, level.
Bitmap indexes store null values, whereas B-tree indexes do not.
Parallel query, parallel data manipulation language (PDML), and parallelized CREATE
statements work with bitmap indexes.
n
r
te
n
I
e
r
O
l
c
a
Creating and Maintaining

Bitmap Indexes
SQL> CREATE BITMAP INDEX departments_idx
2
ON hr.departments(manager_id)
3
STORAGE
(INITIAL 200K NEXT 200K
4
PCTINCREASE 0 MAXEXTENTS 50)
5*
TABLESPACE indx;
O
e
y
l
n
s
U
Maintenance Considerations
In a data warehousing environment, data is usually maintained by way of bulk inserts and
updates. Index maintenance is deferred until the end of each DML operation. For example, if
you insert 1,000 rows, then the inserted rows are placed into a sort buffer and then the
updates of all 1,000 index entries are batched. Thus each bitmap segment is updated only
once per DML operation, even if more than one row in that segment changes.
In the Oracle database, there are different parameters affecting the sort area depending on
the value of WORKAREA_SIZE_POLICY. See the chapter titled Optimizing Sort
Operations for more details.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
B-Tree Indexes and Bitmap Indexes
B-Tree Indexes
Bitmap Indexes
Suitable for high-cardinality

columns
Suitable for low-cardinality

columns
Updates on keys relatively

inexpensive
Updates to key columns very

expensive
Inefficient for queries using

AND/OR predicates
Efficient for queries using

AND/OR predicates
Row-level locking
Bitmap segment-level locking
More storage
Less storage
Useful for OLTP
Useful for DSS
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
l
c
a
r
O
y
l
n
Reverse Key Index
KEY
----1257
2877
4567
6657
8967
9637
9947
...
ROWID
------------------0000000F.0002.0001
0000000F.0006.0001
0000000F.0004.0001
0000000F.0003.0001
0000000F.0005.0001
0000000F.0001.0001
0000000F.0000.0001
...
EMPLOYEE_ID
----------7499
7369
7521
7566
7654
7698
7782
... ...
Index on employee_id column
LAST_NAME ...
--------ALLEN
SMITH
WARD ...
JONES
MARTIN
BLAKE
CLARK
...
employees table
O
e
y
l
n
s
U
Reverse Key Index

Definition
Creating a reverse key index reverses the bytes of each column key value. In the case of a
composite key the column order is kept, but the bytes of each column are reversed.
When to Create Reverse Key Indexes
An ever-increasing key (such as sequential numbers for invoices, employee ids, or order
numbers) repetitively degrades the index height (BLEVEL statistic); you can avoid forced
block splits by spreading the index entries more evenly.
Disadvantage
When application statements specify ranges then the reverse key index cannot be used,
because the keys are not in sequential order. In this case the CBO will choose an explain
plan that uses a full table scan.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Creating Reverse Key Indexes
Create a reverse key unique index:

SQL>
2
3
4
5
CREATE UNIQUE INDEX i1_t1 ON t1(c1)

REVERSE PCTFREE 30
STORAGE(INITIAL 200K NEXT 200K
PCTINCREASE 0 MAXEXTENTS 50)
TABLESPACE indx;
Create a unique index, then alter the index to be

reverse key:
SQL> CREATE UNIQUE INDEX i2_t1 ON t1(c2);
SQL> ALTER INDEX i2_t1 REBUILD REVERSE;
O
e
s
U
Identifying Reverse Key Indexes

Use the following query to list the names of all reverse key indexes:
I
A
SQL> SELECT index_name, index_type

2 FROM dba_indexes
3 WHERE index_type like '%REV';
&
l
a
INDEX_NAME INDEX_TYPE
-------------------------I2_T1
NORMAL/REV
n
r
te
n
I
e
l
c
a
r
O
y
l
n
Oracle Enterprise Manager:

Index Management
O
e
y
l
n
s
U
Oracle Enterprise Manager: Index Management

Use the Oracle Enterprise Manager console to provide management for different objects
stored within the database. In the example shown in the slide the statistics collected for an
index are examined.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Index-Organized Tables
Regular table access
IOT access
ROWID
Non-key columns
Key column
y
l
n
Row header
O
e
s
U
Definition
An index-organized table is like a regular table with an index on one or more of its columns,
but instead of maintaining two separate segments for the table and the B-tree index, the
database system maintains one single B-tree structure that contains both the primary key
value and the other column values for the corresponding row.
For index-organized tables, a primary key constraint is mandatory.
Index-organized tables are suitable for frequent data access through the primary key or
through any key that is a prefix of the primary key, such as in applications that use inverted
indexes. An inverted index keeps the value and all its locations together; this meets the
requirement for the index-organized table having a primary key. Each word has one entry
and that entry records all the places in which the word occurs. This means that the index can
be used to re-create the entire document. Inverted indexes are used in Intermedia.
Benefits
No duplication of the values for the primary key column (index and table columns in
indexed tables), therefore less storage is required.
Faster key-based access for queries that involve an exact match, a range search, or
both.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
and Heap Tables
Compared to heap tables, IOTs have:

Faster key-based access to table data
Reduced storage requirements
Secondary indexes and logical rowids
IOTs have the following restrictions:

Must have a primary key
Cannot be clustered
O
e
y
l
n
s
U
Logical rowids
Index-organized tables do not have regular (physical) rowids. However, the concept of
logical rowids was introduced to overcome certain restrictions caused by the lack of
physical rowids. Logical rowids give the fastest possible access to rows in IOTs by
using two methods:
A physical guess whose access time is equal to that of physical rowids
Access without the guess (or after an incorrect guess); this performs a primary key
access of the IOT
The guess is based on knowledge of the file and block that a row resides in. The latter
information is accurate when the index is created, but changes if the leaf block splits. If the
guess is wrong and the row no longer resides in the specified block, then the remaining
portion of the logical rowid entry, the primary key, is used to get the row.
Logical rowids are stored as a variable-length field, where the size depends on the primary
key value being stored.
The UROWID data type enables applications to use logical rowids in the same way they
use rowids, for example, selecting rowids for later update or as part of a cursor.
UROWID can also be used to store rowids from other databases, accessed by way of
gateways. The UROWID type can also be used to reference physical rowids.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Creating Index-Organized Tables

SQL> CREATE TABLE country
2
( country_id
CHAR(2)
3
CONSTRAINT country_id_nn NOT NULL,
4
country_name
VARCHAR2(40),
5
currency_name
VARCHAR2(25),
6
currency_symbol VARCHAR2(3),
7
map
BLOB,
8
flag
BLOB,
9
CONSTRAINT country_c_id_pk
10
PRIMARY KEY (country_id))
11
ORGANIZATION INDEX
12
TABLESPACE indx
13
PCTTHRESHOLD 20
14
OVERFLOW TABLESPACE users;
y
l
n
O
e
s
U
Creating Index-Organized Tables

Regular B-tree index entries are usually small. They consist of only the primary key value
and a rowid value for each row. Many of these small index entries can be stored in a leaf
block. This is not necessarily the case for index-organized tables because they store full
rows or at least as much as fits without exceeding the limit set by PCTTHRESHOLD.
I
A
&
l
a
Storing large entries in index leaf blocks slows down index searches and scans. You can
specify that the rows go into an overflow area by setting a threshold value that represents a
percentage of block size.
The primary key column must always be stored in the IOT index blocks as a basis for
searching. But you can place non-key values in a separate area, the row overflow area, so
that the B-tree itself remains densely clustered.
n
r
te
n
I
e
r
O
l
c
a
IOT Row Overflow

indx tablespace
users tablespace
Segment = COUNTRY_C_ID_PK
IOT_type = IOT
Segment_type = INDEX
Index_type = IOT - TOP
Segment = SYS_IOT_OVER_n
IOT_type = IOT_OVERFLOW
Segment_type = TABLE
Remaining part of the row
Rows within
y
l
n
PCTTHRESHOLD
O
e
IOT Row Overflow

The PCTTHRESHOLD Clause
I
A
s
U
This clause specifies the percentage of space reserved in the index block for an indexorganized table row. If a row exceeds the size calculated based on this value, all columns
after the column named in the INCLUDING clause are moved to the overflow segment. If
OVERFLOW is not specified, then rows exceeding the threshold are rejected.
PCTTHRESHOLD defaults to 50 and must be a value from 0 to 50.
The INCLUDING Clause
&
l
a
n
r
te
This clause specifies the column at which to divide an index-organized table row into index
and overflow portions. The server accommodates all non-key columns up to the column
specified in the INCLUDING clause in the index leaf block, provided it does not exceed the
specified threshold.
The OVERFLOW Clause and Segment
n
I
e
r
O
l
c
a
This clause affects the index-organized table data rows that exceed the threshold set. The
overflow data is placed in the data segment defined by the segments attributes, which
specify the tablespace, storage, and block utilization parameters.
Querying dba_tables for IOT Information
SQL> SELECT table_name, iot_name, iot_type

2 FROM
dba_tables;
TABLE_NAME
----------------COUNTRY
SYS_IOT_OVER_2268
IOT_NAME
-------COUNTRY
IOT_TYPE
-----------IOT
IOT_OVERFLOW
y
l
n
O
e
s
U
The dba_tables Dictionary View

The iot_type and iot_name columns of the dba_tables view provide information
about index-organized tables.
If there is no overflow area for an IOT, then there is only a single dictionary entry per IOT.
The value of iot_type is IOT and the iot_name field is blank.
I
A
&
l
a
If an overflow area has been specified, then its name appears as an additional new table in
the list of table names. The overflow table is called sys_iot_over_nnnn (where nnnn is
the object ID of the table segment) in dba_tables. The column iot_type is set to
IOT_Overflow for this table and iot_name is set to the name of the index-organized table
to which it belongs.
n
r
te
n
I
e
r
O
l
c
a
Querying dba_indexes
and dba_segments for IOT information
SQL> SELECT index_name, index_type,
2
tablespace_name, table_name
2 FROM dba_indexes;
INDEX_NAME
INDEX_TYPE TABLESPACE
--------------- ---------- ---------COUNTRY_C_ID_PK IOT - TOP
INDX
TABLE_NAME
---------COUNTRY
SQL> SELECT segment_name, tablespace_name,

2
segment_type
3 FROM dba_segments;
SEGMENT_NAME
TABLESPACE_NAME
SEGMENT_TYPE
-----------------------------------------SYS_IOT_OVER_2268
USER
TABLE
COUNTRY_C_ID_PK
INDX
INDEX
y
l
n
O
e
s
U
Querying dba_indexes and dba_segments for IOT information

The dba_indexes Dictionary View
The IOT table name listed is the same as that used in the CREATE TABLE command, but
an index name is also listed for the table, with a default name of sys_iot_top_nnnn.
I
A
The dba_segments Dictionary View

The name of the overflow segment is listed here with the same name as mentioned above,
sys_iot_top_nnnn. The table itself is listed as sys_iot_top_nnnn.
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Using a Mapping Table
SQL>
2
3
4
5
6
7
8
9
10
CREATE TABLE country

( country_id
CHAR(2)
CONSTRAINT country_id_nn NOT NULL
, country_name
VARCHAR2(40)
, currency_name
VARCHAR2(25)
, currency_symbol VARCHAR2(3)
, CONSTRAINT
country_c_id_pk
PRIMARY KEY (country_id))
ORGANIZATION INDEX
MAPPING TABLE TABLESPACE users;
y
l
n
O
e
s
U
Using a Mapping Table

The Oracle database allows a bitmap index to be built on an IOT, providing that there is a
mapping table, because the rowids of an IOT do not remain consistent.
I
A
A bitmap index on an IOT is similar to a bitmap index on a heap table, except that the
rowids used in the bitmap index on an IOT are those of a mapping table and not the base
table. The mapping table maintains a mapping of physical rowids (needed by the bitmap
index code) to logical rowids (needed to access the IOT). There is one mapping table per
IOT and it is used by all the bitmap indexes created on that IOT.
In a heap-organized base table, a bitmap index is accessed using a search key. If the key is
found, the bitmap entry is converted to a physical rowid used to access the base table. In an
IOT, a bitmap index is also accessed using a search key. If the key is found, the bitmap entry
is converted to a physical rowid used to access the mapping table. The access to the
mapping table yields a logical rowid. This logical rowid is used to access the IOT using
either the guess data block address (if it is valid) or the primary key. Though a bitmap index
on an IOT does not store logical rowids, it is still logical in nature.
&
l
a
n
r
te
n
I
e
r
O
l
c
a
The movement of rows in an IOT does not leave the bitmap indexes built on that IOT
unusable. The movement of rows in the IOT invalidates the guess data block address in
some of the mapping tables logical rowid entries, however the IOT can still be accessed
using the primary key.
Maintaining a Mapping Table
Collect statistics on a mapping table by analyzing

the IOT.
Query the dba_indexes view to determine the
percentage accuracy of the mapping table.
SQL> SELECT index_name, pct_direct_access
2 FROM dba_indexes
3 WHERE pct_direct_access IS NOT NULL;
Rebuild the mapping table if required, using the

ALTER TABLE command.
Use the MINIMIZE RECORDS_PER_BLOCK clause of
ALTER TABLE for the mapping table.
y
l
n
O
e
s
U
Maintaining a Mapping Table

Examine the column pct_direct_access column of the dba_indexes view. The
value in this column is an indication of the percentage of rows with a valid guess for a
secondary index on an IOT. This column is populated when the IOT is analyzed.
To rebuild the mapping table the mapping table needs to be dropped and recreated. The
following command will drop the mapping table associated with the countries table:
I
A
&
l
a
SQL> ALTER TABLE countries MOVE NOMAPPING;
n
r
te
Note: To drop a mapping table there must be no bitmap indexes on the IOT.
To create a mapping table on the countries IOT use the command:
n
I
e
SQL> ALTER TABLE countries MOVE MAPPING TABLE;
The recommendation is to use the MINIMIZE RECORDS_PER_BLOCK parameter on

mapping tables that are heavily indexed with bitmap indexes. When enabled the Oracle
database restricts the number of records in any block of the mapping table to the maximum
number of records in any block of the indexed table. This enables the bitmap index to
allocate fewer bits per block and results in smaller bitmap indexes.
The NOMINIMIZE RECORDS_PER_BLOCK clause disables this optimization.
r
O
l
c
a
The ANALYZE Statement
Use the ANALYZE statement to:

VALIDATE STRUCTURE
LIST CHAINED ROWS
Collect statistics not used by the optimizer, such

as information on free list blocks
Sample a number (instead of a percentage) of
rows
SQL> ANALYZE TABLE hr.employees VALIDATE STRUCTURE;
O
e
y
l
n
s
U
The ANALYZE Statement

The ANALYZE statement is the predecessor of the dbms_stats package and can be used
to collect similar information. The dbms_stats package is superior and is thus the
recommended method of collecting statistics. However, the following cannot be collected
using the dbms_stats package:
To use the VALIDATE or LIST CHAINED ROWS clauses
To sample a number (rather than a percentage) of rows
To collect statistics not used by the optimizer (such as information on free list blocks)
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a

Collect Statistics
O
e
y
l
n
s
U
Oracle Enterprise Manager: Collect Statistics

By selecting Analyze in the Oracle Enterprise Manager console the DBA can collect
statistics on various objects. There is also the option to use the dbms_stats package
(recommended) or ANALYZE.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
OLTP Systems
High-throughput, insert- and update-intensive

Large, continuously growing data volume
Concurrent access by many users
Tuning goals:
Availability
Speed
Concurrency
Recoverability
O
e
OLTP Systems
Typical OLTP Applications
Airline reservation systems
Large order-entry applications
Banking applications
Requirements
High availability (7 days a week/24 hours a day)
High speed
High concurrency
Reduced time recovery
&
l
a
I
A
s
U
n
r
te
n
I
e
l
c
a
r
O
y
l
n
OLTP Requirements
Explicit extent allocation

Indexes:
Not too many (B-tree better than bitmap)
Reverse key for sequence columns
Rebuilt regularly
Clusters for tables in join queries:

Index clusters for growing tables
Hash clusters for stable tables
Materialized views
Index-organized tables
O
e
y
l
n
s
U
OLTP Requirements
Space Allocation
Avoid the performance load of dynamic extent allocation; allocate space explicitly to
tables, clusters, and indexes.
Check growth patterns regularly to find the rate at which extents are being allocated so
that you can create extents appropriately.
Indexing
Indexing is critical to data retrieval in OLTP systems. DML statements on indexed
tables need index maintenance and this is a significant performance overhead. Your
indexing strategy must be closely geared to the real needs of the application.
Indexing a foreign key helps child data to be modified without locking the parent data.
B-tree indexing is better than bitmap indexing, because of locking issues affecting
DML operations: when a B-tree index entry is locked, a single row is locked, whereas
when a bitmap index entry is locked, a whole range of rows are locked.
Reverse key indexes avoid frequent B-tree block splits for sequence columns.
You should rebuild indexes regularly.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
OLTP Requirements (continued)

Materialized Views
Materialized views are discussed in another lesson. They can reduce the amount of table
joins on a system. There are not many opportunities for using materialized views in an
OLTP system; most benefits are found in DSS.
An IOT provides fast access to data, because the table data is stored within the index
structure.
Hash Clustering
Using hash clusters should speed up access on equality queries. But you should not
choose this data structure for a table that is:
- Heavily inserted into, because of the use of space and the number of blocks that
must be visited
- Heavily updated using larger column values, because of migration probability
If a table is growing, there are likely to be many collisions on hash keys and this leads
to storing rows in overflow blocks. To avoid this situation, correctly estimate the
HASHKEYS value. With a large number of hash keys for a given number of rows, the
likelihood of a collision decreases.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
OLTP Application Issues
Use declarative constraints instead of application

code.
Make sure that code is shared.
Use bind variables rather than literals for optimally
shared SQL.
Use the CURSOR_SHARING parameter.
O
e
y
l
n
s
U
OLTP Application Issues

Integrity Constraints
If there is a choice between keeping application logic in procedural code or using declarative
constraints, keep in mind that constraints are always less expensive to process. Referential
integrity and check constraints are the main types to consider here.
Shared Code
You should make certain that code is shared by using stored procedural objects, such as
packages, procedures, and functions.
Bind Variables
You want to keep the overhead of parsing to a minimum. Try to ensure that the application
code uses bind variables rather than literals.
The CURSOR_SHARING Parameter
Using the CURSOR_SHARING parameter determines the level of cursor sharing. The
following values are valid:
Exact: Shares cursors only for exact SQL statements. This is the default value.
Similar: Cursors are shared if changing literals to bind variables generates the same
execution path as when the parameter is set to Exact.
Force: Shares cursors by changing literals to bind variables, even if the execution path
changes.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Decision Support Systems

(Data Warehouses)
Queries on large amounts of data

Heavy use of full table scans
Tuning goals:
Fast response time
Focus on SQL
statement tuning
Data
The Parallel Query feature is designed for data

warehouse environments.
O
e
y
l
n
s
U
Characteristics of Decision Support Systems

Decision support applications distill large amounts of information into understandable
reports. They gather data from OLTP systems and use summaries and aggregates in
retrieving it. They make heavy use of full table scans as an access method.
Decision-makers in an organization use this data to determine which strategies the
organization should take.
Example: A marketing tool determines the buying patterns of consumers based on
information gathered from demographic data to determine which items sell best in which
locations.
Requirements
Fast response time: When you design a data warehouse, make sure that queries on
large amounts of data can be performed within a reasonable timeframe.
Focus on SQL statement tuning.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Data Warehouse Requirements
Storage allocation:
Set the block size and
DB_FILE_MULTIBLOCK_READ_COUNT carefully.
Make sure that extent sizes are multiples of this

parameter value.
Run dbms_stats regularly.
O
e
Data Warehouse Requirements

Block Size
I
A
y
l
n
s
U
Data warehouse applications typically perform many table scans; therefore consider a higher
value for the block size parameter. Even if this means re-creating a large database, it is
almost certainly worthwhile, because a larger block size facilitates read-intensive operations,
which are characteristic of data warehouse applications.
Another option is available; you can create a new tablespace with the required block size,
thus having multiple block sizes in the same database.
The DB_FILE_MULTIBLOCK_READ_COUNT Parameter
Pay particular attention to setting the DB_FILE_MULTIBLOCK_READ_COUNT parameter.
During full table scans and fast full index scans this parameter determines how many
database blocks are read into the buffer cache with a single operating system read call. A
larger value decreases the estimated cost of full table scans and therefore the CBO will favor
table scans over index searches.
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Further Data Warehouse Requirements
Evaluate the need for indexes:

Use bitmap indexes when possible.
Use index-organized tables for (range) retrieval by
primary keys.
Generate histograms for indexed columns that are
not distributed uniformly.
Clustering: Consider hash clusters for

performance access.
O
e
y
l
n
s
U
Further Data Warehouse Requirements

Indexing
You should minimize the space and performance overhead of index maintenance. Because
most queries usually use full table scans, you can:
Dispense with indexes altogether
Maintain them only for a few tables that are accessed selectively
Regularly generate histograms for tables with non-uniformly distributed data
Choose bitmap indexes for queries on columns with few distinct values; they offer
much faster retrieval access
Use index-organized tables for faster, key-based access to table data for queries
involving exact matches or range searches and complete row data retrieval
Clustering
Consider using both types of clusters; particularly hash clusters. Do not cluster tables that
grow regularly during bulk loads.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Data Warehouse Application Issues
Parsing time is less important.

The execution plan must be optimal:
Use the Parallel Query feature.

Tune carefully, using hints if appropriate.
Test on realistic amounts of data.
Consider using PL/SQL functions to code logic
into queries.
Bind variables are problematic.
O
e
y
l
n
s
U
Parsing Time
The time taken to parse SELECT statements is likely to be a very small proportion of the
time taken to execute the query. Tuning the library cache is much less of an issue for data
warehouse than for OLTP systems.
Your priority is an optimal access path in the execution plan; small variations can cost
minutes or hours. Developers must:
Use parallelized queries, which enable multiple processes to work together
simultaneously to process a single SQL statement
Use symmetric multiprocessors (SMP), clustered, or massively parallel processing
(MPP) configurations. These configurations gain the largest performance benefits
because the operation can be effectively split among many CPUs on a single system.
Use the EXPLAIN PLAN command to tune the SQL statements and hints to control
access paths
If your application logic uses bind variables, you lose the benefit of this feature: the
optimizer makes a blanket assumption about the selectivity of the column, whereas with
literals, the cost-based optimizer uses histograms. Be careful when setting the
CURSOR_SHARING parameter; it could force a change from literal values to systemgenerated bind variables.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Hybrid Systems
OLTP
Data Warehouse
Performs index searches
More full table scans
Uses B-tree indexes
Uses bitmap indexes
Uses reverse key indexes
Uses index-organized tables
CURSOR_SHARING set to
Similar can assist performance
CURSOR_SHARING should
be left on Exact
Should not use Parallel Query
Employs Parallel Query for

large operations
PCTFREE according to
expected update activity
PCTFREE can be set to 0
Shared code and bind variables
Literal variables and hints
Uses ANALYZE indexes
Generates histograms
O
e
y
l
n
s
U
Hybrid System Issues

OLTP needs more indexes than data warehouse does. They do not necessarily use the
same type of indexes, because of DML/OLTP and queries/data warehouse issues.
OLTP should not use parallel query, whereas Data Warehouse needs it.
Data warehouse requires tightly packed data blocks for optimal full table scans.
Individual rows are generally not updated in a data warehouse environment. Therefore,
PCTFREE should be set to 0 for data warehouse databases, whereas a PCTFREE of 0
for OLTP will lead to chaining, because rows are typically more dynamic.
The cost-based optimizer takes histogram statistics into account when the predicate of
a query uses columns that have histograms generated. This means that if you have
generated histogram statistics it is important for them to be accurate; otherwise the
optimized execution path might not be chosen.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Summary

following:
Explain the role of the DBA in tuning applications
Move tables using the ALTER TABLE command
Redefine a table online

Create different types of indexes
Build and manage index-organized tables
Explain and plan OLTP, DSS, and hybrid systems
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
l
c
a
r
O
y
l
n
Practice 15
1. Connect as hr/hr, drop the new_employees table, and create an IOT called
new_employees in the hr schema. Give the table the same columns as the
hr.employees table. Make the employee_id column the primary key and name
the primary key index new_employees_employee_id_pk.
2. Confirm the creation of the table by querying the user_tables and the
user_indexes views
3. Populate the new_employees table with the rows from the hr.employees table.
4. Create a secondary B-tree index on the last_name column of the
new_employees table. Place the index in the indx tablespace. Name the index
last_name_new_employees_idx. Collect the statistics for the secondary index.
5. Confirm the creation of the index by using the user_indexes view in the data
dictionary. Query the index_name, index_type, blevel, and leaf_blocks.
y
l
n
6. Create a reverse key index on the department_id of the employees_hist

table. Place the index in the indx tablespace. Name the index
emp_hist_dept_id_idx.
O
e
s
U
7. Confirm the creation of the index and that it is a reverse key index, by querying the
user_indexes view in the data dictionary. Query the index_name,
index_type, blevel, and leaf_blocks.
I
A
8. Create a bitmap index on the job_id column of the employees_hist table. Place
the index in the indx tablespace. Name the index bitmap_emp_hist_idx.
&
l
a
n
r
te
9. Confirm the creation of the index and that it is a bitmapped index by querying the
n
I
e
r
O
l
c
a
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Using Materialized Views
O
e
I
A
&
l
a
n
r
te
r
O
l
c
a
n
I
e
y
l
n
s
U
Objectives
After completing this lesson, you should be able to

do the following:
Create materialized views
Refresh materialized views
Create nested materialized views
Create UNION ALL materialized views
Explain the use of query rewrites

Enable and control query rewrites
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
y
l
n
Materialized Views
Instantiations of a SQL query

May be used for query rewrites
Refresh types:
Complete or Fast
Force or Never
Refresh modes:
Manual
Automated (synchronous or asynchronous)
O
e
y
l
n
s
U
Materialized Views
A materialized view (MV) stores both the definition of a view and the rows resulting from
the execution of the view. Like a view, it uses a query as the basis, but the query is executed
at the time the view is created and the results are stored in a table. You can define the table
with the same storage parameters as any other table and place it in the tablespace of your
choice. You can also index and partition the materialized view table, like other tables, to
improve the performance of queries executed against them.
When a query can be satisfied with data in a materialized view, the server transforms the
query to reference the view rather than the base tables. By using a materialized view,
expensive operations such as joins and aggregations do not need to be re-executed; instead
the statement is rewritten to query the materialized view.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Creating Materialized Views
SQL>
2
3
4
5
6
CREATE MATERIALIZED VIEW

depart_sal_sum AS
SELECT d.department_name, SUM(e.salary)
FROM hr.departments d, hr.employees e
WHERE d.department_id = e.department_id
GROUP BY d.department_name;
O
e
y
l
n
s
U
Creating Materialized Views

Materialized views have an advantage over regular views in that the result of the view is
stored for future use. This means that the query does not have to be rebuilt every time the
query is run.
One of the problems with materialized views is that the data stored in the view can become
outdated with the next modification to the underlying tables. Therefore, it is required to
refresh the data periodically.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Refreshing Materialized Views

The required parameters are:
A comma-delimited list of materialized views to
refresh
The refresh method: F-Fast, ?-Force, C-Complete
Refresh after errors
True: allows the process to continue after an error
False: refresh will stop with errors (default value)
For warehouse refresh, set them to False, 0,0,0.

Atomic refresh
True: All refreshes are done in one transaction
False: Each refresh is a separate transaction
SQL> EXEC dbms_mview.refresh ('SALES_MV', 2

'F', '', TRUE, FALSE, 0,0,0, FALSE);
O
e
y
l
n
s
U
Refreshing Materialized Views

Materialized views use the same internal mechanism as snapshots and they support several
refreshing techniques.
A complete refresh of a materialized view involves truncating existing data and reinserting
all the data based on the detail tables by re-executing the query definition from the CREATE
command.
Fast refreshes apply the changes made since the last refresh and do not do a complete
rebuild. Two types of fast refresh are available:
Fast refresh using materialized view logs: In this case, all changes to the base tables
are captured in a log and then applied to the materialized view.
Fast refresh using rowid range: A materialized view can be refreshed using fast
refresh after direct path loads, based on the rowids of the new rows. Direct loader
logs are required for this refresh type.
A view defined with a refresh type of Force refreshes with the fast mechanism if that is
possible. Otherwise a complete refresh is used. Force is the default refresh type.
The Never option suppresses all refreshes of the materialized view.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Refreshing Materialized Views (continued)

Manual refreshes are performed using the dbms_mview package. The dbms_mview
package provides a number of procedures and functions to manage materialized views,
including the REFRESH, REFRESH_DEPENDENT, and REFRESH_ALL_MVIEWS
procedures.
Automatic refreshing can be performed:
On commit: When the ON COMMIT option is specified for a materialized view, that
view will be updated whenever changes to one of the base tables are committed. The
update to the materialized view occurs asynchronously when the transaction is
committed and therefore does not degrade the users perceived performance.
At a specified time: Refreshes of a materialized view can be scheduled to occur at a
specified time. For example, a view can be refreshed every Monday at 9:00 a.m. by
using the START WITH and NEXT clauses. In order for such refreshes to occur, the
instance must initiate job processes with the JOB_QUEUE_PROCESSES parameter set
to a value greater than 0.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Materialized Views: Manual Refreshing
Refresh specific materialized views:
dbms_mview.refresh
(CUST_SALES, parallelism => 10);
Refresh materialized views based on one or more

base tables:
dbms_mview.refresh_dependent (SALES);
Refresh all materialized views that are due to be

refreshed:
dbms_mview.refresh_all_mviews;
O
e
y
l
n
s
U
Materialized Views: Manual Refresh

The following is a list of possible refresh scenarios for materialized views:
Refresh specific materialized views by using the dbms_mview.refresh procedure
Refresh all materialized views that depend on a given set of base tables by using the
dbms_mview.refresh_dependent procedure
Refresh all materialized views that have not been refreshed since the last bulk load to
one or more detail tables by using the dbms_mview.refresh_all_mviews
procedure
The procedures in the package use a number of parameters to specify:
Refresh method
Whether to proceed if an error is encountered
Whether to use a single transaction (consistent refresh)
Which rollback segment to use
Server job queues are used to run the refresh job. Therefore the appropriate initialization
parameters, JOB_QUEUE_PROCESSES and JOB_QUEUE_INTERVAL, must be set to
enable job queue refresh processes.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Nested Materialized Views
Level 2
TOTAL_SALES
PROD_MV
PRODUCTS
Level 1
SALES_CUST_MV
CUSTOMERS
SALES
Level 0
O
e
y
l
n
s
U
Nested Materialized Views

The Oracle database allows the use of full or fast refreshes with nested material views
containing joins and aggregates. The nested structure is allowed to be unbounded.
You can create materialized views containing aggregates or joins on top of other aggregated
or joined materialized views. Being able to create aggregated and joined nested materialized
views, is of great use in data warehouse environments where often materialized views are
built on other materialized views that themselves have been built as aggregates from
multiple tables.
Nested Replicated Materialized Views
Aggregated or joined materialized views can be built on data replicated from another
database, using materialized views.
Restrictions
The middle layer views (level 1 in the example) must be materialized views containing
joins, aggregates, or both. If this requirement is not met then an error is reported when
creating the higher-level materialized view.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Nested Materialized Views (continued)

Restrictions (continued)
Specifying a fast refresh ON COMMIT is not supported for the higher-level materialized view
(level 2 in the preceding example).
It is important to sequence the refresh times. For accurate materialized views you must start
refreshing at the lowest level, level 1, and work up. In the previous example given, it is
recommended that materialized views PROD_MV and SALES_CUST_MV be refreshed
before TOTAL_SALES. The Oracle database does not report errors if refreshes occur out of
sequence and the materialized views will not be marked stale.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Nested Materialized View Example
O
e
y
l
n
s
U
Nested Materialized View Example

The example in this slide builds the structure shown previously. The screenshot shows the
Oracle Enterprise Manager console creating the materialized view total_sales. The
following example demonstrates the complete nested materialized view build. The same
sequence should be followed when building the nested materialized views using Oracle
Enterprise Manager. To provide a fast refresh capability, the base tables on level 0 require
materialized view logs.
I
A
SQL>
2
3
4
SQL>
2
3
SQL>
2
3
4
CREATE MATERIALIZED VIEW LOG ON sh.sales

WITH SEQUENCE,
ROWID (cust_id, time_id, prod_id)
INCLUDING NEW VALUES;
CREATE MATERIALIZED VIEW LOG ON sh.customers
WITH SEQUENCE, ROWID (cust_id)
CREATE MATERIALIZED VIEW LOG ON sh.products
WITH SEQUENCE,
ROWID (prod_id, prod_name, prod_list_price)
n
r
te
n
I
e
l
c
a
r
O
&
l
a
Nested Materialized View Example (continued)

Create the materialized views required for level 1. Ensure that all views at this level contain
either aggregates or joins. For the next level to be fast refreshable the materialized views on
this level must have materialized view logs created as well.
SQL>
2
3
4
5
6
7
SQL>
2
3
SQL>
2
3
4
5
6
SQL>
2
3
CREATE MATERIALIZED VIEW sales_cust_mv

REFRESH FAST ON DEMAND AS
SELECT c.rowid cid, s.rowid sid,
cust_last_name, time_id, prod_id,
amount_sold, quantity_sold
FROM sales s, customers c
WHERE s.cust_id = c.cust_id;
CREATE MATERIALIZED VIEW LOG on sales_cust_mv
WITH ROWID
CREATE MATERIALIZED VIEW prod_mv
REFRESH FAST ON COMMIT AS
SELECT prod_id, prod_name,
MIN(prod_list_price) PRICE
FROM products
GROUP BY prod_id, prod_name;
CREATE MATERIALIZED VIEW LOG ON prod_mv
WITH SEQUENCE, ROWID
y
l
n
Create the materialized view total_sales.

SQL>
2
3
4
5
6
7
CREATE MATERIALIZED VIEW total_sales

REFRESH FAST AS
SELECT p.rowid pid, s.rowid sid2,
cust_last_name, amount_sold,
quantity_sold, prod_name, price
FROM prod_mv p, sales_cust_mv s
WHERE p.prod_id = s.prod_id;
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Union All Materialized Views
y
l
n
O
e
s
U
Union All Materialized Views

You can specify the fast refresh option on a materialized view utilizing the UNION ALL
construct. To determine the table from which a row originates, because all the rows from
each table are present, you use a column, named MARKER that is an alphanumeric constant.
Each table is assigned a constant value for all rows.
Materialized views can be built on top of this view. A materialized view can be fast
refreshable with aggregate functions and joins.
Materialized view logs must be created on all the base tables, using the WITH ROWID
option.
For the materialized view shown the following logs must be created:
I
A
&
l
a
n
r
te
n
I
e
SQL>
2
3
4
SQL>
2
3
4
l
c
a
r
O
CREATE MATERIALIZED VIEW LOG ON employees

WITH ROWID,
SEQUENCE (employee_id, last_name, first_name)
CREATE MATERIALIZED VIEW LOG ON employees_hist
WITH ROWID,
SEQUENCE (employee_id, last_name, first_name)
Union All Materialized Views (continued)

The materialized view can be created using the command as follows:
SQL> CREATE MATERIALIZED VIEW employees_mv
2 REFRESH FAST ON DEMAND AS
3 (SELECT 1 AS MARKER, NULL hid, e.rowid eid,
4
employee_id, last_name, first_name
5
FROM employees e
6
UNION ALL
7
SELECT 2 AS MARKER, h.rowid hid, NULL eid,
8
h.employee_id, h.last_name, h.first_name
9
FROM employees_hist h );
The materialized view can be fast refreshed using the command as follows:
SQL> EXECUTE dbms_mview.refresh
2 ('employees_mv', 'F', '', TRUE, FALSE,3
0,0,0, FALSE);
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Query Rewrite Overview
To use materialized views instead of the base

tables, a query must be rewritten.
Query rewrites are transparent and do not require
any special privileges on the materialized view.
Materialized views can be enabled or disabled for
query rewrites.
Query rewrites can:
Ignore alphabetic case
Recognize equivalent joins
Compare the defining text of a named view
O
e
y
l
n
s
U
Query Rewrite Overview

Accessing a materialized view may be significantly faster than accessing the underlying
base tables, so the optimizer rewrites a query to access the view when the query allows it.
The query rewrite activity is transparent to applications. In this respect, their use is similar to
the use of an index.
Users do not need explicit privileges on materialized views to use them. Queries executed by
any user with privileges on the underlying tables can be rewritten to access the materialized
view.
Ignore Alphabetic Case
Text match rewrite is able to ignore alphabetic case where SQL lexical semantics do not
distinguish uppercase from lowercase.
Join Equivalence Recognition
Query rewrite is able to make many transformations based upon the recognition of
equivalent joins.
Text Match Rewrite with Named View Defining Text
Text match rewrite compares the defining text of a named view with the defining text of a
materialized view.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Query Rewrites
The QUERY_REWRITE_ENABLED initialization

parameter must be set to True.
The QUERY REWRITE privilege allows users to
enable materialized views.
The Summary Advisor of the dbms_olap package
has options to use materialized views.
O
e
y
l
n
s
U
Query Rewrites
The optimizer performs a rewrite of the query; the rewrite is transparent to the application.
The ability to perform rewrites must be enabled either at the session level or at the instance
level by using the QUERY_REWRITE_ENABLED parameter.
To enable or disable individual materialized views for query rewrites requires the GLOBAL
QUERY REWRITE or the QUERY REWRITE system privilege. Both privileges allow users
to enable materialized views in their own schema. The GLOBAL QUERY REWRITE
privilege requires that the materialized view be in the users schema, whereas the QUERY
REWRITE privilege requires that the user own the base tables and the materialized view.
Overview of the Summary Advisor in the dbms_olap Package
Materialized views provide high performance for complex, data-intensive queries. The
summary advisor helps you achieve this performance benefit by choosing the proper set of
materialized views for a given workload. In general, as the number of materialized views
and space allocated to materialized views is increased, query performance improves. But the
additional materialized views have some cost: they consume additional storage space and
must be refreshed, which increases maintenance time. The summary advisor considers these
costs and makes the most cost-effective trade-off when recommending the creation of new
materialized views and evaluating the performance of existing materialized views.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Creating a Materialized View
SQL> CREATE MATERIALIZED VIEW sales_summary

2
TABLESPACE users
3
PARALLEL (DEGREE 4)
4
BUILD IMMEDIATE
5
ENABLE QUERY REWRITE
6
AS
7
SELECT p.prod_name,
8
SUM (s.quantity_sold),
8
SUM (s.amount_sold)
9
FROM
sales s, products p
10
WHERE s.prod_id = p.prod_id
11
GROUP BY p.prod_name;
O
e
y
l
n
s
U
Creating a Materialized View

The syntax for creating a materialized view is similar to the CREATE SNAPSHOT
command. There are some additional options. In the example in the slide, the BUILD
IMMEDIATE option will cause the materialized view to be populated when the CREATE
command is executed. This is the default behavior. You can choose the BUILD DEFERRED
option, which creates the structure but does not populate it until the first refresh occurs.
One other option, ON PREBUILT TABLE, is used when you want a pre-Oracle8i table to
be the source of a materialized view.
The ENABLE/DISABLE QUERY REWRITE clause determines whether query rewrites are
automatically enabled for the materialized view.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Materialized Views and

Query Rewrites: Example
SQL>
2
3
4
5
SELECT p.prod_name,SUM (s.quantity_sold),

SUM (s.amount_sold)
FROM
sales s, products p
SQL> select operation, object_name

2 from v$sql_plan
3 where object_name like 'SALES%';
OPERATION
NAME
---------------------- ----------------SELECT STATEMENT
TABLE ACCESS
SALES_SUMMARY
O
e
y
l
n
s
U
Materialized Views and Query Rewrites

The execution plan for the query (from the v$sql_plan view) shows that the query did
not run against the two base tables, but simply scanned the materialized view table. This
example illustrates the power of materialized views and query rewrites. The table
comprising the materialized view substitutes completely for the base tables and all the
operations on them named in the query.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Enabling and Controlling

Query Rewrites
Initialization parameters:
OPTIMIZER_MODE
QUERY_REWRITE_ENABLED
QUERY_REWRITE_INTEGRITY
Dynamic and session-level parameters:

QUERY_REWRITE_ENABLED
QUERY_REWRITE_INTEGRITY
Hints: REWRITE and NOREWRITE
Dimensions
O
e
y
l
n
s
U
Query Rewrite Parameters

The following parameters control query rewrites:
OPTIMIZER_MODE: Query rewrites are only available under cost-based optimization;
if rule-based optimization is used, query rewrites do not occur. This parameter can be
changed using an ALTER SESSION command.
QUERY_REWRITE_ENABLED: This parameter can be set to False to suppress query
rewrites even when using the cost-based optimizer. This parameter can be altered
dynamically for the whole instance as well as for individual sessions.
QUERY_REWRITE_INTEGRITY: This parameter can also be reset dynamically for
the instance and for an individual session. It accepts the following values:
- Enforced (the default): Enables query rewrites only if the server can guarantee
consistency. Only up-to-date materialized views and enabled validated
constraints are used for query rewrites.
- Trusted: Allows query rewrites based on declared, but not necessarily enforced,
relationships. All updated materialized views and constraints with the Rely flag
are used for query rewrites.
- Stale_tolerated: Allows query rewrites to use materialized views that have not
been refreshed since the last declared DML operation and relationships.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Query Rewrite Parameters (continued)

Query Rewrite: Privileges and Hints
Query rewrites are treated similarly to execution plan paths. Therefore, there are no object
privileges associated with them. Users who have access to the detail tables implicitly benefit
from summary rewrites.
A hint, REWRITE, can be used to restrict the materialized views that are considered for
query rewrites. Another hint, NOREWRITE, is available to suppress rewrites for a query
block.
Dimensions
Dimensions are data dictionary structures that define hierarchies based on columns in
existing database tables. Although they are optional, they are highly recommended because
they:
Enable additional rewrite possibilities without the use of constraints (Implementation
of constraints may not be desirable in a data warehouse for performance reasons.)
Help document dimensions and hierarchies explicitly
Can be used by OLAP tools
For more information about dimensions, see the Oracle9i Database Performance Tuning
Guide and Reference Release 2 (9.2) manual part number A96533-01.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Disabling Query Rewrites: Example
SQL>
2
3
4
5
6
SELECT /*+ NOREWRITE */

p.prod_name, SUM (s.quantity_sold),
SUM (s.amount_sold)
FROM
sales s, products p
SQL>
2
3
4
SELECT p.operation, p.object_name

FROM v$sql_plan p, v$sql s
WHERE p.address = s.address
AND sql_text LIKE 'SELECT /*+ NO%';
O
e
y
l
n
s
U
Disabling Query Rewrites

In example in this slide, the NOREWRITE hint is used to tell the optimizer not to rewrite the
query to make use of the materialized view. The execution plan derived from the query
shows that the original statement is executed, including the hash join between the two tables
and the sort to obtain the groups.
A REWRITE/NOREWRITE hint overrides a materialized views definition, set in the
CREATE or ALTER MATERIALIZED VIEW command with the ENABLE QUERY
REWRITE clause.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Union All Query Rewrite

CREATE MATERIALIZED VIEW sales_cube_mv
ENABLE QUERY REWRITE
AS
SELECT ...
GROUPING_ID(calendar_year,) gid,
GROUPING(calendar_year) grp_y,
...
GROUPING(cust_city) grp_c,
FROM sales s, times t, customers c
WHERE s.time_id=t.time_id
AND s.cust_id=c.cust_id
GROUP BY
GROUPING SETS(
(calendar_year, cust_city),
(calendar_year,..., cust_state_province),
(calendar_year,..., cust_city));
O
e
y
l
n
s
U
Union All Query Rewrite

A query with grouping sets can be rewritten using materialized views containing only a
subset of the groupings. When investigating a materialized view for rewrite, all groupings
that can directly cover groupings in the query are marked. The remaining grouping from the
query is resubmitted to the rewrite and subsequent rewrites are connected using the union all
operator. Groupings that cannot be rewritten are found in the last branch of the UNION ALL
statement and access the base data tables.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Using the dbms_mview Package
The package contains the following procedures:

explain_mview
explain_rewrite
refresh
refresh_all_mviews
O
e
y
l
n
s
U
Using the dbms_mview Package

The explain_mview procedure is used to determine what is possible with a materialized
view or potential materialized view. For example, you can determine whether a materialized
view is fast refreshable and which types of query rewrite you can perform with a particular
materialized view.
The explain_rewrite procedure is used to learn why a query failed to rewrite. Using
the results from the procedure, you can take the appropriate action to make a query rewrite if
at all possible. The query being investigated is not actually executed.
The refresh procedure consistently refreshes one or more materialized views that are not
members of the same refresh group.
The refresh_all_mviews procedure refreshes all materialized views that do not reflect
changes to their master table or master materialized view.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Summary

following:
Create materialized views
Refresh materialized views
Creating nested materialized views
Create UNION ALL materialized views
Explain the use of query rewrites

Enable and control query rewrites
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
l
c
a
r
O
y
l
n
Practice 16
In this practice you will make use of the AUTOTRACE feature and create the plan_
table table. These are covered in detail in the chapter titled SQL Statement Tuning.
1. Connect as sh/sh and confirm that the plan_table table exists. If the table does
exist then truncate it, otherwise create the plan_table table using
$ORACLE_HOME/rdbms/admin/utlxplan.sql.
2. Create a materialized view cust_sales having two columns, cust_last_name
and the total_sales for that customer. This will mean joining the sales and
customers tables using cust_id and grouping the results by cust_last_name.
Make sure that query rewrite is enabled on the view.
3. Confirm the creation of the materialized view cust_sales by querying the
user_mviews data dictionary view, selecting the columns mview_name,
rewrite_enabled and query.
4. Set AUTOTRACE to Traceonly Explain, to generate the explain plan for the query
$HOME/STUDENT/LABS/lab16_04.sql
y
l
n
5. Set the QUERY_REWRITE_ENABLED parameter to True for the session and run the
same query, $HOME/STUDENT/LABS/lab16_04.sql, as in the previous practice.
Note the change in the explain plan due to the query rewrite. Set AUTOTRACE to Off
and disable query rewrite after the script has completed running.
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Monitoring and Detecting

Lock Contention
O
e
I
A
&
l
a
n
r
te
r
O
l
c
a
n
I
e
y
l
n
s
U
Objectives

the following:
Define levels of locking
Identify causes of contention
Prevent locking problems
Use Oracle utilities to detect lock contention
Resolve contention in an emergency
Resolve deadlock conditions
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
y
l
n
Locking Mechanism
Automatic management
High level of data concurrency
Row-level locks for DML transactions
No locks required for queries
Multi-version consistency
Exclusive and Share lock modes
Locks held until commit or rollback operations
are performed
O
e
y
l
n
s
U
Lock Management
The Oracle server automatically manages locking. The default locking mechanisms lock
data at the lowest level of restriction to guarantee data consistency while allowing the
highest degree of data concurrency.
Note: The default mechanism can be modified by the ROW_LOCKING parameter. The
default value is Always, which leads the Oracle server to always lock at the lowest and
least restrictive level (the row level, not the table level) during DML statements. The other
possibility is to set the value to Intent, which leads the Oracle server to lock at a more
constraining level (the table level), except for a SELECT FOR UPDATE statement, for
which a row-level lock is used.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Data Concurrency
Transaction 2
Transaction 1
SQL> UPDATE employees
2 SET salary=salary*1.1
3 WHERE id= 24877;
1 row updated.

3 WHERE id= 24878;
1 row updated.

2 SET salary=salary+1200;
13120 rows updated.
SQL> SELECT salary

2
FROM employees
3
WHERE id = 10;
SALARY
--------1000
O
e
y
l
n
s
U
Data Concurrency
Locks are designed to allow a high level of data concurrency; that is, many users can
safely access the same data at the same time.
Data Manipulation Language (DML) locking is at row level.
A query holds no locks, unless the user specifies that it should.
Data Consistency
The Oracle server also provides multi-version consistency; that is, the user sees a static
picture of the data, even if other users are changing it.
Duration
Locks are held until the transaction is committed, rolled back, or terminated. If a
transaction terminates abnormally, then the PMON process cleans up the locks.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Data Concurrency (continued)

Locking Modes
Exclusive lock mode prevents the associated resource from being shared with other
transactions, until the exclusive lock is released.
Example: Exclusive locks are set at row level for a DML transaction:
Transaction 1
Transaction 2

3 WHERE id= 24877;
1 row updated.

3 WHERE id= 24877;
Transaction 2 waits.
In Share lock mode, several transactions can acquire share locks on the same resource.
Example: Shared locks are set at table level for DML transactions:
Transaction 1
Transaction 2

3 WHERE id= 24877;
1 row updated.

3 WHERE id= 24878;
1 row updated.
y
l
n
O
e
The two transactions update different rows in the same table.

Lock Duration
Transactions hold locks until the transactions are committed or rolled back:
I
A
Transaction 1
s
U
Transaction 2
&
l
a

3 WHERE id= 24877;
1 row updated.
SQL> commit;
Commit complete.
n
r
te
n
I
e

3 WHERE id= 24877;
Transaction 2 waits until
transaction 1 is committed.
1 row updated.
l
c
a
As soon as Transaction 1 is committed, Transaction 2 can update the row, because the
transaction acquired the requested lock. Transaction 2 must wait because it wants to
update the same row as Transaction 1.
r
O
Two Types of Locks
DML or data locks:

Table-level locks
Row-level locks
(TM)
DDL or dictionary locks

(TX)
y
l
n
O
e
s
U
DML Locks
DML locks guarantee the integrity of data being accessed concurrently by multiple users
for incorporating changes. They prevent destructive interference of simultaneous
conflicting DML and DDL operations.
DML Levels: A table-level lock (TM type) is set for any DML transaction that modifies a
table: INSERT, UPDATE, DELETE, SELECT...FOR UPDATE, or LOCK TABLE. The
table lock prevents DDL operations that would conflict with the transaction.
Example
I
A
&
l
a
Transaction 1
n
r
te
l
c
a
n
I
e

2 SET salary=salary*1.1;
13120 rows updated.
r
O
Transaction 2
SQL> DROP TABLE employees;
ERROR at line 1:
ORA-00054: resource busy and
acquire with NOWAIT specified
DML Locks (continued)

The row-level lock (TX type) is automatically acquired for each row modified by
INSERT, UPDATE, DELETE, or SELECT...FOR UPDATE statements. The row-level
lock ensures that no other user can modify the same row at the same time. Therefore, there
is no risk that a user can modify a row that is being modified and not yet committed by
another user.
Example
Transaction 1
Transaction 2

2
SET salary=salary*1.1
3
WHERE id= 24877;
1 row updated.

2
3
WHERE id= 24877;
DDL Locks
A DDL lock protects the definition of a schema object while that object is acted upon or
referred to by an ongoing DDL operation. The Oracle server automatically acquires a DDL
lock to prevent any destructive interference from other DDL operations that might modify
or reference the same schema object.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
DML Locks
A DML transaction gets at least two locks:

A shared table lock
An exclusive row lock
O
e
y
l
n
s
U
DML Transactions Acquire at Least Two Locks

Two kinds of lock structures are used for DML statements (INSERT, UPDATE, DELETE,
or SELECT...FOR UPDATE):
The transaction gets a shared lock on the table that is referenced as a TM lock, no
matter what shared lock mode it is.
The transaction gets an exclusive lock on the rows it is changing, referenced as a TX
lock. Each row gets a lock byte turned on in the row header pointing to the interested
transaction list (ITL) slot used by the transaction. The lock mode at row level can
only be exclusive.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Enqueue Mechanism
The enqueue mechanism keeps track of:

Users waiting for locks
The requested lock mode
The order in which users requested the lock
O
e
y
l
n
s
U
Enqueue Mechanism
The Oracle server maintains all locks as enqueues. The enqueue mechanism keeps track
of:
Users waiting for locks held by other users
The lock mode these users require
The order in which users requested the lock
If three users want to update the same row at the same time, all of them get the shared
table lock but only one (the first) gets the row lock. The table-locking mechanism keeps
track of who holds the row lock and who waits for it.
You can increase the overall number of locks available for an instance by increasing the
values of the DML_LOCKS and ENQUEUE_RESOURCES parameters. This may be
necessary in a Real Application Clusters configuration.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Table Lock Modes
These table lock modes are automatically assigned

by the Oracle server:
Row Exclusive (RX): INSERT, UPDATE, DELETE
Row Share (RS): SELECT... FOR UPDATE
y
l
n
O
e
s
U
Automatic Table Lock Modes

You often see the two TM table lock modes held by DML transactions, RX and RS. These
table lock modes are automatically assigned by the Oracle server for DML transactions.
The level of a table locks mode determines the modes in which other table locks on the
same table can be obtained and held.
Row Exclusive (RX):
Permits other transactions to query, insert, update, delete, or lock other rows
concurrently in the same table
Prevents other transactions manually locking the table for exclusive reading or
writing
Is allocated automatically when using insert, update, delete, or lock statements
Example
I
A
&
l
a
n
r
te
l
c
a
n
I
e
Transaction 1 (RX table lock held)
r
O

2
3
WHERE id= 24877;
1 row updated.

2
3
WHERE id= 24878;
1 row updated.
Automatic Table Lock Modes (continued)

Row Share (RS):
Permits other transactions to query, insert, update, delete, or lock other rows
concurrently in the same table.
This prevents other transactions from manually locking the table for exclusive write
access.
You can choose to lock rows during a query by using the SELECT ... FOR
UPDATE statement.
Example
Transaction 1 (RS table lock held)
SQL>
2
3
4
SQL> LOCK TABLE employees

2
IN EXCLUSIVE MODE;
SELECT id,salary
FROM employees
WHERE id=24877
FOR UPDATE;
ID
SALARY
--------- --------24877
1100
SQL> COMMIT;
Commit complete.
Table(s) Locked.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Manually Locking a Table
Manually acquired in LOCK TABLE statement:

SQL> LOCK TABLE hr.employees IN share MODE;
Share (S)
No DML operations allowed
Implicitly used for referential integrity
y
l
n
O
e
s
U
Manual Table Lock Modes

The table lock modes can be assigned manually by an explicit LOCK TABLE command.
For example:
I
A
SQL> LOCK TABLE employees IN exclusive MODE;

Table(s) Locked.
&
l
a
Often there are good application reasons for explicit locking but if you get lock contention
you may want to check with the developers. Non-Oracle developers sometimes use
unnecessarily high locking levels.
The table locking modes available for manual locking include:
Share (S) Lock Mode
This lock mode permits other transactions to only query the SELECT ... FOR
UPDATE table. It prevents any modification to the table.
n
r
te
n
I
e
l
c
a
Referential integrity statements implicitly get a Share lock.
r
O
Manually Locking a Table
Share Row Exclusive (SRX)

No DML operations or Share mode allowed
Implicitly used for referential integrity
No index is required on the foreign key column in
the child table
Exclusive (X)
No DML or DDL operations allowed by other
sessions
No manual locks allowed by other sessions
Queries are allowed
y
l
n
O
e
s
U
Manual Table Lock Modes (continued)

Share Row Exclusive (SRX) Lock Mode
This is an even higher level of table lock, which prevents DML statements and the manual
share lock mode from being acquired. Referential integrity statements implicitly get a
Share Row Exclusive lock.
Exclusive (X) Lock Mode
This is the highest level of table lock, thus the most restrictive mode. Exclusive table lock:
Permits other transactions to only query the table
Prevents any type of DML statements and any manual lock mode
Example
I
A
&
l
a
n
r
te
n
I
e
Transaction 1 (X table lock held)

SQL> LOCK TABLE department IN
EXCLUSIVE MODE;
Table(s) Locked.
r
O
l
c
a
Transaction 2 (RX table lock requested)

SQL> SELECT * from department
2
FOR UPDATE;
DML Locks in Blocks

Block Header
TX slot 1 TX slot 2
Row 6
Lock bytes
Row 1
O
e
y
l
n
s
U
Technical Note
This locking information is not cleared out when transactions are committed but rather
when the next query reads the block. This is known as delayed block cleanout.
The query that does the cleaning must check the status of the transaction and the system
change number (SCN) in the transaction table held in the rollback segment header.
Within blocks, the Oracle server keeps an identifier for each active transaction in the block
header. At row level, the lock byte stores an identifier for the slot containing the
transaction.
Example: In the diagram shown ion the slide, the transaction using slot 1 is locking row 6
and the transaction in slot 2 is locking row 1.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
DDL Locks
Exclusive DDL locks are required for:

DROP TABLE statements
ALTER TABLE statements
(The lock is released when the DDL statement
completes.)
Shared DDL locks are required for:

CREATE PROCEDURE statements
AUDIT statements
(The lock is released when the DDL parse
completes.)
Breakable parse locks are used for invalidating

statements in the shared SQL area.
y
l
n
O
e
s
U
DDL Locks
You are unlikely to see contention for DDL locks because they are held only briefly and
are requested in NOWAIT mode. There are three types of DDL locks.
I
A
Exclusive DDL Locks

Some DDL statements, such as CREATE, ALTER, and DROP must get an exclusive lock
on the object they are working on.
Users cannot get an exclusive lock on the table if any other user holds any level of lock, so
an ALTER TABLE statement fails if there are users with uncommitted transactions on that
table.
Example
&
l
a
n
r
te
Transaction 1
l
c
a
n
I
e

2 SET salary=salary*1.1;
3120 rows updated.
r
O
Transaction 2
SQL> ALTER TABLE employees
2 DISABLE PRIMARY KEY;
ORA-00054: resource busy and
acquire with NOWAIT specified
DDL Locks (continued)

Shared DDL Locks
Some statements, such as GRANT and CREATE PACKAGE, need a shared DDL lock on
the objects they reference.
This type of lock does not prevent similar DDL statements or any DML statements but it
prevents another user from altering or dropping the referenced object.
Breakable Parse Locks
A statement or PL/SQL object in the library cache holds one of these locks for every
object it references, until the statement is aged out of the shared pool.
The breakable parse lock is there to check whether the statement should be invalidated if
the object changes.
You could think of this lock as a pointer. It never causes waits or contention. However,
this does impact the system in that when a breakable parse lock on an object is broken any
objects, such as cursors and procedures, that reference that object will require parsing
again. This could cause potential contention on the shared pool.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Possible Causes of Lock Contention
Unnecessarily high locking levels

Long-running transactions
Uncommitted changes
Other products imposing higher-level locks
O
e
y
l
n
s
U
Development and User Issues

The Oracle server locks are inexpensive and efficient and most sites do not have problems
with locking. If locks do cause contention, it is often because:
Developers have coded in unnecessarily high locking levels
Developers have coded in unnecessarily long transactions
Users are not committing changes when they should
The application uses the Oracle server in conjunction with other products that impose
higher locking levels
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Diagnostic Tools for Monitoring

Locking Activity
Transaction 1
Transaction 2
Transaction 3
UPDATE employees
SET salary =
salary x 1.1;
UPDATE employees
SET salary =
salary x 1.1
WHERE empno = 1000;
UPDATE employees
SET salary =
salary x 1.1
WHERE empno = 2000;
v$lock
v$locked_object
dba_waiters
dba_blockers
O
e
y
l
n
s
U
Diagnostic Tools for Monitoring Locking Activity

dba_waiters and dba_blockers
These views give further insight into who is holding or waiting for which tables. To create
these views run the catblock.sql script. On UNIX systems this is found in the
$ORACLE_HOME/rdbms/admin directory.
The v$lock View
Two of the columns in this view are type and id1. These columns have the values:
Lock type
ID1
TX
Rollback segment number and slot number
TM
Object ID of the table being modified
Any process that is blocking others is likely to be holding a lock obtained by a user
application. The locks acquired by user applications are:
Table locks (TM)
Row-level locks (TX)
To find the table name that corresponds to a particular resource ID 1 of the v$lock view:
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
SQL> SELECT object_name

2 FROM dba_objects, v$lock
3 WHERE object_id=id1 AND type='TM';
Diagnostic Tools for Monitoring Locking Activity (continued)

The v$locked_object View
The columns of this view are:
XIDUSN: Rollback segment number
OBJECT_ID: ID of the object being modified
SESSION_ID: ID of the session locking the object
ORACLE_USERNAME
LOCKED_MODE
Example
To find the table name that corresponds to a particular object ID in the
v$locked_object view:
SQL> SELECT xidusn, object_id, session_id, locked_mode
2 FROM v$locked_object;
XIDUSN OBJECT_ID SESSION_ID LOCKED_MODE
--------- --------- ---------- ----------3
2711
9
3
0
2711
7
3
SQL> SELECT object_name FROM dba_objects
2 WHERE object_id = 2711;
OBJECT_NAME
------------EMPLOYEES
y
l
n
O
e
s
U
If the value of xidusn is 0, then the session with the corresponding session ID is
requesting and waiting for the lock being held by the session, for which xidusn value is
different from 0.
The utllockt.sql Script
You can also use the utllockt.sql script to display lock wait-for in a hierarchy. The
script prints the sessions that are waiting for locks and the sessions that are blocking.
You must run the catblock.sql script (found in $ORACLE_HOME/rdbms/admin
folder) as a sysdba user before using utllockt.sql. The catblock.sql script
creates the dba_locks and dba_blockers views along with others that will be used
by utllockt.sql.
I
A
&
l
a
n
r
te
n
I
e
For example, in the following output session 9 is waiting for session 8, sessions 7 and 10
are waiting for 9.
a
r
O
cl
WAITING
SESSION
------8
9
7
10
TYPE MODE
REQUESTED
---- ------------NONE None
TX
Share (S)
RW
Exclusive (X)
RW
Exclusive (X)
MODE
HELD
------------None
Exclusive (X)
S/Row-X (SSX)
S/Row-X (SSX)
LOCK LOCK
ID1
ID2
----- ----0
0
65547 16
33554440 2
33554440 2
Guidelines for Resolving Contention

Transaction 1
Transaction 2
UPDATE employees
SET salary = salary x 1.1
WHERE empno = 1000;
9:00
9:05
10:30
>COMMIT/ROLLBACK;
>ALTER
UPDATE employees
WHERE empno = 1000;
11:30 1 row updated;
SYSTEM KILL SESSION 10,23;
O
e
y
l
n
s
U
Guidelines for Resolving Contention

Killing Sessions
If a user is holding a lock required by another user, you can:
Contact the holder and ask this user to commit or roll back the transaction
As a last resort, kill the Oracle user session; this rolls back the transaction and
releases locks
Any of the monitoring methods detailed previously will give you the session identifier for
the user.
You can kill user sessions with the ALTER SYSTEM KILL SESSION command:
I
A
&
l
a
n
r
te
SQL> SELECT sid, serial#, username

2 FROM v$session
3 WHERE type=USER;
n
I
e
a
r
O
cl
SID
SERIAL#
----- --------8
122
10
23
USERNAME
-------SYSTEM
SCOTT
SQL> ALTER SYSTEM KILL SESSION '10,23';

System altered.
Guidelines for Resolving Contention (continued)

Which Row Is Causing Contention?
If you need to know which row is causing contention, the v$session view contains the
following columns:
row_wait_block#
row_wait_row#
row_wait_file#
row_wait_obj#
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Performance Manager: Locks
O
e
y
l
n
s
U
Performance Manager: Locks

The Performance Manager has a set of charts labeled Locks. This set of charts can be used
to determine which locks are causing other users to wait. These are termed blocking
locks and must be resolved before the waiting transaction can proceed.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Deadlocks
Transaction
Transaction
UPDATE employees
WHERE empno = = 1000;
9:00
UPDATE employees
SET manager = 1342
WHERE empno = 2000;
UPDATE employees
WHERE empno = 2000;
9:15
UPDATE employees
SET manager = 1342
WHERE empno = 1000;
ORA-00060:
Deadlock detected while
waiting for resource
9:16
y
l
n
O
e
s
U
Deadlocks
A deadlock can arise when two or more users wait for data locked by each other.
The Oracle server automatically detects and resolves deadlocks by rolling back the
statement that detected the deadlock.
I
A
&
l
a
Transaction 1
Time
Transaction 2

3 WHERE id= 24877;
1 row updated.

2 SET
salary=salary*1.1
3 WHERE id= 24876;
1 row updated.

3 WHERE id= 24876;

2 SET
salary=salary*1.1
3 WHERE id= 24877;
ORA-00060: deadlock
detected while waiting for
resource
n
r
te
n
I
e
l
c
a
r
O
Deadlocks (continued)
If the second update in Transaction 1 detects the deadlock, the Oracle server rolls back that
statement and returns the message. Although the statement that caused the deadlock is
rolled back, the transaction is not, and you receive an ORA-00060 error. Your next action
should be to roll back the remainder of the transaction.
Technical Note
Deadlocks most often occur when transactions explicitly override the default locking of
the Oracle server. Distributed deadlocks are handled in the same way as nondistributed
deadlocks.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Deadlocks
ORA-00060:
Deadlock detected while
waiting for resource
Server
process
SID_ora_PID.trc
UNIX
Trace
file
in USER_DUMP_DEST directory
y
l
n
O
e
s
U
Trace File
A deadlock situation is recorded in a trace file in the USER_DUMP_DEST directory. It is
advisable to monitor trace files for deadlock errors to determine whether there are
problems with the application. The trace file contains the rowids of the locking rows.
I
A
In distributed transactions, local deadlocks are detected by analyzing a waits for graph
and global deadlocks are detected by a time-out.
When detected, nondistributed and distributed deadlocks are handled by the database and
application in the same way.
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Summary
In this lesson, you should have learned to do the

following:
Define levels of locking
Identify causes of contention
Prevent locking problems
Use Oracle utilities to detect lock contention
Resolve contention in an emergency
Resolve deadlock conditions
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
l
c
a
r
O
y
l
n
Practice 17
The objective of this practice is to use available diagnostic tools to monitor lock
contention. You will need to start three sessions in separate windows. Log in as hr/hr in
two separate sessions (sessions 1 and 3) and as sys/oracle as sysdba in another
session (session 2). Throughout this practice Oracle Enterprise Manager can be used if
desired. SQL Worksheet can be used instead of SQL*Plus and there are many uses for the
Oracle Enterprise Manager console. (Solutions for Oracle Enterprise Manager can be
found in Appendix B).
1. In session 1 (user hr/hr), update the salary by 10% for all employees with a salary
< 15000 in the temp_emps table. Do not COMMIT.
2. In session 2 connect as sys/oracle AS sysdba and check to see whether any
locks are being held by querying the v$lock view.
3. In session 3 ( the session not yet used), connect as hr/hr and drop the temp_emps
table. Does it work?
4. In session 3 (hr/hr), update the salary by 5% for all employees with a salary >
15000 in the temp_emps table. Do not COMMIT.
y
l
n
5. In session 2, check to see what kind of locks are being held on the temp_emps
table, using the v$lock view.
O
e
6. In session 3, roll back the changes you made and set the manager_id column to 10
for all employees who have a salary < 15000.
I
A
s
U
Note: This session will be hanging, so do not wait for the statement to complete.
&
l
a
8. In session 2, run the $ORACLE_HOME/rdbms/admin/catblock.sql script.

The script will create the dba_waiters view, which gives information regarding
sessions holding or waiting on a lock. Use this view to determine the session ID for
the session that is holding locks. Use this value to query v$session to obtain the
serial number for the session holding the lock. Then issue the alter system
kill session command to release the session holding the lock.
n
r
te
n
I
e
r
O
l
c
a
Lock Matrix
Type of Request
Initialization parameters
Lock Mode Lock Target
Conflicts/Notes
None
None
No locks on reads
Mode 6, so no exclusive DDL
(this is the least restrictive
lock.)
Lock table in Row Share

mode
Mode 2
TM(RS) lock on table
Lock table partition in

Row Share mode
Mode 2
Mode 2
Mode 6, so no exclusive DDL

TM (RS)lock on table
(This is the least restrictive
TM (RS) lock on table partition
lock.
Mode 2
Mode 2
Select for update
Mode 6
Lock table in Row
Exclusive mode
Mode 3
Lock table partition in

Row Exclusiving mode
Mode 3
Mode 3
TM (RS) lock on table

Mode 6 and any selects for
or DML on same rows
TM (RS) lock on each tableupdate
partition
TX lock on RBX TX slot No exclusive DDL
TM (RX) lock on table

partition
I
A
DML (up/ins/del)
Mode 3
Mode 6
l&
DML (up/ins/del) on a
partioned table
a
r
O
e
l
c
Mode 3
Mode 3
Mode 6
y
l
n
O
e
Modes 4, 5, 6 on the same

partition
Updates allowed, because
mode 3 does not conflict
with mode 3
No share locks and no
referential integrity locks
s
U

TX lock on RBS TX
slot
Modes 4, 5, 6 Select for

update or DML on same
rows

TM (RX) lock on each
table partition owning
the updated rows
TX lock on RBS TX
slot
Modes 4, 5, 6 Select for

update or DML on same
rows
a
n
r
e
t
In
Modes 4, 5, 6 (updates
allowed, because mode 3
does not conflict with mode
3.) No share locks and no
Lock Matrix (continued)

Type of Request
Lock table in Share mode
Mode 4
Mode 2
Lock table partition in Share mode
Mode 4
Lock table in Share Row Exclusive

Mode mode
5
Conflicts/Notes
TM (S) lock on table
Modes 3, 5, 6
Allows Select for Update and
other Share Locks
No possible ORA 1555 error
on locked table
Mode 3,5,6 on the same

partition
Allows Select for Update and
other Share locks
TM(S) lock on table partition
No possible ORA 1555 on
locked table
TM(SRX) lock on table
Mode 3,4,5,6
Allows Select for Update only
No Share locks
No ORA 1555
No cascaded deletes
y
l
n
O
e
Mode 4 on the same partition

Mode 3,5,6 on any partition
Mode 2
Allows Select for Update only
Lock table in partition in Share Row Exclusive mode
Mode 4
TM(S) lock on table partition
No ORA 1555
No cascaded deletes
I
A
l&
a
n
r
Lock table in Exclusive modeMode 6
e
t
In
Mode 3
Lock table partition in Exclusive mode
Mode 6
a
r
O
e
l
c
TM(X) lock on table
s
U
Mode 2,3,4,5,6 Selects only;

no DDL
Most restrictive lock mode
Mode 2,3,4,5,6 on the same

partition
TM(X) lock on table
Mode 5 on any partition
TM(X) lock on table partition
No exclusive DDL
Most restrictive lock mode on
partition
Lock Matrix (continued)

Type of Request
Conflicts/Notes
Drop, Truncate, Create

Table and Create Index
DDL
Mode 6
No wait
TM(X) lock on table
Drop, Truncate, ADD

Partition DDL
Mode 3
Mode 6
No wait
TM(X) lock on table

TM(X) lock on table
partition
Mode 2,3,4,5,6
Selects only; No DDL
DDL fails if any other lock
mode on table due to no
wait
Mode 2,3,4,5,6 on the same
partition
Mode 5 on any partition
DDL fails if any other lock
mode on table partition due
to no wait
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Using Resource Manager
O
e
I
A
&
l
a
n
r
te
r
O
l
c
a
n
I
e
y
l
n
s
U
Objectives

the following:
Set up Database Resource Manager
Assign users to Resource Manager groups
Create resource plans within groups
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
y
l
n
Overview
Manage mixed workload

Control system performance
Database
resource manager
OLTP
More resources
OLTP
user
DSS
Less resources
Oracle9i
DSS
user
O
e
y
l
n
s
U
Overview
By using the Database Resource Manager, the database administrator (DBA) has more
control over certain resource utilization than is normally possible through operating system
resource management alone. With the Oracle database it is possible to have control over
CPU utilization and the degree of parallelism. If resource management decisions are left in
the hands of the operating system, then this can cause inefficient scheduling or the
rescheduling of Oracle servers while latches are being held.
With the Database Resource Manager, the DBA can:
Guarantee groups of users a minimum amount of processing resources regardless of
the load on the system and the number of users.
Distribute available processing resources, by allocating percentages of CPU time to
different users and applications. In an OLTP environment, a higher priority can be
given to OLTP applications than to DSS applications during normal business hours.
Limit the degree of parallelism that a set of users can use.
Configure an instance to use a particular plan for allocating resources. A DBA can
dynamically change the method, for example, from a daytime setup to a nighttime
setup, without having to shut down and restart the instance.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Database Resource
Management Concepts
User groups with similar
resource needs (one
active resource consumer
group per session)
Resource
consumer
group
Resource plan
Resource plan
directives
Allocates CPU and PQ

servers (one active plan)
Assigns groups and

resources to plans
O
e
y
l
n
s
U
Database Resource Manager Concepts

Administering systems using the database resource management involves the use of resource
plans, resource consumer groups, and resource plan directives.
Resource Consumer Group
Resource consumer groups define a set of users who have similar requirements for using a
resource. Groups also specify the method for allocating the CPU among sessions. Resource
consumption is controlled by assigning user sessions to resource consumer groups. A user
can be assigned to multiple consumer groups but only one group can be active at a time for a
session. The user or DBA can switch the consumer group during a session.
Resource Plan
Resource allocations are specified in a resource plan, which contains resource plan
directives that specify the resources to be allocated to each resource consumer group. The
resources that can be allocated include the maximum CPU time and the undo consumption.
Resource Plan Directives
There is one resource plan directive for each entry in the plan. The directives are a means of:
Assigning consumer groups or sub-plans to resource plans
Allocating resources among consumer groups in the plan by specifying parameters for
each resource allocation method
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Using Sub-Plans to Limit CPU Utilization

MYDB
PLAN
70% @ L1
30% @ L1
MAILDB
PLAN
40% @ L1
BUGDB
PLAN
100% @ L3
100% @ L3
100% @ L2
80% @ L1
100% @ L2
20% @ L1
POSTMAN MAIL MAINT OTHER ONLINE BATCH BUG MAINT

Groups Group Group
Group
Group
Group
O
e
y
l
n
s
U
Using Sub-Plans to Limit CPU Utilization

Sub-Plan
A plan does not contain resource consumer groups only; it can also contain other plans,
called sub-plans. It is possible for a sub-plan or consumer group to have more than one
parent (owning plan), but there cannot be any loops in a plan.
Example of Limiting the CPU Resource
If the mydb resource plan were active and the CPU was experiencing a 100% demand, then
the maildb plan would be in effect 30% of the time (30% @ L1), whereas the bugdb plan
would be in effect 70% of the time (70%@ L1). Each group may divide a resource at
different levels. In the above example the mydb plan has only one level, whereas the
bugdb plan has three levels. The levels provide a priority ranking within the plan: the needs
of level 1 are met before level 2, and so on.
If the maildb plan allocates 40% of resources to the postman consumer group (40% @
L1) and the bugdb plan allocates 80% of resources to the online consumer group, then
users in the postman group would be run 12% (40% of 30%) of the time, whereas users in
the online group would be run 56% (80% of 70%) of the time.
These limits are only imposed when the CPU is overloaded. For example, if there is only
one user on the system and the user belongs to the other consumer group, then the user will
experience the full CPU utilization and not have the limit (100% @ L 3 ) imposed.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Resource Allocation Methods
Method
Resource
Recipient
Round-robin
CPU to sessions
Groups
Emphasis
CPU to groups
Plans
Absolute
Parallel degree
Plans
O
e
y
l
n
s
U
Resource Allocation Methods

Resource allocation methods determine the method that Database Resource Manager uses
when allocating a particular resource to a resource consumer group or resource plan. The
resource allocation method for allocating the CPU among resource consumer groups is the
emphasis method. The only resource allocation method for limiting the degree of parallelism
is the absolute method.
CPU Allocation between Sessions in a Group: Round-Robin Method
Inside each consumer group, the CPU resources are distributed in a round-robin fashion.
Parallel Degree Limit for Resource Plans: Absolute Method
This limits the maximum degree of parallelism of any operation. This parameter is only
allowed in directives that refer to resource consumer groups. The absolute method is the
only one possible. It specifies how many processes may be assigned to an operation. If there
are multiple plan directives referring to the same sub-plan or consumer group, the parallel
degree limit for that sub-plan or consumer group will be the minimum of all the incoming
values.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Resource Allocation Methods (continued)

CPU Allocation between Groups in a Plan: Emphasis Method
The emphasis CPU allocation method determines how much emphasis is given to sessions in
different consumer groups in a resource plan. CPU usage is assigned levels from 1 to 8, with
level 1 having the highest priority. Percentages specify how to allocate CPU to each
consumer group at each level. The following rules apply for the emphasis resource
allocation method:
Sessions in resource consumer groups with nonzero percentages at higher-priority
levels always get the first opportunity to run.
CPU resources are distributed at a given level based on the specified percentages. The
percentage of CPU specified for a resource consumer group is a maximum for how
much that consumer group can use at a given level. If any CPU resources are left after
all resource consumer groups at a given level have been given an opportunity to run,
the remaining CPU resources fall into to the next level.
The sum of percentages at any given level must be less than or equal to 100.
Any unused CPU time gets recycled. In other words, if no consumer groups are
immediately interested in a specific period of CPU time (due to percentages), the
consumer groups get another opportunity to use the CPU time, starting at level one.
Any levels that have no plan directives explicitly specified have a default of 0% for all
sub-plans or consumer groups.
The emphasis resource allocation method avoids starvation problems.
The previous rules apply under the following assumptions: The Database Resource Manager
percentage limits are not hard limits. It is certain to act as limits only if system throughput is
at maximum. If less than maximum, resource consumer groups can be provided the
resources they demand, even if that means more than the specified limit, provided the
consumer groups in question do not have other higher priority groups requesting the spare
resources. Database Resource Manager first seeks to maximize throughput, then to prioritize
among the consumer groups.
Distribution of Resources to Consumer Groups versus Limitations on Private Usage
Profiles define resource limits for individual users or sessions. An example is the
idle_time resource limit. A resource consumer group is a set of users treated as a
collective unit by the resource manager. The resource plan directives assign resources to
consumer groups as a whole, not to individual sessions, whereas profiles limit the resources
that individual sessions can consume regardless of other sessions that might be executing.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
The Initial Plan: SYSTEM_PLAN

Resource
consumer
group
Allocation methods
P1CPU
P2CPU P3CPU P1//
SYS_GROUP
100%
0%
0%
OTHER_GROUPS
0%
100%
0%
LOW_GROUP
0%
0%
100%
y
l
n
O
e
s
U
The Initial Plan: SYSTEM_PLAN

The initial resource plan provided is the SYSTEM_PLAN. This plan contains directives for
the following provided consumer groups:
SYS_GROUP: The initial consumer group for the users sys and system.
OTHER_GROUPS: Used for all sessions who belong to consumer groups that are not
part of the active resource plan. There must be a plan directive for OTHER_GROUPS in
any active plan.
LOW_GROUP: A group with lower priority than SYS_GROUP and OTHER_GROUPS in
this plan. You must decide which user sessions will be part of LOW_GROUP. Initially
no user is associated with this consumer group. The switch privilege is granted to
PUBLIC for this group.
I
A
&
l
a
n
r
te
n
I
e
Initial Resource Consumer Group

The initial consumer group of a user is the consumer group to which any session created by
that user initially belongs. If you have not set the initial consumer group for a user, the
users initial consumer group will automatically be the DEFAULT_CONSUMER_GROUP.
l
c
a
r
O
Note: This setting will simulate a priority system.
Administering the Database

Resource Manager
Assign the resource manager system privileges

to the administrator.
Create resource objects with the package
dbms_resource_manager:
Resource consumer groups
Resource plans
Resource plan directives
Assign users to groups with the package

dbms_resource_manager_privs.
Specify the plan to be used by the instance.
y
l
n
O
e
s
U
Administering the Database Resource Manager

To administer the Database Resource Manager, you must have the
ADMINISTER_RESOURCE_MANAGER system privilege. DBAs have this privilege with
the ADMIN option because it is part of the dba role. Being an administrator for the Database
Resource Manager allows you to execute all of the procedures in the
dbms_resource_manager package.
The administer_resource_manager privilege is granted and revoked with the
dbms_resource_manager_privs package. It cannot be granted through the SQL
grant or revoke statements.
I
A
&
l
a
n
r
te
n
I
e
The dbms_resource_manager Procedures

create_plan: Names a resource plan and specifies its allocation methods
update_plan: Updates a resource plans comment
delete_plan: Deletes a resource plan and its directives
delete_plan_cascade: Deletes a resource plan and all of its descendents
create_consumer_group: Names a resource consumer group and specifies its
allocation method
update_consumer_group: Updates a consumer groups comment
delete_consumer_group: Deletes a consumer group
r
O
l
c
a
The dbms_resource_manager Procedures (continued)

create_plan_directive: Specifies the resource plan directives that allocate
resources to resource consumer groups within a plan or among sub-plans in a
multilevel plan schema.
update_plan_directive: Updates plan directives.
delete_plan_directive: Deletes plan directives.
create_pending_area: Creates a pending area (scratch area) within which
changes can be made to a plan schema.
validate_pending_area: Validates the pending changes to a plan schema.
clear_pending_area: Clears all pending changes from the pending area.
submit_pending_area: Submits all changes to a plan schema.
set_initial_consumer_group: Sets the initial consumer group for a user.
switch_consumer_group_for_sess: Switches the consumer group of a
specific session.
switch_consumer_group_for_user: Switches the consumer group of all
sessions belonging to a specific user.
The dbms_resource_manager_privs Procedures
grant_system_privilege: Grants ADMINISTER_RESOURCE_MANAGER
system privilege to a user or role.
revoke_system_privilege: Revokes ADMINISTER_RESOURCE_MANAGER
system privilege to a user or role.
grant_switch_consumer_group: Grants permission to a user, role, or
PUBLIC to switch to a specified resource consumer group.
revoke_switch_consumer_group: Revokes permission for a user, role, or
PUBLIC to switch to a specified resource consumer group.
y
l
n
O
e
s
U
The above description provides an overview of the possibilities. For a comprehensive

description of the various procedures, refer to the Oracle9i Supplied PL/SQL Packages and
Types Reference Release 2 (9.2) manual (Part Number A96612-01).
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a

Resource Manager
O
e
s
U
Oracle Enterprise Manager: Resource Manager

In the Oracle Enterprise Manager console the DBA can administer resource plans.
I
A
&
l
a
n
r
te
n
I
e
l
c
a
r
O
y
l
n
Assigning the Resource Manager Privilege
Assign the resource manager system privileges to

the administrator.
dbms_resource_manager_privs.grant_system_privilege (
grantee_name => 'OE',
privilege_name => 'ADMINISTER_RESOURCE_MANAGER',
admin_option => False
);
O
e
y
l
n
s
U
Granting Privileges Needed to Administer Resources

The dbms_resource_manager_privs.grant_system_privilege procedure is
used to grant the privilege to a user. The example in the slide permits the oe users to
manage database resources.
The privilege_name parameter defaults to ADMINISTER_RESOURCE_MANAGER.
The third parameter specifies that oe has been granted the privilege without the ADMIN
OPTION.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Creating Database Resource

Manager Objects
Create resource objects with the

dbms_resource_manager package.
Create a pending area.

dbms_resource_manager.create_pending_area();
Create resource consumer groups.

dbms_resource_manager.create_consumer_group (
consumer_group => 'OLTP',
comment =>
'Online users' );
y
l
n
O
e
s
U
Creating a Pending Area

The pending area is a scratch area for staging your changes and validating them before they
are made active. Only one pending area can be created in an instance at a given point in
time. It is created using the create_pending_area procedure. Views are available for
inspecting all active resource plan as well as the pending ones (see at the end of this lesson).
I
A
&
l
a
dbms_resource_manager.create_pending_area();
Creating Resource Consumer Groups

When a consumer group is defined, it is stored in the pending area. A DBA can specify the
name and a comment while defining a consumer group. Procedures are available to modify
or delete a consumer group.
n
r
te
n
I
e
dbms_resource_manager.create_consumer_group
(consumer_group => OLTP, comment => Online users);
r
O
l
c
a

Manager Objects
Create resource plans.
dbms_resource_manager.create_plan (
plan =>
'NIGHT',
comment => 'DSS/Batch priority, ...' );
Create resource plan directives.
dbms_resource_manager.create_plan_directive (
plan =>
'NIGHT',
group_or_subplan =>
'SYS_GROUP',
comment =>
'...',
cpu_p1 =>
100,
parallel_degree_limit_p1 => 20);
y
l
n
O
e
s
U
Creating Database Resource Manager Objects

Creating Resource Plans
When a resource plan is defined, it is stored in the pending area. A DBA can specify the
name and a comment while defining a resource plan. Procedures are also available to modify
or delete a resource plan. Other arguments like MAX_ACTIVE_SESS_TARGET_MTH,
CPU_MTH, PARALLEL_DEGREE_LIMIT_MTH can be specified when creating the plan.
I
A
&
l
a
dbms_resource_manager.create_plan (
plan => NIGHT, comment => DSS/Batch priority, ...);
n
r
te
Creating Resource Plan Directives

A consumer group or a sub-plan is associated with a resource plan using the
create_plan_directive procedure. A DBA uses the arguments CPU_P1,
CPU_P2,..., CPU_P8 to distribute CPU resources up to eight levels.
n
I
e
r
O
l
c
a
dbms_resource_manager.create_plan_directive (
plan => NIGHT, group_or_subplan => SYS_GROUP,
comment => ..., cpu_p1 => 100,
parallel_degree_limit_p1 => 20);
Active Session Pool
DBAs use Database Resource Manager to limit the

amount of concurrent active sessions per resource
consumer group by defining an active session pool.
Benefits of an active session pool:
DBAs can meet performance service-level
objectives by limiting the concurrent system
workload.
The number of servers taking resources in the
system is reduced. This avoids inefficient paging,
swapping, and other resource depletion.
O
e
y
l
n
s
U
Active Session Pool

CPU resources are typically allocated at the beginning of a transaction or query and not
freed until the transaction commits or the query finishes. There is no way to free the
resources associated with such operations until the operation completes. Newly arriving
operations either cause the system performance to be significantly impeded or cause
individual operations to error when unable to allocate a resource such as temporary space.
The active session pool feature allows the DBA to control the maximum number of
concurrently active sessions per resource consumer group. With this functionality, a DBA
can indirectly control the amount of resources that any resource consumer group uses
because resource consumption is proportional to the number of active sessions. After the
active session pool is filled, the Database Resource Manager will queue all subsequent
requests and run them only after the existing active sessions complete.
The main goal of the active session pool is to reduce the number of servers taking resources
in the system, thus avoiding inefficient paging, swapping, and other resource depletion
(memory, temporary space, and so on.) resulting from attempting to run too many jobs
simultaneously. In essence, it is an attempt to guarantee some minimum resources to an
operation and to establish limits on the resource consumer group.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Active Session Pool Mechanism
The active session pool

Size can be set per resource consumer group
Size is limited to only one per consumer group.
Is the maximum number of concurrently active
sessions
Is defined as a session currently part of an active
transaction, query, or parallel operation
When the active session pool is filled with active

sessions, all subsequent sessions attempting to
become active are queued.
Individual parallel slaves do not count toward the
number of sessions. The entire parallel operation
counts as one active session.
O
e
y
l
n
s
U
Active Session Pool Mechanism

Queuing Method
After the active session pool is filled with active sessions, the Database Resource Manager
queues all subsequent sessions attempting to become active until other active sessions
complete or become inactive. There is only one queue per resource consumer group and the
queuing method is first in, first out (FIFO) with a timeout.
The queue is a simply memory structure. There is no view that shows the queue directly. To
see some queue information you can use the following views:
v$session: A new column called current_queue_duration. If queued, it
shows how long the session has been queued. It will be 0 (zero) if the session is not
currently queued.
v$rsrc_consumer_group: A new column called queue_length. This shows
the number of sessions currently queued per consumer group.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Active Session Pool Parameters
The active session pool is defined by setting the

parameters:
ACTIVE_SESS_POOL_P1
Identifies the number of active sessions that
establishes the resource consumer group's
threshold
Default is 1000000
QUEUEING_P1
Indicates how long, in seconds, any session will
wait on the queue before aborting the current
operation
Default is 1000000
O
e
y
l
n
s
U
Active Session Pool Parameters

ACTIVE_SESS_POOL_P1: Identifies the number of active sessions that establishes the
resource consumer groups threshold and therefore its active session pool.
QUEUEING_P1: This optional parameter will indicate how long any session waits on the
queue. If a session waits on the consumer groups queue for longer than the specified
QUEUEING_P1, the operation will abort with an error.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Setting the Active Session Pool
Example:
GROUP
ACTIVE SESSION POOL
OLTP
BATCH
ACTIVE_SESS_POOL_P1 = 5
QUEUEING_P1 = 600
OLTP: Set no limit on concurrent active sessions.

BATCH: Set to limit concurrent active sessions to 5.
QUEUEING_P1, set to 600, aborts all operations that
wait on the queue for more than ten minutes.
O
e
y
l
n
s
U
Setting the Active Session Pool

In the example in the slide, the resource consumer group OLTP has no limit on the number
of concurrent active sessions because the ACTIVE_SESS_POOL_P1 parameter was not
set. The resource consumer group BATCH has an ACTIVE_SESS_POOL_P1 value of 5.
The BATCH group also has the QUEUEING_P1 parameter set to 600 (ten minutes). All
BATCH sessions waiting on the queue for more than ten minutes will abort with an error.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Maximum Estimated Execution Time
The Database Resource Manager can estimate the

execution time of an operation proactively.
A DBA can specify a maximum estimated
execution time for an operation at the resource
consumer group level.
Operation will not start if the estimate is longer
than MAX_EST_EXEC_TIME
The benefit of this feature is the elimination of the
exceptionally large job that uses too many system
resources.
The default is 1000000 seconds.
O
e
y
l
n
s
U
Maximum Estimated Execution Time

A DBA can define the maximum estimated execution time any operation can take at any
given time by setting the resource plan directive MAX_EST_EXEC_TIME parameter. When
this parameter is set the Database Resource Manager estimates the time a specific job will
take. If the operations estimate is more than MAX_EST_EXEC_TIME, then the operation
will not start. This eliminates any exceptionally large jobs that would utilize too many
system resources.
If a resource consumer group has more than one plan directive referring to it, it may have
more than one MAX_EST_EXEC_TIME. The Database Resource Manager will then choose
the most restrictive of all incoming values.
The estimated execution time for a given statement is calculated using the statistics from the
cost-based optimizer.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Automatic Consumer Group Switching
The Database Resource Manager automatically

switches a sessions consumer group based on
the following resource plan directive parameters:
SWITCH_GROUP: Group switched to. Default is NULL.
SWITCH_TIME: Active time in seconds. Default is
1000000.
SWITCH_ESTIMATE: If value is True, execution time
estimate is used to decide whether to switch an
operation even before it starts. Default is False.
This feature can be used to limit the resources

consumed by long-running operations.
O
e
y
l
n
s
U
Automatic Change of Resource Manager Group

The Database Resource Manager switches a running session to SWITCH_GROUP if the
session is active for more than SWITCH_TIME seconds. Active means the session is
running and consuming resources, not waiting idly for user input nor waiting for CPU
cycles. After the session finishes its operation and becomes idle, it is switched back to its
original group. If a resource consumer group has more than one plan directive referring to it,
it may have more than one SWITCH_GROUP and SWITCH_TIME. The Database Resource
Manager chooses the most restrictive of all incoming values.
If SWITCH_ESTIMATE is set to True, the Database Resource Manager uses a predicted
estimate of how long the operation will take to complete, to decide whether to switch a
session before an operation even starts running. If this parameter is not set, the operation
will just start running and will switch groups only if the other switch criteria are met.
A DBA can use this feature to manage the workload better by segregating long-running
batch jobs from short OLTP transactions. Batch jobs can be automatically assigned to
consumer groups with lower resource allocation during daytime to ensure good response
time for OLTP users.
Setting a limit on SWITCH_TIME changes the Resource Manager group and the execution
continues. The MAX_EST_EXEC_TIME parameter prevents the statement from starting
should the estimated execution time exceed the MAX_EST_EXEC_TIME parameter value.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Undo Quota
The UNDO_POOL plan directive:
Limits the amount of undo space that can be used

When exceeded, prevents DML
SELECT statements are still allowed
Is specified in kilobytes
Default is 1000000
y
l
n
O
e
s
U
Undo Quota
The DBA can use the Database Resource Manager to limit the undo space consumed by a
transaction. This limit uses the UNDO_POOL resource plan directive parameter.
I
A
It is defined as a quota of undo space per resource consumer group.

Whenever the total undo space is exceeded, no further INSERT, UPDATE, or DELETE
commands will be allowed until undo space is freed by another session in the same group or
undo quota is increased.
If the consumer groups quota is exceeded during the execution of a DML statement, the
operation will abort and return an error.
The UNDO_POOL limit can be used with automatic undo management and user-defined
rollback segments.
&
l
a
n
r
te
n
I
e
r
O
l
c
a

Manager Objects
Validate the pending area.
dbms_resource_manager.validate_pending_area();
Commit the pending area.
dbms_resource_manager.submit_pending_area();
O
e
y
l
n
s
U
Validating the Pending Area

Use the validate_pending_area procedure to validate at any time the changes made
to the pending area. When validating, the following rules must be adhered to:
No plan schema can contain any loops.
All plan and/or resource consumer groups referred to by plan directives must exist.
All plans must have plan directives that point to plans or resource consumer groups.
All percentages in any given level must not add up to greater than 100 for the
EMPHASIS resource allocation method.
A plan that is currently being used as a top plan by an active instance cannot be
deleted.
The plan directive PARALLEL_DEGREE_LIMIT_P1 parameter can appear only in
plan directives that refer to resource consumer groups (not other resource plans).
There can be no more than 32 resource consumer groups in any active plan schema.
Also, at most, a plan can have 32 children. All leaves of a top plan must be resource
consumer groups; at the lowest level in a plan schema the plan directives must refer to
consumer groups.
Plans and resource consumer groups cannot have the same name.
There must be a plan directive for OTHER_GROUPS somewhere in any active plan
schema.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Validating the Pending Area (continued)

If any of the rules are violated, then the user receives an error. At this point the user may
clear all changes using clear_pending_area and reissue the commands or use the
appropriate procedure to correct the errors.
Committing the Pending Area
After you have validated your changes, you can make them active by calling the
submit_pending_area procedure. If successful, this command clears the pending area.
If there is a validation error, an exception is raised and the user can make corrections before
invoking this procedure again. The submit procedure also performs validation, so you are
not forced to call the validate procedure. However, debugging problems is often easier if
you incrementally validate your changes, especially if you are manipulating complex plans.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Assigning Users to Consumer Groups
Assign users to groups.

dbms_resource_manager_privs.
grant_switch_consumer_group (
grantee_name =>
'MOIRA',
consumer_group =>
'OLTP',
grant_option =>
False );
Set the initial consumer group for users:

dbms_resource_manager.
set_initial_consumer_group (
user =>
'MOIRA',
consumer_group =>
'OLTP' );
y
l
n
O
e
s
U
Assigning Users to Groups

Before enabling the Database Resource Manager, users must be assigned to resource
consumer groups. The dbms_resource_manager_privs package contains the
procedure to assign resource consumer groups to users. Granting the switch privilege to a
user enables the user to switch the current consumer group. You do not use a pending area
for any of these procedures.
I
A
&
l
a
dbms_resource_manager_privs.grant_switch_consumer_group (
grantee_name => MOIRA, consumer_group => OLTP,
grant_option => False );
n
r
te
Setting the Initial Consumer Group for Users

The users initial consumer group is the one to which any session created by that user
initially belongs. If it is not set for a user, the users initial consumer group will default to
DEFAULT_CONSUMER_GROUP. You must directly grant to the user, or to Public, the
switch privilege to a consumer group before it can be the users initial consumer group. The
switch privilege cannot come from a role granted to that user.
n
I
e
r
O
l
c
a
dbms_resource_manager.set_initial_consumer_group (
user => MOIRA, consumer_group => OLTP );
Setting the Resource Plan for an Instance
Specify the plan to be used by the instance.

Specify the RESOURCE_MANAGER_PLAN
initialization parameter.
RESOURCE_MANAGER_PLAN=day
Change the resource plan without shutting down

and restarting the instance.
ALTER SYSTEM
SET RESOURCE_MANAGER_PLAN=night;
y
l
n
O
e
s
U
Using the RESOURCE_MANAGER_PLAN Initialization Parameter

The plan for an instance can be defined using the RESOURCE_MANAGER_PLAN parameter.
This parameter specifies the top plan to be used for this instance. If no plan is specified, the
Database Resource Manager is not activated for the instance. If the plan specified in the
parameter file is not defined in the database, then the database cannot be opened and the
following error is returned:
I
A
&
l
a
ORA-07452: specified resource manager plan does not exist

in the data dictionary
n
r
te
If this error is encountered, then the instance must be shut down, the parameter modified to
show a correct value and the instance restarted. You can also activate, deactivate, or change
the current top plan by using the ALTER SYSTEM statement. If the resource plan is
changed using this command, then it takes effect immediately.
n
I
e
r
O
l
c
a
Changing a Consumer Group

Within a Session
The user or the application can switch the current
consumer group.
dbms_session.
switch_current_consumer_group (
new_consumer_group => 'DSS',
old_consumer_group => v_old_group,
initial_group_on_error => False );
y
l
n
O
e
s
U
Changing the Current Consumer Group

When logged in a session, a user can use the switch_current_consumer_group
procedure to switch to another resource consumer group. The new group must be one to
which the user has been specifically authorized to switch. If the caller is another procedure,
then this procedure enables users to switch to a consumer group for which the owner of that
procedure has switch privileges.
I
A
&
l
a
dbms_session.switch_current_consumer_group (
new_consumer_group => DSS,
old_consumer_group => v_old_group,
initial_group_on_error => False );
n
r
te
n
I
e
For example, an online application that wants to generate a report at the end of a user
session could execute the command shown so that the report runs at a different priority than
the rest of the application. The old value is returned to the calling application. If necessary,
the consumer group can be switched back to the users initial group within the application.
The third argument, if True, sets the current consumer group of the invoker to the initial
consumer group in the event of an error.
r
O
l
c
a
Changing Consumer Groups for Sessions
Can be set by DBA for a session

switch_consumer_group_for_sess (
session_id => 7,
session_serial => 13,
consumer_group => 'OLTP');
Can be set by DBA for all sessions for a user

switch_consumer_group_for_user (
user => 'MOIRA',
consumer_group => 'OLTP');
y
l
n
O
e
s
U
Changing Consumer Groups

A database administrator can switch the consumer group for a session or for a user. These
changes take effect immediately. To switch the consumer group for a session, use the
switch_consumer_group_for_sess procedure and specify the SESSION_ID,
SESSION_SERIAL number, and new CONSUMER_GROUP for the session. The user must
have been assigned the consumer group that is specified for this operation to succeed. To
determine the SESSION_ID and SESSION_SERIAL number, query v$session:
I
A
&
l
a
SQL> SELECT sid, serial#

2 FROM v$session
3 WHERE USERNAME = MOIRA;
SID
SERIAL#
---------- ---------7
13
n
r
te
n
I
e
l
c
a
The switch_consumer_group_for_user procedure provides a convenient method

for the database administrator to switch all sessions for a given user that are to be switched
into a new consumer group. The username and the new consumer group are the parameters
passed to this procedure.
Note that both of these procedures will also change the consumer group of any parallel
query slave sessions associated with the coordinators session.
r
O
Database Resource Manager Information
dba_rsrc_plans plans and status

dba_rsrc_plan_directives plan directives
dba_rsrc_consumer_groups consumer groups
dba_rsrc_consumer_group_privs users/roles
dba_users column
initial_rsrc_consumer_group
dba_rsrc_manager_system_privs users/roles
y
l
n
O
e
s
U
Database Resource Manager Information

Several new data dictionary views are available to check the resource plans, consumer
groups and plan directives declared in the instance. This section discusses some useful
information that can be obtained from these views. For more detailed information about the
contents of each of these views refer to Oracle9i Database Reference Release 2 (9.2)
manual (Part Number A96536-01 ).
Resource Plans
Use the following query to obtain information on resource plans defined in the database:
I
A
&
l
a
n
r
te
SQL> SELECT plan, num_plan_directives, status, mandatory

2 FROM dba_rsrc_plans;
PLAN
NUM_PLAN_DIRECTIVES STATUS
MAN
-------------- ------------------- --------- --NIGHT_PLAN
3 ACTIVE
NO
SYSTEM_PLAN
3 ACTIVE
NO
n
I
e
r
O
l
c
a
A status of Active indicates that the plan has been submitted and can be used, whereas
a status of Pending shows that the plan has been created, but is still in the pending area.
If the mandatory column is assigned a value of Yes then the plan cannot be deleted.
SQL> SELECT plan, group_or_subplan, cpu_p1, cpu_p2,

2
cpu_p3, parallel_degree_limit_p1, status
3 FROM dba_rsrc_plan_directives;
y
l
n
O
e
s
U

Use the above query to retrieve information on resource plan directives defined in the
database. The below is an example of the output from the above query:
PLAN
---------NIGHT_PLAN
NIGHT_PLAN
NIGHT_PLAN
SYSTEM_PLAN
SYSTEM_PLAN
SYSTEM_PLAN
I
A
GROUP_OR_SUBPLA CPU_P1 CPU_P2 CPU_P3 PARALL ST

--------------- ------ ------ ------ ------ -BATCH
70
0
0
20 AC
OLTP
25
0
0
2 AC
OTHER_GROUPS
5
0
0
2 AC
SYS_GROUP
100
0
0
0 AC
OTHER_GROUPS
0
100
0
0 AC
LOW_GROUP
0
0
100
0 AC
&
l
a
n
r
te
n
I
e
Note that the SYSTEM_PLAN specifies SYS_GROUP at level 1, OTHER_GROUPS at level

2, and LOW_GROUP at level 3 for CPU usage. This setting will simulate a priority system.
r
O
l
c
a
Resource Consumer Groups

and Privileges
SQL> SELECT *
2 FROM dba_rsrc_consumer_group_privs;
y
l
n
O
e
s
U
Resource Consumer Groups and Privileges

The query in the slide lists all resource consumer groups, and the users and roles assigned to
them. The following is an example of the output from the above query:
GRANTEE
------------BRUCE
DAVID
DAVID
JEAN-FRANCOIS
PUBLIC
PUBLIC
SYSTEM
I
A
GRANTED_GROUP
-----------------------------BATCH
BATCH
OLTP
OLTP
DEFAULT_CONSUMER_GROUP
LOW_GROUP
SYS_GROUP
&
l
a
n
r
te
l
c
a
n
I
e
GRA
--NO
NO
YES
YES
YES
NO
NO
I
N
Y
N
Y
Y
N
Y
The columns shown have the following definitions:

grantee: The user or role receiving the grant
granted_group: The granted consumer group name
grant_option: Whether grant was with the GRANT option
initial_group: Whether consumer group is designated as the default for this user
or role
r
O
Resource Consumer Groups and Privileges (continued)

SQL> SELECT consumer_group, status, mandatory
2 FROM dba_rsrc_consumer_groups;
CONSUMER_GROUP
STATUS
MAN
------------------------------ ---------- --BATCH
ACTIVE
NO
OLTP
ACTIVE
NO
OTHER_GROUPS
ACTIVE
YES
ACTIVE
YES
SYS_GROUP
ACTIVE
NO
LOW_GROUP
ACTIVE
NO
The dba_rsrc_manager_system_privs view lists all the users and roles that have
been granted the administer_resource_manager system privilege :
SQL> SELECT *
2 FROM dba_rsrc_manager_system_privs;
GRANTEE
PRIVILEGE
------------------ --------------------------DBA
ADMINISTER RESOURCE MANAGER
EXP_FULL_DATABASE ADMINISTER RESOURCE MANAGER
IMP_FULL_DATABASE ADMINISTER RESOURCE MANAGER
ADM
--YES
NO
NO
Initial Resource Consumer Group

The dba_users view describes all users of the database and the
initial_rsrc_consumer_group relates to the Database Resource Manager :
y
l
n
O
e
SQL> SELECT username, initial_rsrc_consumer_group

2 FROM dba_users;
USERNAME
INITIAL_RSRC_CONSUMER_GROUP
---------------------- -----------------------------SYS
SYS_GROUP
SYSTEM
SYS_GROUP
OUTLN
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Current Database Resource

Manager Settings
v$session: Contains the
resource_consumer_group column that
shows the current group for a session

v$rsrc_plan: A view that shows the active
resource plan
v$rsrc_consumer_group: A view that contains
statistics for all active groups
y
l
n
O
e
s
U
CPU Utilization
There are at least three different views in the system that can provide you with information
about the CPU utilization inside the Oracle database:
v$rsrc_consumer_group shows CPU utilization statistics on a per consumer
group basis, if you are running the Oracle Database Resource Manager. This view
displays data related to currently active resource consumer groups.
v$sysstat shows the Oracle database CPU usage for all sessions. The statistic
CPU used by this session shows the aggregate CPU used by all sessions.
v$sesstat shows the Oracle database CPU usage per session. You can use this view
to determine which particular session is using the most CPU.
The v$rsrc_consumer_group View
I
A
&
l
a
n
r
te
n
I
e
Here is a quick description of some of its columns :

name: Name of the consumer group
active_sessions: Number of currently active sessions in this consumer group
execution_waiters: Number of active sessions waiting for a time slice
requests: Cumulative number of requests executed in this consumer group
cpu_wait_time: Cumulative amount of time that sessions waited for CPU
consumed_cpu_time: Cumulative amount of CPU time consumed by all sessions
r
O
l
c
a
Summary

following:
Set up Database Resource Manager
Assign users to Resource Manager groups
Create resource plans within groups
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
l
c
a
r
O
y
l
n
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Tuning the Operating System
O
e
I
A
&
l
a
n
r
te
r
O
l
c
a
n
I
e
y
l
n
s
U
Objectives

the following:
Describe different system architectures
Describe the primary steps of OS tuning
Identify similarities between OS and DB tuning
Understand virtual memory and paging
Explain the difference between a process and a
thread
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
y
l
n
Operating System Tuning

Memory
SGA
Non-Oracle
processes
Oracle
processes
OS
OS and DB
files
O
e
y
l
n
s
U
Introduction to Operating System Tuning

The system administrator, the person responsible for tuning the operating system (OS), has
tuning concerns similar to those of the database administrator. But the system administrator
is also concerned with how applications other than Oracle applications affect performance.
When tuning, the system administrator considers:
Memory usage
I/O levels
CPU usage
Network traffic
This lesson provides an overview of OS tuning, not specifics. This class focuses on OS
tuning as it relates to the Oracle database rather than system performance tuning issues.
The operating system is tuned in a specific order because each area has its effect on the other
underlying areas. If the memory usage is too high for example, an extra load is placed on the
I/O layer, which in turn places an extra load on the CPU. The correct tuning order is:
1. Memory
2. I/O
3. CPU
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
System Architectures
The Oracle database can run on different system

architectures. Some examples are:
Uni Processor systems
Symmetric multiprocessing systems (SMP)
Massively parallel processing systems (MPP)
Clustered systems
Nonuniform memory architecture systems (NUMA)
O
e
y
l
n
s
U
System Architectures
Uni Processor Systems
Uni Processor systems have only one CPU and one memory.
Symmetric Multiprocessing (SMP) Systems
SMP systems have multiple CPUs. The number commonly ranges from two to 64. All of the
CPUs in an SMP machine share the same memory, system bus, and I/O system. A single
copy of the operating system controls all of the CPUs.
Massively Parallel Processing (MPP) Systems
MPP systems consist of several nodes connected together. Each node has its own CPU,
memory, bus, disks, and I/O system. Each node runs its own copy of the operating system.
Clustered (Cluster) Systems
A cluster consists of several nodes loosely coupled using local area network (LAN)
interconnection technology. Each of the individual nodes can contain one or more CPUs. In
a cluster, system software balances the workload among the nodes and provides for high
availability.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
System Architectures (continued)

Nonuniform Memory Architecture (NUMA) Systems
NUMA systems consist of several SMP systems that are interconnected to form a larger
system. In contrast to a clustered system all of the memory in all of the SMP systems are
connected together to form a single large memory space transparent to all sub-systems. A
single copy of the operating system runs across all the SMP systems.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Virtual and Physical Memory
MMU
Virtual
memory
Physical
memory
Page table
possibly with ISM
O
e
y
l
n
s
U
Virtual Memory
Operating systems make use of virtual memory. Virtual memory gives the application the
feeling that it is the only application on the system. Each application sees a complete
isolated memory area starting at address zero. This virtual memory area is divided into
memory pages, which are usually 4 or 8 KB in size. The operating system maps these virtual
memory pages into physical memory by the use of a memory management unit (MMU). The
mapping between virtual and physical memory is under the control of a page table. On most
operating systems, each process has its own page table. This can cause memory wastage if
many processes need to access a very large area of shared memory. On some platforms,
Solaris for example, this memory wastage can be avoided by sharing the page table entries
for a shared memory area. This is called intimate shared memory (ISM). An additional
benefit of using ISM is that the shared memory area gets locked into physical memory.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Paging and Swapping

Memory
Process
Page
Swap device
O
e
y
l
n
s
U
Paging and Swapping

Operating systems use the same technique to manage memory as the Oracle database: keep
the most recently used pages in real memory. Inadequate memory resources cause too much
paging or swapping to occur. This symptom is often called thrashing, because it causes
blocks to be transferred back and forth (thrashed) between memory and disk.
Paging occurs when a process needs a page (block) of memory that is no longer in real
memory but in virtual memory. The block must be read (paged) in from the disk and the
block in memory that it replaces may also need to be written to disk. Swapping is similar to
paging, except that the memory space of the entire process is removed from memory. If
there are too many processes running at a time, swapping may increase to an unacceptable
level.
Both swapping and paging require adequate disk space to temporarily hold the memory
blocks on disk. These files are I/O intensive, so they also need to be considered when
balancing I/O. Some operating systems, such as Microsoft Windows, do not use swapping
but only paging. Most other operating systems use swapping only as a last resort when the
amount of free memory is getting unacceptably low.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Tuning Memory
Database tuning can improve paging performance

by locking SGA into real memory.
The DBA should monitor real and virtual memory
use.
The DBA should use intimate shared memory, if
it is available.
O
e
y
l
n
s
U
Tuning Memory
DB Tuning and Its Effects on Paging
Besides tuning the SGA, the DBA can also affect paging and swapping performance in
another way.
On some operating systems, the DBA can lock the SGA into real memory by setting the
LOCK_SGA initialization parameter to True, so it is never paged out to disk. Obviously, the
Oracle server performs better if the entire SGA is kept in real memory.
This should be used only on systems that have sufficient memory to hold all the SGA pages
without degrading performance in other areas.
Monitor Memory Usage
Real and virtual memory usage and paging and swapping can usually be monitored by
process or for the entire operating system. The amount of paging and swapping that is
acceptable varies by operating system; some tolerate more than others.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Tuning I/O
Memory
CPU
System bus
I/O
controller
I/O
controller
I/O
controller
O
e
y
l
n
s
U
Tuning I/O
The system administrator improves the performance of disk I/O by balancing the load across
disks and disk controllers.
I/O-intensive systems, such as database servers, perform better with many small disks
instead of a few large disks. More disks reduce the likelihood that a disk becomes a
bottleneck. Parallel Query operations also benefit by distributing the I/O workload over
multiple disk drives.
Raw Devices
A raw device is a disk or disk partition without a file or directory structure. They are more
difficult to administer than operating system files.
Monitoring
I/O performance statistics usually include the number of reads and writes, reads and writes
per second, and I/O request queue lengths. Acceptable loads vary by device and controller.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Understanding Different I/O System Calls
Operating systems can perform disk I/O in two

different ways:
Normal (blocking) I/O
Asynchronous (nonblocking) I/O is implemented
on most platforms and file systems
O
e
y
l
n
s
U
Understanding Different I/O System Calls

The Normal (or Blocking) I/O System Call
When the Oracle database issues an I/O request (read or write) using a normal (or blocking)
I/O system call, it has to wait until the I/O operation has completed. This limits the amount
of I/O that can be performed in a certain amount of time.
The Asynchronous (or Nonblocking) I/O System Call
When the Oracle database issues an I/O request (read or write) using an asynchronous (or
non blocking) I/O system call, processing can continue with no waiting for the I/O operation
to complete. This allows many I/O requests to be issued at the same time. By using
asynchronous I/O the Oracle database can overlap several I/O requests. After the operating
system completes an asynchronous I/O, the operating system notifies the Oracle database
that the I/O request has been completed along with the status of this particular I/O request.
Asynchronous I/O on File Systems
Although asynchronous I/O on file systems is supported on most UNIX implementations, it
is usually implemented using the user-level multithreading capabilities in the operating
system. Therefore, it induces a significant CPU overhead. To avoid this CPU overhead it is
preferred to use multiple database writers or use database writer I/O slaves rather than
asynchronous I/O.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
CPU Tuning
Guidelines:
Maximum CPU busy rate: 90%
Maximum OS/User processing ratio: 40/60
CPU load balanced across CPUs
Monitoring:
CPU
Process
O
e
y
l
n
s
U
CPU Tuning Guidelines

When tuning CPU usage, the system administrator has the following primary concerns:
Are there adequate CPU resources? The system administrator ensures that the CPU is
not too busy. As a general rule, if the CPU is busy 90% of the time, it has probably
reached its capacity.
Is there a good ratio between operating system processing and application processing?
Operating system processing includes the tasks that the operating system performs for
the applications; for example, reading and writing to devices, sending messages
between processes, and scheduling processes.
The goal is to have the CPU working mostly on the application and least on operating
system related tasks. Too much time spent in the operating system mode is a symptom
of an underlying problem, such as:
- Insufficient memory, which also causes swapping or paging
- Poor application design, causing too many operating system calls
For multiprocessing systems, the system administrator must also check that the CPU
load is balanced across all of the CPUs, particularly if any of the CPUs have a very
high usage rate.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
CPU Tuning Guidelines (continued)

CPU Monitoring
Operating system monitors for CPU usage normally include the percentage of time the CPU
is active and the time spent in operating system versus user tasks. Process monitors show the
process status and statistics on the number of I/Os, operating system calls, and paging and
swapping rates.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Process versus Thread

P
r
o
c
e
s
s
e
s
Oracle processes
S
Q
L
P
L
U
S
s
m
o
n
p
m
o
n
a
r
c
0
SQL*PLUS
process
T
h
r
e
a
d
s
c
k
p
t
l
g
w
r
d
b
w
0
Oracle.exe
process
Thread
Threads
O
e
y
l
n
s
U
Processes and Threads

On most operating systems, each Oracle process is also an operating system process.
However under some operating systems, notably Microsoft Windows, the Oracle processors
are implemented as a single operating system process with multiple threads. In Microsoft
Windows the Oracle process threads share the memory allocated to the process.
Each Oracle process is a thread within the operating system process. A thread is a sequence
of instructions that can execute independently of other threads in the same process. This
configuration makes SGA access and communication among Oracle processes more
efficient at the expense of having a limit on the maximum process memory.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Summary
In this lesson, you should have learned how to:

Describe different system architectures
Describe the primary steps of OS tuning
Identify similarities between OS and DB tuning
Understand virtual memory and paging
Explain the difference between a process and
a thread
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
l
c
a
r
O
y
l
n
Workshop Overview
O
e
I
A
&
l
a
n
r
te
r
O
l
c
a
n
I
e
y
l
n
s
U
Objectives

the following:
Use the Oracle tuning methodology to diagnose
and resolve performance problems
Use Oracle tools to diagnose performance
problems
Understand the goals of the workshop
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
y
l
n
Approach to Workshop
Group-oriented and interactive

Intensive hands-on diagnosis and problem
resolution
Proactive participant involvement
O
e
y
l
n
s
U
Approach to Workshop
Group-Oriented and Interactive
The workshop is structured to enable groups of individuals to work together to perform
tuning diagnostics and resolution. Each group is encouraged to share its tuning diagnostic
and resolution approach with other groups in the class.
Intensive Hands-On Diagnosis and Problem Resolution
The intent is to provide you with as much hands-on experience as possible to diagnose and
work through a performance tuning methodology, diagnosis, and resolution. The experience
and knowledge gained from the first four days of this course play a major role in
successfully completing the workshop.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Company Information
Small startup company

Shares a Sun server with 10 other companies
Presently has four employees that use the database
Looking to expand shortly to 20 database users

System was set up by a part-time trainee DBA
System performance is very slow
O
e
y
l
n
s
U
Company Information
Present Situation
The company has two OLTP type users and two DSS types. The system was set up by a
trainee DBA and, though it works, the performance is not acceptable. The company rents
space on a Sun server which it shares with 10 other companies. Due to this there is a
requirement that resources used be kept to a minimum.
Future Goals
At present the company has 4 employees. The company is expanding and is expected to
have 20 concurrent database users. You have been invited in to get the system ready for the
new workload. It is expected that there will be 10 of each type of user.
After collecting the statistics that you think are necessary, implement whatever database
changes your investigation determines would improve the situation. For example, which
parameter values you would set, which tables could do with an index, and so on.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Physical Workshop Configuration
Each client account is set up in the following manner:

All workshop files are located in E:\Labs\Wkshop
All the data files are located at

E:\ORANT\ORA92\ORADATA\ORCL
The E:\ORANT\ORA92\ADMIN\ORCL\BDUM
directory is used for instance-specific trace files.
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
y
l
n
Workshop Database Configuration
The database consists of a sample schema.

Users log in as oltp or dss depending on the
nature of their work.
End users have access to sample schema objects.
There are seven tablespaces: system, undotbs,
temp, users, indx, sample, tools.
The DBA account is system/oracle.
The sys account is sys/oracle.
O
e
y
l
n
s
U
Database Configuration
Use the Oracle data dictionary views to obtain a complete picture of the database
configuration.
Setup for Statspack
Ensure that the job scheduler is set to collect statistics every 10 minutes. This is done by
connecting as the user perfstat and executing the following statement:
I
A
&
l
a
SQL> SELECT job, next_date, next_sec

2 FROM user_jobs;
n
r
te
n
I
e
r
O
l
c
a
Workshop Procedure
1.
2.
3.
4.
5.
6.
7.
Choose a scenario.
Create a Statspack report.
Run the workload generator.
Determine what changes should take place.
Implement the changes.
Return to the second step to check that the
changes have made an improvement.
8. When the changes have improved performance,
choose another scenario.
y
l
n
O
e
s
U
Workshop Procedure
The workshop is executed against the local database. There is a WORKSHOP group on your
desktop. This group includes icons for choosing a scenario and apply a workload.
Choose a Scenario
Seven scenarios are available. Each scenario is represented in the WORKSHOP group as a
.bat file, to set the database for scenario 1 select the icon labeled 1.bat.
I
A
&
l
a
Run the Workload Generator

The two options you have for the workload level you want to run against the database are:
Four users (two OLTP and two DSS)
Twenty users (ten OLTP and ten DSS)
Using these options you can tune the database for the present load and examine which
changes are required to prepare for the future load. The workload scripts are set to run for a
minimum of twenty minutes.
Each logon gets a separate window. This means that for the twenty users there will be
twenty windows opened. These windows must be manually closed by pressing any key
when the window is active. You must check these windows for error messages because these
will be the error messages that your users will report.
n
r
te
n
I
e
r
O
l
c
a
Choosing a Scenario
Open the WORKSHOP group.

Select the icon for the chosen scenario.
Script then makes the relevant changes.
The database is left up and running.
O
e
y
l
n
s
U
Executing the Script

Set up the database appropriately by selecting the icon in the WORKSHOP group that
corresponds to the requested scenario.
After the script has completed the database will be left in an active condition. However,
there are problems with the instance as per the scenario chosen. You must now resolve these
issues.
When resizing memory components, remember not to consume more memory than is
actually required to meet the objects given. The purpose of the workshop is to be as realistic
as possible.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Workshop Scenarios
Choose from the following scenarios:

Shared pool
Buffer cache
Redo log buffer
Indexes
Rollback segments / undo tablespace
Sort area size

Assorted
y
l
n
O
e
s
U
Workshop Scenarios
Workshop Scenario 5
After completing this scenario, change the database back into Automatic Managed Undo.
This can be performed manually or by running the script 0.bat.
I
A
Workshop Scenario 7
This scenario provides a mixture of database tuning problems. Some of the problems are the
same as in other scenarios.
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Collecting Information
To perform a physical investigation of your workshop

database environment, collect statistics by using:
The v$ dynamic performance views
Data dictionary views

Table statistics
Statspack
O
e
y
l
n
s
U
Physical Investigation
Perform a physical investigation of your workshop database environment. Remember to use
the tools that are available to you within the Oracle environment, such as the v$ dynamic
performance views, data dictionary views, table statistics, Statspack, and Oracle Enterprise
Manager. Use the statistics and ratios presented during the first four days of the class to
analyze the baseline. Depending on the scenario used, there are a number of statistics in the
report file that are contrary to a well-tuned database.
Note: While the workload generator is executing, you can use available tools to monitor
database performance. Also ensure that you are in a writable directory when you run the
spreport.sql script.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Generating a Workshop Load
To run the workshop load:

Open the WORKSHOP group
Select the desired workload:

Four users (current)
Twenty Users (future)
O
e
y
l
n
s
U
Generating a Workshop Load

To generate a workshop load:
Open the WORKSHOP group on the desktop.
Select the workload generator required:
- Current: This workload represents the companies current position. There are
four users, two DSS and 2 OLTP. This workload should be used for tuning the
current database.
- Future: This workload represents the future of the company. There are twenty
users, ten OLTP and ten DSS. The workload should be used to plan for needs in
the future.
After a number of snapshots have been collected by Statspack, run the
spreport.sql script. For the time period, choose a begin and end time within the
period that the workload generator was running. Remember that the closer the snapshot
is to the database startup, the more that event will affect the statistics that are collected.
Name the report in a manner associated with the scenario, for example, for scenario 1
use reportscn1.txt, for Scenario 5 use reportscn5.txt, and so on.
Look for the report that you generated.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Results
Present your conclusions and findings.

Demonstrate the effectiveness of the tuning
strategy and what effect the changes to the
instance and database parameters had on overall
performance.
What was done and why?

What were the results?
Are there still any issues pending?
What would you do differently?
O
e
y
l
n
s
U
Conclusions
Each group presents its conclusions and findings to the rest of class. The intent is to
demonstrate the effectiveness of the tuning strategy and show what effect the modifications
to the instance and database parameters had on overall performance. Include the following
items in your presentation:
What was done?
What was the justification?
What were the results?
Are there any pending issues?
What would you do differently?
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Summary
In this lesson, you should have learned how to:

Follow the Oracle tuning methodology:
Collect and review statistics.
List the objectives for enhanced performance
before modifications.
Modify the instance and the database.
Re-collect and review new statistics.
Compare the new results with the objectives.
Implement Oracle architectural options for

enhancing performance.
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
l
c
a
r
O
y
l
n
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Practice Solutions Using SQL Plus
O
e
I
A
&
l
a
n
r
te
r
O
l
c
a
n
I
e
y
l
n
s
U
Practice 2
The goal of this practice is to familiarize you with the different methods of collecting
statistical information. Throughout this practice Oracle Enterprise Manager can be used if
1. Log on as directed by the instructor. If the database is not already started, connect to
SQL*Plus using sys/oracle as sysdba, then start up the instance using the
STARTUP command. Ensure that the password for the user system is set to oracle.
Check that TIMED_STATISTICS has been set to True; if it has not, then set it
using the ALTER SYSTEM statement.
SQL> CONNECT sys/oracle AS sysdba
SQL> ALTER USER system IDENTIFIED BY oracle;
SQL> SHOW PARAMETER TIMED_STATISTICS
If a value of True is returned, then continue to question 2. If a value of False is

returned, then set the TIMED_STATISTICS parameter to True using the command:
SQL> ALTER SYSTEM SET TIMED_STATISTICS = True
2
SCOPE = both;
y
l
n
2. Connect to SQL*Plus as the system user and issue a command that will create a
trace file for this session. Run a query to count the number of rows in the
dba_tables dictionary view. To locate your new trace file easier, if possible,
delete all the trace files in the USER_DUMP_DEST directory before running the
trace. Remember to disable the trace command after running the query.
O
e
SQL>
SQL>
SQL>
SQL>
I
A
s
U
CONNECT system/oracle
ALTER SESSION SET SQL_TRACE = TRUE;
SELECT COUNT(*) FROM dba_tables;
ALTER SESSION SET SQL_TRACE = FALSE;
&
l
a
n
r
te
3. At the operating system level view the resulting trace file located in the directory set
by USER_DUMP_DEST. Do not try to interpret the content of the trace file, because
this is the topic of a later lesson.
n
I
e
$cd $HOME/ADMIN/UDUMP
$ls l
r
O
l
c
a
-rw-r----- 1 user487 dba 4444 Apr 24 22:28 U487_ora_3270.trc
Oracle9i Database Performance Tuning A-2
4. Open two sessions, the first as hr/hr, and the second as sys/oracle as
sysdba. From the second session generate a user trace file for the first session using
the dbms_system.set_sql_trace_in_session procedure. Get the user id
and serial# from v$session.
From Session 1
$ SQL*Plus hr/hr
Change to Session 2
$ SQL*Plus sys/oracle as sysdba
SQL> SELECT username, sid, serial#
2 FROM v$session
3 WHERE username = 'HR';
SQL> BEGIN
2 dbms_system.set_sql_trace_in_session
3 (&SID,&SERIALNUM,TRUE);
4 END;
5 /
Change to Session 1
SQL> SELECT * FROM employees;
Change to Session 2
SQL>
2
3
4
5
BEGIN
dbms_system.set_sql_trace_in_session
(&SID,&SERIALNUM,FALSE);
END;
/
y
l
n
O
e
s
U
5. Confirm that the trace file has been created in the directory set by
USER_DUMP_DEST.
$ls l
-rw-r----- 1 dba01 dba
dba01_ora_3270.trc
dba01_ora_3281.trc
I
A
4444 Apr 24 22:28
&
l
a
15443 Apr 24 22:42
n
r
te
6. Connect to SQL*Plus using sys/oracle as sysdba and create a new

tablespace (tools) to hold the tables and other segments required by Statspack.
This tablespace must be 200 MB and be dictionary managed (this is not a
requirement of Statspack, but will be used later in the course). Name the datafile
tools01.dbf and place it in the $HOME/ORADATA/u05 directory.
Note: Dictionary managed is not the default.
n
I
e
r
O
l
c
a
SQL>
SQL>
2
3
CONNECT sys/oracle AS sysdba

CREATE TABLESPACE tools
DATA FILE '$HOME/ORADATA/u05/tools01.dbf' SIZE 200M
EXTENT MANAGEMENT DICTIONARY;
7. Confirm and record the amount of free space available within the tools tablespace
by querying the dba_free_space view. Also check that the tablespace is
dictionary managed.
SQL>
2
3
SQL>
2
3
4
SELECT tablespace_name, extent_management

FROM dba_tablespaces
WHERE tablespace_name = 'TOOLS';
SELECT tablespace_name, sum(bytes)
FROM dba_free_space
WHERE tablespace_name = 'TOOLS'
GROUP BY tablespace_name;
8. Connect using sys/oracle as sysdba, then install Statspack using the

spcreate.sql script located in your $HOME/STUDENT/LABS directory. Use
the following settings when asked by the installation program:
- Users Default Tablespace = TOOLS
- Users Temporary Tablespace = TEMP
SQL> @$HOME/STUDENT/LABS/spcreate.sql
y
l
n
9. Query dba_free_space to determine the amount of free space left in the tools
tablespace. The difference between this value and the one recorded in step 7 will be
the space required for the initial installation of Statspack.
O
e
s
U
Note: The amount of storage space required will increase in proportion to the
amount of information stored within the Statspack tables, that is, the number of
snapshots.
I
A
Subtract the value received now, from the value received in step 7 to get the amount
of space required to install Statspack
&
l
a
10. Manually collect current statistics using Statspack by running the snap.sql script
located in $HOME/STUDENT/LABS. This will return the snap_id for the
snapshot just taken, which should be recorded.
n
r
te
n
I
e
SQL > @$HOME/STUDENT/LABS/snap.sql
r
O
l
c
a
11. To have Statspack automatically collect statistics every three minutes execute the
spauto.sql script located in your $HOME/STUDENT/LABS directory. Query the
database to confirm that the job has been registered using the user_jobs view.
SQL > @$HOME/STUDENT/LABS/spauto.sql
SQL > SELECT job, next_date, next_sec, last_sec
2
FROM user_jobs;
Note: The spauto.sql script in the $HOME/STUDENT/LABS directory has been

altered from the spauto.sql script shipped with the Oracle database. The
alteration has changed the time between snapshots from 1 hour to 3 minutes.
12. After waiting for a period in excess of three minutes query the stats$snapshot
view to list which snapshots have been collected. There must be at least two
snapshots before moving to the next step.
SQL>
2
3
4
5
6
7
SELECT snap_id,
TO_CHAR(startup_time, 'dd Mon "at" HH24:mi:ss')
instart_fm,
TO_CHAR(snap_time,'dd Mon YYYY HH24:mi') snap_date,
snap_level level
FROM stats$snapshot
ORDER BY snap_id;
Note: If the job scheduler is not working, check the value of the
JOB_QUEUE_PROCESSES parameter. The value should be greater than 0.
y
l
n
O
e
s
U
13. When there are at least two snapshots, start to generate a report. This is performed
using the spreport.sql script found in the $HOME/STUDENT/LABS directory.
The script lists the snapshot options available and then requests the beginning snap
id and the end snap id. The user is then requested to give a filename for the
report. It is often best left to the default.
I
A
&
l
a
SQL> @$HOME/STUDENT/LABS/spreport.sql
n
r
te
14. Locate the report file in the users current directory, then using any text editor, open
and examine the report. The first page shows a collection of the most queried
statistics.
n
I
e
l
c
a
$ vi sp_X_Y.lst
where X is the starting snapshot and Y is the ending snapshot (this is true if the
default report filename was used).
r
O
15. Connect to the database as a system administrator sys/oracle as sysdba.

16. Query the database to determine what system wait events have been registered since
startup using v$system_event.
SQL> SELECT event, total_waits, time_waited
2 FROM v$system_event;
Dynamic Performance Views

17. Determine whether there are any sessions actually waiting for resources, using
v$session_wait.
SQL> SELECT sid, event, p1text, wait_time, state
2 FROM v$session_wait;
18. Stop the automatic collection of statistics by removing the job. This is performed by
connecting as perfstat/perfstat and querying the user_jobs view to get
the job number. Then execute the dbms_job.remove procedure.
SQL>
SQL>
2
SQL>
CONNECT perfstat/perfstat
SELECT job, log_user
FROM user_jobs;
EXECUTE dbms_job.remove ($job_to_remove);
y
l
n
O
e
19. Connect to your database using Oracle Enterprise Manager. The lecturer will supply
the information required to connect to the Oracle Management Server. After you
have connected to the database, use Oracle Enterprise Manager to explore the
database. Examine items such as the number of tablespaces, users, and tables.
I
A
s
U
Oracle Classroom Only

If you are in an Oracle classroom you must perform the following four steps that are
specific to the Oracle classroom setup:
a. Click the omsconfig file update icon on the desktop and enter the name of
the UNIX server your class is using. Your instructor will provide the server
name. Please note that this is a case-sensitive entry.
b. Open an MSDOS window.
c. At the command prompt enter: oemctl start oms
Wait for the message: The Oracleoracle901_homeManagementServer service
was started successfully.
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Oracle Classroom Only (continued)
d. Close the MSDOS window.
Start the Oracle Enterprise Manager Console and set the Administrator to
sysman and the password to oem_temp. When prompted, change the
password to oracle. Select Discover Nodes from the Navigator and enter
the host name of the server of your working database.
i. From the Start menu > Programs > Oracle OracleHome >
Enterprise Manager Console
ii. Make sure the Login to the Oracle Management Server is selected.
iii. Administrator: sysman
iv. Password: oem_temp
v. Management server is your machine.
vi. When prompted to change the sysman password to oracle.
vii. Select Navigator > Discover Nodes from the console menu, or select
Discover Nodes from the right mouse shortcut menu to open the
Discover Nodes dialog box.
viii. From the Discovery Wizard: Introduction page, click Next, enter the
name of your UNIX database server, and click Next.
ix. Click Next, give your regular administrator access to your database.
x. Click Finish, then OK. If your discovery was not successful contact
your instructor.
y
l
n
O
e
20. From Oracle Enterprise Manager load Oracle Expert and create a new tuning session.
Limit the tuning scope to Check for Instance Optimizations. This is done to reduce
the time taken to collect information. Collect a new set of data.
I
A
s
U
Note: Do not implement the changes that Oracle Expert recommends, because this
will be done during the course.
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Practice 3
Throughout this practice Oracle Enterprise Manager can be used if desired. SQL
Worksheet can be used instead of SQL*Plus and there are many uses for the Oracle
Enterprise Manager console. (Solutions for Oracle Enterprise Manager can be found in
Appendix B).
1. Connect as system/oracle and diagnose database file configuration by querying
the v$datafile, v$logfile and v$controlfile dynamic performance
views.
SQL>
SQL>
2
3
4
5
6
7
8
9
10
11
SELECT name FROM v$datafile
UNION
SELECT member FROM v$logfile
UNION
SELECT name FROM v$controlfile
UNION
SELECT value FROM v$parameter
WHERE (name LIKE `log_archive_dest%
AND name NOT LIKE 'log_archive_dest_state%')
OR name IN
('log_archive_dest','log_archive_duplex_dest');
y
l
n
2. Diagnose database file usage by querying the v$filestat dynamic performance

view, combine with v$datafile to get the data file names.
SQL> SELECT phyrds, phywrts, d.name
2 FROM v$datafile d, v$filestat f
3 WHERE d.file#=f.file#;
I
A
O
e
s
U
3. Determine whether there are waits for redo log files by querying the
v$system_event dynamic performance view, where the waiting event is log file
sync or log file parallel write.
SQL>
2
3
4
&
l
a
SELECT event, total_waits,time_waited, average_wait

FROM v$system_event
WHERE event = 'log file sync'
OR event = 'log file parallel write';
n
r
te
n
I
e
Waits for log file sync are indicative of slow disks that store the online logs or
unbatched commits. The log file parallel write is much less useful because this event
only shows how often LGWR waits, not how often server processes wait. If LGWR
waits without impacting user processes, there is no performance problem. If LGWR
waits, it is likely that the log file sync event (mentioned above) will also be evident.
r
O
l
c
a
4. Connect as perfstat/perfstat and diagnose file usage from Statspack.
a. Generate a Statspack report using
$HOME/STUDENT/LABS/spreport.sql
b. Locate and open the report file.
c. Examine the report and search for the File IO Stats string.
Note: On a production database care should be taken in monitoring the disk
and controller usage by balancing the workload across all devices. If your
examination shows a distinct over-utilization of a particular data file, consider
resolving the cause of the amount of I/O. For example, investigate the number
of full table scans, clustering of files on a specific device and under-utilization
of indexes. If after this the problem remains then look at placing the data file on
a low utilization device.
5. Connect as system/oracle and enable checkpoints to be logged in the alert file
by setting the value of the LOG_CHECKPOINTS_TO_ALERT parameter to True
using the ALTER SYSTEM SET command.
SQL> CONNECT system/oracle
SQL> ALTER SYSTEM SET LOG_CHECKPOINTS_TO_ALERT = True;
y
l
n
6. Connect as sh/sh and execute the $HOME/STUDENT/LABS/lab03_06.sql

script to provide a workload against the database.
SQL> CONNECT sh/sh
SQL> @$HOME/STUDENT/LABS/lab03_06.sql
O
e
s
U
7. At the operating system level use the editor to open the alert log file (located in the
directory specified by BACKGROUND_DUMP_DEST). Then determine the
checkpoint frequency for your instance by searching for messages containing the
phrase Completed Checkpoint. The time difference between two consecutive
messages is the checkpoint interval.
I
A
&
l
a
Open the alert log file using an editor and search for the line: Completed checkpoint.
The line before this will be the time at which the checkpoint occurred. Search for the
following checkpoint time and then subtract to get the time between checkpoints.
n
r
te
n
I
e
Note: On a production system the checkpoint interval should range between 15

minutes to 2 hours. The actual interval is dependant on the type of application and
the amount of DML activity.
r
O
l
c
a
Practice 4
The objective of this practice is to use diagnostic tools to monitor and tune the shared pool.
Appendix B).
1. Connect using sys/oracle as sysdba and check the size of the shared pool.
SQL> SHOW PARAMETER SHARED_POOL
NAME
---------------------------shared_pool_reserved_size
shared_pool_size
TYPE
----------big integer
big integer
VALUE
--------------2516582
50331648
2. Connect as perfstat/perfstat, execute the

$HOME/STUDENT/LABS/snap.sql script to collect initial snapshot of statistics,
and note the snapshot number.
y
l
n
SQL> CONNECT perfstat/perfstat

SQL> @$HOME/STUDENT/LABS/snap.sql
O
e
3. To simulate user activity against the database open two operating system sessions. In
session 1 connect as hr/hr and run the
$HOME/STUDENT/LABS/lab04_03_1.sql script. In the second session
connect as hr/hr and run the $HOME/STUDENT/LABS/lab04_03_2.sql
script.
I
A
In session 1:
&
l
a
s
U
SQL> CONNECT hr/hr

SQL> @$HOME/STUDENT/LABS/lab04_03_1.sql
In session 2:
n
r
te
SQL> CONNECT hr/hr

SQL> @$HOME/STUDENT/LABS/lab04_03_2.sql
n
I
e
4. Connect as system/oracle and measure the pin-to-reload ratio for the library
cache by querying v$librarycache. Determine whether it is a good ratio or not.
l
c
a
Using the dynamic view:
r
O
SQL>
SQL>
2
3
SELECT SUM(pins), SUM(reloads),
SUM(pins) * 100 / SUM(pins+reloads) Pin Hit%
FROM v$librarycache;
5. Connect as system/oracle and measure the get-hit ratio for the data dictionary
cache by querying v$rowcache. Determine whether it is a good ratio or not using
the dynamic view.
SQL>
SQL>
2
3
SELECT SUM(getmisses), SUM(gets),
SUM(getmisses )*100/SUM(gets)MISS %
FROM v$rowcache;
If GETMISSES are lower than 15% of the GETS, then it is a good ratio.
6. Connect as perfstat/perfstat and run the
$HOME/STUDENT/LABS/snap.sql script to collect a statistic snapshot and
obtain the snapshot number. Record this number.
7. As perfstat/perfstat obtain the statistics report between the two recorded

snapshot IDs (from questions 2 and 6) by running the
$HOME/STUDENT/LABS/spreport.sql script.
y
l
n
O
e
s
U
The following is an example of using a beginning snapshot_id of 3 and an

ending snapshot_id of 5.
I
A
Specify the Begin and End Snapshot Ids

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Enter value for begin_snap:
3
&
l
a
Enter value for end_snap: 5

End
Snapshot Id specified: 5
n
r
te
Specify the Report Name

~~~~~~~~~~~~~~~~~~~~~~~
The default report file name is sp_3_5. To use this
name, press <return> to continue, otherwise enter an
alternative.
Enter value for report_name:
n
I
e
r
O
l
c
a
8. Analyze the generated report in the current directory. What would you consider
doing if the library hit ratio (found under the heading Instance Efficiency
Percentages) is less than 98%?
Increase the SHARED_POOL_SIZE parameter.
9. Connect as system/oracle and determine which packages, procedures, and
triggers are pinned in the shared pool by querying v$db_object_cache.
SQL> SELECT name, type, kept
2 FROM v$db_object_cache
3 WHERE type IN
4 ('PACKAGE', 'PROCEDURE', 'TRIGGER', 'PACKAGE
BODY');
10. Connect using sys/oracle as sysdba and pin one of the Oracle supplied
packages that must be kept in memory, such as sys.standard using the
dbms_shared_pool.keep procedure, which is created by running the
$ORACLE_HOME/rdbms/admin/dbmspool.sql script.
SQL>
SQL>
SQL>
SQL>
2
3
4
CONNECT sys/oracle AS SYSDBA

@?/rdbms/admin/dbmspool
EXECUTE dbms_shared_pool.keep('SYS.STANDARD');
SELECT distinct owner, name
FROM v$db_object_cache
WHERE kept='YES'
AND name LIKE '%STAND%';
y
l
n
O
e
I
A
s
U
11. Determine the amount of session memory used by your session by querying the
v$mystat view. Limit the output by including the clause:
WHERE name = 'session uga memory'

SQL>
2
3
4
&
l
a
SELECT a.name, b.value

FROM v$statname a, v$mystat b
WHERE a.statistic# = b.statistic#
AND name = 'session uga memory';
n
r
te
Note: Because you are not using the Oracle Shared Server configuration this
memory resides outside the SGA.
n
I
e
l
c
a
12. Determine the amount of session memory used for all sessions, using v$sesstat
and v$statname views:
r
O
SQL>
2
3
4
SELECT SUM(value)||' bytes' "Total session memory

FROM v$sesstat, v$statname
AND v$sesstat.statistic# = v$statname.statistic#;
Practice 5
The objective of this practice is to use available diagnostic tools to monitor and tune the
database buffer cache. Throughout this practice Oracle Enterprise Manager can be used if
1. Connect as perfstat/perfstat and run a statistic snapshot. Make a note of the
snapshot number. The snap shot can be taken by running the
$HOME/STUDENT/LABS/snap.sql script file.
2. To simulate user activity against the database, connect as the hr/hr user and run
the lab05_02.sql script.
SQL> CONNECT hr/hr
3. Connect as system/oracle and measure the hit ratio for the database buffer
cache using the v$sysstat view. Determine whether it is a good ratio or not.
SQL>
SQL>
2
3
4
5
6
7
8
y
l
n
O
e
SELECT 1 - (phy.value lob.value dir.value)
/ ses.value "CACHE HIT RATIO
FROM
v$sysstat ses, v$sysstat lob,
v$sysstat dir, v$sysstat phy
WHERE ses.name = 'session logical reads'
AND
dir.name = 'physical reads direct'
AND
lob.name = 'physical reads direct (lob)'
AND
phy.name = 'physical reads';
I
A
&
l
a
s
U
4. Connect as perfstat/perfstat run a statistic snapshot. Make a note of the

snapshot number. The snapshot can be taken by running the
$HOME/STUDENT/LABS/snap.sql script file.
n
r
te
n
I
e

l
c
a
5. Use the report from Statspack between the last two snapshots to check the buffer
cache hit ratio, using the $HOME/STUDENT/LABS/spreport.sql script. Then
analyze the buffer hit % in the Instance Efficiency Percentages section.
r
O
Note: On a production database if the ratio is bad, add new buffers, run steps 2 to 5,
and examine the new ratio to verify that the ratio has improved. If the ratio is good,
remove buffers, run steps 2 to 5, and verify if the ratio is still good.
6. Connect as system/oracle and determine the size of the temp_emps table in
the hr schema that you want to place in the keep buffer pool. Do this by using the
dbms_stats.gather_table_stats procedure and then query the blocks
column of the dba_tables view for the temp_emps table.
SQL>
SQL>
>
SQL>
2
3
EXECUTE dbms_stats.gather_table_stats ('HR','TEMP_EMPS');
SELECT table_name , blocks
FROM dba_tables
WHERE table_name IN ('TEMP_EMPS');
7. Keep temp_emps in the keep pool. Use the ALTER SYSTEM command to set
DB_KEEP_CACHE_SIZE to 4 MB for the keep pool. Limit the scope of this
command to the spfile.
SQL> ALTER SYSTEM SET DB_KEEP_CACHE_SIZE=4M
SCOPE=spfile;
y
l
n
O
e
8. For the keep pool to be allocated the database needs to be restarted. You will need to
be connected as a sysdba user to perform this task.
SQL> SHUTDOWN IMMEDIATE
SQL> STARTUP
I
A
s
U
9. Connect as system/oracle and enable the temp_emps table in the hr schema

for caching in the keep pool, using the storage clause of the ALTER TABLE
command.
&
l
a
n
r
te

SQL> ALTER TABLE hr.temp_emps
2 STORAGE (BUFFER_POOL Keep);
n
I
e
SQL> SELECT table_name, buffer_pool

2 FROM dba_tables
3 WHERE buffer_pool = 'KEEP';
r
O
l
c
a
10. Connect as hr/hr and run the $HOME/STUDENT/LABS/lab05_10.sql script.
This will execute a query against the temp_emps table in the hr schema.
SQL> CONNECT hr/hr
11. Connect using sys/oracle as sysdba and check for the hit ratio in different
buffer pools, using the v$buffer_pool_statistics view.
SQL>
SQL>
2
3
4

SELECT name, physical_reads, db_block_gets,
consistent_gets, 1 - (physical_reads
/ (db_block_gets + consistent_gets)) "hits"
FROM v$buffer_pool_statistics;
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Practice 6
Appendix B).
1. Connect as sys/oracle AS sysdba and, without restarting the instance, resize
the DB_CACHE_SIZE to 12 Mb. Limit the effect of this command to memory, so as
not to modify the spfile.
SQL> ALTER SYSTEM SET DB_CACHE_SIZE = 12M
2
SCOPE = memory;
Note: This will encounter an error because the total SGA size will be bigger than
SGA_MAX_SIZE. To overcome this you must either change the value of
SGA_MAX_SIZE and restart the instance (which is what dynamic allocation is
meant to avoid) or resize a component, thus making memory available for the
increase in the buffer cache.
2. Reduce the memory used by the shared pool. Limit the effect of this command to
memory, so as not to modify the spfile.
y
l
n
O
e
SQL> ALTER SYSTEM SET SHARED_POOL_SIZE = 40M

2
SCOPE = memory;
s
U
3. Without restarting the instance, resize the DB_CACHE_SIZE to 12 Mb. Limit the
effect of this command to memory, so as not to modify the spfile.
I
A
SQL> ALTER SYSTEM SET DB_CACHE_SIZE = 12M

2
SCOPE = memory;
&
l
a
Note: This time the memory is available so the command will be executed.
n
r
te
4. To return the SGA to the original configuration, restart the instance. You must be
connected as a sysdba user to perform this task.
n
I
e

SQL> SHUTDOWN IMMEDIATE
SQL> STARTUP
r
O
l
c
a
Practice 7
Appendix B).
1. Connect as perfstat/perfstat and collect a snapshot of the current statistics
by running the $HOME/STUDENT/LABS/snap.sql script. Record the snapshot
ID for later use.
SQL> @$HOME/STUDENT/LABS/snap;
2. Connect as user sh/sh and run the $HOME/STUDENT/LABS/lab07_02.sql

script in the $HOME/STUDENT/LABS directory to put a workload on the database.
SQL> CONNECT sh/sh
3. Connect as system/oracle and query the v$sysstat view to determine

whether there are space requests for the redo log buffer.
SQL>
SQL>
2
3
4
y
l
n
SELECT rbar.name, rbar.value, re.name, re.value
FROM v$sysstat rbar, v$sysstat re
WHERE rbar.name = 'redo buffer allocation retries'
AND re.name = 'redo entries';
O
e
I
A
s
U
4. Connect as perfstat/perfstat and collect another set of statistics using the

$HOME/STUDENT/LABS/snap.sql script. Then use
$HOME/STUDENT/LABS/spreport.sql to generate a report using the two
snapshot IDs that you have collected. From the list of snapshots select a beginning
and end value. The beginning is the value recorded in step 1 and the end value step
4. Record the name of the report file. View the generated file using an editor and
locate the log buffer space statistic.
&
l
a
n
r
te

SQL> @$HOME/STUDENT/LABS/snap.sql;
n
I
e
r
O
l
c
a
5. Connect as sys/oracle AS sysdba and increase the size of the redo log buffer
in the spfile by changing the value of the LOG_BUFFER parameter. Because this
parameter is static you must specify spfile.
SQL> ALTER SYSTEM SET LOG_BUFFER = 128000
2
SCOPE = spfile;
6. To have the new value for the LOG_BUFFER take effect, you must restart the
instance. Then confirm that the change has occurred.
SQL> SHUTDOWN immediate
SQL> STARTUP
SQL> SHOW PARAMETER LOG_BUFFER
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Practice 9
Appendix B).
1. Set the database to use the manual sort option by changing the value of the
WORKAREA_SIZE_POLICY parameter to Manual. Set the SORT_AREA_SIZE
parameter to 512 bytes.
SQL> ALTER SYSTEM SET WORKAREA_SIZE_POLICY = manual
2
SCOPE = both;
SQL> ALTER SYSTEM SET SORT_AREA_SIZE = 512
2
SCOPE= spfile;
2. For the new value of the LOG_BUFFER parameter to take effect, you must restart the
instance. Then query the v$sysstat view and record the value for sorts (memory)
and sorts (disk).
SQL>
SQL>
SQL>
2
3
SHUTDOWN immediate
STARTUP
SELECT name, value
FROM v$sysstat
WHERE name LIKE 'sorts%';
y
l
n
O
e
Note: The statistics in v$sysstat are collected from startup. If you need to obtain
accurate statistics per statement, you must record statistics before the statement runs
and again afterwards. Subtracting to two values gives the statistics for the statement.
I
A
s
U
3. To perform a sort on the database that will have sorts to disk connect as sh/sh and
execute the $HOME/STUDENT/LABS/lab09_03.sql script.
&
l
a
SQL> CONNECT sh/sh

SQL> @$HOME/STUDENT/LABS/lab09_03.sql;
n
r
te
Note: If this script fails due to a lack of free space in the temp tablespace then
connect as system/oracle and resize the temporary tablespace.
n
I
e

SQL> ALTER DATABASE TEMPFILE
2 '$HOME/ORADATA/u02/temp01.dbf' RESIZE 400M;
r
O
l
c
a
4. Connect as system/oracle, query the v$sysstat view again, and record the
value for sorts (memory) and sorts (disk). Subtract the values from the recorded
value in question 2. If the ratio of Disk to Memory sorts is greater than 5% then
increase the sort area available.
SQL>
SQL>
2
3
SELECT name, value
FROM v$sysstat
5. Connect as system/oracle and query the tablespace_name,

current_users, used_extents, and free_extents columns from the
v$sort_segment view. The used_extents and free_extents columns
are useful in monitoring the usage of the temporary tablespace.
SQL> SELECT tablespace_name, max_sort_size,
2
max_used_size
3 FROM v$sort_segment;
Note: If this statement returns no rows, it means that all sort operations since startup
have completed in memory.
6. To decrease the number of sorts going to a temporary tablespace, increase the value
of the SORT_AREA_SIZE parameter to 512000 using the ALTER SESSION
command.
O
e
y
l
n
SQL> ALTER SESSION SET SORT_AREA_SIZE = 512000;
7. Connect as system/oracle and configure the parameters for automatic PGA

memory allocation using the ALTER SYSTEM command. Use the values Auto for
WORKAREA_SIZE_POLICY and 10M for PGA_AGGREGATE_TARGET).
I
A
s
U

SQL> ALTER SYSTEM SET PGA_AGGREGATE_TARGET = 10M
2
SCOPE = Both;
SQL> ALTER SYSTEM SET WORKAREA_SIZE_POLICY = Auto
2
SCOPE = Both;
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Practice 10
rollback segments. This would require setting the database to Manual Undo Management
mode. Throughout this practice Oracle Enterprise Manager can be used if desired. SQL
Appendix B).
1. Set the database in Manual Undo Mode by connecting as sys/oracle AS
sysdba and change the following parameters to the values shown:
undo_management = Manual
undo_tablespace = Null
Restart the database and confirm that the UNDO_MANAGEMENT parameter is set to
Manual and that UNDO_TABLESPACE is Null.
SQL>
SQL>
2
SQL>
2
SQL>
SQL>
SQL>

ALTER SYSTEM SET UNDO_MANAGEMENT = Manual
SCOPE = Spfile;
ALTER SYSTEM SET UNDO_TABLESPACE = ''
SCOPE = Spfile;
SHUTDOWN immediate
STARTUP
SHOW PARAMETER undo
y
l
n
O
e
2. Use the CREATE TABLESPACE command to create a new rollback segment

tablespace rbs_test that is 2 MB in size. Name the data file rbs_test.dbf
and place it in the $HOME/ORADATA/u03 directory. Create the tablespace as
dictionary managed, which is required for rollback segments.
I
A
s
U
SQL> CREATE TABLESPACE rbs_test

2 DATAFILE '$HOME/ORADATA/u03/rbs_test.dbf' size 2M
3 EXTENT MANAGEMENT DICTIONARY;
&
l
a
Note: This is not to be an UNDO tablespace and you must specify that it is to be
dictionary managed.
n
r
te
3. For the purposes of this practice, create a new rollback segment called rbsx in the
rbs_test tablespace. For the storage parameters, use 64 KB for the INITIAL and
NEXT extent sizes with MINEXTENTS value set to 20. Set the OPTIMAL value so
that the segment shrinks back to 1280 KB automatically.
n
I
e
r
O
l
c
a
SQL>
2
3
4
CREATE ROLLBACK SEGMENT rbsx

TABLESPACE rbs_test
STORAGE (INITIAL 64K NEXT 64K MINEXTENTS 20
OPTIMAL 1280K);
4. Bring the rbsx rollback segment online and ensure that any others (except the
system rollback segment) are offline. Query the dba_rollback_segs view to
get the segment_name and status of the rollback segments to be taken offline using
the ALTER ROLLBACK SEGMENT command.
SQL> ALTER ROLLBACK SEGMENT rbsx ONLINE;
SQL> SELECT segment_id, segment_name, status
2 FROM dba_rollback_segs;
5. Before executing a new transaction, find the number of bytes written so far in the
rbsx rollback segment, using the writes column of v$rollstat.
SQL> SELECT usn, writes
2 FROM v$rollstat
3 WHERE usn>0;
6. Open two sessions. In session 1 connect as hr/hr and run the

$HOME/STUDENT/LABS/ins_temps.sql script. The script inserts 100 new
rows into the temp_emps table. Do not COMMIT this transaction. In the second
session, log in as system/oracle, determine how many rollback segment blocks
or bytes the transaction is using. To do this query the writes column of
v$rollstat to get the number of bytes written in the rbsx rollback segment so
far. Record this value.
y
l
n
In session 1:
I
A
In Session 2:
SQL>
SQL>
2
3
SELECT usn, writes
FROM v$rollstat
WHERE usn>0;
&
l
a
O
e
s
U
SQL> CONNECT hr/hr

SQL> @$HOME/STUDENT/LABS/ins_temps.sql
n
r
te
Note: The number of writes in the rollback segment between questions 5 and 6 is the
difference in the value of the writes column at the respective times.
n
I
e
7. In session 2, join the v$transaction and v$session views to find, in the

used_ublk column, how many blocks the ins_temps transaction is using.
r
O
l
c
a
SQL> SELECT s.username, t.used_ublk, t.start_time

2 FROM v$transaction t, v$session s
3 WHERE t.addr = s.taddr;
8. Return to the hr session (the first session) and commit the insert. Run the
$HOME/STUDENT/LABS/del_temps.sql script. Do not COMMIT. The script
deletes the hundred rows you have just inserted. As user system (in the second
session), check the amount of rollback space used, using the writes column of
v$rollstat. Note the difference between the return value and that found in
question 6.
In session 1:
SQL> COMMIT;
SQL> @$HOME/STUDENT/LABS/del_temps.sql
In session 2:
2 FROM v$rollstat
3 WHERE usn>0;
9. In session 2, connect as system/oracle and find out if you have had any rollback
segment contention since startup, using the waits and gets columns in the
v$rollstat view.
SQL> SELECT SUM(waits)/SUM(gets) Ratio",
2 SUM(waits) "Waits", SUM(gets) "Gets
3 FROM v$rollstat;
y
l
n
O
e
Note: In a production environment a better source of information would be

Rollback Segment section in the Statspack report.
I
A
s
U
10. Does the v$system_event view show any waits related to rollback segments?
Using session 2, query in v$system_event view for the undo segment tx slot
entry.
&
l
a
SQL> SELECT * from v$system_event

2 WHERE event ='undo segment tx slot';
n
r
te
Note: Because only one session is making changes it is unlikely that there will be
any contention for the undo segment transaction slot.
n
I
e
11. In session 1 commit the transaction. Then connect as hr/hr and run the
$HOME/STUDENT/LABS/ins_temps.sql script again, allocating the
transaction to a specific rollback segment rbsx, using the set transaction use
rollback segment command. In session 2, check that the transaction is using the
defined rollback segment join the v$rollstat, v$session, and
v$transaction views.
r
O
l
c
a
In session 1:
SQL> COMMIT;
SQL> SET TRANSACTION USE ROLLBACK SEGMENT rbsx;
SQL> @$HOME/STUDENT/LABS/ins_temps.sql
In session 2:
SQL>
2>
3>
4>
5>
SELECT s.username, rn.name

FROM v$session s, v$transaction t,
v$rollstat r, v$rollname rn
WHERE s.saddr = t.ses_addr
AND t.xidusn = r.usn AND r.usn = rn.usn;
12. Close session 2, then in session 1 connect as sys/oracle AS sysdba and set
the database in Auto Undo Mode by changing the following parameters to the values
shown:
undo_management = Auto
undo_tablespace = undotbs
Auto and that UNDO_TABLESPACE is undotbs.
SQL>
SQL>
2
SQL>
2
SQL>
SQL>
SQL>

ALTER SYSTEM SET UNDO_MANAGEMENT = Auto
SCOPE = Spfile;
ALTER SYSTEM SET UNDO_TABLESPACE = undotbs
SCOPE = Spfile;
SHUTDOWN immediate
STARTUP
SHOW PARAMETER undo
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
l
c
a
r
O
y
l
n
Practice 11
The objective of this practice is to familiarize you with SQL statement execution plans and
to interpret the formatted output of a trace file generated using SQL Trace and the
formatted output generated by TKPROF. Throughout this practice Oracle Enterprise
Manager can be used if desired. SQL Worksheet can be used instead of SQL*Plus and
there are many uses for the Oracle Enterprise Manager console. (Solutions for Oracle
Enterprise Manager can be found in Appendix B).
1. Connect as hr/hr and create the plan_table table under the hr schema, if it is
not already created, by running the
$ORACLE_HOME/rdbms/admin/utlxplan.sql script.
SQL> CONNECT hr/hr
SQL> @$ORACLE_HOME/rdbms/admin/utlxplan.sql
Note: If plan_table already exists and holds rows then truncate the table.
2. Set the optimizer mode to rule based using the ALTER SESSION command and
generate the explain plan for the statement
$HOME/STUDENT/LABS/lab11_02.sql. View the generated plan by querying
object name, operation, option, and optimizer from the plan_table table.
SQL>
SQL>
2
SQL>
2
y
l
n
ALTER SESSION SET OPTIMIZER_GOAL = Rule;

EXPLAIN PLAN FOR
@$HOME/STUDENT/LABS/lab11_02.sql
SELECT object_name, operation, options, optimizer
FROM plan_table;
O
e
I
A
s
U
3. Truncate the plan_table table. Change the optimizer mode to cost based by
setting the value to All_rows and rerun the explain plan for
$HOME/STUDENT/LABS/lab11_02.sql. Notice that the optimizer mode and
the explain plan have changed.
SQL>
SQL>
SQL>
2
SQL>
2
&
l
a
TRUNCATE TABLE plan_table;

ALTER SESSION SET OPTIMIZER_GOAL = all_rows;
EXPLAIN PLAN FOR
FROM plan_table;
n
r
te
l
c
a
n
I
e
Note: Although exactly the same scripts are being run, due to the different optimizer
settings, different explain paths are found. With rule-based, one of the rules is to use
any index that is on the columns in the where clause. By using cost-based optimizer
mode, the server has been able to determine that it will be faster to just perform a full
table scan, due to the number of rows being returned by the script.
r
O
4. Truncate the plan_table table and set the optimizer mode to Rule by using the
ALTER SESSION command. This time generate the explain plan for the
$HOME/STUDENT/LABS/lab11_04.sql script. Examine the script which is a
copy of $HOME/STUDENT/LABS/lab11_02.sql except that it changes the line
SELECT * to include a hint /*+ all_rows*/ for the optimizer. View the
generated execution plan by querying object name, operation, option, and optimizer
from plan_table table.
SQL>
SQL>
SQL>
2
SQL>
2

EXPLAIN PLAN FOR
FROM plan_table;
5. Exit out of SQL*Plus, change the directory to $HOME/ADMIN/UDUMP and delete

all the trace files already generated.
SQL> EXIT
$ cd $HOME/ADMIN/UDUMP
$ rm *.trc
y
l
n
Note: this step is performed only to make it easier to find the trace file generated. It
is not a requirement of SQL Trace.
O
e
6. Connect as sh/sh and enable SQL Trace, using the ALTER SESSION command,
to collect statistics for the script, $HOME/STUDENT/LABS/lab11_06.sql. Run
the script. After the script has completed, disable SQL Trace, then format your trace
file using TKPROF. Use the options SYS=NO and EXPLAIN= sh/sh. Name the
file myfile.txt.
I
A
s
U
SQL> CONNECT sh/sh

SQL> ALTER SESSION SET SQL_TRACE = True;
SQL> ALTER SESSION SET SQL_TRACE = False;
$ ls -l
-rw-r----- 1 user457 dba 2180 May 4 00:27
ser457_ora_10424.trc
$ tkprof user457_ora_10424.trc myfile.txt explain=sh/sh
sys=no
&
l
a
n
r
te
n
I
e
r
O
l
c
a
7. View the output file myfile.txt and note the CPU, current, and query figures for
the fetch phase. Do not spend time analyzing the contents of this file because the
only objective here is to become familiar and comfortable with running TKPROF and
SQL*Trace.
$ more myfile.txt
Practice 12
The objective of this practice is to familiarize you with the dbms_stats package.
Appendix B).
1. Connect as hr/hr and create a table new_employees as a copy of the
employees table. Gather statistics on the new_employees table and determine
the current number of rows in the new_employees table. Record the number of
rows for comparison later.
SQL> CONNECT hr/hr
SQL> CREATE TABLE new_employees
2
AS SELECT *
3
FROM employees;
SQL> EXECUTE >
dbms_stats.gather_table_stats
('HR','NEW_EMPLOYEES');
SQL> SELECT table_name, num_rows
2 FROM user_tables
3 WHERE table_name = 'NEW_EMPLOYEES';
y
l
n
2. Increase the size of the new_employees table by using the lab12_02.sql

script.
O
e
s
U
3. Confirm that the statistics have not been changed in the data dictionary by re-issuing
the same statement as in question 1.
I
A

2 FROM user_tables
&
l
a
n
r
te
4. Connect hr/hr and gather statistics for all objects under the hr schema using the
dbms_stats package. While gathering the new statistics save the current statistics
in a table named stats.
n
I
e
a. Connect as hr/hr and create a table to hold statistics in that schema.
r
O
l
c
a
SQL> CONNECT hr/hr

SQL> execute dbms_stats.create_stat_table('HR','STATS');
b. Save the current schema statistics into your local statistics table.
SQL> execute
dbms_stats.export_schema_stats('HR','STATS');
c. Analyze all objects under the hr schema.

SQL> execute dbms_stats.gather_schema_stats('HR');
5. Determine that the current number of rows in the employees table has been updated
in the data dictionary. This should be twice the number of rows recorded in question
1.
2 FROM user_tables
6. Remove all schema statistics from the dictionary and restore the original statistics
you saved in step b.
SQL> execute dbms_stats.delete_schema_stats('HR');
SQL> execute
dbms_stats.import_schema_stats('HR','STATS');
7. Confirm that the number of rows in the employees table recorded in the data
dictionary has returned to the previous value collected in question 1.
2 FROM user_tables
O
e
y
l
n
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Practice 13
Appendix B).
1. Connect using sys/oracle AS sysdba and query the tablespace_name
and extent_management columns of dba_tablespaces to determine which
SQL> CONNECT / AS sysdba
SQL> SELECT tablespace_name, extent_management
2 FROM dba_tablespaces;

SQL> ALTER USER hr DEFAULT TABLESPACE tools;
enqueue.
y
l
n
SQL> SELECT event, total_waits

2 FROM v$system_event
3 WHERE event = 'enqueue';
O
e
s
U
I
A
&
l
a
SQL> SELECT *
2 FROM v$enqueue_stat
3 WHERE eq_type = 'ST';
n
r
te
5. Exit out of the SQL*Plus session and change the directory to

$HOME/STUDENT/LABS. Run the lab13_04.sh script from the operating
system prompt. This script will log five users onto the database simultaneously and
then each user creates and drops tables. The tables each have many extents. The
script must be run from the $HOME/STUDENT/LABS directory or it will fail.
n
I
e
r
O
l
c
a
$ cd $HOME/STUDENT/LABS
$ ./lab13_04.sh
eq_type 'ST' to determine the value of total_wait# for the ST enqueue, which
is the space management enqueue.
$ SQL*Plus system/oracle
SQL> SELECT *
anagement using a dictionary managed tablespace. This value is found by subtracting
the first wait value (from practice 13-04) from the second wait value (from practice
13-06).
7. Create a new locally managed tablespace test, name the data file test01.dbf,
and place it in the $HOME/ORADATA/u06 directory. Set the size to 120 MB and a
SQL> CREATE TABLESPACE test
2 DATAFILE '$HOME/ORADATA/u06/test01.dbf' SIZE 120M
3 UNIFORM SIZE 20k;
y
l
n
O
e
SQL> ALTER USER hr DEFAULT TABLESPACE test;
s
U
I
A
view.
&
l
a
SQL> SELECT *
n
r
te
n
I
e
10. Exit out of the SQL*Plus session and change directory to $HOME/STUDENT/LABS.
Run the lab13_04.sh script from the operating system prompt. This script will
log five users onto the database simultaneously and then each user creates and drops
tables. The tables each have many extents. The script must be run from the
$HOME/STUDENT/LABS directory or it will fail.
r
O
l
c
a
$ cd $HOME/STUDENT/LABS
$ ./lab13_04.sh
SQL> SELECT *
the first wait value (from practice 13-09) from the second wait value (from practice
13-11). Compare the two results for the different tablespaces. The locally managed
12. Connect as the hr/hr user and run the
$HOME/STUDENT/LABS/lab13_12.sql script. This will create a similar table
(new_emp) as the employees table but with PCTFREE = 0. The table is then
populated with data from the employees table.
SQL> CONNECT hr/hr
SQL> @$HOME/STUDENT/LABS/lab13_12.sql;
y
l
n
13. Run ANALYZE on the new_emp table and query the dba_tables view to
determine the value of chain_cnt for the new_emp table. Record this value.
SQL>
SQL>
2
3
O
e
s
U
ANALYZE TABLE new_emp COMPUTE STATISTICS;

SELECT table_name, chain_cnt
FROM user_tables
WHERE table_name = 'NEW_EMP';
I
A

SQL>
2
SQL>
2
3
&
l
a
n
r
te
CREATE INDEX new_emp_name_idx ON new_emp(last_name)

TABLESPACE indx;
SELECT index_name, status
FROM user_indexes
WHERE index_name = 'NEW_EMP_NAME_IDX';
l
c
a
n
I
e
15. Run the $HOME/STUDENT/LABS/lab13_15.sql script, which will update the

rows of the new_emp table. Analyze the new_emp table again and query the
user_tables view to get the new value of chain_cnt Record this value. Also
check the status of the new_emp_name_idx index.
r
O
SQL>
SQL>
SQL>
2
3
SQL>
2
3
FROM user_tables
FROM user_indexes
table. Confirm that the migration has been resolved by querying chain_cnt
column in the user_tables view and confirm that the index is valid by querying
the user_indexes view.
SQL>
2
SQL>
SQL>
SQL>
2
3
SQL>
2
3
ALTER TABLE new_emp MOVE

TABLESPACE users;
ALTER INDEX new_emp_name_idx REBUILD;
SELECT table_name, blocks, empty_blocks, chain_cnt
FROM user_tables
FROM user_indexes
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Practice 15
Appendix B).
1. Connect as hr/hr, drop the new_employees table, and create an IOT called
hr.employees table. Make the employee_id column the primary key and
name the primary key index new_employees_employee_id_pk.
SQL>
SQL>
SQL>
2
3
4
5
6
7
8
9
10
11
12
13
14
15
CONNECT hr/hr
DROP TABLE new_employees;
CREATE TABLE new_employees
(employee_id
NUMBER(6),
first_name
VARCHAR2(20),
last_name
VARCHAR2(25),
email
VARCHAR2(25),
phone_number
VARCHAR2(20),
hire_date
DATE,
job_id
VARCHAR2(10),
salary
NUMBER(8,2),
commission_pct
NUMBER (2,2),
manager_id
NUMBER(6),
department_id
NUMBER(4),
CONSTRAINT
new_employees_employee_id_pk
PRIMARY KEY
(employee_id))
ORGANIZATION INDEX;
y
l
n
O
e
I
A
s
U
user_indexes views
&
l
a
The IOT is a table and so will be found in the user_tables view.

2 FROM user_tables
3 WHERE table_name LIKE 'NEW_EMPLOYEES%';
n
r
te
The IOT is an index and so will be found in the user_indexes view.

2 FROM user_indexes
n
I
e
l
c
a
3. Populate the new_employees table with the rows from the hr.employees
table.
r
O
SQL> INSERT INTO new_employees

2
SELECT *
3
FROM employees;
last_name_new_employees_idx. Collect the statistics for the secondary
index.
SQL>
2
3
SQL>
>
CREATE INDEX last_name_new_employees_idx

ON new_employees(last_name)
TABLESPACE indx;
EXECUTE dbms_stats.gather_index_stats ('HR','LAST_NAME_NEW_EMPLOYEES_IDX');
dictionary. Query the index_name, index_type, blevel, and
leaf_blocks.
SQL> SELECT index_name, index_type, blevel, leaf_blocks
2 FROM user_indexes
3 WHERE index_name = 'LAST_NAME_NEW_EMPLOYEES_IDX';
Note: If the values for blevel and leaf_blocks are null then there were no
statistics collected. Confirm that the value of index_type is normal.
y
l
n

SQL>
2
3
4
s
U
CREATE INDEX emp_hist_dept_id_idx

ON employees_hist (department_id)
TABLESPACE indx
REVERSE;
I
A
&
l
a
O
e
n
r
te

2 FROM user_indexes
3 WHERE index_name = 'EMP_HIST_DEPT_ID_IDX';
n
I
e
l
c
a
Note: This time the values of blevel and leaf_blocks should be null, because
you did not collect statistics for this index while creating it. Also the value for index
type should now be normal/reverse.
r
O
8. Create a bitmap index on the job_id column of the employees_hist table.
Place the index in the indx tablespace. Name the index
bitmap_emp_hist_idx.
SQL> CREATE BITMAP INDEX bitmap_emp_hist_idx
2 ON employees_hist (job_id)
3 TABLESPACE indx;
2 FROM user_indexes
3 WHERE index_name = 'BITMAP_EMP_HIST_IDX';
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Practice 16
Appendix B).
SQL> CONNECT sh/sh
SQL> DESC plan_table
If the table is found:

SQL> TRUNCATE table plan_table;
If the table is not found then:

SQL> @$ORACLE_HOME/rdbms/admin/utlxplan
2. Create a materialized view cust_sales having two columns,

cust_last_name and the total_sales for that customer. This will mean
joining the sales and customers tables using cust_id and grouping the
results by cust_last_name. Make sure that query rewrite is enabled on the view.
y
l
n
O
e
SQL> CREATE MATERIALIZED VIEW cust_sales

2 ENABLE QUERY REWRITE AS
3
SELECT c.cust_last_name, sum(s.amount_sold)
4
5
WHERE c.cust_id = s.cust_id
6
GROUP BY c.cust_last_name;
I
A
&
l
a
s
U

n
r
te
SQL> SELECT mview_name, rewrite_enabled, query

2 FROM user_mviews;
n
I
e
Note: The rewrite_enabled column must have a value of Y in order for the
practice on query rewrite to work.
r
O
l
c
a
$HOME/STUDENT/LABS/lab16_04.sql
SQL> SET AUTOTRACE Traceonly Explain
same query, $HOME/STUDENT/LABS/lab16_04.sql, as in the previous
practice. Note the change in the explain plan due to the query rewrite. Set
AUTOTRACE to Off and disable query rewrite after the script has completed running.
SQL>
SQL>
SQL>
SQL>
ALTER SESSION SET QUERY_REWRITE_ENABLED = True;

SET AUTOTRACE Off
ALTER SESSION SET QUERY_REWRITE_ENABLED = False;
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Practice 17
The objective of this practice is to use available diagnostic tools to monitor lock
contention. You will need to start three sessions in separate windows. Log in as hr/hr in
two separate sessions (sessions 1 and 3) and as sys/oracle as sysdba in another
session (session 2). Throughout this practice Oracle Enterprise Manager can be used if
1. In session 1 (user hr/hr), update the salary by 10% for all employees with a salary
< 15000 in the temp_emps table. Do not COMMIT.
SQL>
SQL>
2
3
CONNECT hr/hr
UPDATE TEMP_EMPS
SET SALARY = SALARY * 1.1
WHERE salary <15000;
2. In session 2 connect as sys/oracle AS sysdba and check to see whether any

locks are being held by querying the v$lock view.
SQL>
SQL>
2
3

SELECT sid, type, id1, lmode, request
FROM v$lock
WHERE type IN ('TX','TM');
y
l
n
O
e
SQL> CONNECT hr/hr
SQL> DROP TABLE hr.temp_emps;
I
A
s
U
Note: The DDL statement requires an exclusive table lock. It cannot obtain it
because session 1 already holds a row exclusive table lock on the temp_emps table.
&
l
a
n
r
te
4. In session 3 (hr/hr), update the salary by 5% for all employees with a salary >
n
I
e
SQL>
SQL>
2
3
r
O
l
c
a
CONNECT hr/hr
UPDATE temp_emps
SET salary = salary * 1.05
WHERE salary > 15000;
SQL> SELECT sid, type, id1, id2, lmode, request
2 FROM v$lock
3 WHERE id1 =
4
(SELECT object_id FROM dba_objects
5
WHERE object_name = 'TEMP_EMPS'
6
AND object_type = 'TABLE');
SQL>
SQL>
2
3
rollback;
UPDATE hr.temp_emps
SET MANAGER_id = 10
WHERE salary < 15000;
y
l
n
O
e

2 FROM v$lock
3 WHERE id1 =
4
(SELECT object_id
5
FROM dba_objects
6
7
I
A
s
U

sessions holding or waiting on a lock. Use this view to determine the session ID for
the session that is holding locks. Use this value to query v$session to obtain the
serial number for the session holding the lock. Then issue the ALTER SYSTEM
KILL SESSION command to release the session holding the lock.
&
l
a
n
r
te
n
I
e
SQL>
SQL>
2
SQL>
2
3
SQL>
r
O
l
c
a
@$ORACLE_HOME/rdbms/admin/catblock.sql
SELECT waiting_session, holding_session
FROM dba_waiters;
SELECT sid, serial#, username
FROM v$session
WHERE SID ='&HOLDING_SESSION';
ALTER SYSTEM KILL SESSION '&SID,&SERIAL_NUM';
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Practice Solutions
Using Enterprise Manager
O
e
I
A
&
l
a
n
r
te
r
O
l
c
a
n
I
e
y
l
n
s
U
Practice 2
The goal of this practice is to familiarize you with the different methods of collecting
statistical information. Throughout this practice Oracle Enterprise Manager can be used if
Oracle Enterprise Manager console.
1. Log on as directed by the instructor. If the database is not already started, connect to
SQL*Plus using sys/oracle as sysdba then start up the instance using the
STARTUP command. Ensure that the password for user system is set to oracle.
Check that TIMED_STATISTICS has been set to True; if it has not, then set it using
the ALTER SYSTEM statement.
Use Enterprise Manager Console - Instance Configuration
Check All Initialization Parameters Looking for TIMED_STATISTICS
If a value of True is returned, then continue to question 2. If a value of False is
returned, then set the TIMED_STATISTICS parameter to True using the command:
Use Enterprise Manager SQL Worksheet
SQL> ALTER SYSTEM SET TIMED_STATISTICS = True
2
SCOPE = both;
y
l
n
2. Connect to SQL*Plus as the system user and issue a command that will create a
trace file for this session. Run a query to count the number of rows in the
dba_tables dictionary view. To locate your new trace file easier, if possible, delete
all the trace files in the USER_DUMP_DEST directory before running the trace.
Remember to disable the trace command after running the query.
O
e
I
A
Use Enterprise Manager SQL Worksheet

SQL>
SQL>
SQL>
SQL>
s
U
ALTER SESSION SET SQL_TRACE = TRUE;
SELECT COUNT(*) FROM dba_tables;
ALTER SESSION SET SQL_TRACE = FALSE;
&
l
a
n
r
te
3. At the operating system level view the resulting trace file located in the directory set
by USER_DUMP_DEST. Do not try to interpret the content of the trace file, as this is
the topic of a later lesson.
n
I
e
$ls l
l
c
a
-rw-r----- 1 user487 dba 4444 Apr 24 22:28 U487_ora_3270.trc
r
O
Oracle9i Database Performance Tuning B-2
4. Open two sessions, the first as hr/hr and the second as sys/oracle as
sysdba. From the second session generate a user trace file for the first session using
the dbms_system.set_sql_trace_in_session procedure. Get the user id
and serial# from v$session.
Open multiple SQL Worksheets. Add the connect string for your database.
From Session 1
SQL> CONNECT hr/hr
Change to Session 2
SQL>
SQL>
2
3
SQL>
2
3
4
5
CONNECT sys/oracle as sysdba

SELECT username, sid, serial#
FROM v$session
WHERE username = 'HR';
BEGIN
(&SID,&SERIALNUM,TRUE);
END;
/
Change to Session 1
SQL> SELECT * FROM employees;
y
l
n
Change to Session 2
SQL>
2
3
4
5
BEGIN
(&SID,&SERIALNUM,FALSE);
END;
/
I
A
O
e
s
U
5. Confirm that the trace file has been created in the directory set by USER_DUMP_DEST
$ls l
&
l
a
4444 Apr 24 22:28 dba01_ora_3270.trc

15443 Apr 24 22:42 dba01_ora_3281.trc
n
r
te
6. Connect to SQL*Plus using sys/oracle as sysdba and create a new

tablespace (tools) to hold the tables and other segments required by Statspack. This
tablespace needs to be 200 MB and be dictionary managed (this is not a requirement of
Statspack, but will be used later in the course). Name the data file tools01.dbf and
place it in the $HOME/ORADATA/u05 directory.
n
I
e
l
c
a
r
O
Note: Dictionary managed is not the default.

Use Enterprise Manager Console - Storage - Tablespaces
7. Confirm and record the amount of free space available within the tools tablespace
by querying the dba_free_space view. Also check that the tablespace is
dictionary managed.
8. Connect using sys/oracle as sysdba, then install Statspack using the
spcreate.sql script located in your E:\LABS\LABS directory. Use the following
settings when asked by the installation program:
- Users Default Tablespace = TOOLS
- User's Temporary Tablespace = TEMP
SQL> @E:\LABS\LABS\spcreate.sql
9. Query dba_free_space to determine the amount of free space left in the tools
tablespace. The difference between this value and the one recorded in step 7 will be the
space required for the initial installation of Statspack.
y
l
n
Note: The amount of storage space required will increase in proportion to the amount
of information stored within the Statspack tables, that is, the number of snapshots.
O
e
Subtract the value received now, from the value received in step 7 to get the amount of
space required to install Statspack
I
A
s
U
10. Manually collect current statistics using Statspack by running the snap.sql script
located in E:\LABS\LABS. This will return the snap_id for the snapshot just taken,
which should be recorded.
&
l
a
SQL > @E:\LABS\LABS\snap.sql
n
r
te
n
I
e
r
O
l
c
a
11. To have Statspack automatically collect statistics every three minutes execute the
spauto.sql script located it your E:\LABS\LABS directory. Query the database
to confirm that the job has been registered using the user_jobs view.
SQL > @E:\LABS\LABS\spauto.sql
SQL > SELECT job, next_date, next_sec, last_sec
2
FROM user_jobs;
Note: The spauto.sql script in the E:\LABS\LABS directory has been altered
from the spauto.sql script shipped with the Oracle database. The alteration has
changed the time between snapshots from 1 hour to 3 minutes.
12. After waiting for a period in excess of three minutes query the stats$snapshot
view to list what snapshots have been collected. There must be at least two snapshots
before moving to the next step.
SQL>
2
3
4
5
6
7
SELECT snap_id,
TO_CHAR(startup_time,' dd Mon "at" HH24:mi:ss')
instart_fm,
TO_CHAR(snap_time,'dd Mon YYYY HH24:mi') snap_date,
snap_level "level"
FROM stats$snapshot
ORDER BY snap_id;
y
l
n
O
e
Note: If the job scheduler is not working, check the value of the
JOB_QUEUE_PROCESSES parameter. The value should be greater than 0.
s
U
13. When there are at least two snapshots, start to generate a report. This is performed
using the spreport.sql script found in the E:\LABS\LABS directory. The script
lists the snapshot options available and then requests the beginning snap id and the
end snap id. The user is then requested to give a filename for the report. It is often
best left to the default.
I
A
&
l
a
SQL> @E:\LABS\LABS\spreport.sql
n
r
te
14. Locate the report file in the users current directory, then using any text editor, open
and examine the report. The first page shows a collection of the most queried statistics.
n
I
e
$ vi sp_X_Y.lst
l
c
a
where X is the starting snapshot and Y is the ending snapshot (this is true if the default
report filename was used).
r
O
15. Connect to the database as a system administrator sys/oracle as sysdba.

16. Query the database to determine what system wait events have been registered since
startup using v$system_event.
SQL> SELECT event, total_waits, time_waited
2 FROM v$system_event;
Dynamic Performance Views

17. Determine whether there are any sessions actually waiting for resources, using
v$session_wait.
SQL> SELECT sid, event, p1text, wait_time, state
2 FROM v$session_wait;
18. Stop the automatic collection of statistics by removing the job. This is performed by
connecting as perfstat/perfstat and querying the user_jobs view to get the
job number. Then execute the dbms_job.remove procedure.
SQL>
SQL>
2
SQL>
CONNECT perfstat/perfstat
SELECT job, log_user
FROM user_jobs;
EXECUTE dbms_job.remove ($job_to_remove);
y
l
n
19. Connect to your database using Oracle Enterprise Manager. The lecturer will supply
the information required to connect to the Oracle Management Server. After you have
connected to the database, use Oracle Enterprise Manager to explore the database.
Examine items such as the number of tablespaces, users, and tables.
O
e
I
A
s
U
Oracle Classroom Only

If you are in an Oracle classroom you must perform the following four steps that are specific
to the Oracle classroom setup:
a. Click the omsconfig file update icon on the desktop and enter the name of the
UNIX server your class is using. Your instructor will provide the server name.
Please note that this is a case-sensitive entry.
b. Open an MSDOS window.
c. At the command prompt enter: oemctl start oms
Wait for the message: The Oracleoracle901_homeManagementServer service
was started successfully.
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Oracle Classroom Only (continued)
d. Close the MSDOS window.
Start the Oracle Enterprise Manager Console and set the Administrator to
sysman and the password to oem_temp. When prompted, change the
password to oracle. Select Discover Nodes from the Navigator and enter the
host name of the server of your working database.
i. From the Start menu > Programs > Oracle OracleHome >
Enterprise Manager Console
ii. Make sure the Login to the Oracle Management Server is selected.
iii. Administrator: sysman
iv. Password: oem_temp
v. Management server is your machine.
vi. When prompted to change the sysman password to oracle.
vii. Select Navigator > Discover Nodes from the console menu, or select
Discover Nodes from the right mouse shortcut menu to open the Discover
Nodes dialog box.
viii. From the Discovery Wizard: Introduction page, click Next, enter the name
of your UNIX database server, and click Next.
ix. Click Next, give your regular administrator access to your database.
x. Click Finish, then OK. If your discovery was not successful contact
your instructor.
y
l
n
O
e
20. From Oracle Enterprise Manager load Oracle Expert and create a new tuning session.
Limit the tuning scope to Check for Instance Optimizations. This is done to reduce
the time taken to collect information. Collect a new set of data.
I
A
s
U
Note: Do not implement the changes that Oracle Expert recommends, because this will
be done during the course.
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Practice 3
console.
1. Connect as system/oracle and diagnose database file configuration by querying
the v$datafile, v$logfile and v$controlfile dynamic performance
views.
Use Enterprise Manager Console - Storage - Controlfile
Use Enterprise Manager Console - Storage - Datafiles
Use Enterprise Manager Console - Storage - Redo Log Groups
2. Diagnose database file usage by querying the v$filestat dynamic performance
view, combine with v$datafile to get the data file names.
Use Enterprise Manager Performance Manager - I/O - File Statistics
3. Determine whether there are waits for redo log files by querying the
v$system_event dynamic performance view, where the waiting event is log file
sync or log file parallel write.
Use Enterprise Manager Performance Manager - Wait Events
O
e
y
l
n
s
U
Waits for log file sync are indicative of slow disks that store the online logs or
unbatched commits. The log file parallel write is much less useful. The reason it is less
useful is that this event only shows how often LGWR waits, not how often server
processes wait. If LGWR waits without impacting user processes, there is no
performance problem. If LGWR waits, it is likely that the log file sync event
(mentioned above) will also be evident.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
4. Connect as perfstat/perfstat and diagnose file usage from Statspack.
a. Generate a Statspack report using E:\LABS\LABS\spreport.sql
b. Locate and open the report file.
c. Examine the report and search for the File IO Stats string.
Note: On a production database care should be taken in monitoring the disk and
controller usage by balancing the workload across all devices. If your
examination shows a distinct over utilization of a particular data file, consider
resolving the cause of the amount of I/O. For example, investigate the number of
full table scans, clustering of files on a specific device and under utilization of
indexes. If after this the problem remains then look at placing the data file on a
low utilization device.
5. Connect as system/oracle and enable checkpoints to be logged in the alert file by
setting the value of the LOG_CHECKPOINTS_TO_ALERT parameter to True using
the ALTER SYSTEM SET command.
Use Enterprise Manager Console - Instance - Configuration - All Initialization
Parameters
6. Connect as sh/sh and execute the E:\LABS\LABS\lab03_06.sql script to
provide a workload against the database.
y
l
n
O
e
SQL> CONNECT sh/sh

SQL> @E:\LABS\LABS\lab03_06.sql
s
U
7. At the operating system level use the editor to open the alert log file (located in the
directory specified by BACKGROUND_DUMP_DEST). Then determine the checkpoint
frequency for your instance by searching for messages containing the phrase
Completed Checkpoint. The time difference between two consecutive messages is
the checkpoint interval.
I
A
&
l
a
Open the alert log file using an editor and search for the line: Completed checkpoint.
The line before this will be the time at which the checkpoint occurred. Search for the
following checkpoint time and then subtract to get the time between checkpoints.
n
r
te
n
I
e
Note: On a production system the checkpoint interval should range between 15

minutes to 2 hours. The actual interval is dependant on the type of application and the
amount of DML activity.
r
O
l
c
a
Practice 4
The objective of this practice is to use diagnostic tools to monitor and tune the shared pool.
console.
1. Connect using sys/oracle as sysdba and check the size of the shared pool.
Parameters
2. Connect as perfstat/perfstat, execute the E:\LABS\LABS\snap.sql
script to collect initial snapshot of statistics and note the snapshot number.
SQL> @E:\LABS\LABS\snap.sql
3. To simulate user activity against the database open two operating system sessions. In
session 1 connect as hr/hr and run the E:\LABS\LABS\lab04_03_1.sql
script. In the second session connect as hr/hr and run the
E:\LABS\LABS\lab04_03_2.sql script.
y
l
n
O
e
In session 1
SQL> CONNECT hr/hr
SQL> @E:\LABS\LABS\lab04_03_1.sql
In session 2
I
A
SQL> CONNECT hr/hr

SQL> @E:\LABS\LABS\lab04_03_2.sql
s
U
4. Connect as system/oracle and measure the pin-to-reload ratio for the library
cache by querying v$librarycache. Determine whether it is a good ratio or not.
&
l
a
n
r
te
Use Enterprise Manager Performance Manager - Memory
n
I
e
r
O
l
c
a
5. Connect as system/oracle and measure the get-hit ratio for the data dictionary
cache by querying v$rowcache. Determine whether it is a good ratio or not using
the dynamic view.
Use Enterprise Manager Performance Manager - Memory
If GETMISSES are lower than 15% of the GETS, it is a good ratio.
6. Connect as perfstat/perfstat and run the E:\LABS\LABS\snap.sql
script to collect a statistic snapshot and obtain the snapshot number. Record this
number.
7. As perfstat/perfstat obtain the statistics report between the two recorded

snapshot IDs (from questions 2 and 6) by running the
E:\LABS\LABS\spreport.sql script.
y
l
n
The following is an example of using a beginning snapshot_id of 3 and an ending

snapshot_id of 5.
Enter value for end_snap: 5

End
Snapshot Id specified: 5
&
l
a
I
A
O
e
s
U
Specify the Begin and End Snapshot Ids

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Enter value for begin_snap:
3
Specify the Report Name

~~~~~~~~~~~~~~~~~~~~~~~
The default report file name is sp_3_5. To use this name,
press <return> to continue, otherwise enter an
alternative.
Enter value for report_name:
n
r
te
n
I
e
l
c
a
You can also determine an appropriate size for the Shared Pool by using:
r
O
Enterprise Manager Console - Instance - Configuration - Memory - Advice
8. Analyze the generated report in the current directory. What would you consider doing
if the library hit ratio (found under the heading Instance Efficiency Percentages) is
less than 98%?
Increase the SHARED_POOL_SIZE parameter.
9. Connect as system/oracle and determine which packages, procedures and triggers
are pinned in the shared pool by querying v$db_object_cache.
SQL>
SQL>
2
3
4
SELECT name, type, kept
WHERE type IN
('PACKAGE', 'PROCEDURE', 'TRIGGER', 'PACKAGE BODY');
10. Connect using sys/oracle as sysdba and pin one of the Oracle supplied
packages that needs to be kept in memory, such as sys.standard using the
dbms_shared_pool.keep procedure , that is created by running the
$ORACLE_HOME/rdbms/admin/dbmspool.sql script.
SQL>
SQL>
SQL>
SQL>
2
3
4
CONNECT sys/oracle AS SYSDBA

@?/rdbms/admin/dbmspool
EXECUTE dbms_shared_pool.keep('SYS.STANDARD');
SELECT distinct owner, name
WHERE kept='YES'
AND name LIKE '%STAND%';
y
l
n
O
e
I
A
s
U
11. Determine the amount of session memory used by your session by querying the
v$mystat view. Limit the output by including the clause:

SQL>
2
3
4
&
l
a
SELECT a.name, b.value

FROM v$statname a, v$mystat b
WHERE a.statistic# = b.statistic#
AND name = 'session uga memory';
n
r
te
Note: Since you are not using the Oracle Shared Server configuration this memory
resides outside the SGA.
n
I
e
l
c
a
12. Determine the amount of session memory used for all sessions, using v$sesstat
and v$statname views:
r
O
SQL>
2
3
4
SELECT SUM(value)||' bytes' "Total session memory

FROM v$sesstat, v$statname
AND v$sesstat.statistic# = v$statname.statistic#;
Practice 5
database buffer cache. Throughout this practice Oracle Enterprise Manager can be used if
Oracle Enterprise Manager console.
snapshot number. The snap shot can be taken by running the
E:\LABS\LABS\snap.sql script file.
2. To simulate user activity against the database, connect as the hr/hr user and run the
lab05_02.sql script.
SQL> CONNECT hr/hr
3. Connect as system/oracle and measure the hit ratio for the database buffer cache
using the v$sysstat view. Determine whether it is a good ratio or not.
y
l
n
Use Enterprise Manager Performance Manager - Database Instance - Instance

Efficiency Statistics
O
e

snapshot number. The snapshot can be taken by running the
E:\LABS\LABS\snap.sql script file.
&
l
a
I
A
s
U
5. Use the report from Statspack between the last two snapshots to check the buffer cache
hit ratio, using the E:\LABS\LABS\spreport.sql script. Then analyze the
buffer hit % in the Instance Efficiency Percentages section.
n
r
te
n
I
e
r
O
l
c
a
Note: On a production database if the ratio is bad, add new buffers, run steps 2 to 5
and examine the new ratio to verify that the ratio has improved. If the ratio is good,
remove buffers, run steps 2 to 5 and verify if the ratio is still good.
6. Connect as system/oracle and determine the size of the temp_emps table in the
hr schema that you want to place in the keep buffer pool. Do this by using the
dbms_stats.gather_table_stats procedure and then query the blocks
column of the dba_tables view for the temp_emps table.
SQL>
SQL>
>
SQL>
2
3
EXECUTE dbms_stats.gather_table_stats ('HR','TEMP_EMPS');
SELECT table_name , blocks
FROM dba_tables
WHERE table_name IN ('TEMP_EMPS');
7. Keep temp_emps in the keep pool. Use the ALTER SYSTEM command to set
DB_KEEP_CACHE_SIZE to 4 MB for the keep pool. Limit the scope of this
command to the spfile.
Parameters
y
l
n
O
e
8. For the keep pool to be allocated the database needs to be restarted. You will need to
Shut down and start up the instance using:
Enterprise Manager Console - Instance - Configuration
I
A
s
U
9. Connect as system/oracle and enable the temp_emps table in the hr schema

for caching in the keep pool, using the storage clause of the ALTER TABLE
command.
&
l
a
n
r
te

SQL> ALTER TABLE hr.temp_emps
2 STORAGE (BUFFER_POOL Keep);
n
I
e
SQL> SELECT table_name, buffer_pool

2 FROM dba_tables
3 WHERE buffer_pool = 'KEEP';
r
O
l
c
a
10. Connect as hr/hr and run the E:\LABS\LABS\lab05_10.sql script. This will
execute a query against the temp_emps table in the hr schema.
SQL> CONNECT hr/hr
11. Connect using sys/oracle as sysdba and check for the hit ratio in different
buffer pools, using the v$buffer_pool_statistics view.
Use Enterprise Manager Performance Manager - Database Instance - Instance
Efficiency Statistics
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Practice 6
console.
1. Connect as sys/oracle AS sysdba and, without restarting the instance, resize
the DB_CACHE_SIZE to 12 Mb. Limit the effect of this command to memory, so as
not to modify the spfile.
Parameters
Note: This will encounter an error because the total SGA size will be bigger than
SGA_MAX_SIZE. To overcome this you will must either change the value of
SGA_MAX_SIZE and restart the instance (which is what dynamic allocation is meant
to avoid) or resize a component, thus making memory available for the increase in the
buffer cache.
2. Reduce the memory used by the shared pool. Limit the effect of this command to
memory, so as not to modify the spfile.
y
l
n

Parameters
O
e
3. Without restarting the instance, resize the DB_CACHE_SIZE to 12 Mb. Limit the
effect of this command to memory, so as not to modify the spfile.
I
A
s
U

Parameters
Note: This time the memory is available so the command will be executed.
&
l
a
4. To return the SGA to the original configuration, restart the instance. You will need to
n
r
te
Use Enterprise Manager Console - Instance - Configuration
n
I
e
r
O
l
c
a
Practice 7
console.
1. Connect as perfstat/perfstat and collect a snapshot of the current statistics by
running the script E:\LABS\LABS\snap.sql. Record the snapshot ID for later
use.
SQL> @E:\LABS\LABS\snap;
2. Connect as user sh/sh and run the E:\LABS\LABS\lab07_02.sql script in the

E:\LABS\LABS directory to put a workload on the database.
SQL> CONNECT sh/sh
3. Connect as system/oracle and query the v$sysstat view to determine whether

there are space requests for the redo log buffer.
y
l
n
Use Enterprise Manager Performance Manager - Wait Events
4. Connect as perfstat/perfstat and collect another set of statistics using the

E:\LABS\LABS\snap.sql script. Then use E:\LABS\LABS\spreport.sql
to generate a report using the two snapshot IDs that you have collected. From the list
of snapshots select a beginning and end value. The beginning is the value recorded in
step 1 and the end value step 4. Record the name of the report file. View the
generated file using an editor and locate the log buffer space statistic.
O
e

SQL> @E:\LABS\LABS\snap.sql;
&
l
a
I
A
s
U
n
r
te
5. Connect as sys/oracle AS sysdba and increase the size of the redo log buffer
in the spfile by changing the value of the LOG_BUFFER parameter. Since this
parameter is static you must specify spfile.
n
I
e

Parameters
l
c
a
r
O
6. To have the new value for the LOG_BUFFER take effect, you must restart the instance.
Then confirm that the change has occurred.
Practice 9
console.
1. Set the database to use the manual sort option by changing the value of the
WORKAREA_SIZE_POLICY parameter to Manual. Set the SORT_AREA_SIZE
parameter to 512 bytes.
Parameters
2. For the new value of the LOG_BUFFER parameter to take effect, you must restart the
instance. Then query the v$sysstat view and record the value for sorts (memory)
and sorts (disk).
SQL> SELECT name, value
2 FROM v$sysstat
3 WHERE name LIKE 'sorts%';
y
l
n
Note: The statistics in v$sysstat are collected from startup. If you need to get
accurate statistics per statement, you must record statistics before the statement runs
and again afterwards. Subtracting to two values gives the statistics for the statement.
O
e
s
U
3. To perform a sort on the database that will have sorts to disk connect as sh/sh and
execute the E:\LABS\LABS\lab09_03.sql script.
I
A
SQL> CONNECT sh/sh

SQL> @E:\LABS\LABS\lab09_03.sql;
&
l
a
Note: If this script fails due to a lack of free space in the temp tablespace then
connect as system/oracle and resize the temporary tablespace.
n
r
te
Use Enterprise Manager Console - Storage - Datafiles
n
I
e
4. Connect as system/oracle, query the v$sysstat view again, and record the
value for sorts (memory) and sorts (disk). Subtract the values from the recorded value
in question 2. If the ratio of Disk to Memory sorts is greater than 5% then increase the
sort area available.
r
O
l
c
a
SQL>
SQL>
2
3
SELECT name, value
FROM v$sysstat
5. Connect as system/oracle and query the tablespace_name,

current_users, used_extents, and free_extents columns from the
v$sort_segment view. The used_extents and free_extents columns are
useful in monitoring the usage of the temporary tablespace.
SQL> SELECT tablespace_name, max_sort_size,
2
max_used_size
3 FROM v$sort_segment;
Note: If this statement returns no rows, it means that all sort operations since startup
have completed in memory.
6. To decrease the number of sorts going to a temporary tablespace, increase the value of
the SORT_AREA_SIZE parameter to 512000 using the ALTER SESSION
command.
SQL> ALTER SESSION SET SORT_AREA_SIZE = 512000;
y
l
n
O
e
7. Connect as system/oracle and configure the parameters for automatic PGA

memory allocation using the ALTER SYSTEM command. Use the values Auto for
WORKAREA_SIZE_POLICY and 10M for PGA_AGGREGATE_TARGET).
I
A
s
U

Parameters
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Practice 10
rollback segments. This would require setting the database to Manual Undo Management
mode. Throughout this practice Oracle Enterprise Manager can be used if desired. SQL
Enterprise Manager console.
1. Set the database in Manual Undo Mode by connecting as sys/oracle AS
sysdba and change the following parameters to the values shown:
undo_management = Manual
undo_tablespace = Null
Manual and that UNDO_TABLESPACE is Null.
Parameters
SQL> SHOW PARAMETER undo
2. Use the CREATE TABLESPACE command to create a new rollback segment

tablespace rbs_test that is 2 MB in size. Name the data file rbs_test.dbf and
place it in the $HOME/ORADATA/u03 directory. Create the tablespace as dictionary
managed, which is required for rollback segments.
y
l
n
O
e
s
U
Note: This is not to be an UNDO tablespace and you must specify that it is to be
dictionary managed.
I
A
3. For the purposes of this practice, create a new rollback segment called rbsx in the
rbs_test tablespace. For the storage parameters, use 64 KB for the INITIAL and
NEXT extent sizes with MINEXTENTS value set to 20. Set the OPTIMAL value so that
the segment shrinks back to 1280 KB automatically.
SQL>
2
3
4
&
l
a
n
r
te
CREATE ROLLBACK SEGMENT rbsx

TABLESPACE rbs_test
STORAGE (INITIAL 64K NEXT 64K MINEXTENTS 20
OPTIMAL 1280K);
n
I
e
r
O
l
c
a
4. Bring the rbsx rollback segment online and ensure that any others (except the
system rollback segment) are offline. Query the dba_rollback_segs view to
get the segment_name and status of the rollback segments to be taken offline using the
ALTER ROLLBACK SEGMENT command.
SQL> ALTER ROLLBACK SEGMENT rbsx ONLINE;
SQL> SELECT segment_id, segment_name, status
2 FROM dba_rollback_segs;
5. Before executing a new transaction, find the number of bytes written so far in the
rbsx rollback segment, using the writes column of v$rollstat.
2 FROM v$rollstat
3 WHERE usn>0;
6. Open two sessions. In session 1 connect as hr/hr and run the

E:\LABS\LABS\ins_temps.sql script. The script inserts 100 new rows into the
temp_emps table. Do not COMMIT this transaction. In the second session, log in as
system/oracle, determine how many rollback segment blocks or bytes the
transaction is using. To do this query the writes column of v$rollstat to get the
number of bytes written in the rbsx rollback segment so far. Record this value.
y
l
n
O
e
In session 1:
SQL> CONNECT hr/hr
SQL> @E:\LABS\LABS\ins_temps.sql
In Session 2:
SQL>
SQL>
2
3
SELECT usn, writes
FROM v$rollstat
WHERE usn>0;
&
l
a
I
A
s
U
Note: The number of writes in the rollback segment between questions 5 and 6 is the
difference in the value of the writes column at the respective times.
n
r
te
7. In session 2, join the v$transaction and v$session views to find, in the

used_ublk column, how many blocks the ins_temps transaction is using.
n
I
e
r
O
l
c
a
SQL> SELECT s.username, t.used_ublk, t.start_time

2 FROM v$transaction t, v$session s
3 WHERE t.addr = s.taddr;
8. Return to the hr session (the first session) and commit the insert. Run the
E:\LABS\LABS\del_temps.sql script. Do not COMMIT. The script deletes the
hundred rows you have just inserted. As user system (in the second session), check
the amount of rollback space used, using the writes column of v$rollstat. Note
the difference between the return value and that found in question 6.
In session 1:
SQL> COMMIT;
SQL> @E:\LABS\LABS\del_temps.sql
In session 2:
2 FROM v$rollstat
3 WHERE usn>0;
9. In session 2, connect as system/oracle and find out if you have had any rollback
segment contention since startup, using the waits and gets columns in the
v$rollstat view.
SQL> SELECT SUM(waits)/SUM(gets) "Ratio",
2 SUM(waits) "Waits", SUM(gets) "Gets
3 FROM v$rollstat;
y
l
n
O
e
Note: In a production environment a better source of information would be Rollback

Segment section in the Statspack report.
I
A
s
U
10. Does the v$system_event view show any waits related to rollback segments?
Using session 2, query in v$system_event view for the undo segment tx slot
entry.
&
l
a
SQL> SELECT * from v$system_event

2 WHERE event ='undo segment tx slot';
n
r
te
Note: Since only one session is making changes it is unlikely that there will be any
contention for the undo segment transaction slot.
n
I
e
l
c
a
11. In session 1 commit the transaction. Then connect as hr/hr and run the
E:\LABS\LABS\ins_temps.sql script again, allocating the transaction to a
specific rollback segment rbsx, using the set transaction use rollback segment
command. In session 2, check that the transaction is using the defined rollback
segment join the v$rollstat, v$session, and v$transaction views.
r
O
In session 1:
SQL> COMMIT;
SQL> SET TRANSACTION USE ROLLBACK SEGMENT rbsx;
SQL> @E:\LABS\LABS\ins_temps.sql
In session 2:
SQL>
2>
3>
4>
5>
SELECT s.username, rn.name

FROM v$session s, v$transaction t,
v$rollstat r, v$rollname rn
WHERE s.saddr = t.ses_addr
AND t.xidusn = r.usn AND r.usn = rn.usn;
12. Close session 2, then in session 1 connect as sys/oracle AS sysdba and set the
database in Auto Undo Mode by changing the following parameters to the values
shown:
undo_management = Auto
undo_tablespace = undotbs
Auto and that UNDO_TABLESPACE is undotbs.
y
l
n

Parameters
O
e
SQL> SHOW PARAMETER undo
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Practice 11
The objective of this practice is to familiarize you with SQL statement execution plans and
to interpret the formatted output of a trace file generated using SQL Trace and the formatted
output generated by TKPROF. Throughout this practice Oracle Enterprise Manager can be
used if desired. SQL Worksheet can be used instead of SQL*Plus and there are many uses
for the Oracle Enterprise Manager console.
1. Connect as hr/hr and create the plan_table table under the hr schema, if it is
not already created, by running the
@%ORACLE_HOME%\rdbms\admin\utlxplan.sql script.
SQL> CONNECT hr/hr
SQL> @%ORACLE_HOME%\rdbms\admin\utlxplan.sql
Note: If plan_table already exists and holds rows then truncate the table.
2. Set the optimizer mode to rule based using the ALTER SESSION command and
generate the explain plan for the statement E:\LABS\LABS\lab11_02.sql.
View the generated plan by querying object name, operation, option, and optimizer
from the plan_table table.
SQL>
SQL>
2
SQL>
2
y
l
n

EXPLAIN PLAN FOR
@E:\LABS\LABS\lab11_02.sql
FROM plan_table;
O
e
s
U
3. Truncate the plan_table table. Change the optimizer mode to cost based by setting
the value to All_Rows and rerun the explain plan for
E:\LABS\LABS\lab11_02.sql. Notice that the optimizer mode and the explain
plan have changed.
I
A
SQL>
SQL>
SQL>
2
SQL>
2
&
l
a

ALTER SESSION SET OPTIMIZER_GOAL = all_rows;
EXPLAIN PLAN FOR
FROM plan_table;
n
r
te
n
I
e
l
c
a
Note: Although exactly the same scripts are being run, due to the different optimizer
settings, different explain paths are found. With rule based, one of the rules is to use
any index that is on the columns in the where clause. By using cost based optimizer
mode, the server has been able to determine that it will be faster to just perform a full
table scan, due to the number of rows being returned by the script.
r
O
4. Truncate the plan_table table and set the optimizer mode to Rule by using the
ALTER SESSION command. This time generate the explain plan for the
E:\LABS\LABS\lab11_04.sql script. Examine the script which is a copy of
E:\LABS\LABS\lab11_02.sql except it changes the line SELECT * to
include a hint /*+ all_rows*/ for the optimizer. View the generated execution
plan by querying object name, operation, option, and optimizer from plan_table
table.
SQL>
SQL>
SQL>
2
SQL>
2

EXPLAIN PLAN FOR
FROM plan_table;
5. Exit out of SQL*Plus, change the directory to $HOME/ADMIN/UDUMP and delete all
the trace files already generated.
SQL> EXIT
$ rm *.trc
y
l
n
Note: this step is performed only to make it easier to find the trace file generated. It is
not a requirement of SQL Trace.
O
e
6. Connect as sh/sh and enable SQL Trace, using the ALTER SESSION command, to
collect statistics for the script, E:\LABS\LABS\lab11_06.sql. Run the script.
After the script has completed, disable SQL Trace, then format your trace file using
TKPROF. Use the options SYS=NO and EXPLAIN= sh/sh. Name the file
myfile.txt.
I
A
&
l
a
s
U
SQL> CONNECT sh/sh

SQL> ALTER SESSION SET SQL_TRACE = True;
SQL> ALTER SESSION SET SQL_TRACE = False;
$ ls -l
-rw-r----- 1 user457 dba 2180 May 4 00:27 ser457_ora_10424.trc
$ tkprof user457_ora_10424.trc myfile.txt explain=sh/sh sys=no
n
r
te
n
I
e
l
c
a
7. View the output file myfile.txt and note the CPU, current and query figures for
the fetch phase. Do not spend time analyzing the contents of this file as the only
objective here is to become familiar and comfortable with running TKPROF and
SQL*Trace.
r
O
$ more myfile.txt
Practice 12
The objective of this practice is to familiarize you with the dbms_stats package.
console.
1. Connect as hr/hr and create a table new_employees as a copy of the
employees table. Gather statistics on the new_employees table and determine
the current number of rows in the new_employees table. Record the number of
rows for comparison later.
SQL>
SQL>
2
3
SQL>
>
SQL>
2
3
CONNECT hr/hr
AS SELECT *
FROM employees;
EXECUTE dbms_stats.gather_table_stats ('HR','NEW_EMPLOYEES');
SELECT table_name, num_rows
FROM user_tables
WHERE table_name = 'NEW_EMPLOYEES';
2. Increase the size of the new_employees table by using the lab12_02.sql script.
y
l
n
O
e
3. Confirm that the statistics have not been changed in the data dictionary by re-issuing
the same statement as in question 1.
I
A
s
U

2 FROM user_tables
&
l
a
4. Connect hr/hr and gather statistics for all objects under the hr schema using the
dbms_stats package. While gathering the new statistics save the current statistics in
a table named stats.
n
r
te
a. Connect as hr/hr and create a table to hold statistics in that schema.
n
I
e
SQL> CONNECT hr/hr

SQL> execute dbms_stats.create_stat_table('HR','STATS');
l
c
a
b. Save the current schema statistics into your local statistics table.
SQL> execute dbms_stats.export_schema_stats('HR','STATS');
r
O
c. Analyze all objects under the hr schema.

SQL> execute dbms_stats.gather_schema_stats('HR');
5. Determine that the current number of rows in the employees table has been updated in
the data dictionary. This should be twice the number of rows recorded in question 1.
2 FROM user_tables
6. Remove all schema statistics from the dictionary and restore the original statistics you
saved in step b.
SQL> execute dbms_stats.delete_schema_stats('HR');
SQL> execute dbms_stats.import_schema_stats('HR','STATS');
7. Confirm that the number of rows in the employees table recorded in the data
dictionary has returned to the previous value collected in question 1.
2 FROM user_tables
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Practice 13
console.
1. Connect using sys/oracle AS sysdba and query the tablespace_name and
extent_management columns of dba_tablespaces to determine which
Use Enterprise Manager Console - Security - Users - HR
enqueue.
SQL> SELECT event, total_waits
2 FROM v$system_event
3 WHERE event = 'enqueue';
y
l
n
O
e
s
U
SQL> SELECT *
&
l
a
I
A
5. Exit out of the SQL*Plus session and change directory to E:\LABS\LABS. Run the
lab13_04.bat script from the operating system prompt. This script will log five
users onto the database simultaneously and then each user creates and drops tables.
The tables each have many extents. The script must be run from the E:\LABS\LABS
directory or it will fail.
n
r
te
n
I
e
r
O
l
c
a
$ cd E:\LABS\LABS
$ lab13_04.bat
eq_type 'ST' to determine the value of total_wait# for the ST enqueue, which is
the space management enqueue.
$ SQL*Plus system/oracle
SQL> SELECT *
management using a dictionary managed tablespace. This value is found by subtracting
the first wait value (from practice 13-04) from the second wait value (from practice 1306).
7. Create a new locally managed tablespace test, name the data file test01.dbf and
place it in the directory $HOME/ORADATA/u06. Set the size to 120 MB and a
Use Enterprise Manager Console - Security - Users - HR
y
l
n
O
e
I
A
s
U
view.
&
l
a
SQL> SELECT *
n
r
te
10. Exit out of the SQL*Plus session and change directory to E:\LABS\LABS. Run the
lab13_04.bat script from the operating system prompt. This script will log five
users onto the database simultaneously and then each user creates and drops tables.
The tables each have many extents. The script must be run from the E:\LABS\LABS
directory or it will fail.
n
I
e
r
O
l
c
a
$ cd E:\LABS\LABS
$ ./lab13_04.bat
SQL> SELECT *
the first wait value (from practice 13-09) from the second wait value (from practice 1311). Compare the two results for the different tablespaces. The locally managed
12. Connect as the hr/hr user and run the E:\LABS\LABS\lab13_12.sql script.
This will create a similar table (new_emp) as the employees table but with
PCTFREE = 0. The table is then populated with data from the employees table.
SQL> CONNECT hr/hr
SQL> E:\LABS\LABS\lab13_12.sql;
y
l
n
13. Run ANALYZE on the new_emp table and query the dba_tables view to determine
the value of chain_cnt for the new_emp table. Record this value.
SQL>
SQL>
2
3
O
e

FROM user_tables
I
A
s
U

SQL>
2
SQL>
2
3
&
l
a
CREATE INDEX new_emp_name_idx ON new_emp(last_name)

TABLESPACE indx;
FROM user_indexes
n
r
te
n
I
e
l
c
a
15. Run the E:\LABS\LABS\lab13_15.sql script, which will update the rows of the
new_emp table. Analyze the new_emp table again and query the user_tables
view to get the new value of chain_cnt Record this value. Also check the status of
the new_emp_name_idx index.
r
O
SQL>
SQL>
SQL>
2
3
SQL>
2
3
FROM user_tables
FROM user_indexes
table. Confirm that the migration has been resolved by querying chain_cnt column
in the user_tables view and confirm that the index is valid by querying the
user_indexes view.
SQL>
2
SQL>
SQL>
SQL>
2
3
SQL>
2
3
ALTER TABLE new_emp MOVE

TABLESPACE users;
ALTER INDEX new_emp_name_idx REBUILD;
SELECT table_name, blocks, empty_blocks, chain_cnt
FROM user_tables
FROM user_indexes
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Practice 15
console.
1. Connect as hr/hr, drop the new_employees table and create an IOT called
hr.employees table. Make the employee_id column the primary key and name
the primary key index new_employees_employee_id_pk.
SQL>
SQL>
SQL>
2
3
4
5
6
7
8
9
10
11
12
13
14
15
CONNECT hr/hr
DROP TABLE new_employees;
(employee_id
NUMBER(6),
first_name
VARCHAR2(20),
last_name
VARCHAR2(25),
email
VARCHAR2(25),
phone_number
VARCHAR2(20),
hire_date
DATE,
job_id
VARCHAR2(10),
salary
NUMBER(8,2),
commission_pct
NUMBER (2,2),
manager_id
NUMBER(6),
department_id
NUMBER(4),
CONSTRAINT
new_employees_employee_id_pk
PRIMARY KEY
(employee_id))
ORGANIZATION INDEX;
y
l
n
O
e
s
U
user_indexes views
I
A
The IOT is a table and so will be found in the user_tables view.
&
l
a

2 FROM user_tables
n
r
te
The IOT is an index and so will be found in the user_indexes view.

2 FROM user_indexes
n
I
e
l
c
a
3. Populate the new_employees table with the rows from the hr.employees table.
r
O
SQL> INSERT INTO new_employees

2
SELECT *
3
FROM employees;
last_name_new_employees_idx. Collect the statistics for the secondary index.
SQL>
2
3
SQL>
>
CREATE INDEX last_name_new_employees_idx

ON new_employees(last_name)
TABLESPACE indx;
EXECUTE dbms_stats.gather_index_stats ('HR','LAST_NAME_NEW_EMPLOYEES_IDX');
dictionary. Query the index_name, index_type, blevel and leaf_blocks.
2 FROM user_indexes
3 WHERE index_name = 'LAST_NAME_NEW_EMPLOYEES_IDX';
Note: If the values for blevel and leaf_blocks are null then there were no
statistics collected. Confirm that the value of index_type is normal.
SQL>
2
3
4
CREATE INDEX emp_hist_dept_id_idx

ON employees_hist (department_id)
TABLESPACE indx
REVERSE;
I
A
y
l
n
O
e
s
U
index_type, blevel and leaf_blocks.
&
l
a

2 FROM user_indexes
3 WHERE index_name = 'EMP_HIST_DEPT_ID_IDX';
n
r
te
n
I
e
Note: This time the values of blevel and leaf_blocks should be null, because
you did not collect statistics for this index while creating it. Also the value for index
type should now be normal/reverse.
r
O
l
c
a
8. Create a bitmap index on the job_id column of the employees_hist table. Place
the index in the indx tablespace. Name the index bitmap_emp_hist_idx.
SQL> CREATE BITMAP INDEX bitmap_emp_hist_idx
2 ON employees_hist (job_id)
3 TABLESPACE indx;
2 FROM user_indexes
3 WHERE index_name = 'BITMAP_EMP_HIST_IDX';
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Practice 16
console.
SQL> CONNECT sh/sh
SQL> DESC plan_table
If the table is found:

SQL> TRUNCATE table plan_table;
If the table is not found then:

SQL> @$ORACLE_HOME/rdbms/admin/utlxplan
2. Create a materialized view cust_sales having two columns, cust_last_name

and the total_sales for that customer. This will mean joining the sales and
customers tables using cust_id and grouping the results by cust_last_name.
Make sure that query rewrite is enabled on the view.
y
l
n
O
e
SQL> CREATE MATERIALIZED VIEW cust_sales

2 ENABLE QUERY REWRITE AS
3
SELECT c.cust_last_name, sum(s.amount_sold)
4
5
WHERE c.cust_id = s.cust_id
6
GROUP BY c.cust_last_name;
I
A
s
U

&
l
a
n
r
te
SQL> SELECT mview_name, rewrite_enabled, query

2 FROM user_mviews;
n
I
e
Note: The rewrite_enabled column must have a value of Y in order for the
practice on query rewrite to work.
r
O
l
c
a
E:\LABS\LABS\lab16_04.sql
SQL> SET AUTOTRACE Traceonly Explain
same query, E:\LABS\LABS\lab16_04.sql, as in the previous practice. Note
the change in the explain plan due to the query rewrite. Set AUTOTRACE to Off and
disable query rewrite after the script has completed running.
SQL>
SQL>
SQL>
SQL>
ALTER SESSION SET QUERY_REWRITE_ENABLED = True;

SET AUTOTRACE Off
ALTER SESSION SET QUERY_REWRITE_ENABLED = False;
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Practice 17
The objective of this practice is to use available diagnostic tools to monitor lock contention.
You will need to start three sessions in separate windows. Log in as hr/hr in two separate
sessions (sessions 1 and 3) and as sys/oracle as sysdba in another session (session 2).
console.
1. In session 1 (user hr/hr), update the salary by 10% for all employees with a salary <
SQL>
SQL>
2
3
CONNECT hr/hr
UPDATE TEMP_EMPS
SET SALARY = SALARY * 1.1
WHERE salary <15000;
2. In session 2 connect as sys/oracle AS sysdba and check to see if any locks are
being held by querying the v$lock view.
SQL>
SQL>
2
3

SELECT sid, type, id1, lmode, request
FROM v$lock
WHERE type IN ('TX','TM');
y
l
n
O
e
SQL> CONNECT hr/hr
SQL> DROP TABLE hr.temp_emps;
I
A
s
U
Note: The DDL statement requires an exclusive table lock. It cannot obtain it, because
session 1 already holds a row exclusive table lock on the temp_emps table.
&
l
a
4. In session 3 (hr/hr), update the salary by 5% for all employees with a salary > 15000
in the temp_emps table. Do not COMMIT.
SQL>
SQL>
2
3
n
I
e
l
c
a
r
O
n
r
te
CONNECT hr/hr
UPDATE temp_emps
SET salary = salary * 1.05
WHERE salary > 15000;
5. In session 2, check to see what kind of locks are being held on the temp_emps table,
using the v$lock view.
2 FROM v$lock
3 WHERE id1 =
4
(SELECT object_id FROM dba_objects
5
6
SQL> rollback;
SQL> UPDATE hr.temp_emps SET MANAGER_id = 10
2 WHERE salary < 15000;
7. In session 2, check to see what kind of locks are being held on the temp_emps table,
using the v$lock view.
2 FROM v$lock
3 WHERE id1 =
4
(SELECT object_id
5
FROM dba_objects
6
7
y
l
n
O
e
Or use Enterprise Manager Lock Manager
&
l
a
I
A
s
U

sessions holding or waiting on a lock. Use this view to determine the session ID for the
session that is holding locks. Use this value to query v$session to obtain the serial
number for the session holding the lock. Then issue the ALTER SYSTEM KILL
SESSION command to release the session holding the lock.
n
r
te
r
O
l
c
a
n
I
e
SQL>
SQL>
2
SQL>
2
3
SQL>
@$ORACLE_HOME/rdbms/admin/catblock.sql
SELECT waiting_session, holding_session
FROM dba_waiters;
SELECT sid, serial#, username
FROM v$session
WHERE SID ='&HOLDING_SESSION';
ALTER SYSTEM KILL SESSION '&SID,&SERIAL_NUM';
Tuning Workshop
O
e
I
A
&
l
a
n
r
te
r
O
l
c
a
n
I
e
y
l
n
s
U
Workshop Scenarios
Small shared pool

Small database buffer cache
Small redo log buffer cache
Missing indexes
Rollback segments and undo tablespace
Sort area size incorrectly set
Assorted
O
e
y
l
n
s
U
Workshop Scenario
At the beginning of each scenario, the database is shut down and then restarted.
When resizing memory components, do not consume more memory than is actually required
to meet the requirements of the objects given. For example, there is little point in resizing
the shared pool to 500 MB. The purpose of the workshop is to be as realistic as possible.
The company concerned has at present two OLTP users and two DSS users. The system was
set up by a trainee DBA, and though it works, the performance is very slow. You have been
invited in to resolve the current performance problems, and to prepare the present system for
an increase in the number of users accessing the database. The company is about to expand
to 10 of each type of user (twenty users in all). At the same time the company is unwilling to
spend extra on new hardware components.
Therefore, the management has imposed a limit of 20 MB for the entire SGA.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Oracle9i Database Performance Tuning C-2
Workshop Methodology
O
e
y
l
n
s
U
Workshop Methodology
Perform the following steps:
Make sure that the job scheduler is set to collect statistics at least every 10 minutes or
use manual snapshot collection.
Open the WORKLOAD window and select the desired workload.
Each scenario has a icon labeled with the scenario number.
Allow time for some statistics to be generated (at least 20 minutes). Shorter time
periods make it more difficult to determine where problems exist.
The workload generator has been set to run for a minimum of 20 minutes. After 20
minutes the users will complete what they are working on and then log off the
database. Check each window before closing for any errors that the user might have
received.
Generate a report by running the spreport.sql script. Choose a start and end time
that falls between the period that the workload generator was running. Name the report
in a manner associated with the scenario; for example, for scenario 1 use
reportscn1.txt, for Scenario 5 use reportscn5.txt, and so on.
Look for the generated report in the directory from which SQL*Plus was executed.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Workshop Procedure
1.
2.
3.
4.
5.
6.
7.
Choose a scenario.
Determine what changes should take place.
Implement the changes.
Return to the second step to check that the
changes have made an improvement.
8. When the changes have improved performance,
choose another scenario.
y
l
n
O
e
s
U
Workshop Procedure
The workshop is executed against the local database. There is a WORKSHOP group on your
desktop. This group includes icons for choosing a scenario and apply a workload.
Choose a Scenario
There are seven scenarios available. Each scenario is represented in the WORKSHOP group
as a .bat file. To set the database for scenario 1 select the icon labeled 1.bat.
I
A
&
l
a
Run the Workload Generator

The two options you have for the workload level you wish to run against the database are:
Four users (two OLTP and two DSS)
Twenty users (ten OLTP and ten DSS)
Using these options you can tune the database for the present load and examine what
changes are required to prepare for the future load. The workload scripts are set to run for a
minimum of twenty minutes.
Each logon gets a separate window. This means that for the twenty users there will be
twenty windows opened. These windows must be manually closed by pressing any key
when the window is active. You must check these windows for error messages because these
will be the error messages your users will report.
n
r
te
n
I
e
r
O
l
c
a
Workshop Scenario 1
(Shared Pool)
Provide a workload by executing the

workload generator.
Make sure that Statspack is collecting statistics.
Generate a report.
O
e
y
l
n
s
U
Workshop Scenario 1
Waits recorded on the latch Shared pool, library cache could be indicative of a small
shared pool. However, before increasing the SHARED_POOL_SIZE, it would be advisable
to determine why the pool is too small. Some reasons are listed below:
Many SQL statements stored in the SQL area are only executed once, and they often
differ only in literals in the WHERE clause. A case could be made here for using bind
variables, or setting CURSOR_SHARING. To determine these SQL statements
examine the report created by Statspack, or query v$sql using the like option of
the WHERE clause to collect information regarding similar SQL statements.
Examine which packages are loaded using the query shown below:
I
A
&
l
a
n
r
te
n
I
e
SQL>
2
3
4
5
6
l
c
a
r
O
SELECT *
WHERE sharable_mem > 10000
AND (type=PACKAGE OR type=PACKAGE BODY
OR type=FUNCTION OR type=PROCEDURE)
AND KEPT=NO;
Workshop Scenario 1 (continued)

If these packages are used frequently, pin them in memory using the
dbms_shared_pool.keep(Package_name) package. Another area to examine
would be reducing the size of the package. Determine whether there are large portions of the
package that are not commonly used. If possible, separate procedures into packages that will
have their contents utilized.
Examine SQL statements that are executed often using the following statement:
SQL> SELECT sum(sharable_mem)
2 FROM v$sqlarea
3 WHERE executions > 5;
With this information determine whether the SQL statement can be converted into a
procedure and stored as a package; this can assist users in sharing the same cursor.
After you have reduced the number of SQL statements as much as possible, run the
following query:
SQL> SELECT SUM(pins) "Executions", SUM(reloads)
2
"Cache Misses", SUM(reloads)/SUM(pins)
3 FROM v$librarycache;
Increase the shared pool to reduce cache misses. Record the increase received for each
increase in the shared pool in order to determine whether the extra memory is worth the
increase received.
y
l
n
Data Dictionary Cache

The data dictionary cache cannot be independently resized. The Oracle server automatically
assigns space from the SHARED_POOL_SIZE parameter for the shared SQL area, and the
data dictionary cache. Most of the increase to SHARED_POOL_SIZE is allocated to the
shared SQL area.
To determine the hit ratio of the data dictionary cache, run the query:
O
e
I
A
s
U
SQL> SELECT parameter, gets, getmisses

2 FROM v$rowcache;
The result of this query is a row for each segment of the data dictionary cache. Each area can
then be checked for usage. For example, if there is a large number of gets on dc_sequences,
this is probably due to sequence numbers not being cached. To reduce the number of gets on
dc_sequences, examine increasing the number of sequence numbers cached.
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Workload Scenario 2
(Buffer Cache)

workload generator.
Generate a report.
O
e
y
l
n
s
U
Workshop Scenario 2
The first indication that the buffer cache is too small is waits on the free buffer waits event.
The cache buffers LRU chain latch may also indicate that the buffer cache is too small.
Waits on the latch may also signify that the DBWR process is not able to keep up with the
work load.
To determine which problem is causing the latch contention, examine the number of writes
in the file statistics found in the Statspack report.
On the front page of the Statspack report, the section named Instance Efficiency
Percentages lists the important ratios of the instance. For this scenario, the value of Buffer
Hit%: is of interest.
The value of the Buffer Hit%: depends on individual systems. Ideally, this value should be
close to 100 percent. There may be several reasons why this goal cannot be realized. A low
percentage indicates that there are a lot of buffers being read into the database buffer cache.
Before increasing the size of the database buffer cache you should examine what SQL
statements are being run against the database. You are looking for statements that cause a
high number of buffer gets and how many times these statements are executed.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a

If a statement is executed only a few times, it may not be worth the effort of tuning.
However, a statement that is executed many times, and has a high number of buffer gets is
an ideal candidate for SQL tuning.
The Statspack report lists the SQL statements that have been executed on the database. The
first such listing orders the statements according to the number of gets. Examine the top
statements, keeping in mind that packages are also listed here, not just the SQL statements.
When a candidate statement is found, examine the SQL statement to determine if:
There are indexes that could be created to assist in using less blocks
There is a better way to write the statement to return the same data, but use less blocks
Investigate if the statement has to be executed so often. Can output be generated and
then shared between users?
After you have examined the SQL statements, and exhausted all means to reduce the number
of buffers, then consider changing the size of the buffer cache. You must determine two
items before changing the buffer cache size:
1. What is the current size?
Query the data dictionary to determine the current size of the buffer cache. This can be
performed by using:
- Show parameter
- The v$sgastat view
SQL> SELECT *
2 FROM v$sgastat
3 WHERE name =db_block_buffers;
y
l
n
O
e
- The front page of the Statspack report

2. What is an appropriate size for the buffer cache?
Determine the new value of the buffer cache by using the DB_CACHE_ADVICE
parameter. This parameter can have one of three values: Off, On, and Ready. Setting
the value to On will start collecting the required statistics. The value can be changed
by either:
- Changing the parameter and bouncing the database
- Using the ALTER SYSTEM SET DB_CACHE_ADVICE = On; command
I
A
&
l
a
s
U
When the value has been set to On, allow the system to run the required scripts to collect
information regarding buffer usage.
After the database executes a typical load, query the v$db_cache_advice view and set
a new value for the DB_CACHE_SIZE parameter. When a new size has been determined,
use the following command to dynamically change the size of the cache.
n
r
te
n
I
e
SQL> ALTER SYSTEM SET DB_CACHE_SIZE = new_value;
l
c
a
Run a test load with this new value. Collect the statistics again. If the increase has resolved
the problem then change the value in the parameter file.
r
O
Workshop Scenario 3
(Redo Log Buffer)

workload generator.
Generate a Statspack report.
y
l
n
O
e
s
U
Workshop Scenario 3
Waits on the LOG BUFFER SPACE event is an indication that your log buffer is too small.
I
A
On the first page of the Statspack report there is a section named Instance Efficiency
Percentages. Note the value of the statistic REDO NO WAIT. While this statistics ideal
value of 100 percent is seldom achieved, any lesser value could indicate that the Redo Log
Buffer is not correctly sized. Consider reducing the amount of redo created by the use of NO
LOGGING in appropriate statements. Query the data dictionary to determine the current size
of the Redo Log Buffer.
Estimate the increase required by examining the amount of redo generated. The first page of
the Statspack report has this information under the heading Load Profile.
Edit the LOG_BUFFER_SIZE parameter to set a new size for the redo log buffer. This
parameter is static so you will need to bounce the database after making the change.
Rerun the workload generator and collect the statistics again. If the increase has resolved the
problem and if the change was vast, then repeat the process with a larger redo log buffer.
Note: The redo log buffer does not always have the size stipulated in the parameter file. This
is due to minimum size, and rounding upwards to the nearest Oracle block. To confirm the
actual redo log buffer size use the v$sgastat view.
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Workshop Scenario 4 (Indexes)
All the indexes have been eliminated.

Result full table scans instead of using indexes

Examine the SQL statements executed.
Determine which indexes should be re-created.
O
e
y
l
n
s
U
Workshop Scenario 4
Several indexes have been deleted and performance has decreased. The results are seen in
the Statspack report where there are many indications that untuned SQL is running. For
example:
The buffer cache hit ratio is lower.This can be seen on the first page of the Statspack
report in the Load Profile section.
There are more waits on the free buffer waits event.
There are more full table scans occurring.
Missing or incorrect indexes cause too many full table scans. This can also be caused by
badly written SQL statements.
To resolve the problem you must determine which SQL statements are run on the database
during a normal workload. Either use the SQL Trace utility or examine the top resource
users in the Statspack report to collect a representation of these SQL statements.
After the appropriate statements are collected, examine the WHERE clauses. Any columns
referenced in the WHERE clause are good candidates for indexes.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a

To determine whether an index would be used by the optimizer, you must look at the
expected number of rows to be returned. The more rows to be returned, the less likely an
index will improve performance.
Confirm that the required indexes are present and enabled. The index might have been
disabled for some reason. If the index is not present, then create the index.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Workshop Scenario 5
(Rollback Segments)
Create a workload by running the

workload generator.
Determine whether there is contention for
rollback segments.
This can be resolved by:
Creating extra rollback segments
Using Auto Managed Undo
O
e
y
l
n
s
U
Workshop Scenario 5
Presently the company has four users that log on to the database. Currently, the system is set
up with one very large rollback segment.
The company is planning on increasing the number of users to twenty. Having only one
rollback segment is likely to cause contention.
Collect statistics during the running of the workload generator and generate a Statspack
report. In the report there is a section named Buffer Wait Statistics which has an undo
header statistic. This statistic indicates that there is contention for the rollback segment
header blocks.
Use the following two methods to resolve this problem:
Create extra rollback segments
Use Auto Managed Undo
Options for Resolving Rollback Contention in an Oracle9i Database
In Oracle9i, the problems around the number and size of rollback segments have been
eliminated. Instead of creating rollback segments, the DBA only has to create an undo
tablespace that is large enough.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a

Options for Resolving Rollback Contention in a Pre-Oracle9i Database
To resolve contention on the rollback segment header, more rollback segments must be
created and current rollback segments resized. To do this requires some planning. For the
DSS users there should be few very large rollback segments, and smaller rollback segments
are used for the OLTP users.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Workload Scenario 6 (Sorting)
Create a workload by running the

workload generator.
After statistics have been collected, generate
a report.
Examine the report.
O
e
y
l
n
s
U
Workshop Scenario 6
The DSS users log on and create a series of reports for management. This requires a lot of
sorting. Currently, the scripts are completing. However, management wants a more rapid
completion.
The first step is to run the workload and collect the Statspack report. Also make a note of
how many transactions are completed during your running period (should be at least twenty
minutes).
Because of the concern about sorts, the tendency is to jump straight to the Instance Activity
stats and look for the values of Sorts (Disk), Sorts (Memory), and Sorts (Rows). However,
doing so ignores some good information found on the front page.
On the front page, look at the buffer hit ratio. In a data warehouse environment you would
expect this ratio to drop; however, combining this information with the high number of
Buffer Busy Waits indicates that the buffer cache is too small for the number of sorts taking
place. So you would likely want to increase the size of the buffer cache.
Moving to the Instance Activity report, you find that a large number of sorts are having to go
to disk. Ideally, no sorts should go to disk; however, accomplishing this has a high cost in
memory. The ratio of sorts (Disk) to sorts (Memory) should be less than 5 percent.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a

Increasing the value of SORT_AREA_SIZE will resolve this issue, and more sorts will be
performed in memory. The disadvantage of increasing the SORT_AREA_SIZE parameter is
that more memory is consumed, and after completing the sort run, this memory is not
released back to the operation system. It is released, but only to the sessions UGA. Therefore
many users performing large sorts will consume memory. Increasing the
SORT_AREA_SIZE parameter can cause the operating system to page due to limited
memory. Confirm that increasing SORT_AREA_SIZE does not cause this problem.
Try increasing the value of the SORT_AREA_SIZE parameter by a factor of 10, and see
what the effect is on the number of sorts (Disk).
Prior to the Oracle9i database release, there was nothing a DBA could do to resolve this
problem. A choice had to be made between increasing memory consumption (by changing
the value of SORT_AREA_SIZE), or live with sorts going to disk.
In the Oracle9i database it is possible to change the manner in which sorts are handled in
memory. Instead of allocating memory in terms of SORT_AREA_SIZE (which would then
be locked onto one session), the Oracle9i database release allows one memory allocation to
be used for all sessions, thereby enabling the sharing of memory after the sort has
completed.
The PGA_AGGREGATE_TARGET parameter allocates the memory for sorting. The size
ranges from 10 MB to 4000 GB. When setting the value for this parameter, keep in mind
that this is the total sort area for all sessions performing sorts.
To enable use of PGA_AGGREGATE_TARGET, set the WORKAREA_SIZE_POLICY
parameter to Auto.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Workload Scenario 7 (Assorted)

After statistics have been collected, generate
a report.
Examine the report.
O
e
y
l
n
s
U
Workshop Scenario 7 (Assorted)

This scenario is provided to give a more real world type of example. For this scenario the
database has a multitude of problems that are causing performance degradation. Some of the
previous scenarios have been combined in this scenario, and some extra problems created.
After resolving the performance problems present your findings to the group.
I
A
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Example of Statspack Report
O
e
I
A
&
l
a
n
r
te
r
O
l
c
a
n
I
e
y
l
n
s
U
STATSPACK report for

DB Name
DB Id
Instance
Inst Num Release
Cluster Host
------------ ----------- ------------ -------- ----------- ------- -----------ORCL
995156390 orcl
1 9.2.0.1.0
NO
EDT3R4P1
Snap Id
Snap Time
Sessions Curs/Sess Comment
------- ------------------ -------- --------- ------------------Begin Snap:
1 30-Jul-02 15:14:22
5.0
End Snap:
2 30-Jul-02 16:01:23
5.9
Elapsed:
(mins)
47.02
Cache Sizes (end)

~~~~~~~~~~~~~~~~~
Buffer Cache:
4M
Std Block Size:

Shared Pool Size:
8M
4K
Log Buffer:
63K
Load Profile
~~~~~~~~~~~~
Per Second
Per Transaction
Redo size:
--------------897.28
--------------2,981.43
Logical reads:
Block changes:
775.82
6.52
2,577.84
21.65
Physical reads:
Physical writes:
718.92
5.58
User calls:
Parses:
0.21
1.05
Hard parses:
Sorts:
Logons:
Executes:
Transactions:
I
e
Rollback per transaction %:

Rows per Sort:
r
O
l
c
a
na
r
e
nt
% Blocks changed per Read:

Recursive Call %:
l&
O
e
I
A
s
U
2,388.78
18.55
O
0.03
0.19
y
l
n
0.71
3.47
0.11
0.65
0.01
2.98
0.02
9.89
0.30
0.84
98.36
0.00
3677.05
Oracle9i Database Performance Tuning D-2
Instance Efficiency Percentages (Target 100%)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Buffer Nowait %:
Redo NoWait %:
98.34
100.00
Buffer Hit
In-memory Sort %:
%:
7.59
Library Hit
Soft Parse %:
%:
97.33
Execute to Parse %:
Latch Hit %:
64.88
Parse CPU to Parse Elapsd %:

% Non-Parse CPU:
2.11
74.50
96.95
Shared Pool Statistics

Memory Usage %:
% SQL with executions>1:
% Memory for SQL w/exec>1:
100.00
99.66
Begin
End
-----94.93
-----95.69
71.80
48.25
87.21
84.48
Top 5 Timed Events

~~~~~~~~~~~~~~~~~~
Event
Waits
% Total
Time (s) Ela Time
-------------------------------------------- ------------ ----------- -------db file sequential read

189,111
29,773
50.93
db file scattered read
buffer busy waits
25,114
2,031
42.96
3.47
724
3,085
535
325
.91
.56
enqueue
direct path read
s
U
O
e
-------------------------------------------------------------
I
A
&
l
a
n
r
te
n
I
e
l
c
a
r
O
y
l
n
130,326
36,307
Wait Events for DB: ORCL

-> s - second
-> cs - centisecond -> ms - millisecond -
Instance: orcl
Snaps: 1 -2
100th of a second
1000th of a second
-> us - microsecond - 1000000th of a second

-> ordered by wait time desc, waits desc (idle events last)
Avg
Event
Waits
Total Wait
Timeouts
Time (s)
wait
(ms)
Waits
/txn
---------------------------- ------------ ---------- ---------- ------ -------db file sequential read

189,111
0
29,773
157
222.7
buffer busy waits
130,326
36,307
0
0
25,114
2,031
193
56
153.5
42.8
724
3,085
19
0
535
325
738
105
0.9
3.6
PL/SQL lock timer

library cache load lock
217
177
216
20
222
86
1023
485
0.3
0.2
log file parallel write

control file parallel write
898
892
760
0
58
55
65
61
1.1
1.1
db file parallel write

control file sequential read
872
406
436
0
39
24
45
59
1.0
0.5
library cache pin

direct path write
170
280
0
0
20
13
117
48
0.2
0.3
log file sync

row cache lock
174
38
0
0
5
2
26
41
latch free
SQL*Net break/reset to clien
213
38
18
0
0
0
SQL*Net message from client

SQL*Net message to client
561
561
0
0
enqueue
direct path read
I
A
s
U
O
e
221
0
1
0
394
0
-------------------------------------------------------------
&
l
a
n
r
te
n
I
e
r
O
l
c
a
y
l
n
0.2
0.0
0.3
0.0
0.7
0.7
Background Wait Events for DB: ORCL Instance: orcl Snaps: 1 -2

-> ordered by wait time desc, waits desc (idle events last)
Avg
Event
Waits
Timeouts
Total Wait
Time (s)
wait
(ms)
Waits
/txn
---------------------------- ------------ ---------- ---------- ------ -------log file parallel write

898
760
58
65
1.1
control file parallel write
db file parallel write
892
872
0
436
55
39
61
45
1.1
1.0
control file sequential read

db file sequential read
406
121
0
0
24
5
59
42
0.5
0.1
direct path read

172
2
0
0
0
0
1
7
0.2
0.0
latch free
direct path write
3
16
1
0
0
0
1
0
0.0
0.0
log file sync

rdbms ipc message
1
4,137
0
3,607
0
17,594
0
4253
0.0
4.9
smon timer
SQL*Net message from client
9
1
9
0
4,591 ######
214 ######
0.0
0.0
SQL*Net message to client
0.0
-------------------------------------------------------------
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
SQL ordered by Gets for DB: ORCL Instance: orcl

-> End Buffer Gets Threshold:
10000
Snaps: 1 -2
-> Note that resources reported for PL/SQL includes the resources used by
all SQL statements called within the PL/SQL code. As individual SQL
statements are also reported, it is possible and valid for the summed
total % to exceed 100
CPU
Elapsd
Buffer Gets
Executions Gets per Exec %Total Time (s) Time (s) Hash Value
--------------- ------------ -------------- ------ -------- --------- ---------1,460,071
10
146,007.1
66.7
72.00 ######### 4281857347
43.9
58.55 ######### 1750902811
43.8
58.48 ######### 2215370455
Module: SQL*Plus
BEGIN workload_generator.oltp1; END;
960,366
100
9,603.7
Module: Workload Generator

DELETE from sh.customers where cust_id = :b1
959,410
100
9,594.1

select /*+ all_rows */ count(1) from "SH"."SALES" where "CUST_I
D" = :1
725,161
Module: SQL*Plus
10
72,516.1
33.1
56.83 #########
O
e
BEGIN workload_generator.dss1; END;

724,775
Module: Shipping Queries
33
21,962.9
y
l
n
899679532
33.1
s
U
60.44 ######### 3035176266
I
A
SELECT c.cust_last_name, p.prod_name, s.amount_sold, s.quantity_

sold
from sh.customers c, sh.products p, sh.sales s
where c.
cust_id = s.cust_id
and s.prod_id = p.prod_id
and s.quantity
_sold = (select MAX(quantity_sold) from sh.sales)
and rownum =
&
l
a
n
r
te
436,669
200
2,183.3
SELECT * from sh.customers

rownum < 2 for update
l
c
a
n
I
e
6,536
200
Module: Workload Generator - oe-emp

SELECT employee_id from oe.employees
r
O
20.0
27.36 ######### 3675510457
where cust_id >= :b1 and
32.7
0.3
0.11
119.93 3247722561
where employee_
id >= :b1 and rownum < 2 for update

10000
Snaps: 1 -2
CPU
Elapsd
Buffer Gets
--------------- ------------ -------------- ------ -------- --------- ---------5,716
200
28.6
Module: Workload Generator - oe_ord

SELECT order_id from oe.orders
0.3
0.13
188.80 3558587519
where order_id >= :b1
and rownum < 2 for update

4,890
200
Module: Workload Generator - oe_prod
24.5
0.2
0.09
SELECT product_id from oe.product_information

product_id >= :b1 and rownum < 2 for update
4,083
313
13.0
161.84 2089710453
where
0.2
0.20
4.13 4168585130

INSERT into oe.order_items (order_id, line_item_id,
product_id, unit_price, quantity)
(:b5, :b4,
:b3, :b2, :b1)
1,460,071
10
146,007.1
O
e
66.7
72.00 ######### 4281857347
Module: SQL*Plus
960,366
100
9,603.7

959,410
&
l
a
100
n
r
te
9,594.1
y
l
n
values
43.9
I
A
43.8
s
U
58.55 ######### 1750902811
58.48 ######### 2215370455

D" = :1
n
I
e
725,161
Module: SQL*Plus
10
72,516.1
33.1
56.83 #########
l
c
a
r
O
899679532

10000
Snaps: 1 -2
CPU
Elapsd
Buffer Gets
--------------- ------------ -------------- ------ -------- --------- ---------724,775
33
21,962.9
33.1
60.44 ######### 3035176266

sold
where c.
cust_id = s.cust_id
and s.quantity
1
436,669
200
2,183.3

and rownum =
20.0
27.36 ######### 3675510457

6,536
200
32.7

5,716
0.11
28.6

0.3
l&
24.5
O
0.2
na

I
e
4,083
313
188.80 3558587519
r
e
nt
13.0
0.09
161.84 2089710453
where
0.2
0.20

l
c
a

(:b5, :b4,
:b3, :b2, :b1)
r
O
O
e
s
U
0.13
I
A
y
l
n
119.93 3247722561
where employee_
200
4,890
200
0.3
values
4.13 4168585130

10000
Snaps: 1 -2
CPU
Elapsd
Buffer Gets
--------------- ------------ -------------- ------ -------- --------- ---------3,041
160
19.0
0.1
0.36
7.81 1915274376

INSERT into hr.employees (employee_id, last_name, first_name, em
ail,
phone_number, hire_date, job_id, salary, com
mission_pct, manager_id,
department_id)
values (:b11, :b10, :b9, :b8,
, :b4,
:b3,:b2, :b1)
1,992
313
:b7, :b6, :b5
6.4
0.1
0.05

SELECT (NVL(MAX(line_item_id),0)+1) FROM order_items
0.37
467603321
WHERE
order_id = :b1
y
l
n
1,790
517
3.5
0.1
0.22
0.50 3935516425
update seq$ set increment$=:2,minvalue=:3,maxvalue=:4,cycle#=:5,
order$=:6,cache=:7,highwater=:8,audit$=:9,flags=:10 where obj#=:
1
1,350
313
4.3

DELETE oe.order_items where ROWID = :b1
1,280
&
l
a
160
8.0
0.1
0.1
0.05
0.15 4170474221
0.09
0.36 2950658496
I
A
s
U
O
e
select c.name, u.name from con$ c, cdef$ cd, user$ u where c.co
n# = cd.con# and cd.enabled = :1 and c.owner# = u.user#
n
r
te
1,259
160
7.9
0.1
0.19
2.40 2729780859
0.0
0.22
0.36 1994657103

SELECT hr.employees_seq.nextval from dual
l
c
a
n
I
e
1,076
150
7.2

SELECT sh.customers_seq.nextval from dual
r
O

10000
Snaps: 1 -2
CPU
Elapsd
Buffer Gets
--------------- ------------ -------------- ------ -------- --------- ---------848
948
0.9
115
5.0
0.0
0.06
1.42 3615375148
0.0
0.05
0.23 1351631542
Module: SQL*Plus
COMMIT
575
select o.name, c.name from con$ c, user$ o

d owner# = user#
554
24
where c.con# = :1 an
23.1
0.0
0.02
1.24 1819073277
select owner#,name,namespace,remoteowner,linkname,p_timestamp,p_
obj#, d_owner#, nvl(property,0),subname from dependency$,obj$ wh
ere d_obj#=:1 and p_obj#=obj#(+) order by order#
515
125
DELETE oe.inventories where
4.1
0.0
0.08
y
l
n
0.03 3863742839
O
e
ROWID = :b1
s
U
511
26
19.7
0.0
0.05
14.45 3111103299
select /*+ index(idl_ub1$ i_idl_ub11) +*/ piece#,length,piece fr
I
A
om idl_ub1$ where obj#=:1 and part=:2 and version=:3 order by pi

ece#
413
&
l
a
24
17.2
O
0.0
0.02
0.78 4049165760
select order#,columns,types from access$ where d_obj#=:1
n
r
te
390
95
4.1
0.0
0.00
select intcol#,nvl(pos#,0),col# from ccol$ where con#=:1
220
In
55
4.0
0.0
0.02
select obj#,type#,ctime,mtime,stime,status,dataobj#,flags,oid$,
spare1, spare2 from obj$ where owner#=:1 and name=:2 and namespa
e
l
c
ce=:3 and(remoteowner=:4 or remoteowner is null and :4 is null)a

nd(linkname=:5 or linkname is null and :5 is null)and(subname=:6
a
r
O
or subname is null and :6 is null)
0.06 2085632044
0.86 2591785020

10000
Snaps: 1 -2
CPU
Elapsd
Buffer Gets
--------------- ------------ -------------- ------ -------- --------- ---------181
177
1.0
0.0
0.02

UPDATE oe.order_items set unit_price = :b1
0.03 1375013356
where
ROWID = :b2
139
26
5.3
0.0
0.00
0.76 3218356218
select /*+ index(idl_sb4$ i_idl_sb41) +*/ piece#,length,piece fr
om idl_sb4$ where obj#=:1 and part=:2 and version=:3 order by pi
ece#
135
45
3.0
0.0
0.05
0.38 4059714361
select type#,blocks,extents,minexts,maxexts,extsize,extpct,user#
,iniexts,NVL(lists,65535),NVL(groups,65535),cachehint,hwmincr, N
y
l
n
VL(spare1,0) from seg$ where ts#=:1 and file#=:2 and block#=:3
O
e
87
29
3.0
0.0
0.02
0.14
select o.owner#,o.name,o.namespace,o.remoteowner,o.linkname,o.su
bname,o.dataobj#,o.flags from obj$ o where o.obj#=:1
I
A
189272129
s
U
72
26
2.8
0.0
0.00
0.19 1428100621
&
l
a
-------------------------------------------------------------
n
r
te
n
I
e
r
O
l
c
a
SQL ordered by Reads for DB: ORCL Instance: orcl

-> End Disk Reads Threshold:
1000
Snaps: 1 -2
CPU
Elapsd
Physical Reads Executions Reads per Exec %Total Time (s) Time (s) Hash Value
--------------- ------------ -------------- ------ -------- --------- ---------1,327,038
10
132,703.8
65.4
72.00 ######### 4281857347
46.6
58.55 ######### 1750902811
46.6
58.48 ######### 2215370455
Module: SQL*Plus
944,747
100
9,447.5

944,693
100
9,446.9

D" = :1
700,549
Module: SQL*Plus
10
70,054.9
34.5
56.83 #########
899679532
34.5
60.44 ######### 3035176266

700,532
33
21,228.2

sold
where c.
I
A
381,590
200
1,908.0
&
l
a

n
r
te
251
26
O
18.8
O
e
s
U
cust_id = s.cust_id
and s.quantity
and rownum =
1
y
l
n
27.36 ######### 3675510457
9.7
0.0
0.05
14.45 3111103299

n
I
e
ece#
l
c
a
30
24
1.3
0.0
0.02
1.24 1819073277
r
O


1000
Snaps: 1 -2
CPU
Elapsd
--------------- ------------ -------------- ------ -------- --------- ---------28
200
0.1
0.0
0.09

161.84 2089710453
where

22
313
0.1
0.0
0.20

(:b5, :b4,
4.13 4168585130
values
:b3, :b2, :b1)
20
26
0.8
0.0
0.00
0.76 3218356218
ece#
19
160
0.1
0.0
0.36
ail,
department_id)
, :b4,
values (:b11, :b10, :b9, :b8,

:b3,:b2, :b1)
17
55
0.0
I
A
O
e
s
U
:b7, :b6, :b5
0.3
y
l
n
7.81 1915274376

0.02
0.86 2591785020
&
l
a

n
r
te
16
24
0.7
0.0
0.02
l
c
a
n
I
e
13
45
0.3
0.0
0.05
r
O
0.78 4049165760
0.38 4059714361

1000
Snaps: 1 -2
CPU
Elapsd
--------------- ------------ -------------- ------ -------- --------- ---------7
26
0.3
0.0
0.00
0.19 1428100621

ece#
7
160
0.0
0.0
0.19
2.40 2729780859

6
26
0.2
0.0
0.02
select /*+ index(idl_char$ i_idl_char1) +*/ piece#,length,piece
0.34
957616262
from idl_char$ where obj#=:1 and part=:2 and version=:3 order by

piece#
6
200
0.0

0.0
0.13
188.80 3558587519
y
l
n
O
e
6
517
0.0
0.0
0.22
0.50 3935516425
s
U

1
3
160
0.0
0.0
I
A
0.09
0.36 2950658496
2
&
l
a
29
n
r
te
0.1
0.0
0.02
0.14
189272129
0.37
467603321
n
I
e
2
313
l
c
a
0.0
0.0

order_id = :b1
r
O
0.05
WHERE

1000
Snaps: 1 -2
CPU
Elapsd
--------------- ------------ -------------- ------ -------- --------- ---------2
16
0.1
0.0
0.00
0.03
931956286
select grantee#,privilege#,nvl(col#,0),max(mod(nvl(option$,0),2)
)from objauth$ where obj#=:1 group by grantee#,privilege#,nvl(co
l#,0) order by grantee#
2
115
0.0
0.0
0.05
0.23 1351631542
select o.name, c.name from con$ c, user$ o where c.con# = :1 an
d owner# = user#
2
95
0.0
0.0
0.00
0.06 2085632044
-------------------------------------------------------------
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
SQL ordered by Executions for DB: ORCL

-> End Executions Threshold:
100
Instance: orcl
Snaps: 1 -2
CPU per
Elap per
Executions
Rows Processed
Rows per Exec
Exec (s)
Exec (s) Hash Value
------------ --------------- ---------------- ----------- ---------- ---------948
0.0
0.00
0.00 3615375148
517
1.0
0.00
0.00 3935516425
Module: SQL*Plus
COMMIT
517

1
313
313
1.0
0.00

order_id = :b1
313
313
1.0
0.00
467603321
WHERE
0.00
0.01 4168585130

(:b5, :b4,
:b3, :b2, :b1)
313
313
1.0
0.00
1.0
I
A

DELETE oe.order_items where ROWID = :b1
200
200

&
l
a
n
r
te
200
200
1.0

l
c
a
n
I
e
200
200

r
O
y
l
n
values
O
e
0.00 4170474221
s
U
0.00
0.81 2089710453
where
0.00
0.60 3247722561
where employee_
1.0
0.00
0.94 3558587519

100
Instance: orcl
Snaps: 1 -2
CPU per
Elap per
Executions
Rows Processed
Rows per Exec
Exec (s)
Exec (s) Hash Value
------------ --------------- ---------------- ----------- ---------- ---------200
200
1.0

0.14 ########### 3675510457

177
177
1.0
0.00

ROWID = :b2
160
0.00 1375013356
where
0.0
0.00
0.05 1915274376

ail,
department_id)
, :b4,
values (:b11, :b10, :b9, :b8,

:b3,:b2, :b1)
160
160
:b7, :b6, :b5
1.0
0.00
1.0
0.00

160
160
I
A
y
l
n
O
e
0.02 2729780859
s
U
0.00 2950658496
150
&
l
a
150
1.0

SELECT sh.customers_seq.nextval from dual
n
r
te
150
0.0
0.00
0.00 1994657103
0.00
0.00 2386552905

INSERT into sh.customers (cust_id, cust_first_name, cust_last_na
n
I
e
me,
cust_street_address, cust_city, country_id, c
ust_credit_limit,
cust_email)
valu
l
c
a
es (:b8, :b7, :b6,

:b2, :b1)
r
O
:b5, :b4, :b3,

100
Instance: orcl
Snaps: 1 -2
CPU per
Elap per
Executions
Rows Processed
Rows per Exec
Exec (s)
Exec (s) Hash Value
------------ --------------- ---------------- ----------- ---------- ---------125
125
1.0
0.00
0.00 3863742839
1.0
0.00
0.00 1351631542

DELETE oe.inventories where ROWID = :b1
115
115

d owner# = user#
100
95
1.0
0.59 ########### 1750902811

100
100
1.0
0.58 ########### 2215370455

D" = :1
95
100
1.1
0.00
55
47
0.9
0.00
y
l
n
0.00 2085632044
s
U
I
A
O
e
0.02 2591785020

&
l
a
45
45
1.0
0.00
0.01 4059714361
n
r
te
33
In
33
1.0
1.83 ########### 3035176266

e
l
c
sold
where c.
cust_id = s.cust_id
and s.quantity
a
r
O

1
and rownum =

100
Instance: orcl
Snaps: 1 -2
CPU per
Elap per
Executions
Rows Processed
Rows per Exec
Exec (s)
Exec (s) Hash Value
------------ --------------- ---------------- ----------- ---------- ---------29
29
1.0
0.00
0.00
189272129
26
0.2
0.00
0.01
957616262

piece#
26
8
0.3
0.00
0.01 1428100621
ece#
26
102
3.9
0.00
0.56 3111103299

O
e
y
l
n
-------------------------------------------------------------
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
SQL ordered by Parse Calls for DB: ORCL

-> End Parse Calls Threshold:
1000
Instance: orcl
Snaps: 1 -2
% Total
Parse Calls Executions
Parses Hash Value
------------ ------------ -------- ---------517
517
17.53 3935516425
1
211
948
7.15 3615375148
160
5.42 2950658496
Module: SQL*Plus
COMMIT
160
150
150
5.08 2386552905

INSERT into sh.customers (cust_id, cust_first_name, cust_last_na
me,
ust_credit_limit,
cust_street_address, cust_city, country_id, c

cust_email)
valu
es (:b8, :b7, :b6,

:b2, :b1)
115
115
3.90 1351631542

d owner# = user#
45
45
1.53 4059714361
I
A
&
l
a
n
r
te
32
55
1.08 2591785020
n
I
e

l
c
a
r
O
26
0.88
O
e
s
U
26
y
l
n
:b5, :b4, :b3,
957616262

piece#

1000
Instance: orcl
Snaps: 1 -2
% Total
Parses Hash Value
------------ ------------ -------- ---------26
26
0.88 1428100621

ece#
26
26
0.88 3111103299
ece#
26
26
0.88 3218356218

ece#
24
24
0.81 1819073277
24
24
0.81 4049165760

20
200
0.68 2089710453
20
200
&
l
a
I
A
s
U
where
0.68 3247722561
n
r
te

where employee_
n
I
e
20
200
0.68 3558587519
l
c
a
r
O
O
e
y
l
n

1000
Instance: orcl
Snaps: 1 -2
% Total
Parses Hash Value
------------ ------------ -------- ---------20
200
0.68 3675510457


14
14
0.47 1705880752
select file# from file$ where ts#=:1
13
100
0.44 1750902811

13
100
0.44 2215370455

D" = :1
12
29
0.41 189272129
O
e
s
U
12
16
0.41 931956286
select grantee#,privilege#,nvl(col#,0),max(mod(nvl(option$,0),2)
I
A
)from objauth$ where obj#=:1 group by grantee#,privilege#,nvl(co

l#,0) order by grantee#
11
20
&
l
a
0.37 2385919346
select name,intcol#,segcol#,type#,length,nvl(precision#,0),decod
e(type#,2,nvl(scale,-127/*MAXSB1MINAL*/),178,scale,179,scale,180
n
r
te
,scale,181,scale,182,scale,183,scale,231,scale,0),null$,fixedsto
rage,nvl(deflength,0),default$,rowid,col#,property, nvl(charseti
d,0),nvl(charsetform,0),spare1,spare2,nvl(spare3,0) from col$ wh
n
I
e
10
Module: SQL*Plus
10
0.34
899679532
l
c
a
r
O
y
l
n

1000
Instance: orcl
Snaps: 1 -2
% Total
Parses Hash Value
------------ ------------ -------- ---------10
177
0.34 1375013356

where
ROWID = :b2
10
160
0.34 1915274376
ail,
-------------------------------------------------------------
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Instance Activity Stats for DB: ORCL
Instance: orcl
Snaps: 1 -2
Statistic
Total
per Second
per Trans
--------------------------------- ------------------ -------------- -----------CPU used by this session
CPU used when call started
15,305
15,305
5.4
5.4
18.0
18.0
4,555
1,556,535
1.6
551.8
5.4
1,833.4
Commit SCN cached

DBWR buffers scanned
50
1,102
0.0
0.4
0.1
1.3
DBWR checkpoint buffers written

DBWR checkpoints
2,049
0
0.7
0.0
2.4
0.0
DBWR free buffers found

DBWR lru scans
1,039
6
0.4
0.0
1.2
0.0
DBWR make free requests

DBWR summed scan depth
6
1,102
0.0
0.4
0.0
1.3
430
723
0.2
0.3
0.5
0.9
501
2,806
0.2
1.0
0.6
3.3
2,720
2,130,206
1.0
755.1
3.2
2,509.1
buffer is pinned count

bytes received via SQL*Net from c
2,539
56,493
0.9
20.0
3.0
66.5
bytes sent via SQL*Net to client

calls to get snapshot scn: kcmgss
65,619
29,701
23.3
10.5
calls to kcmgas
calls to kcmgcs
6,251
160
2.2
0.1
change write time

cleanout - number of ktugct calls
31
2,253
cleanouts and rollbacks - consist

cleanouts only - consistent read
1,481
130
CR blocks created
Cached Commit SCN referenced
DBWR transaction table writes

DBWR undo block writes
SQL*Net roundtrips to/from client
active txn count during cleanout
background timeouts
buffer is not pinned count
y
l
n
O
e
s
U
77.3
35.0
7.4
0.2
0.0
0.8
0.0
2.7
0.5
0.1
1.7
0.2
830
478
0.3
0.2
1.0
0.6
2
127
0.0
0.1
0.0
0.2
1
2,551
0.0
0.9
0.0
3.0
2,421
243
0.9
0.1
2.9
0.3
10,340
2,169,211
3.7
769.0
12.2
2,555.0
consistent gets - examination

current blocks converted for CR
18,811
6
6.7
0.0
22.2
0.0
cursor authentications
data blocks consistent reads - un
76
10,076
0.0
3.6
0.1
11.9
cluster key scan block gets

cluster key scans
I
A
commit cleanout failures: block l

commit cleanout failures: callbac
na
l&
commit cleanout failures: cannot

commit cleanouts
r
e
nt
commit cleanouts successfully com

commit txn count during cleanout
I
e
consistent changes
consistent gets
r
O
l
c
a
Instance: orcl
Snaps: 1 -2
Statistic
Total
per Second
per Trans
--------------------------------- ------------------ -------------- -----------db block changes
db block gets
18,384
19,379
6.5
6.9
21.7
22.8
deferred (CURRENT) block cleanout

dirty buffers inspected
1,229
55
0.4
0.0
1.5
0.1
enqueue conversions
enqueue releases
2,507
8,921
0.9
3.2
3.0
10.5
enqueue requests
enqueue timeouts
8,940
19
3.2
0.0
10.5
0.0
enqueue waits
execute count
665
8,399
0.2
3.0
0.8
9.9
12,938
2,027,711
4.6
718.8
15.2
2,388.4
hot buffers moved to head of LRU

immediate (CR) block cleanout app
695
1,611
0.3
0.6
0.8
1.9
immediate (CURRENT) block cleanou

index fast full scans (full)
195
547
0.1
0.2
0.2
0.6
2,405
2,799
0.9
1.0
2.8
3.3
3
18
0.0
0.0
0.0
0.0
logons cumulative
messages received
20
1,046
0.0
0.4
messages sent
no buffer to keep pinned count
1,046
31
0.4
0.0
no work - consistent read gets

opened cursors cumulative
2,125,242
2,601
free buffer inspected

free buffer requested
index fetch by key

index scans kdiixs1
leaf node 90-10 splits
leaf node splits
physical writes
physical writes direct
0.0
1.1
0.1
3.5
52
2,468
0.0
0.9
0.1
2.9
2,028,073
5,585
718.9
2.0
2,388.8
6.6
15,751
13,586
5.6
4.8
18.6
16.0
14,508
12,860
5.1
4.6
17.1
15.2
1,703,051
30
603.7
0.0
2,006.0
0.0
I
A
r
e
nt
physical writes non checkpoint

pinned buffers inspected
I
e
prefetched blocks
prefetched blocks aged out before
l
c
a
process last non-idle time

recovery blocks read
r
O
l&
na
s
U
1.2
0.0
2,503.2
3.1
90
2,950
physical reads
physical reads direct
O
e
0.0
1.2
753.4
0.9
parse count (hard)

parse count (total)
parse time cpu
parse time elapsed
y
l
n
20,561,129,916
0
7,288,596.2 ############
0.0
0.0
recursive calls
recursive cpu usage
36,164
15,194
12.8
5.4
42.6
17.9
redo blocks written
5,545
2.0
6.5
Instance: orcl
Snaps: 1 -2
Statistic
Total
per Second
per Trans
--------------------------------- ------------------ -------------- -----------redo entries
redo size
10,568
2,531,236
3.8
897.3
12.5
2,981.4
479
175
0.2
0.1
0.6
0.2
248,460
6,413
88.1
2.3
292.7
7.6
0
897
0.0
0.3
0.0
1.1
498
3,110
0.2
1.1
0.6
3.7
redo synch time

redo synch writes
redo wastage
redo write time
redo writer latching time
redo writes
rollback changes - undo records a
rollbacks only - consistent read
rows fetched via callback
session connect time
929
20,561,129,916
session logical reads

session pga memory
2,188,590
0
775.8
0.0
2,577.8
0.0
0
295,704
0.0
104.8
0.0
348.3
8,836,212
2,375
3,132.3
0.8
10,407.8
2.8
140
409
0.1
0.1
0.2
0.5
2,018,699
134
715.6
0.1
2,377.7
0.2
98
3,109
0.0
1.1
0.1
3.7
session pga memory max

session uga memory
session uga memory max
shared hash latch upgrades - no w
sorts (disk)
sorts (memory)
sorts (rows)
summed dirty queue length
switch current to new buffer
table fetch by rowid
table fetch continued row
table scan blocks gotten
174
2,123,096
table scan rows gotten

table scans (long tables)
181,473,409
2,480
transaction tables consistent rea

transaction tables consistent rea
na
l&
user calls
user commits
r
e
nt
workarea executions - multipass

workarea executions - optimal
I
e
O
e
s
U
0.2
2,500.7
64,329.5
0.9
213,749.6
2.9
3,352
162
1.2
0.1
4.0
0.2
3
257
0.0
0.1
0.0
0.3
602
849
0.2
0.3
0.7
1.0
134
595
0.1
0.2
0.2
0.7
write clones created in foregroun

17
0.0
-------------------------------------------------------------
r
O
l
c
a
y
l
n
0.1
752.6
I
A
table scans (short tables)

transaction rollbacks
0.3
1.1
7,288,596.2 ############
0.0
Tablespace IO Stats for DB: ORCL Instance: orcl

->ordered by IOs (Reads + Writes) desc
Snaps: 1 -2
Tablespace
-----------------------------Av
Av
Av
Av
Buffer Av Buf
Reads Reads/s Rd(ms) Blks/Rd

Writes Writes/s
Waits Wt(ms)
-------------- ------- ------ ------- ------------ -------- ---------- -----EXAMPLE
318,868
113
90.6
6.3
856
36,250
56.0
5,585
130.6
1.0
13,586
0.0
25
62.0
1.0
1,161
0.0
476
52.0
1.0
22
57
21.1
61
9.3
1.0
126
0.0
TEMP
UNDOTBS1
SYSTEM
TOOLS
------------------------------------------------------------File IO Stats for DB: ORCL Instance: orcl Snaps: 1 -2
->ordered by Tablespace, File
Tablespace
Filename
------------------------ ---------------------------------------------------Av
Av
Av
Reads Reads/s Rd(ms) Blks/Rd
Av
Writes Writes/s
y
l
n
Buffer Av Buf
Waits Wt(ms)
O
e
-------------- ------- ------ ------- ------------ -------- ---------- -----EXAMPLE

E:\ORANT\ORA92\ORADATA\ORCL\EXAMPLE01.DBF
113
476
5,585
61
E:\ORANT\ORA92\ORADATA\ORCL\TOOLS01.DBF
9.3
1.0
126
0
62.0
SYSTEM
TEMP
90.6
6.3
856
s
U
318,868
I
A
36,250
E:\ORANT\ORA92\ORADATA\ORCL\SYSTEM01.DBF
52.0
1.0
22
0
l&
57
E:\ORANT\ORA92\ORADATA\ORCL\TEMP01.DBF
TOOLS
UNDOTBS1
130.6
1.0
13,586
a
n
r
e
t
In
E:\ORANT\ORA92\ORADATA\ORCL\UNDOTBS01.DBF
25
e
l
c
1.0
1,161
-------------------------------------------------------------
a
r
O
56.0
21.1
Buffer Pool Statistics for DB: ORCL Instance: orcl

-> Standard block size Pools D: default, K: keep,
Snaps: 1 -2
R: recycle
-> Default Pools for other block sizes: 2k, 4k, 8k, 16k, 32k
Free
Write
Buffer
Buffer Complete
Waits
Waits
Busy
Waits
--- ---------- ----- ----------- ----------- ---------- ------- -------D

979 53.2
4,320,233
2,022,481
2,165
0
0
-----36,307
Number of Cache
Buffers Hit %
Buffer
Gets
Physical
Reads
Physical
Writes
------------------------------------------------------------Instance Recovery Stats for DB: ORCL Instance: orcl

-> B: Begin snapshot, E: End snapshot
Targt Estd
MTTR MTTR
Recovery
Actual
Snaps: 1 -2
Log File
Size
Target
Log Ckpt
Timeout
Log Ckpt
Interval
(s)
(s)
Estd IOs Redo Blks Redo Blks Redo Blks Redo Blks Redo Blks
- ----- ----- ---------- ---------- ---------- ---------- ---------- ---------B
E
16
16
12
12
152
159
558
0
18432
18432
18432
18432
------------------------------------------------------------Buffer Pool Advisory for DB: ORCL Instance: orcl End Snap: 2
-> Only rows with estimated physical reads >0 are displayed
-> ordered by Block Size, Buffers For Estimate
Size for Size
Buffers for Est Physical
D
D
4
8
1.0
2.0
979
1,958
1.00
0.89
D
D
12
16
3.0
4.0
2,937
3,916
0.80
0.72
D
D
20
24
5.0
6.0
4,895
5,874
0.65
0.58
D
D
28
32
7.0
8.0
6,853
7,832
D
D
36
40
9.0
10.0
8,811
9,790
D
D
44
48
11.0
12.0
D
D
52
56
13.0
14.0
D
D
60
64
D
D
O
e
2,029,871
1,801,958
s
U
1,620,631
1,468,751
1,318,356
1,184,142
0.51
0.43
1,043,838
875,666
0.36
0.29
730,044
582,543
10,769
11,748
0.20
0.07
397,890
140,097
12,727
13,706
0.01
0.01
23,791
20,051
15.0
16.0
14,685
15,664
0.01
0.01
20,051
20,014
68
72
17.0
18.0
16,643
17,622
0.01
0.01
20,014
20,014
76
80
19.0
20.0
18,601
19,580
0.01
0.01
20,014
20,014
l&
na
r
e
nt
I
e
l
c
a
r
O
D
D
I
A
y
l
n
Estimated
P
Estimate (M) Factr
Estimate
Read Factor
Physical Reads
--- ------------ ----- ---------------- ------------- ------------------
-------------------------------------------------------------
Buffer wait Statistics for DB: ORCL
Instance: orcl
Snaps: 1 -2
-> ordered by wait time desc, waits desc
Class
Waits
Tot Wait
Time (s)
------------------------------------------------------ ----------- ---------Avg

Time (ms)
--------data block
56
36,172
2,022
2nd level bmb

224
20
segment header
39
90
1st level bmb

28
25
------------------------------------------------------------PGA Aggr Target Stats for DB: ORCL Instance: orcl Snaps: 1 -2
-> B: Begin snap
E: End snap (rows dentified with B or E contain data
which is absolute i.e. not diffed over the interval)
-> PGA cache hit % - percentage of W/A (WorkArea) data processed only in-memory
-> Auto PGA Target - actual workarea memory target
y
l
n
-> W/A PGA Used

-> %PGA W/A Mem
- amount of memory used for all Workareas (manual + auto)

- percentage of PGA memory allocated to workareas
-> %Auto W/A Mem

-> %Man W/A Mem
- percentage of workarea memory controlled by Auto Mem Mgmt

- percentage of workarea memory under manual control
O
e
s
U
PGA Cache Hit % W/A MB Processed Extra W/A MB Read/Written
I
A
--------------- ---------------- ------------------------76.4

105
32
PGA Aggr Auto PGA

Target(M) Target(M)
PGA Mem
Alloc(M)
l&
W/A PGA
Used(M)
a
n
r
%PGA
%Auto
%Man
W/A
Mem
W/A
Mem
W/A
Mem
Global Mem
Bound(K)
- --------- --------- ---------- ---------- ------ ------ ------ ---------B

24
17
8.0
0.0
.0
.0
.0
1,228
E
24
e
t
In
17
8.0
0.0
.0
.0
.0
1,228
-------------------------------------------------------------
e
l
c
a
r
O
PGA Aggr Target Histogram for DB: ORCL
Instance: orcl
Snaps: 1 -2
-> Optimal Executions are purely in-memory operations

Low
High
Optimal Optimal
Total Execs Optimal Execs 1-Pass Execs M-Pass Execs
------- ------- -------------- ------------- ------------ -----------4K

8K
456
456
0
0
8K
16K
16K
32K
8
2
8
2
0
0
0
0
32K
64K
64K
128K
133
1
1
1
0
0
132
0
128K
256K
256K
512K
2
66
0
66
0
0
2
0
1M
2M
66
66
0
0
-------------------------------------------------------------
PGA Memory Advisory for DB: ORCL
Instance: orcl
End Snap: 2
-> When using Auto Memory Mgmt, minimally choose a pga_aggregate_target value
where Estd PGA Overalloc Count is 0
Estd Extra
PGA Target
Est (MB)
Size
Factr
Estd PGA
Estd PGA
Cache
Hit %
Overalloc
Count
W/A MB
W/A MB Read/
Processed Written to Disk
---------- ------- ---------------- ---------------- -------- ---------12

0.5
0.0
0.0
0.0
1
18
24
0.8
1.0
0.0
0.0
0.0
0.0
29
34
1.2
1.4
0.0
0.0
0.0
0.0
38
43
1.6
1.8
0.0
0.0
0.0
0.0
48
72
2.0
3.0
0.0
0.0
96
144
4.0
6.0
0.0
0.0
192
0.0
0.0
I
A
l&
a
n
r
O
e
s
U
0.0
0.0
1
0
0
0
0.0
0.0
0
0
0.0
0.0
0.0
0.0
0
0
0.0
0.0
0.0
0.0
0
0
y
l
n
8.0
0.0
0.0
0.0
0
-------------------------------------------------------------
e
t
In
Enqueue activity for DB: ORCL Instance: orcl Snaps: 1 -2

-> Enqueue stats gathered prior to 9i should not be compared with 9i data
-> ordered by Wait Time desc, Waits desc
e
l
c
a
r
O
Eq
Requests
Succ Gets Failed Gets
Waits
Avg Wt
Time (ms)
Wait
Time (s)
-- ------------ ------------ ----------- ----------- ------------- -----------TX

2,077
2,058
19
465
964.33
448
TM
7,814
7,814
0
200
433.54
-------------------------------------------------------------
87
Rollback Segment Stats for DB: ORCL
Instance: orcl
Snaps: 1 -2
->A high value for "Pct Waits" suggests more rollback segments may be required
->RBS stats may not be accurate between begin and end snaps when using Auto Undo
managment, as RBS may be dynamically created and dropped as needed
RBS No
Trans Table
Gets
Pct
Waits
Undo Bytes
Written
Wraps
Shrinks
Extends
------ -------------- ------- --------------- -------- -------- -------0

10.0
0.00
0
0
0
0
1
2
428.0
441.0
0.00
0.00
73,508
71,700
2
2
0
0
2
2
3
4
464.0
396.0
0.00
0.00
63,328
58,240
1
2
0
0
1
2
5
6
437.0
446.0
0.00
0.00
67,164
67,546
0
2
0
0
0
2
7
8
378.0
481.0
0.00
0.00
66,198
75,778
0
2
0
0
0
2
9
10
379.0
466.0
0.00
0.00
54,632
183,916
0
0
0
0
0
0
------------------------------------------------------------Rollback Segment Storage for DB: ORCL Instance: orcl Snaps: 1 -2

->Optimal Size should be larger than Avg Active
RBS No
Segment Size
Avg Active
Optimal Size
Maximum Size
------ --------------- --------------- --------------- --------------0
1
425,984
716,800
6,144
32,145
2
3
913,408
2,093,056
22,536
147,845
4
5
585,728
1,175,552
17,759
0
6
7
716,800
1,175,552
17,759
0
8
9
651,264
2,289,664
17,759
0
10
I
A
s
U
913,408
2,093,056
585,728
1,175,552
716,800
1,175,552
651,264
2,289,664
1,175,552
0
1,175,552
-------------------------------------------------------------
e
t
In
Undo Segment Summary for DB: ORCL

-> Undo segment block stats:
-> uS - unexpired Stolen,
-> eS - expired
Stolen,
e
l
c
ra
Undo
O
e
425,984
716,800
l&
a
n
r
y
l
n
Undo
Instance: orcl
Snaps: 1 -2
uR - unexpired Released,
eR - expired
Released,
Num
Max Qry
uU - unexpired reUsed
eU - expired
reUsed
Max Tx Snapshot Out of uS/uR/uU/
TS#
Blocks
Trans Len (s)
Concurcy Too Old Space eS/eR/eU
---- -------------- ---------- -------- ---------- -------- ------ -------------
O
1
811
14,114
660
10
0
0 0/0/0/0/0/0
-------------------------------------------------------------
Undo Segment Stats for DB: ORCL
Instance: orcl
Snaps: 1 -2
-> ordered by Time desc

Undo
Blocks
End Time
Num Max Qry

Trans Len (s)
Max Tx Snap
Out of uS/uR/uU/
Concy Too Old Space eS/eR/eU
------------ ------------ -------- ------- -------- ------- ------ ------------30-Jul 15:58

0
0
0
0
0
0 0/0/0/0/0/0
30-Jul 15:48
30-Jul 15:38
5
5
3,595
3,549
399
660
8
7
0
0
0 0/0/0/0/0/0
0 0/0/0/0/0/0
30-Jul 15:28
30-Jul 15:18
4
797
3,525
3,445
453
219
10
5
0
0
0 0/0/0/0/0/0
0 0/0/0/0/0/0
------------------------------------------------------------Latch Activity for DB: ORCL Instance: orcl Snaps: 1 -2

->"Get Requests", "Pct Get Miss" and "Avg Slps/Miss" are statistics for
willing-to-wait latch get requests
->"NoWait Requests", "Pct NoWait Miss" are for no-wait latch get requests
->"Pct Misses" for both should be very close to 0.0
Pct
Get
Get
Avg
Slps
Wait
Time
Pct
NoWait NoWait
Latch
Requests
Miss /Miss
(s)
Requests
Miss
------------------------ -------------- ------ ------ ------ ------------ -----Consistent RBA
FOB s.o list latch
898
118
0.0
0.0
0
0
SQL memory manager latch

SQL memory manager worka
1
60,311
0.0
0.0
0
0
active checkpoint queue

cache buffer handles
1,377
69
0.0
0.0
cache buffers chains

cache buffers lru chain
6,520,208
4,151,271
0.0
0.0
channel handle pool latc

channel operations paren
40
1,853
0.0
0.0
checkpoint queue latch

child cursor hash table
62,800
1,049
I
A
s
U
0
0
892
0
0
0
0
0
0.0
0.0
0
0
1,731
0
10,660
40
0.0
0.0
0
0
0
0
21,119
5,205
0.0
0.0
0
0
0
0
event group latch

file number translation
20
19,558
0.0
0.0
0
0
0
0
hash table column usage

hash table modification
35
2
0.0
0.0
0
0
92
0
9
1,271
0.0
0.0
0
0
0
0
57,587
0.0
476
dml lock allocation

dummy allocation
enqueue hash chains
enqueues
I
e
l
c
a
r
O
ktm global data

lgwr LWN SCN
library cache
r
e
nt
na
1.0
1.0
0.0
0
0
3,787,163
2,398
y
l
n
O
e
0
0
l&
1.0
1.3
0
0
0.0
0.0
0.0
0.0
0.0
Latch Activity for DB: ORCL
Instance: orcl
Snaps: 1 -2
Get
Requests
Latch
Pct
Avg
Wait
Pct
Get
Miss
Slps
/Miss
Time
(s)
NoWait NoWait
Requests
Miss
------------------------ -------------- ------ ------ ------ ------------ -----library cache load lock
library cache pin
577
35,875
0.0
0.0
0
0
0
0
library cache pin alloca

list of block allocation
14,850
38
0.0
0.0
0
0
0
0
loader state object free

longop free list parent
684
390
0.0
0.0
0
0
0
98
9,781
1,271
0.0
0.0
0
0
0
0
625,480
46
0.0
0.0
0
0
0
0
104
1,809
0.0
0.0
0
0
0
174
20
40
0.0
0.0
0
0
20
0
redo allocation
redo copy
12,734
4
0.0
0.0
0
0
redo writing
row cache enqueue latch
5,047
13,873
0.0
0.0
row cache objects

sequence cache
16,402
1,085
0.0
0.0
session allocation
session idle bit
5,513
2,409
0.0
0.0
46
957
messages
mostly latch-free SCN
multiblock read objects
ncodef allocation latch
object stats modificatio
post/wait queue
process allocation
process group creation
session switching
session timer
shared pool
sim partition latch
simulator hash latch
n
I
e
I
A
s
U
0
0
0
0
0
0
0.0
0.0
0
0
0
0
23,586
0
0.0
0
0
0
257
269,094
0.0
l&
r
O
l
c
a
0.0
0.0
0.0
0
0
723
0
y
l
n
O
e
0
10,561
0
0
na
r
e
t
1.1
0.0
0.0
0.0
Latch Activity for DB: ORCL
Instance: orcl
Snaps: 1 -2
Get
Requests
Latch
Pct
Avg
Wait
Pct
Get
Miss
Slps
/Miss
Time
(s)
NoWait NoWait
Requests
Miss
------------------------ -------------- ------ ------ ------ ------------ -----simulator lru latch

144,571
0.0
1.0
0
18
0.0
sort extent pool
trace latch
1,163
19
0.0
0.0
0
0
0
0
50
46
0.0
0.0
0
0
0
0
13,816
80
0.0
0.0
0
0
1
0
transaction allocation
transaction branch alloc
undo global data
user lock
0.0
------------------------------------------------------------Latch Sleep breakdown for DB: ORCL Instance: orcl Snaps: 1 -2

-> ordered by misses desc
Get
Requests
Latch Name
Misses
Spin &
Sleeps Sleeps 1->4
y
l
n
-------------------------- -------------- ----------- ----------- -----------cache buffers lru chain

4,151,271
92
117 0/67/25/0/0
625,480
6,520,208
58
18
57,587
19,558
10
1
library cache
file number translation ta
I
A
O
e
66 0/50/8/0/0
18 0/0/0/0/0
s
U
10 0/10/0/0/0
1 0/1/0/0/0
simulator lru latch

144,571
1
1 0/1/0/0/0
-------------------------------------------------------------
&
l
a
n
r
te
n
I
e
r
O
l
c
a
Latch Miss Sources for DB: ORCL
Instance: orcl
Snaps: 1 -2
-> only latches with sleeps are shown

-> ordered by name, sleeps desc
NoWait
Waiter
Latch Name
Where
Misses
Sleeps
Sleeps
------------------------ -------------------------- ------- ---------- -------cache buffers chains
kcbgtcr: kslbegin excl

kcbrls: kslbegin
0
0
13
2
12
1

kcbzib: finish free bufs

kcbzwb
0
0
2
1
0
3

kcbzgb: wait
kcbzar: KSLNBEGIN
0
0
90
15
3
112

file number translation
kcbzgm
kftts2a
0
0
12
1
0
1
library cache
library cache
kgldte: child 0
kglpnc: child
0
0
5
3
0
8
library cache
kglupc: child
kcbzib: mbr get
0
0
2
42
2
40

simulator lru latch
kcbzib: normal mbr free

kcbs_lookup_setid
0
0
24
1
26
1
------------------------------------------------------------Dictionary Cache Stats for DB: ORCL Instance: orcl Snaps: 1 -2

->"Pct Misses" should be very low (< 2% in most cases)
O
e
->"Cache Usage" is the number of cache entries being used

->"Pct SGA"
is the ratio of usage to allocated size for that cache
Get
Pct
Scan
I
A
s
U
Pct
y
l
n
Mod
Final
Cache
Requests
Miss
Reqs Miss
Reqs
Usage
------------------------- ------------ ------ ------- ----- -------- ---------dc_free_extents
dc_histogram_defs
9
212
0.0
29.7
dc_object_ids
dc_objects
924
284
3.1
19.4
20
234
dc_profiles
dc_rollback_segments
dc_segments
dc_sequences
dc_tablespaces
dc_user_grants
l
c
a
I
e
dc_usernames
dc_users
r
O
0
0
1
63
0
0
0
0
211
460
0.0
0.0
0
0
0
0
1
14
273
511
16.5
0.8
0
0
0
511
147
7
980
200
0.0
6.0
0
0
0
0
6
13
179
3,425
2.8
0.4
0
0
0
0
9
19
l&
na
r
e
nt
0
0
-------------------------------------------------------------
Library Cache Activity for DB: ORCL

->"Pct Misses"
Instance: orcl
Snaps: 1 -2
should be very low

Get
Requests
Namespace
Pct
Miss
Pin
Requests
--------------------------------------------- ------------ ------ -------------Pct

InvaliMiss
Reloads dations
------ ---------- -------BODY
60.6
CLUSTER
0.0
SQL AREA
1.3
TABLE/PROCEDURE
7.0
3
TRIGGER
4.0
160
6.3
160
0.0
11
3,937
2.0
15,510
1,510
4.3
2,841
50
4.0
50
------------------------------------------------------------Shared Pool Advisory for DB: ORCL Instance: orcl End Snap: 2
-> Note there is often a 1:Many correlation between a single logical object
in the Library Cache, and the physical number of memory objects associated
y
l
n
with it. Therefore comparing the number of Lib Cache objects (e.g. in
v$librarycache), with the number of Lib Cache Memory Objects is invalid
O
e
Estd
Shared Pool
Size for
SP
Size
Estd
Lib Cache
Estd
Lib Cache
s
U
Estd Lib LC Time

Cache Time
Saved
I
A
Estd Lib Cache
Estim (M) Factr

Size (M)
Mem Obj
Saved (s)
Factr
Mem Obj Hits
----------- ----- ---------- ------------ ------------ ------- --------------4
8
.5
1.0
5
7
1,527
2,481
12
16
1.5
2.0
7
7
2,481
2,481
l&
a
n
r
171
171
1.0
1.0
17,801
17,817
171
171
1.0
1.0
17,817
17,817
------------------------------------------------------------SGA Memory Summary for DB: ORCL Instance: orcl Snaps: 1 -2

SGA regions
e
t
In
Size in Bytes
------------------------------ ---------------Database Buffers

4,194,304
e
l
c
Fixed Size
Redo Buffers
a
r
O
Variable Size
sum
452,992
143,360
25,165,824
----------------
29,956,480
-------------------------------------------------------------
SGA breakdown difference for DB: ORCL

Pool
Name
Instance: orcl
Snaps: 1 -2
Begin value
End value
% Diff
------ ------------------------------ ---------------- ---------------- ------shared 1M buffer

2,098,176
2,098,176
0.00
shared Checkpoint queue
shared FileIdentificatonBlock
282,304
323,292
282,304
323,292
0.00
0.00
shared FileOpenBlock
shared KGK heap
695,504
3,756
695,504
3,756
0.00
0.00
1,573,468
504,860
1,102,560
534,044
-29.93
5.78
shared KQR S PO
shared KQR S SO
109,072
1,280
117,544
3,340
7.77
160.94
shared KSXR large reply queue

shared KSXR pending messages que
166,104
841,036
166,104
841,036
0.00
0.00
shared KSXR receive buffers

shared MTTR advisory
1,033,000
8,352
1,033,000
8,352
0.00
0.00
shared PL/SQL DIANA

shared PL/SQL MPCODE
1,977,180
183,432
824,776
844,676
-58.29
360.48
2,068
330,844
2,068
330,844
0.00
0.00
shared dictionary cache

shared enqueue
1,610,880
171,860
1,610,880
171,860
0.00
0.00
shared errors
shared event statistics per sess
23,468
1,718,360
23,468
1,718,360
shared fixed allocation callback

shared free memory
180
1,275,960
180
1,085,252
0.00
-14.95
4,220
603,524
0.00
4.40
148,652
3,009,736
0.00
6.43
shared KGLS heap

shared KQR M PO
shared PLS non-lib hp

shared character set object
shared joxs heap init

shared kgl simulator
4,220
578,108
I
A
y
l
n
O
e
s
U
0.00
0.00
shared ksm_file2sga region

shared library cache
148,652
2,828,032
shared message pool freequeue

shared miscellaneous
834,752
3,540,008
834,752
4,439,036
0.00
25.40
7,308
410,720
3,880
410,720
-46.91
0.00
38,108
1,691,548
38,108
1,834,540
0.00
8.45
840
2,788
2,800
1,384
233.33
-50.36
1,076
1,228
1,492
264
38.66
-78.50
4,194,304
452,992
4,194,304
452,992
0.00
0.00
log_buffer
133,120
133,120
-------------------------------------------------------------
0.00
shared parameters
shared sessions
shared sim memory hea
shared sql area
r
e
nt
shared table definiti

shared trigger defini
I
e
shared trigger inform

shared trigger source
l
c
a
buffer_cache
fixed_sga
r
O
na
l&
init.ora Parameters for DB: ORCL
Instance: orcl
Snaps: 1 -2
End value
Parameter Name
Begin value
(if different)
----------------------------- --------------------------------- -------------background_dump_dest
compatible
E:\orant\ora92\admin\ORCL\bdump
9.2.0.0.0
control_files
core_dump_dest
E:\orant\ora92\oradata\ORCL\contr
E:\orant\ora92\admin\ORCL\cdump
db_block_size
db_cache_size
4096
4194304
db_domain
db_file_multiblock_read_count 16
db_keep_cache_size
db_name
0
ORCL
db_recycle_cache_size
fast_start_mttr_target
0
10
hash_join_enabled
instance_name
TRUE
ORCL
java_pool_size
large_pool_size
0
0
log_buffer
log_checkpoint_timeout
64000
10
open_cursors
pga_aggregate_target
300
25165824
processes
query_rewrite_enabled
150
FALSE
remote_login_passwordfile
shared_pool_reserved_size
EXCLUSIVE
1024000
shared_pool_size
sort_area_size
8388608
512
star_transformation_enabled
timed_statistics
FALSE
TRUE
undo_management
undo_retention
AUTO
10800
&
l
a
y
l
n
O
e
I
A
s
U
n
r
te
undo_tablespace
user_dump_dest
UNDOTBS1
E:\orant\ora92\admin\ORCL\udump
workarea_size_policy
MANUAL
-------------------------------------------------------------
n
I
e
l
c
a
End of Report
r
O
Redundant Arrays of
Inexpensive Disks Technology (RAID)
O
e
I
A
&
l
a
n
r
te
r
O
l
c
a
n
I
e
y
l
n
s
U
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Oracle9i Database Performance Tuning E-2
System Hardware Configuration

Storage Subsystem Detail
Storage subsystem performance is one of the most important aspects of tuning an Oracle
database server for optimal performance. The architecture and design of the storage
subsystem must therefore be considered early in the system design process. In performing
the storage subsystem design, system requirements such as the required volume of online
transaction data, peak transactions per second load, and system availability are transformed
into specific storage subsystem design requirements for storage capacity, peak sustainable
I/Os per second, and fault tolerance. Values for design parameters in the selected technology
are then chosen to meet these specific requirements.
Modern storage systems offer great flexibility in meeting a wide range of design criteria;
technologies such as striping, mirroring, and other fault-tolerant RAID configurations
provide the ability to meet these design requirements. Matching the right technology with
application I/O characteristics is key to achieving the promised performance and fault
tolerance levels; conversely, using the wrong technology for a specific I/O characteristic can
lead to I/O bottlenecks and degraded response times. In this section, key parameters in the
design of the storage subsystem are described, as well as how they relate to the performance
of an Oracle database.
Storage Subsystem Design Parameters and Oracle
When designing a storage subsystem, the available design parameters are weighed against
each other until a design solution is achieved that meets or exceeds all design requirements.
In the context of an Oracle database server, certain measures are available to specify these
requirements. These measures can be categorized under performance, availability, and cost.
Performance
Random read performance: Important for Oracle indexed or hash-based queries and
rollback segment reads
Random write performance: Important for Oracle DBWn writes; heavy in an OLTP
environment, light in a data warehouse
Sequential read performance: Backups, Oracle full table scans, index creations,
parallel queries, temporary segment reads, and recovery from archived redo log files
Sequential write performance: Oracle LGWR writes, temporary segment writes, directpath loader writes, tablespace creations
Impact of concurrency
Availability
Outage frequency: Expected number of occurrences of a possible outage per unit of
time specified in mean time to failure (MTTF)
Outage duration: The mean time to repair (MTTR) for a given outage event
Performance degradation during outage: Whether a disk configuration provides service
during a fault, and if so, at what level
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Storage Subsystem Design Parameters and Oracle (continued)

Cost
Acquisition cost: The cost of purchasing, installing, and configuring the storage
subsystem
Operational cost: The cost of running and maintaining the system to meet the system
availability and service level requirements
The Redundant Arrays of Inexpensive Disks (RAID) technologies have been developed for
nonmainframe, open system solutions. RAID provides low-cost fault tolerance and
improved performance. Several levels of RAID are available and can be mixed within one
storage subsystem design. Each level of RAID can be categorized against the measures
listed above and its impact on Oracle database performance. Some levels of RAID
configurations have been available for many years under different names. Key parameters
when configuring a RAID system are:
Array size: The number of drives in the array
Disk size: The size of each disk
Stripe size: The size of an I/O chunk, written to or read from a contiguous location on
a disk (Striping allows data files to be interleaved and spread across the disks in an
array in an attempt to parallelize file I/O.)
The throughput of a storage subsystem, expressed in I/Os per second, determines how many
transactions can be processed by the subsystem before queuing delays begin to occur. If the
I/Os-per-second requirement of the application is known, broken down into reads per
transaction, writes per transaction, and transactions per second, you can determine whether a
particular RAID configuration will support the transaction rate applied by an application. To
calculate throughput, or total sustainable I/Os-per-second load that a RAID array can
support, simply multiply the number of drives in the array times the sustainable I/Os per
second of one drive, currently in the approximate range of 35 to 50 I/Os per second.
Different RAID configurations, however, add to the I/O load on a disk array applied by the
application in order to provide the fault tolerance function. Once the total I/O load on the
array is known, the number of drives required to support the load can be found. Simply
divide the total I/Os per second load by the random I/O throughput rating for the selected
drive.
The sections below briefly describe each RAID level and some of its characteristics. For
each level, an equation is provided to calculate the total I/Os per second load on a RAID
array, to illustrate the impact of the RAID configuration on the arrays capacity. Also
provided is an equation for calculating the size of the disk drives required for an array.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
RAID Level 0, Nonredundant Striping
RAID 0 refers to simple data striping of multiple disks into a single logical volume, and has
no fault tolerance. When properly configured, it provides excellent response times for high
concurrency random I/O and excellent throughput for low concurrency sequential I/O.
Selection of the array and stripe sizes requires careful consideration in order to achieve the
promised throughput. For RAID 0, the total I/Os-per-second load generated against the array
is calculated directly from the application load, because there is no fault tolerance in this
configuration:
Total I/O per second load on array = (reads/transaction + writes/ transaction) *
transactions/second
The size of each drive in the array can be calculated from the online volume requirements as
follows:
Drive size = [total space required by application / number of drives in array] Rounded
up to next drive size.
Below is a summary of RAID 0 characteristics:
- Random read performance: Excellent under all concurrency levels if each I/O
request fits within a single striping segment
- Random write performance: Same as random read performance
- Sequential read performance: Excellent with fine-grained striping at low
concurrency levels
- Sequential write performance: Same as sequential read performance
- Outage frequency: Poor; any single disk failure will cause application outage
- Outage duration: Poor; the duration of a RAID 0 outage is the time required to
detect the failure, replace the disk drive, and perform Oracle media recovery
- Performance degradation during outage: Poor; any disk failure causes all
applications requiring use of the array to crash
- Acquisition cost: Excellent, because there is no redundancy; you buy only
enough for storage and I/Os per second requirements
- Operational cost: Fair to poor; frequent media recoveries increase operational
costs and may outweigh the acquisition cost advantage
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
RAID Level 1, Mirroring
RAID Level 1, or disk mirroring, provides the best fault tolerance of any of the RAID
configurations. Each disk drive is backed up by an exact copy of itself on an identical drive.
A storage subsystem of mirrored drives can continue at full performance with a multiple
disk failure as long as no two drives in a mirrored pair have failed. The total I/Os per load
applied to a mirrored pair is calculated as follows:
Total I/O per second load on array = (reads/transaction + 2*writes/ transaction) *
transactions/second
Note the two multiplier of the writes/transaction factor. This is due to the fact that each write
request by an application to a mirrored pair actually results in two writes, one to the primary
disk and one to the backup disk. The size of the drive required is:
Drive size = [total space required by application / number of drives in array/2]
Rounded up to next drive size.
In the simplest RAID 1 configuration, the number of drives in the array is two: the primary
drive and its backup. The definition of RAID 1, however, includes the ability to expand the
array in units of two drives to achieve a striped and mirrored configuration. Striping occurs
in an array of four or more disks. Some industry literature (for example, Millsap,1996) refers
to striped and mirrored configurations as RAID 0 + 1. The Compaq hardware used as an
example configuration in this document supports both configurations. Compaq uses only the
RAID 1 term to describe all 100% mirrored configurations in arrays of even-numbered
disks. Because the performance of a simple two-drive RAID 1 pair is somewhat different
from a striped and mirrored array, the figures for striped and mirrored are presented
separately under the RAID 0 + 1 section.
Below is a summary of characteristics of the two-disk array RAID configuration:
Random read performance: Good; if the implementation uses read-optimized RAID 1
controllers, which read from the drive with the smallest I/O setup cost, then slightly
better than an independent disk
Random write performance: Good (Application write requests are multiplied by two,
because the data must be written to two disks. Thus, some of the I/Os-per-second
capacity of the two drives is used up by the mirroring function.)
Sequential read performance: Fair; throughput is limited to the speed of one disk
Sequential write performance: Fair; same factors as are influencing the random write
performance
Outage frequency: Excellent
Outage duration: Excellent; for hot swapable drives, no application outage is
encountered by a single failure
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
RAID Level 1, Mirroring (continued)

Performance degradation during outage: Excellent; there is no degradation during a
disk outage (After replacing of the failed drive, the resilvering operation that takes
place when the failed disk is replaced will consume some of the available I/Os per
second capacity.)
Acquisition cost: Poor; each RAID 1 pair requires two drives to achieve the storage
capacity of one.
Operational cost: Fair; increased complexity of the configuration leads to higher
training costs and costs to develop custom software to integrate the mirroring
procedures into scheduled maintenance operations.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
RAID Level 0+1, Striping and Mirroring
As noted in the previous section, the striped and mirrored configuration is an expansion of
the RAID 1 configuration from a simple mirrored pair to an array of even-numbered drives.
This configuration offers the performance benefits of RAID 0 striping and the fault tolerance
of simple RAID 1 mirroring. The striped and mirrored configuration is especially valuable
for Oracle data files holding files with high write rates, such as table data files and online
and archived redo log files. Unfortunately, it also presents the high costs of simple RAID 1.
The equations for the total I/Os per second and disk drive size calculations for RAID 0 + 1
are identical to those presented for RAID 1 above. The Compaq SMART array controller
used in the example configuration supports RAID 0 + 1 (RAID 1 in Compaq terminology) in
arrays up to 14 drives, providing the effective storage of 7 drives.
Below is a summary of characteristics of RAID 0 + 1 storage arrays:
Random read performance: Excellent under all concurrency levels if each I/O requests
fits within a single striping segment (Using a stripe size that is too small can cause
dramatic performance breakdown at high concurrency levels.)
Random write performance: Good (Application write requests are multiplied by two
because the data must be written to two disks. Thus, some of the I/Os-per-second
capacity of the two drives is used up by the mirroring function.)
Sequential read performance: Excellent under all concurrency levels if each I/O
request fits within a single striping segment
Sequential write performance: Good
Outage frequency: Excellent; same as RAID 1
Outage duration: Excellent; same as RAID 1
Performance degradation during outage: Excellent; there is no degradation during a
disk outage (The resilvering operation that takes place when the failed disk is replaced
will consume a significant amount of the available I/Os-per-second capacity.)
Acquisition cost: Poor; same as RAID 1
Operational cost: Fair; same as RAID 1
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
RAID Level 3, Bit Interleaved Parity
In the RAID 3 configuration, disks are organized into arrays in which one disk is dedicated
to storage of parity data for the other drives in the array. The stripe size in RAID 3 is 1 bit.
This enables recovery time to be minimized, because data can be reconstructed with a
simple exclusive-OR operation. However, using a stripe size of 1 bit reduces I/O
performance. RAID 3 is not recommended for storing any Oracle database files. Also, RAID
3 is not supported by the Compaq SMART array controllers.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
RAID Level 5, Block-Interleaved with Distributed Parity
RAID 5 is similar to RAID 3, except that RAID 5 striping segment sizes are configurable,
and RAID 5 distributes parity across all the disks in an array. A RAID 5 striping segment
contains either data or parity.
Battery-backed cache greatly reduces the impact of this overhead for write calls, but its
effectiveness is implementation-dependent. Large write-intensive batch jobs generally fill
the cache quickly, reducing its ability to offset the write-performance penalty inherent in the
RAID 5 definition.
The total I/Os per second load applied to a RAID 5 array is calculated as follows:
Total I/O per second load on array = (reads/transaction + 4*writes/ transaction) *
transactions/second
The writes/transaction figure is multiplied by four because the parity data must be written in
a six-step process:
1. Read the data drive containing the old value of the data to be overwritten. This requires
one I/O.
2. Read the parity drive. This requires one I/O.
3. Subtract the contribution of the old data from the parity value.
4. Add the contribution of the new data to the parity value.
5. Write the new value of the parity requiring one I/O.
6. Write the new data value to the data drive. This requires one I/O.
Summing up all I/Os in this process yields four I/Os required for each write requested by the
application. This is the main reason that RAID 5 is not recommended for storing files with a
high I/O performance requirement; the 4 multiplier reduces the effective I/Os-per-second
capacity of the array.
The size of the drive required is:
Drive size = [total space required by application /(total number drives - number of
arrays)] Rounded up to next drive size.
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
RAID Level 5, Block-Interleaved with Distributed Parity (continued)

Note that the figure number of arrays is used to account for the space of one drive per
array consumed by the parity data. If it is necessary to exceed the maximum recommended
array size to meet the I/Os-per-second performance requirement, then multiple arrays are
required.
Below is a summary of the characteristics of RAID 5 storage arrays:
Random read performance: Excellent under all concurrency levels if each I/O requests
fits within a single striping segment (Using a stripe size that is too small can cause
dramatic performance breakdown at high concurrency levels.)
Random write performance: Poor; worst at high concurrency levels (The read-modifywrite cycle requirement of RAID 5 parity implementation reduces the effective
throughput or I/Os-per-second capacity of the array, especially for heavy write I/O
files. It should be noted, however, that under light load, response time is not degraded
from that provided by a faster array configuration such as RAID 0. This is due to the
asynchronous write capabilities provided by most array controllers. With asynchronous
write, the application does not have to wait until the storage subsystem has completed
the read-modify-write cycle before continuing. Instead, the controller buffers the data
in battery-backed RAM, signals the application that the write has completed, then
completes the write to disk. (This buffering does nothing to increase throughput,
however.)
Sequential read performance: Excellent under high concurrency levels if each I/O
request fits within a single striping segment; also excellent with fine grain striping
under low concurrency levels
Sequential write performance: Fair for low concurrency levels, poor for high
concurrency levels (See random write performance.)
Outage frequency: Good; can withstand the loss of any single disk in a given array
without incurring an application outage (Multiple simultaneous disk failures causes
application outage. The possibility of multiple simultaneous failures increase as the
size of the array increases.)
Outage duration: Good; a single disk failure causes no application outage
Performance degradation during outage: Fair; there is no degradation for reads and
writes to or from surviving drives in the array (Reads and writes to a failed drive incur
a high performance penalty, requiring data from all surviving drives in the array to be
read. Reconstruction of the failed drives data also degrades performance.)
Acquisition cost: Fair (If storage capacity were the only factor, the cost would be g/(g1) times the cost of the equivalent RAID 0 capacity, where g is the number of disks in
the array. However, when factoring I/Os-per-second performance requirement, the cost
can meet or exceed the cost of a RAID 0 + 1 implementation.)
Operational cost: Fair (Training is required to configure striped disk arrays for optimal
performance.)
y
l
n
O
e
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a
Ranking of RAID Levels Against Oracle File Types

The following table provides relative rankings for RAID configurations for specific Oracle
file types. The rankings range from 1 (best) to 5 (worst). Adapted from Millsap,1996, page
13.
Query
None
0+1
Control file performance
Redo log file performance
System tablespace performance
Sort segment performance
Rollback segment performance
Indexed read-only data files
Sequential read-only data files
DBWn intensive data files
Direct load-intensive data files
Data protection
Acquisition and operating costs
O
e
y
l
n
I
A
&
l
a
s
U
n
r
te
n
I
e
r
O
l
c
a

9i DBA Performance Tuning R2 V2 - D37163

Uploaded by

Copyright:

Available Formats

9i DBA Performance Tuning R2 V2 - D37163

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

9i DBA Performance Tuning R2 V2 - D37163

Uploaded by

Copyright:

Available Formats

Oracle9i Database Performance

Student Guide Volume Two

Copyright Oracle Corporation, 2002. All rights reserved.

This documentation contains proprietary information of Oracle Corporation. It is

Restricted Rights Legend

Use, duplication or disclosure by the Government is subject to restrictions for

If this documentation is delivered to a U.S. Government Agency not within the

Harald Van Breederode

Overview of Oracle9i Database Performance Tuning

Diagnostic and Tuning Tools

Database Configuration and I/O Issues

Distributing Files Across Devices 3-5

Sizing the Shared Pool

Global Space Allocation 4-26

Sizing the Buffer Cache

Automatic Segment Space Management 5-37

Dynamic Instance Resizing

Sizing Other SGA Structures

Tuning the Oracle Shared Server

Optimizing Sort Operations

10 Tuning Undo Segments

Tuning Manually Managed Rollback Segments 10-22

Index Tuning Wizard 12-11

14 Using Oracle Data Storage Structures Efficiently

OLTP Requirements 15-28

18 Using Resource Manager

D Appendix D: Example of a Statspack Report

E Appendix E: Redundant Arrays of Inexpensive Disks Technology (RAID)

Using Oracle Blocks Efficiently

Copyright Oracle Corporation, 2002. All rights reserved.

After completing this lesson, you should be able to do

Describe the use of Oracle block parameters

Oracle9i Database Performance Tuning 13-2

Database Storage Hierarchy

Copyright Oracle Corporation, 2002. All rights reserved.

Oracle9i Database Performance Tuning 13-3

To avoid the disadvantages of dynamic extent

Copyright Oracle Corporation, 2002. All rights reserved.

Oracle9i Database Performance Tuning 13-4

Avoiding Dynamic Allocation

To display segments with less than 10% free blocks:

To avoid dynamic allocation:

Copyright Oracle Corporation, 2002. All rights reserved.

Avoid Dynamic Extension

Oracle9i Database Performance Tuning 13-5

Locally Managed Extents

Create a locally managed tablespace:

CREATE TABLESPACE user_data_1

With the Oracle database the default extent

Copyright Oracle Corporation, 2002. All rights reserved.

Locally Managed Extents

Oracle9i Database Performance Tuning 13-6

Pros and Cons of Large Extents

Copyright Oracle Corporation, 2002. All rights reserved.

Advantages of Large Extents

Oracle9i Database Performance Tuning 13-7

Advantages of Large Extents (continued)

Oracle9i Database Performance Tuning 13-8

The High-Water Mark

Segment header block