One popular use of virtualization, is creating a MASTER image of one virtual machine and then copy it when necessary.

But, what do we do when we need an Oracle Database on this machine. How can we replicate the machine and work with the database.

Moreover, will the Database itself and the Database Control (Oracle Enterprise Manager) work on the new machine?

Below are the steps to configure the database and the Database control in the new machine.
The following steps were performed on Oracle Database 10g Release 2 (10.2.0.4) 64-bit, on CentOS 5 (64-bit) virtual machine :

Database:

• Change the hostname in the file $ORACLE_HOME/network/admin/listener.ora
  for example:

LISTENER =
   (DESCRIPTION_LIST =
    (DESCRIPTION =
     (ADDRESS = (PROTOCOL = TCP)(HOST = NEW_HOSTNAME)(PORT = 1521))
    )
   )

• Change the hostname in the file $ORACLE_HOME/network/admin/tnsnames.ora
  Please change the hostname in all the relevant entries.
  for example:

 ORCL1 =
   (DESCRIPTION =
    (ADDRESS = (PROTOCOL = TCP)(HOST = NEW_HOSTNAME)(PORT = 1521))
     (CONNECT_DATA =
     (SERVER = DEDICATED)
     (SERVICE_NAME = orcl1)
    )
   )

Database Control:

Recreating the Database control repository is needed. without it, the Database Control won’t start.
In order to recreate the DB control run following commands:

• Dropping the current DB control’s settings.
  In the <NEW HOSTNAME> please make sure to write the new hostname.

$ emca -deconfig dbcontrol db -repos drop -ORACLE_HOSTNAME <NEW HOSTNAME> -SID <ORACLE_SID> -PORT <Listener's Port> -SYSMAN_PWD <SYSMAN password> -SYS_PWD <SYS password></pre>

Information in regards the different ‘emca’ attributes can be acquire by running ‘emca’ without any attribute from the CMD.

 $ emca -deconfig dbcontrol db -repos drop -ORACLE_HOSTNAME ORCLSERVER -SID orcl1 -PORT 1521 -SYSMAN_PWD **** -SYS_PWD ****

STARTED EMCA at Jun 17, 2010 7:54:31 PM EM Configuration Assistant, Version 11.2.0.0.2   Production Copyright (c) 2003, 2005, Oracle.  All rights reserved.
Do you wish to continue? [yes(Y)/no(N)]: y

Jun 17, 2010 7:54:49 PM oracle.sysman.emcp.EMConfig   perform
INFO: This operation is being logged at   /u01/app/oracle/cfgtoollogs/emca/orcl/emca_2010_06_17_19_54_31.log.

Jun 17, 2010 7:54:50 PM   oracle.sysman.emcp.EMDBPreConfig performDeconfiguration
WARNING: EM is not configured for this database. No   EM-specific actions can be performed.
Jun 17, 2010 7:54:50 PM   oracle.sysman.emcp.ParamsManager checkListenerStatusForDBControl WARNING: Error initializing SQL connection. SQL   operations cannot be performed

Jun 17, 2010 7:54:50 PM oracle.sysman.emcp.EMReposConfig   invoke INFO: Dropping the EM repository (this may take a   while) ...

Jun 17, 2010 7:54:50 PM   oracle.sysman.emcp.EMReposConfig invoke INFO: Repository successfully dropped Enterprise Manager configuration completed
successfully FINISHED EMCA at Jun 17, 2010 7:54:50 PM 

• Recreating the DB control’s repository.
  In the <NEW HOSTNAME> please make sure to write the new hostname.

$emca -config dbcontrol db -ORACLE_HOSTNAME <NEW HOSTNAME> -SID <ORACLE_SID> -PORT <Listener's  Port> -SYS_PWD <SYSMAN password> -SYSMAN_PWD <SYSMAN  password> -DBSNMP_PWD <DBSNMP password>

After this step the Database Control’s repository will be recreated and you will able to connect the Database control’s URL.

$ emca -config dbcontrol db -ORACLE_HOSTNAME ORCLSERVER -SID orcl1 -PORT 1521 -SYS_PWD **** -SYSMAN_PWD **** -DBSNMP_PWD ****
STARTED EMCA at Jun 17, 2010 8:04:27 PM

EM Configuration Assistant, Version 11.2.0.0.2   Production
Copyright (c) 2003, 2005, Oracle.  All rights reserved.
Enter the following information:
Email address for notifications (optional):
Outgoing Mail (SMTP) server for notifications (optional):
-----------------------------------------------------------------
You have specified the following settings

Database ORACLE_HOME ................   /u01/app/oracle/product/11.2.0/db_1

Local hostname ................ <HOSTNAME>

Listener ORACLE_HOME ................   /u01/app/oracle/product/11.2.0/db_1

Listener port number ................ 1521

Database SID ................ orcl1

Email address for notifications ...............

Outgoing Mail (SMTP) server for notifications   ...............

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

Do you wish to continue? [yes(Y)/no(N)]: y

Jun 17, 2010 8:04:44 PM oracle.sysman.emcp.EMConfig   perform
INFO: This operation is being logged at   /u01/app/oracle/cfgtoollogs/emca/orcl2/emca_2010_06_17_20_04_27.log          .

Jun 17, 2010 8:04:45 PM   oracle.sysman.emcp.EMReposConfig uploadConfigDataToRepository
INFO: Uploading configuration data to EM repository   (this may take a while) ...

Jun 17, 2010 8:05:43 PM   oracle.sysman.emcp.EMReposConfig invoke
INFO: Uploaded configuration data successfully

Jun 17, 2010 8:05:44 PM   oracle.sysman.emcp.util.DBControlUtil configureSoftwareLib
INFO: Software library is already configured.

Jun 17, 2010 8:05:44 PM   oracle.sysman.emcp.util.DBControlUtil configureSoftwareLib
INFO:    EM_SWLIB_STAGE_LOC (value) will be ignored.

Jun 17, 2010 8:05:44 PM   oracle.sysman.emcp.EMDBPostConfig configureSoftwareLibrary
INFO: Deploying   Provisioning archives ...

Jun 17, 2010 8:06:09 PM   oracle.sysman.emcp.EMDBPostConfig configureSoftwareLibrary
INFO: Provisioning archives deployed successfully.

Jun 17, 2010 8:06:09 PM   oracle.sysman.emcp.util.DBControlUtil secureDBConsole
INFO: Securing Database Control (this may take a   while) ...

Jun 17, 2010 8:06:34 PM   oracle.sysman.emcp.util.DBControlUtil secureDBConsole
INFO: Database Control secured successfully.

Jun 17, 2010 8:06:34 PM   oracle.sysman.emcp.util.DBControlUtil startOMS
INFO: Starting Database Control (this may take a   while) ...

Jun 17, 2010 8:07:28 PM oracle.sysman.emcp.EMDBPostConfig   performConfiguration
INFO: Database Control started successfully

Jun 17, 2010 8:07:28 PM   oracle.sysman.emcp.EMDBPostConfig performConfiguration
INFO: >>>>>>>>>>>   The Database Control URL is https://HOSTNAME:1158/em   <<<<<<<<<<<

Jun 17, 2010 8:07:36 PM   oracle.sysman.emcp.EMDBPostConfig invoke
WARNING:
************************  WARNING    ************************
Management Repository has been placed in secure mode   wherein Enterprise Manager data will be encrypted.  The encryption key has been placed in the   file: /u01/app/oracle/product/11.2.0/db_1/HOSTNAME_orcl2/sysman/config/emkey.ora.   Please ensure this file is backed up as   the encrypted data will become unusable if this file is lost.
***********************************************************

Enterprise Manager configuration completed   successfully

FINISHED EMCA at Jun 17, 2010 8:07:36 PM

Known Issues:

In case no new hostname is provided in the attribute ‘–ORACLE_HOSTNAME’ of the emca command, the utility will use the old hostname and the drop/create operation will fail.

For more information in regards to Drop, Create And Recreate DB Control, please refer to Metalink note: 278100.1

A server process is waiting on “db file sequential read” wait event after it performs a single block I/O operation and it is waiting for the operating system to complete it.

A single block I/O operation occurs when a server process request a single block for the operating system. This happens during operations such as index unique or range scans, table access by rowid, etc.

Seeing this wait event in the top wait events is expected and doesn’t mean that something is wrong. Remember, users are working and reading indexes or table blocks from the disk is common. However, if we see that this event is very high and consuming unreasonable time, we need to check our SQL statement, they might need tuning, or might have unnecessary hints such as the “index” hint.

To read about analyzing wait events in an AWR report, see my post analyzing oracle awr reports – top 5 events.

A server process is waiting on “db file scattered read” wait event after it performs a multiblock I/O operation and it is waiting for the operating system to complete it.

A multiblock I/O operation occurs when the server process asks for a “chunk” of blocks and not for a single block. The amount of blocks in the “chunk” is determined by the DB_FILE_MULTIBLOCK_READ_COUNT initialization parameter. For example, if the database block size is 8k and DB_FILE_MULTIBLOCK_READ_COUNT is 8, a single multiblock I/O operation will read 8 blocks, which is 64KB of data. The maximum size of a multiblock I/O operation is determined by the operating system and storage.

When talking about performance, there are several things we need to remember:

• A server process can perform multiblock I/O operations only in certain cases like full table scans and fast full index scans. It is important to remember that multiblock I/O and DB_FILE_MULTIBLOCK_READ_COUNT are irrelevant to other operations such as index  range/unique scans.
• Setting the DB_FILE_MULTIBLOCK_READ_COUNT to a high value will result in less I/O operations (as long as it is not exceeding the operating system and storage limitation).
• Setting the DB_FILE_MULTIBLOCK_READ_COUNT to a high value can also result in unwanted full table scans, since a higher value lowers the optimizer cost of full table scans.
• Starting in 10gR2, Oracle will determine the best value for the DB_FILE_MULTIBLOCK_READ_COUNT parameter if it is not set. If the parameter is set, Oracle will not automatically set its value.

To read about analyzing wait events in an AWR report, see my post analyzing oracle awr reports – top 5 events.

From Oracle documentation:
“Wait events are statistics that are incremented by a server process or thread to indicate that it had to wait for an event to complete before being able to continue processing.”

For example, wait events can be related to I/O, locks, memory allocation, etc.

The top events tell us what the server processes wait for the most. Eliminating these wait events will definately reduce execution time, since server processes will not have to wait this time for other operations to complete.

There are many wait event in Oracle databases, this is a list of some important and common wait events:

• buffer busy waits
• free buffer waits
• db file scattered read
• db file sequential read
• enqueue waits
• log buffer space
• log file sync

To identify a performance problem we will check the time spent on each wait event and the average wait time. These numbers can be very different for different wait events, I/O wait events will probably have a low average, while waiting on locking related wait events can take a long time. Don’t forget to compare the wait time to the AWR report time period, waiting on I/O for an hour may be reasonable if the AWR report was generated on 6 hours period, but may indicate a problem on a 10 minutes report (the waiting time can exceed the total report time, since it is cumulative for all server processes).

The best way to find performance problems is to compare the wait events and the time spent on them to an AWR report from a time period in which the database worked fine. So try to save reports as a baseline for future reference.

In the next posts we’ll go deeper into analyzing the rest of the AWR report.

• TRUNCATE
• DELETE

The two commands achieve the same result; however, each of the commands acts a little bit different. Each of the two commands have advantages, limitations, and consequences, which have to be considered when deciding which method to use.

In this post we will concentrate in one aspect of these commands usage – the ability to rollback each operation.

DELETE statements delete rows one at a time, logging each row in the transaction log and maintaining the log sequence number (LSN) information.
Even though it will consumes more database resources, it comes in handy as these transactions can be rolled back if necessary by using the log files, when the recovery model of the database is set to full.

But what happens when you issue the TRUNCATE command?

The TRUNCATE statement is much faster statement than the DELETE command.
It deletes all records in a table by deallocating the data pages used to store the table’s data. This operation has a limited logging in the transaction log (only the page deallocations are recorded in the transaction log). In addition fewer locks are acquired with this statement in compare to the DELETE statement.
As a result of the above it is commonly believed that records removed by the TRUNCATE statement cannot be restored – rolled back.

It is true in most cases, however DELETE and TRUNCATE can both be rolled back when they are executed inside a ‘BEGIN TRANSACTION’ block and the current session has not yet ended.
In other words, when the TRUNCATE statement has not been committed yet, it can be rolled back

The following code demonstrates a scenario when a TRUNCATE can be rolled back for that particular session.

--Creating a testTable for the demonstration
CREATE TABLE TESTTABLE (ID INT)

--Inserting rows into the testTable.
INSERT INTO TESTTABLE
SELECT TOP 1000 OBJECT_ID FROM SYS.OBJECTS
BEGIN TRAN
   --Truncating the table
   TRUNCATE TABLE TESTTABLE
   --No rows will return
   SELECT * FROM TESTTABLE
ROLLBACK

--The original rows from testTable will return
SELECT * FROM TESTTABLE

--Dropping the testTable.
DROP TABLE TESTTABLE

To summarize,
DELETE can always be rolled back-

• When the recovery model of the database is set to SIMPLE, the statement can be rolled back – when the statement is executed inside a ‘BEGIN TRANSACTION’ block.
• When the recovery model of the database is set to FULL, the statement can also be recovered from the log files.

TRUNCATE can or cannot be rolled back, depends if it is executed from within a ‘BEGIN TRANSACTION’ block.

1. High concurrency of active sessions
2. Queries using a lot of disk time such as full table scans
3. Long duration locks on rows
4. Hardware failure such as disks defect

Another reason could be because there is a very CPU intensive query that is effecting the performance of the entire database.

This post will demonstrate how to determine which process is taking the most CPU in the system and how to retrieve the SQL statement it is currently running in the database.

** This post applies to Unix/Linux and Oracle 10g, 11g

In order to reach are goal we have to do the following things:

1. Determine which process is consuming the most CPU in the system – we can use the TOP Linux/Unix command.
2. Finding out the query this process is running – we can prepare a script in advance to help us.

Let’s begin with the preparations – preparing the script that will display the actual activity of the session within the database. The script will be a shell script that incorporates an SQL script within (you can find out more on this topic here oracle-running-sqlplus-from-unix-bash-scripts/). The script receives an argument which is the Linux/Unix process ID of the process we want to examine. I usually put such scripts in a folder that is part of my $PATH such as ~/bin (or /home/oracle/bin).

Create a run-able script in Linux:

touch /home/oracle/bin/oraproc
chmod +x /home/oracle/bin/oraproc
vi /home/oracle/bin/oraproc

In this file write the a copy of the following snippet

#!/bin/bash
if [ $# -ne 1 ];then
	echo "Usage: oraproc <Unix Process ID>"
	exit
fi

unix_pid=$1

sqlplus -s -l / as sysdba <<EOF
set head off feed off time off timing off
set serveroutput on lines 10000
DECLARE
	stmt VARCHAR2(32000) := '';
	report BOOLEAN := TRUE;
	SPACECHAR CONSTANT CHAR(1) := ' ';
	TABLEN CONSTANT NUMBER(2) := 10;
BEGIN
	dbms_output.enable(99999);
	FOR rec IN (
		SELECT  s.sid, s.username, s.osuser, s.machine,
				nvl(s.module, s.program) prog, s.event, t.sql_text
		FROM    v\$process p
		JOIN    v\$session s ON s.paddr = p.addr
		LEFT JOIN v\$sqltext_with_newlines t
				ON	t.address = s.sql_address
				AND	t.hash_value = s.sql_hash_value
		WHERE   p.spid = ${unix_pid}
		ORDER BY t.piece ) LOOP

		stmt := stmt || rec.SQL_TEXT;
		IF report THEN
			DBMS_OUTPUT.PUT_LINE(RPAD('SID:', TABLEN, spacechar) || rec.sid);
			DBMS_OUTPUT.PUT_LINE(RPAD('USERNAME:', TABLEN, spacechar) || rec.username);
			DBMS_OUTPUT.PUT_LINE(RPAD('OSUSER:', TABLEN, spacechar) || rec.osuser);
			DBMS_OUTPUT.PUT_LINE(RPAD('MACHINE:', TABLEN, spacechar) || rec.machine);
			DBMS_OUTPUT.PUT_LINE(RPAD('PROGRAM:', TABLEN, spacechar) || rec.prog);
			DBMS_OUTPUT.PUT_LINE(RPAD('EVENT:', TABLEN, spacechar) || rec.event);
			DBMS_OUTPUT.PUT_LINE('---------------------------------------');
			report := FALSE;
		END IF;
	END LOOP;
	IF NOT report THEN
		IF LENGTH(stmt) > 0 THEN
			DBMS_OUTPUT.PUT_LINE(stmt);
		ELSE
			DBMS_OUTPUT.PUT_LINE('No current running statement');
		END IF;
	ELSE
		DBMS_OUTPUT.PUT_LINE('Unix PID ${unix_pid} not found');
	END IF;
END;
/
EXIT
EOF

Now let’s see this script at work. I have written a PL/SQL anonymous block that uses a lot of CPU. It looks like this:

declare
	start_date date;
	end_time date;
	dum number;
begin
	start_date := sysdate;
	end_time := sysdate + 1/24/60; -- minute
	while end_time > sysdate loop
		dum := 0;
		for i in 1..10000 loop
			dum := dum + 1;
		end loop;
	end loop;
	dbms_output.put_line (start_date || ' ' || end_time);
end;
/

This script runs for a minute in a loop so it uses CPU very intensively. I run it from one session and run the TOP command from another session like this:

Notice that we see the process ID 9530 takes 98% CPU time.

We use this PID as an argument to our script by calling it from shell like this:

$ oraproc 9530

This will display the actual statement this process is currently running in the database (with some additional info I like to add). It looks like this:

$ oraproc 9503
SID:      1
USERNAME: DEMO
OSUSER:   oracle
MACHINE:  ora2
PROGRAM:  SQL Developer
EVENT:    SQL*Net message from client
---------------------------------------
declare
	start_date date;
	end_time date;
	dum number;
begin
	start_date := sysdate;
	end_time := sysdate + 1/24/60; -- minute
	while end_time > sysdate loop
		dum := 0;
		for i in 1..10000 loop
			dum := dum + 1;
		end loop;
	end loop;
	dbms_output.put_line (start_date || ' ' || end_time);
end;

Good luck.

(I have written it for SQL 2005 but I guess it runs both on 2000 and 2008 versions)

declare @startupDate datetime
,		@days bigint
,		@hours bigint
,		@minutes bigint
,		@seconds bigint

select	@startupDate = CrDate
,		@seconds = DateDiff(second, CrDate, getdate())
,		@days = @seconds/60/60/24
,		@seconds = @seconds - (@days*60*60*24)
,		@hours = @seconds/60/60
,		@seconds = @seconds - (@hours*60*60)
,		@minutes = @seconds/60
,		@seconds = @seconds - (@minutes*60)

from	sysdatabases (nolock)
where	[name] = 'TempDb'

select	@startupDate startup_time
,		cast(@days as varchar) + ' days ' +
		case when @hours < 10 then '0' else '' end + cast(@hours as varchar) + ':' +
		case when @minutes < 10 then '0' else '' end + cast(@minutes as varchar) + ':' +
		case when @seconds < 10 then '0' else '' end + cast(@seconds as varchar)
		as online_duration		 

1. Developers are not granted the alter system / alter user privileges.
2. When creating users for developers the DBA can add a prefix to the name (DEV_USER1, DEV_JOHN, DEV_RACHEL …).
3. Developers do not share the same username.
4. Multiple developers can run from the same client using different usernames to login to Oracle.
5. A developer can run from multiple client machines – in this case he/she will want to kill sessions opened only from one specific client machine

Tested on:

1. Oracle 10g
2. Oracle 10g RAC
3. Oracle 11g
4. Oracle 11g RAC

Now, I will display the setup code, followed by an explanation: Create owner for the procedure (schema)

create user killer identified by killer;
grant alter system to killer;
grant select on v_$session, gv_$session to killer;
alter user killer account lock;

Create the procedure

create or replace PROCEDURE killer.KILL_MY_CLIENTS AUTHID DEFINER AS
   job_no number;
   user_prefix varchar(20);
   domain_name varchar(20);
   num_of_kills number := 0;
   BACKSLASH constant char(1) := chr(92);
begin
   user_prefix := 'DEV';       -- All my developer username prefixed with DEV
                               -- (DEV_USER1, DEV_USER2, DEV_MIKE, DEV_JOHN ...)
   domain_name := 'WORKGROUP'; -- We work in a workgroup.
                               -- Once we work in a windows domain this variable should
                               -- hold the domain name

   for REC in
       (SELECT SID, SERIAL#, INST_ID, MODULE,
               SYS_CONTEXT('USERENV', 'INSTANCE') MY_INST_ID
        from gv$session s
        where s.username like user_prefix || '%'                  -- precaution
          and s.username = sys_context('USERENV', 'SESSION_USER') -- only my username
          and not (S.SID = SYS_CONTEXT('USERENV', 'SID')          -- excluding my session
          and INST_ID = SYS_CONTEXT('USERENV', 'INSTANCE'))
          and replace(upper(machine), domain_name || BACKSLASH, '')     -- my machine
                 = replace(upper(sys_context('USERENV', 'HOST')), domain_name || BACKSLASH, '')
          and s.module not in ('SQL*Plus', 'SQL Developer')       -- not sqlplus
                                                                  -- nor sql developer
          and s.module not like 'sqlplus@%'
          and S.LOGON_TIME < sysdate-(1/24/60/60)                 -- logged-on more
                                                                  -- than a second
        ORDER BY inst_id asc
       ) LOOP
      if rec.inst_id = rec.my_inst_id then
         ---------------------------------------------------------------------------
         -- kill local sessions immediately
         ---------------------------------------------------------------------------
         dbms_output.put('LOCAL SID ' || rec.sid || '(' || rec.module || ')');
         execute immediate 'alter system kill session ''' || rec.sid || ', ' ||
                            rec.serial# || '''' ;
         dbms_output.put_line('. killed locally ' || job_no);
      ELSE
         ---------------------------------------------------------------------------
         -- kill remote sessions (for RAC) as a job
         ---------------------------------------------------------------------------
         DBMS_OUTPUT.PUT('REMOTE SID ' || REC.SID || ' on instance ' || REC.INST_ID  ||
                         '(' || rec.module || ')');
         DBMS_JOB.SUBMIT (
                 job => job_no,
                 what => 'execute immediate ''alter system kill session ''''' || rec.sid ||', ' ||
                          rec.serial# || ''''''';',
                 INSTANCE => rec.inst_id);
         dbms_output.put_line('. killed with job ' || job_no);
         COMMIT;
      end if;
      num_of_kills := num_of_kills + 1;
   end loop;
   dbms_output.put_line ('number of killed sessions: ' || num_of_kills);
end kill_my_clients;

Make procedure available to all

create public synonym kill_my_clients for killer.kill_my_clients;
grant execute on killer.kill_my_clients to public;
alter user killer account lock;

Use it: login as the developer from client machine to any application that can run statements like SQL*Plus

exec kill_my_clients

Explanation: The commands in the first section create a user called “killer”. This user is the owner of the procedure described in the next section. Notice that this user is very powerful because it can kill any user with the permission “alter system”. That is why we must limit access to it so it is locked. The grants on v_$session and gv_$session must be done by sys or other user with admin options on these views. The second section is the procedure itself. It should be compiled under “killer” (as the code demonstrates). Here is an explanation of this procedure:

1. Identify all sessions running from the developer’s machine from his/hers username except for the session running this query in the current node and remote RAC nodes.
   1. If the session is on the same instance of the current connection – kill it immediately.
   2. If the session is on a different RAC node – kill it by submitting a job on that node.

   There are 2 variables that I usually change when I deploy this procedure in an environment:

   • USER_PREFIX – I try naming all the developer users with a prefix such as DEV_USER1, DEV_USER2, DEV_MIKE, DEV_JOHN … I use this prefix as a measure of precaution – I don’t want my procedure to kill any users not beginning with this prefix. This way if my developer is running this procedure from user sys or system by mistake it will do no harm.
   • DOMAIN_NAME – when working with windows clients sometimes the application is prefixed with the domain name (such as SQL Developer) and sometimes not (such as SQL*Plus). This variable will become crucial to identifying sessions opened from the developer’s machine.
2. Execute kill command on the local instance.
3. Execute kill command on all remote instances of RAC by submitting jobs with instance affinity.

Another factor I take into account is that I don’t want to kill connections from SQL*Plus or from SQL Developer. If you are working with other programs such as PL/SQL Developer or Toad you might want to include them in the where clause as well.

The third section demonstrates how to use this mechanism: You just have to login as the developer from the client machine to any application that can run statements like SQL*Plus and execute the procedure (you do not have to use the owner’s name in the call because you have declared a public synonym for it).

Enjoy 

If your database contains the Oracle Database Diagnostic Pack, then by default, the database generates an AWR snapshot in an hourly interval (it of course can be changed by using the DBMS_WORKLOAD_REPOSITORY.MODIFY_SNAPSHOT_SETTINGS procedure).

Once taken, each two snapshots can be compared in an AWR report and greatly assist in the performance and tuning job.

There’re several methods of generating these AWR report, however, most of the methods are manual methods – creating one report at the time.

The following procedure will create several AWR reports in HTML format in a given directory, based on a begin/end snapshot id parameters.

Procedure’s Parameters:

• Begin_snap – the first AWR snapshot to be compared.
• End_snap – the last AWR snapshot to be compared.
• Directory – the directory in which it will generate the reports

The required begin/end snapshot values can be retrieved from the following query on DBA_HIST_SNAPSHOT:

SELECT     	SNAP_ID,
                TO_CHAR(BEGIN_INTERVAL_TIME,'DD/MM/YYYY HH24:MI') ,
                TO_CHAR(END_INTERVAL_TIME,'DD/MM/YYYY HH24:MI')</pre>
FROM DBA_HIST_SNAPSHOT 
--The following WHERE clause can be used in order to limit the snapshot details.
--WHERE TO_CHAR(BEGIN_INTERVAL_TIME,'DD/MM/YYYY') > TO_CHAR(SYSDATE -2,'DD/MM/YYYY'); 

Once Created, the procedure can be executed as the following example:

EXEC CreateAwrReports (465, 475, ‘C:\TEMP’);

Below is the procedure’s script:

CREATE OR REPLACE PROCEDURE CreateAwrReports (begin_snap number,end_snap number, directory varchar2 )
as
/*---------------------------------------------------------------------------
 Name: CreateAwrReports Procedure
 Purpose : 	Create several AWR reported based on begin_snap and end_snap input parameters.
			The AWR reports will be created in the directory input parameter.
 Date    : 06.21.2010.
 Author  : Roni Vered
 Website : WWW.DBSNAPS.COM
 Execution :	exec CreateAwrReports (462, 472, 'c:\temp');

 Remarks : Run as privileged user
 --------------------------------------------------------------------------- */
	v_Instance_number v$instance.instance_number%TYPE;
	v_Instance_name v$instance.instance_name%TYPE;
	v_dbid V$database.dbid%TYPE;
	v_file UTL_FILE.file_type;

BEGIN

/* Collecting instance information: Instance_number, Instance_name and Dbid */
	SELECT instance_number, instance_name
	into v_Instance_number,v_Instance_name
	FROM   gv$instance
	ORDER BY 1;

	SELECT dbid
	INTO v_dbid
	FROM v$database;

/* Creating a database directory which will point to the acual wanted report directory in the OS */
	EXECUTE IMMEDIATE('CREATE OR REPLACE DIRECTORY TEMP_DIR AS '''||directory||'''');

/*
	Looping on all the snapshots from the begin_snap input parameter to the end_snap input parameter
	On each snapshot pair we will create a file in the given directory which will contain the AWR report.
	We use DBMS_WORKLOAD_REPOSITORY.AWR_REPORT_HTML build in procedure to create the HTML report.
*/
  FOR i IN begin_snap..end_snap-1 LOOP
		BEGIN
			--Creating and Naming the file:
			v_file := UTL_FILE.fopen('TEMP_DIR', 'awr_' || v_Instance_name ||'_'|| v_Instance_number || '_' || i || '_' || (i+1) || '.html', 'w', 32767);
			FOR c_AWRReport IN (
				SELECT output FROM TABLE (DBMS_WORKLOAD_REPOSITORY.AWR_REPORT_HTML( v_dbid, v_Instance_number,  i, i+1))
					   ) LOOP
						--Writing the AWR HTML report content to the file:
						UTL_FILE.PUT_LINE(v_file, c_AWRReport.output);
					   END LOOP;
			--Closing the file:
			UTL_FILE.fclose(v_file);
		END;
	END LOOP;

/* Dropping the database directory which we've created earlier. */
	EXECUTE IMMEDIATE('DROP DIRECTORY TEMP_DIR');

END;

Sometimes, all we need is to get a value from an index we have, and this index is not a sequence number, but a number that has meaning or even text. To solve this problem we can use a regular table or temporary table, but these have some overhead and can be affected by other users or operations.

A simple example for this scenario can be coloring the world map in 4 colors (red, green, blue and yellow). In this example each country has a color and we need to know the color for a given country and go over the countries to check if they have a color.

The most effective way to do that is to use associative arrays with varchar2(30) as the index (for the country names) and varchar2(6) and the value (for the colors).

The following code shows how to work with associative arrays, add new cells, check the array length and go over the entire array.

<pre>declare
   type map_array is table of varchar2(4) index by varchar2(30);
   map map_array;
   idx varchar2(30);
begin
   -- add countries to the array
   map('France'):='blue';
   map('Italy'):='red';

   -- print the number of countries in the arrary
   dbms_output.put_line('There are '||map.count||' countries');

   -- go over the entire array
   idx:=map.first;
   while (idx is not null)
   loop
      dbms_output.put_line('Country '||idx||' is '||map(idx));
      idx:=map.next(idx);
   end loop;

   -- check if a country exists
   idx:='England';
   if (map.exists(idx))
   then
      dbms_output.put_line(idx||' has the color '||map(idx));
   else
      dbms_output.put_line(idx||' does not have a color');
   end if;
end;