snapper4.sql

7/30/2019 snapper4.sql

1/52

---------------------------------------------------------------------------------- File name: snapper4.sql (Oracle Session Snapper v4)-- Purpose: An easy to use Oracle session-level performance measurement tool-- which does NOT require any database changes nor creation of any-- database objects!---- This is very useful for ad-hoc performance diagnosis in environments-- with restrictive change management processes, where creating-- even temporary tables and PL/SQL packages is not allowed or would-- take too much time to get approved.---- All processing is done by a few sqlplus commands and an anonymous-- PL/SQL block, all that's needed is SQLPLUS access (and if you want-- to output data to server-side tracefile then execute rights on-- DBMS_SYSTEM). Snapper only queries some V$ views (and in advanced-- mode some X$ fixed tables, but it does not enable any traces nor-- use oradebug.--

-- The output is formatted the way it could be easily post-processed-- by either Unix string manipulation tools or loaded to spreadsheet.---- Snapper v4 supports RAC and requires Oracle 10.1 or a newer DB version.-- Snapper v3.5 works on Oracle versions starting from Oracle 9.2 (no RAC support)---- Note1: The "ASH" functionality in Snapper just samples GV$SESSION view,-- so you do NOT need Diagnostics Pack licenses to use Snapper's-- "ASH" output

---- Note2: Snapper just reports you performance metric deltas in a snapsphot-- and does not attempt to solve any performance problems for you.-- You still need to interpret and understand these standard Oracle-- metrics yourself---- Author: Tanel Poder ([email protected])-- Copyright: (c) Tanel Poder - http://blog.tanelpoder.com - All rights reserved.---- Disclaimer: This script is provided "as is", so no warranties or guaranteesare

-- made about its correctness, reliability and safety. Use it at your-- own risk!---- License: 1) You may use this script for your (or your businesses) purposes for free-- 2) You may modify this script as you like for your own (or yourbusinesses) purpose,-- but you must always leave this script header (the entire comment section), including the


2/52

-- author, copyright and license sections as the first thing inthe beginning of this file-- 3) You may NOT publish or distribute this script or any variation of it PUBLICLY-- (including, but not limited to uploading it to your public website or ftp server),-- instead just link to its location in blog.tanelpoder.com-- 4) You may distribute this script INTERNALLY in your company, for internal use only,-- for example when building a standard DBA toolset to be deployed to all-- servers or DBA workstations------ Thanks to: Adrian Billington, Jamey Johnston, Marcus Mnnig, Hans-Peter Sloot-- and Ronald Rood for bugfixes, additions and improvements-------------------------------------------------------------------------------------- The Session Snapper v4.09 BETA ( USE AT YOUR OWN RISK !!! )-- (c) Tanel Poder ( http://blog.tanelpoder.com )------ +-----=====O=== Welcome to The Session Snapper! (Yes, you are looking at a

cheap ASCII-- / imitation of a fish and afishing rod.-- | Nevertheless the PL/SQL code below the-- | fish itself should be helpful for quick-- | catching of relevant Oracle performance-- | information.-- | So I wish you happy... um... snapping?-- | )

-- | ......-- | iittii,,....-- iiffffjjjjtttt,,-- ..;;ttffLLLLffLLLLLLffjjtt;;..-- ..ttLLGGGGGGLLffLLLLLLLLLLLLLLffjjii,, ..ii,,-- ffGGffLLLLLLjjttjjjjjjjjffLLLLLLLLLLjjii.. ..iijj;;....-- ffGGLLiittjjttttttiittttttttttffLLLLLLGGffii.. ;;LLLLii;;;;..-- ffEEGGffiittiittttttttttiiiiiiiittjjjjffLLGGLLii.. iiLLLLLLttiiii,,-- ;;ffDDLLiiiitt,,ttttttttttttiiiiiiiijjjjjjffLLLLffttiiiiffLLGGLLjjtttt;;

..-- ..ttttjjiitt,,iiiiiittttttttjjjjttttttttjjjjttttjjttttjjjjffLLDDGGLLttii..-- iittiitttt, ;;iittttttttjjjjjjjjjjttjjjjjjffffffjjjjjjjjjjLLDDGGLLtt;;..-- jjjjttttii:. ..iiiiffLLGGLLLLLLLLffffffLLLLLLLLLLLLLLLLffffffLLLLLLfftt,,-- iittttii,,;;,,ttiiiiLLLLffffffjjffffLLLLLLLLffLLffjjttttttttttjjjjffjjii..-- ,,iiiiiiiiiittttttiiiiiiiiiijjffffLLLLLLLLffLLffttttttii;;;;iiiitttttttt;;..-- ..iittttttffffttttiiiiiiiiiittttffjjjjffffffffttiittii:: ....,,;;iittii;;-- ..;;iittttttttttttttttiiiiiittttttttttjjjjjjtttttt;; ..;;ii


3/52

;;..-- ..;;;;iittttttjjttiittttttttttttttjjttttttttii.. ....-- ....;;;;ttjjttttiiiiii;;;;;;iittttiiii..-- ..;;ttttii;;.... ..;;;;....-- ..iiii;;..-- ..;;,,-- ....------ Usage:---- snapper.sql [,out][,trace][,pagesize=X][,gather=[s][t][w][l][e][b][a]]> ---- ash - sample session activity ASH style, waits and SQL_IDs fromgv$session and-- print a TOP SQL/wait report from these samples (this is the default from-- Snapper 3.0). The columns chosen for TOP calculation aredefined in CONFIG-- section below.---- ash=sql_id+event+wait_class

-- - the above example illustrates that you can also specify the gv$session-- columns for TOP report yourself. The above example will show a TOP-- activity report grouped by SQL_ID + EVENT + WAIT_CLASS-- Note that the columns are separated by a "+" sign (as comma is a snapper-- parameter separator, not ASH column separator)---- ash1-- ash2-- ash3 - in addition to "ash" report you can have 3 more reportedduring the same

-- snapper sampling snapshot. Just include ash1=col1+col2,ash2=col3+col4,...-- parameters if you want multiple TOP reports per Snapper snapshot---- stats - sample gv$sesstat,gv$sess_time_model,gv$session_event performance counters-- and report how much these stats increased (deltas) duringSnapper run-- all - report both ASH and stats sections---- out - use dbms_output.put_line() for output. output will be seen only when

-- Snapper run completes due to dbms_output limitations. This is the default.-- trace - write output to server process tracefile-- (you must have execute permission on sys.dbms_system.ksdwrt() for that,-- you can use both out and trace parameters together if you like )---- pagesize - display header lines after X snapshots. if pagesize=0 don't display


4/52

-- any headers. pagesize=-1 will display a terse header onlyonce---- gather - if omitted, gathers s,t,w statistics (see below)-- - if specified, then gather following:---- Session-level stats:-- s - Session Statistics from gv$sesstat-- t - Session Time model info from gv$sess_time_model-- w - Session Wait statistics from gv$session_event and gv$session_wait---- Instance-level stats:-- l - instance Latch get statistics ( gets + immediate_gets )-- e - instance Enqueue lock get statistics-- b - buffer get Where statistics -- useful in versions up to 10.2.x-- a - All above---- sinclude - if specified, then show only GV$SESSTAT stats which matchthe-- LIKE pattern of sinclude (REGEXP_LIKE in 10g+)-- linclude - if specified, then show only GV$LATCH latch stats which m

atch the-- LIKE pattern of linclude (REGEXP_LIKE in 10g+)-- tinclude - if specified, then show only GV$SESS_TIME_MODEL stats which match the-- LIKE pattern of tinclude (REGEXP_LIKE in 10g+)-- winclude - if specified, then show only GV$SESSION_EVENT wait statswhich match the-- LIKE pattern of winclude (REGEXP_LIKE in 10g+)---- you can combine above parameters in any order, separate them by commas-- !!!don't use spaces as otherwise they are treated as next parametersby sqlplus !!!

-- !!!if you want to use spaces, enclose the whole sqlplus parameter indoublequotes !!!---- - the number of seconds between taking snapshots-- - the number of snapshots to take ( maximum value is power(2,31)-1 )---- can be either one sessionid, multiple sessionids separated by-- commas or a SQL statement which returns a list of SIDs (if you need spaces-- in that parameter text, enclose it in double quotes).--

-- if you want to snap ALL sids, use "all" as value for-- parameter---- alternatively you can used "select sid from gv$session" as value for -- parameter to capture all SIDs. you can write any query (with multiple and/or)-- conditions to specify complex rules for capturing only the SIDs you want---- starting from version 3.0 there are further session_id selection options


5/52

available in-- instead of sid you can write such expressions for snapper's parameter:---- sid=123 -- take sid 123 only (the same as just writing 123)-- user=tanel -- take all sessions where username is 'tanel' (case insensitive)-- -- this is the same as writing following subquery for the-- -- parameter:-- select sid from gv$session where lower(username) like lower('tanel')---- user=tanel% -- take all sessions where username begins with 'tanel%'(case insensitive)-- -- the = means actually LIKE in SQL terms in this script---- spid=1234 -- all these 3 parameters do the same thing:-- ospid=1234 -- they look up the sessions(s) where the processes OS PID=1234-- pid=1234 -- this is useful for quickly looking up what some OS process is doing-- -- if it consumes too much of some resource-- qc=123

-- qcsid=123 -- show query coordinator and all PX slave sessions---- program=sqlplus% -- the following examples filter by corresponding gv$session coulmns-- machine=linux01 -- machine-- osuser=oracle -- os username-- module=HR -- module-- "action=Find Order" -- note the quotes because there is a space inside the parameter-- -- value-- client_id=tanelpoder -- show only sessions where client_identifier isset to tanelpoder-- -- this is very useful in cases with (properly i

nstrumented)-- -- connection pools------ Note that if you want to change some "advanced" snapper configuration parameters-- or default values then search for CONFIG in this file to see configurable-- variable section------ Examples:-- NB! Read the online examples, these are more detailed and list script ou

tput too!---- http://tech.e2sn.com/oracle-scripts-and-tools/session-snapper---- @snapper ash,stats 1 1 515-- (Output one 1-second snapshot of session 515 using dbms_output and exit-- Wait, gv$sesstat and gv$sess_time_model statistics are reported by default-- Starting from V3 the ASH style session activity report is shown as well)


6/52

---- @snapper stats,gather=w 1 1 515-- (Output one 1-second snapshot of session 515 using dbms_output and exit-- only Wait event statistics are reported, no ASH)---- @snapper ash,gather=st 1 1 515-- (Output one 1-second snapshot of session 515 using dbms_output and exit-- only gv$sesstat and gv$sess_Time_model statistics are gathered + ASH)---- @snapper trace,ash,gather=stw,pagesize=0 10 90 117,210,313-- (Write 90 10-second snapshots into tracefile for session IDs 117,210,313-- all statistics are reported, do not print any headers)---- @snapper trace,ash 900 999999999 "select sid from v$session"-- (Take a snapshot of ALL sessions every 15 minutes and write the output to trace,-- loop (almost) forever )---- @snapper out,trace 300 12 "select sid from v$session where username='APPS'"-- (Take 12 5-minute snapshots of all sessions belonging to APPS user, write-- output to both dbms_output and tracefile)--

-- Notes:---- Snapper does not currently detect if a session with given SID has-- ended and been recreated between snapshots, thus it may report bogus-- statistics for such sessions. The check and warning for that will be-- implemented in a future version.----------------------------------------------------------------------------------

set termout off tab off verify off linesize 999 trimspool on trimout on null ""

--debug:-- set termout on serveroutput on

-- Get parameters (future snapper v4.x extended syntax: @snapper )define snapper_options="&1"define snapper_sleep="&2"define snapper_count="&3"define snapper_sid="&4"

-- The following code is required for making this script "dynamic" as due to-- different Oracle versions, script parameters or granted privileges some-- statements might not compile if not adjusted properly.

define _IF_ORA11_OR_HIGHER="--"define _IF_LOWER_THAN_ORA11="--"define _IF_DBMS_SYSTEM_ACCESSIBLE="/* dbms_system is not accessible"-- /*dummy*/ -- this "dummy" is here just for avoiding VIM syntax highlighter going crazy due to previous linedefine _IF_X_ACCESSIBLE="--"

-- plsql_object_id columns available in v$session (from 10.2.0.3)define _YES_PLSQL_OBJ_ID="--"define _NO_PLSQL_OBJ_ID=""


7/52

-- blocking_instance available in v$session (from 10.2)define _YES_BLK_INST="--"define _NO_BLK_INST=""

-- snapper v4 manual before/after snapshottingdefine _MANUAL_SNAPSHOT="--"define _USE_DBMS_LOCK=""

-- set the noprint's value to "noprint" if you don't want these temporary variables to show up in a sqlplus spool fileDEF noprint=""col snapper_ora11higher &noprint new_value _IF_ORA11_OR_HIGHERcol snapper_ora11lower &noprint new_value _IF_LOWER_THAN_ORA11col dbms_system_accessible &noprint new_value _IF_DBMS_SYSTEM_ACCESSIBLEcol x_accessible &noprint new_value _IF_X_ACCESSIBLEcol no_plsql_obj_id &noprint new_value _NO_PLSQL_OBJ_IDcol yes_plsql_obj_id &noprint new_value _YES_PLSQL_OBJ_IDcol no_blk_inst &noprint new_value _NO_BLK_INSTcol yes_blk_inst &noprint new_value _YES_BLK_INSTcol manual_snapshot &noprint new_value _MANUAL_SNAPSHOTcol use_dbms_lock &noprint new_value _USE_DBMS_LOCK

col snapper_sid &noprint new_value snapper_sid

-- sid_filter and inst_filter are the new RAC gv$ friendly way to filter sessions in Snapper v4def sid_filter="/**/"def inst_filter="/**/"col sid_filter &noprint new_value sid_filtercol inst_filter &noprint new_value inst_filter

-- initialize, precompute and determine stuffvar v varchar2(100)var x varchar2(10)var sid_filter varchar2(4000)var inst_filter varchar2(4000)

-- this is here for a reason-- im extracting the first word of the snapper_sid (if its a complex expression,not just a single SID)-- by relying on how DEF and & assignment treat spaces in stringsdef ssid_begin=&snapper_sid

declare

o sys.dbms_describe.number_table;p sys.dbms_describe.number_table;l sys.dbms_describe.number_table;a sys.dbms_describe.varchar2_table;

dty sys.dbms_describe.number_table;def sys.dbms_describe.number_table;inout sys.dbms_describe.number_table;len sys.dbms_describe.number_table;prec sys.dbms_describe.number_table;scal sys.dbms_describe.number_table;rad sys.dbms_describe.number_table;spa sys.dbms_describe.number_table;

tmp number;


8/52

lv_sid_filter varchar2(4000);lv_inst_filter varchar2(4000);

function get_filter(str in varchar2) return varchar2isret varchar2(1000);

beginif str like '%@%' then--dbms_output.put_line('get_filter:1 str= '||str);ret := lower(trim(regexp_replace(substr(str,instr(str,'=')+1), '^(.+)@([

[:digit:]\*]+)(.*)', '\1')));else--dbms_output.put_line('get_filter:2 str= '||str);ret := lower(trim(substr(str,instr(str,'=')+1)));

end if;--dbms_output.put_line('get_filter = ' || ret);return ret;

end get_filter;

begin-- compute inst_filtercase

when regexp_instr('&ssid_begin','@') = 0 thenlv_inst_filter := '/* inst_filter */ s.inst_id=USERENV(''Instance'')

'; when regexp_instr('&ssid_begin','@\*') > 0 or '&ssid_begin' like '(%' then

lv_inst_filter := '/* inst_filter */ 1=1';when regexp_instr('&ssid_begin','@\d+') > 0 then

lv_inst_filter := 's.inst_id = ' || regexp_replace('&ssid_begin', '^(.+)@(\d+)(.*)', '\2');

elselv_inst_filter := 's.inst_id=USERENV(''Instance'')';

--when regexp_instr('&ssid_begin','@\d+') > 0 then regexp_replace(snapper_sid, '^(.+)@\d+', '\1') || ' AND inst_id = ' || regexp_replace(snapper_sid,'^(.+)@(\d+)(.*)', '\2')

end case;

-- compute sid_filtercase

when trim(lower('&ssid_begin')) like 'sid=%' then lv_sid_filter:= 's.sid in ('||get_filter('&ssid_begin')||')'; --||trim(replace('&ssid_begin','sid=',''))||')';

when trim(lower('&ssid_begin')) like 'user=%' then lv_sid_filter:= 'lower(username) like ''' ||get_filter('&ssid_begin')||'''';

when trim(lower('&ssid_begin')) like 'username=%' then lv_sid_filter:= 'lower(username) like ''' ||get_filter('&ssid_begin')||'''';

when trim(lower('&ssid_begin')) like 'machine=%' then lv_sid_filter:= 'lower(machine) like ''' ||get_filter('&ssid_begin')||'''';

when trim(lower('&ssid_begin')) like 'program=%' then lv_sid_filter

:= 'lower(program) like ''' ||get_filter('&ssid_begin')||'''';when trim(lower('&ssid_begin')) like 'service=%' then lv_sid_filter:= 'lower(service_name) like ''' ||get_filter('&ssid_begin')||'''';

when trim(lower('&ssid_begin')) like 'module=%' then lv_sid_filter:= 'lower(module) like ''' ||get_filter('&ssid_begin')||'''';

when trim(lower('&ssid_begin')) like 'action=%' then lv_sid_filter:= 'lower(action) like ''' ||get_filter('&ssid_begin')||'''';

when trim(lower('&ssid_begin')) like 'osuser=%' then lv_sid_filter:= 'lower(osuser) like ''' ||get_filter('&ssid_begin')||'''';

when trim(lower('&ssid_begin')) like 'client_id=%' then lv_sid_filter


9/52

:= 'lower(client_identifier) like '''||get_filter('&ssid_begin')||'''';when trim(lower('&ssid_begin')) like 'spid=%' then lv_sid_filter

:= '(s.inst_id,s.paddr) in (select /*+ UNNEST */ inst_id,addr from gv$process where spid in ('||get_filter('&ssid_begin')||'))';

when trim(lower('&ssid_begin')) like 'ospid=%' then lv_sid_filter:= '(s.inst_id,s.paddr) in (select /*+ UNNEST */ inst_id,addr from gv$process where spid in ('||get_filter('&ssid_begin')||'))';

when trim(lower('&ssid_begin')) like 'pid=%' then lv_sid_filter:= '(s.inst_id,s.paddr) in (select /*+ NO_UNNEST */ inst_id,addr from gv$processwhere spid in ('||get_filter('&ssid_begin')||'))';

when trim(lower('&ssid_begin')) like 'qcsid=%' then lv_sid_filter:= '(s.inst_id,s.sid) in (select /*+ NO_UNNEST */ inst_id,sid from gv$px_session where qcsid in ('||get_filter('&ssid_begin')||'))';

when trim(lower('&ssid_begin')) like 'qc=%' then lv_sid_filter:= '(s.inst_id,s.sid) in (select /*+ NO_UNNEST */ inst_id,sid from gv$px_session where qcsid in ('||get_filter('&ssid_begin')||'))';

when trim(lower('&ssid_begin')) like 'all%' then lv_sid_filter:= '1=1';

when trim(lower('&ssid_begin')) like 'bg%' then lv_sid_filter:= 'type=''BACKGROUND''';

when trim(lower('&ssid_begin')) like 'fg%' then lv_sid_filter:= 'type=''USER''';

when trim(lower('&ssid_begin')) like 'smon%' then lv_sid_filter:= 'program like ''%(SMON)%''';

when trim(lower('&ssid_begin')) like 'pmon%' then lv_sid_filter:= 'program like ''%(PMON)%''';when trim(lower('&ssid_begin')) like 'ckpt%' then lv_sid_filter

:= 'program like ''%(CKPT)%''';when trim(lower('&ssid_begin')) like 'lgwr%' then lv_sid_filter

:= 'program like ''%(LGWR)%''';when trim(lower('&ssid_begin')) like 'dbwr%' then lv_sid_filter

:= 'program like ''%(DBW%)%''';when trim(lower('&ssid_begin')) like 'select%' then /*lv_inst_filter

:= '/* inst_filter2 1=1'; */ lv_sid_filter := q'{(s.inst_id,s.sid) in (&snapper_sid)}';

--when trim(lower('&ssid_begin')) like 'select%' then lv_sid_filter:= '(s.inst_id,s.sid) in ('||regexp_replace(replace(q'{&snapper_sid}','','''''')

, '^select ', 'select /*+ unnest */ ', 1, 1, 'i')||')'; -- '1=1'; lv_inst_filter:= '1=1';--when trim(lower('&ssid_begin')) like 'with%' then lv_sid_filter

:= '(s.inst_id,s.sid) in (&snapper_sid)'; -- '1=1'; lv_inst_filter := '1=1';when trim(lower('&ssid_begin')) like '(%' then lv_inst_filter :

= '/* inst_filter2 */ 1=1'; lv_sid_filter := q'{(s.inst_id,s.sid) in (&snapper_sid)}'; -- '1=1'; lv_inst_filter := '1=1';

else lv_sid_filter:= '/* sid_filter_else_cond */ s.sid in ('||get_filter('&ssid_begin')||')'; --lv_sid_filter := '/* sid_filter_else_cond */ s.sid in (&ssid_begin)';

end case;

:inst_filter := lv_inst_filter;

:sid_filter := lv_inst_filter||' and '||lv_sid_filter;

-- this block determines whether dbms_system.ksdwrt is accessible to us-- dbms_describe is required as all_procedures/all_objects may show this obj

ect-- even if its not executable by us (thanks to o7_dictionary_accessibility=f

alse)begin

execute immediate 'select count(*) from x$kcbwh where rownum = 1' into tmp;


10/52

:x:= ' '; -- x$ tables are accessible, so dont comment any lines outexception

when others then null;end;

sys.dbms_describe.describe_procedure('DBMS_SYSTEM.KSDWRT', null, null,o, p, l, a, dty, def, inout, len, prec, scal, rad, spa

);

-- we never get to following statement if dbms_system is not accessible-- as sys.dbms_describe will raise an exception:v:= '-- dbms_system is accessible';

exceptionwhen others then null;

end;/

-- this query populates some sqlplus variables required for dynamic compilationused belowwith mod_banner as (

selectreplace(banner,'9.','09.') banner

fromv$versionwhere rownum = 1

)select

decode(substr(banner, instr(banner, 'Release ')+8,2), '09', '--', '') snapper_ora10lower,

decode(substr(banner, instr(banner, 'Release ')+8,2), '09', '', '--') snapper_ora9,

decode(substr(banner, instr(banner, 'Release ')+8,1), '1', '', '--') snapper_ora10higher,

case when substr(banner, instr(banner, 'Release ')+8,2) >= '11' then '' else'--' end snapper_ora11higher,

case when substr(banner, instr(banner, 'Release ')+8,2) < '11' then '' else'--' end snapper_ora11lower,nvl(:v, '/* dbms_system is not accessible') dbms_system_accessible,nvl(:x, '--') x_accessible,case when substr( banner, instr(banner, 'Release ')+8, instr(substr(banner,i

nstr(banner,'Release ')+8),' ') ) >= '10.2' then '' else '--' end yes_blk_inst,

case when substr( banner, instr(banner, 'Release ')+8, instr(substr(banner,instr(banner,'Release ')+8),' ') ) >= '10.2' then '--' else '' end no_blk_inst,

case when substr( banner, instr(banner, 'Release ')+8, instr(substr(banner,instr(banner,'Release ')+8),' ') ) >= '10.2.0.3' then '' else '--' end yes_plsql_obj_id,

case when substr( banner, instr(banner, 'Release ')+8, instr(substr(banner,instr(banner,'Release ')+8),' ') ) >= '10.2.0.3' then '--' else '' end no_plsql_obj_id,

case when lower('&snapper_options') like '%,begin%' or lower('&snapper_options') like 'begin%' or lower('&snapper_options') like '%,end%' or lower('&snapper_options') like 'end%' then '' else '--' end manual_snapshot,

case when lower('&snapper_options') like '%,begin%' or lower('&snapper_options') like 'begin%' or lower('&snapper_options') like '%,end%' or lower('&snapper_options') like 'end%' then '--' else '' end use_dbms_lock,

:sid_filter sid_filter,


11/52

:inst_filter inst_filterfrom

mod_banner/

set termout on serveroutput on size 1000000 format wrapped

prompt Sampling SID &4 with interval &snapper_sleep seconds, taking &snapper_count snapshots...

-- let the Snapping start!!!-- main()declare

-- Snapper start-- forward declarationsprocedure output(p_txt in varchar2);procedure fout;

function tptformat( p_num in number,p_stype in varchar2 default 'STAT',p_precision in number default 2,p_base in number default 10,p_grouplen in number default 3

)

return varchar2;function getopt( p_parvalues in varchar2,p_extract in varchar2,p_delim in varchar2 default ','

)return varchar2;

-- type, constant, variable declarations

-- trick for holding 32bit UNSIGNED event and stat_ids in 32bit SIGNED PLS_INTEGER

pls_adjust constant number(10,0) := power(2,31) - 1;

type srec is record (ts timestamp, stype varchar2(4), inst_id number, sid number, statistic# number, value number, event_count number );

type stab is table of srec index by pls_integer;type ltab is table of srec index by varchar2(100); -- lookup tab for various

average calculations1 stab;s2 stab;l1 ltab;l2 ltab;

type snrec is record (stype varchar2(4), statistic# number, name varchar2(100));

type sntab is table of snrec index by pls_integer;sn_tmp sntab;sn sntab;

type sntab_reverse is table of snrec index by varchar2(100); -- used for looking up stat id from stat name

sn_reverse sntab_reverse;

tmp_varchar2 varchar2(1000); -- misc


12/52

function get_useful_average(c in srec /* curr_metric */, p in srec /* all_prev_metrics */) return varchar2;

type tmp_sestab is table of gv$session%rowtype index by pls_integer;type sestab is table of gv$session%rowtype index by varchar2(20);

g_sessions sestab;g_empty_sessions sestab;

type hc_tab is table of number index by pls_integer; -- index is sql hash value

type ses_hash_tab is table of hc_tab index by pls_integer; -- index is SID

g_ses_hash_tab ses_hash_tab;g_empty_ses_hash_tab ses_hash_tab;

-- dbms_debug_vc2coll is a built-in collection present in every oracle dbg_ash sys.dbms_debug_vc2coll := new sys.dbms_debug_vc2coll();g_empty_ash sys.dbms_debug_vc2coll := new sys.dbms_debug_vc2coll();g_snap1 sys.dbms_debug_vc2coll;g_snap2 sys.dbms_debug_vc2coll;

g_ash_samples_taken number := 0;

g_count_statname number;g_count_eventname number;

g_mysid number;

i number;a number;b number;

c number;delta number;evcnt number;changed_values number;

pagesize number:=99999999999999;missing_values_s1 number := 0;missing_values_s2 number := 0;disappeared_sid number := 0;lv_curr_sid number := 0; -- used for determining whether to print an e

mpty line between session statsd1 timestamp(6);d2 timestamp(6);ash_date1 date;ash_date2 date;lv_gather varchar2(1000);gv_header_string varchar2(1000);lv_data_string varchar2(1000);

lv_ash varchar2(1000);lv_stats varchar2(1000);

gather_stats number := 0;gather_ash number := 0;

g_snap_begin varchar2(1000);g_snap_end varchar2(1000);


13/52

-- CONFIGURABLE STUFF --

-- this sets what are the default ash sample TOP reporting group by columnsg_ash_columns varchar2(1000) := 'inst_id + sql_id + sql_child_number + e

vent + wait_class';g_ash_columns1 varchar2(1000) := 'inst_id + event + p1 + wait_class';g_ash_columns2 varchar2(1000) := 'inst_id + sid + user + machine + progra

m';g_ash_columns3 varchar2(1000) := 'inst_id + plsql_object_id + plsql_subpr

ogram_id + sql_id';

-- output column configurationoutput_header number := 0; -- 1=true 0=falseoutput_username number := 1; -- v$session.usernameoutput_inst number := 0; -- instoutput_sid number := CASE WHEN dbms_utility.is_cluster_database = TRU

E THEN 0 ELSE 1 END; -- just sidoutput_inst_sid number := CASE WHEN dbms_utility.is_cluster_database = TRU

E THEN 1 ELSE 0 END; -- inst_id and sid togetheroutput_time number := 0; -- time of snapshot startoutput_seconds number := 0; -- seconds in snapshot (shown in footer of ea

ch snapshot too)output_stype number := 1; -- statistic type (WAIT,STAT,TIME,ENQG,LATG,.

..)

output_sname number := 1; -- statistic nameoutput_delta number := 1; -- raw deltaoutput_delta_s number := 0; -- raw delta normalized to per secondoutput_hdelta number := 0; -- human readable deltaoutput_hdelta_s number := 1; -- human readable delta normalized to per sec

ondoutput_percent number := 1; -- percent of total time/samplesoutput_eventcnt number := 1; -- wait event countoutput_eventcnt_s number := 1; -- wait event countoutput_eventavg number := 1; -- average wait durationoutput_pcthist number := 1; -- percent of total visual bar (histogram) --

Histograms seem to work for me on 9.2.0.7 + - JBJ2)

-- column widths in ASH report outputw_inst_id number := 4;w_sid number := 6;w_username number := 20;w_machine number := 20;w_terminal number := 20;w_program number := 25;w_event number := 35;w_wait_class number := 15;w_state number := 8;w_p1 number := 20;w_p2 number := 20;w_p3 number := 20;

w_row_wait_obj# number := 10;w_row_wait_file# number := 6;w_row_wait_block# number := 10;w_row_wait_row# number := 6;w_blocking_session_status number := 15;w_blocking_instance number := 12;w_blocking_session number := 12;w_sql_hash_value number := 12;w_sql_id number := 15;w_sql_child_number number := 9;


14/52

w_plsql_entry_object_id number := 10;w_plsql_entry_subprogram_id number := 10;w_plsql_object_id number := 10;w_plsql_subprogram_id number := 10;w_module number := 25;w_action number := 25;w_client_identifier number := 25;w_service_name number := 25;

w_activity_pct number := 7;

-- END CONFIGURABLE STUFF --

-- constants for ash collection extraction from the vc2 collections_inst_id constant number := 1 ;s_sid constant number := 2 ;s_username constant number := 3 ;s_machine constant number := 4 ;s_terminal constant number := 5 ;s_program constant number := 6 ;s_event constant number := 7 ;s_wait_class constant number := 8 ;s_state constant number := 9 ;s_p1 constant number := 10 ;

s_p2 constant number := 11 ;s_p3 constant number := 12 ;s_row_wait_obj# constant number := 13 ;s_row_wait_file# constant number := 14 ;s_row_wait_block# constant number := 15 ;s_row_wait_row# constant number := 16 ;s_blocking_session_status constant number := 17 ;s_blocking_instance constant number := 18 ;s_blocking_session constant number := 19 ;s_sql_hash_value constant number := 20 ;s_sql_id constant number := 21 ;s_sql_child_number constant number := 22 ;s_plsql_entry_object_id constant number := 23 ;

s_plsql_entry_subprogram_id constant number := 24 ;s_plsql_object_id constant number := 25 ;s_plsql_subprogram_id constant number := 26 ;s_module constant number := 27 ;s_action constant number := 28 ;s_client_identifier constant number := 29 ;s_service_name constant number := 30 ;

-- constants for ash collection reporting, which columns to show in reportc_inst_id constant number := power(2, s_inst_id

);c_sid constant number := power(2, s_sid

);

c_username constant number := power(2, s_username);c_machine constant number := power(2, s_machine

);c_terminal constant number := power(2, s_terminal

);c_program constant number := power(2, s_program

);c_event constant number := power(2, s_event

);


15/52

c_wait_class constant number := power(2, s_wait_class);

c_state constant number := power(2, s_state);

c_p1 constant number := power(2, s_p1);



c_row_wait_obj# constant number := power(2, s_row_wait_obj#);

c_row_wait_file# constant number := power(2, s_row_wait_file#);

c_row_wait_block# constant number := power(2, s_row_wait_block#);

c_row_wait_row# constant number := power(2, s_row_wait_row#);

c_blocking_session_status constant number := power(2, s_blocking_session_status );

c_blocking_instance constant number := power(2, s_blocking_instance );

c_blocking_session constant number := power(2, s_blocking_session );

c_sql_hash_value constant number := power(2, s_sql_hash_value);c_sql_id constant number := power(2, s_sql_id

);c_sql_child_number constant number := power(2, s_sql_child_numbe

r );c_plsql_entry_object_id constant number := power(2, s_plsql_entry_obj

ect_id );c_plsql_entry_subprogram_id constant number := power(2, s_plsql_entry_sub

program_id);c_plsql_object_id constant number := power(2, s_plsql_object_id

);c_plsql_subprogram_id constant number := power(2, s_plsql_subprogra

m_id );c_module constant number := power(2, s_module);

c_action constant number := power(2, s_action);

c_client_identifier constant number := power(2, s_client_identifier );

c_service_name constant number := power(2, s_service_name);

/*----------------------------------------------------- proc for outputting data to trace or dbms_output

---------------------------------------------------*/procedure output(p_txt in varchar2) isbegin

if (getopt('&snapper_options', 'out') is not null)or(getopt('&snapper_options', 'out') is null and getopt('&snapper_optio

ns', 'trace') is null)then

dbms_output.put_line(p_txt);


16/52

end if;

-- The block below is a sqlplus trick for conditionally commenting out PL/SQL code

&_IF_DBMS_SYSTEM_ACCESSIBLEif getopt('&snapper_options', 'trace') is not null then

sys.dbms_system.ksdwrt(1, p_txt);sys.dbms_system.ksdfls;

end if;-- */

end; -- output

/*----------------------------------------------------- function for converting interval datatype to microseconds---------------------------------------------------*/function get_seconds(i interval day to second) return numberasbegin

return to_number(extract(second from i)) +to_number(extract(minute from i)) * 60 +to_number(extract(hour from i)) * 60 * 60 +to_number(extract(day from i)) * 60 * 60 * 24;

end get_seconds;

/*----------------------------------------------------- proc for outputting data, utilizing global vars---------------------------------------------------*/procedure fout is

l_output_username VARCHAR2(100);gsid varchar2(20);

begin--if s2(b).stype='WAIT' then output( 'DEBUG WAIT ' || sn(s2(b).statistic

#).name || ' ' || delta ); end if;--output( 'DEBUG, Entering fout(), b='||to_char(b)||' sn(s2(b).statistic

#='||s2(b).statistic# );--output( 'DEBUG, In fout(), a='||to_char(a)||' b='||to_char(b)||' s1.co

unt='||s1.count||' s2.count='||s2.count||' s2.count='||s2.count);

gsid := trim(to_char(s2(b).inst_id))||','||trim(to_char(s2(b).sid));

if output_username = 1 thenbegin

l_output_username := nvl( g_sessions(gsid).username, substr(g_sessions(gsid).program, instr(g_sessions(gsid).program,'(')) );

exceptionwhen no_data_found then l_output_username := 'error';when others then raise;

end;end if;

-- DEBUG--output('before');--output (CASE WHEN output_eventavg = 1 THEN CASE WHEN s2(b).stype IN

('WAIT') THEN lpad(tptformat(delta / CASE WHEN evcnt = 0 THEN 1 ELSE evcnt END,s2(b).stype), 10, ' ')||' average wait' ELSE get_useful_average(s2(b), s1(a)) END END);

--output('after');

output( CASE WHEN output_header = 1 THEN 'SID= ' END|| CASE WHEN output_inst = 1 THEN to_char(s2(b).inst_id, '99


17/52

99')||', ' END|| CASE WHEN output_sid = 1 THEN to_char(s2(b).sid,'999999'

)||', ' END|| CASE WHEN output_inst_sid = 1 THEN to_char(s2(b).sid,'99999')

||' '||lpad('@'||trim(to_char(s2(b).inst_id, '99')),3)||', ' END|| CASE WHEN output_username = 1 THEN rpad(CASE s2(b).sid WHEN -

1 THEN ' ' ELSE NVL(l_output_username, ' ') END, 10)||', ' END|| CASE WHEN output_time = 1 THEN to_char(d1, 'YYYYMMDD HH24

:MI:SS')||', ' END|| CASE WHEN output_seconds = 1 THEN to_char(case get_seconds(d

2-d1) when 0 then &snapper_sleep else get_seconds(d2-d1) end, '9999999')||', ' END

|| CASE WHEN output_stype = 1 THEN s2(b).stype||', ' END|| CASE WHEN output_sname = 1 THEN rpad(sn(s2(b).statistic#).

name, 58, ' ')||', ' END|| CASE WHEN output_delta = 1 THEN to_char(delta, '9999999999

99')||', ' END|| CASE WHEN output_delta_s = 1 THEN to_char(delta/(case get_se

conds(d2-d1) when 0 then &snapper_sleep else get_seconds(d2-d1) end),'999999999')||', ' END

|| CASE WHEN output_hdelta = 1 THEN lpad(tptformat(delta, s2(b).stype), 10, ' ')||', ' END

|| CASE WHEN output_hdelta_s = 1 THEN lpad(tptformat(delta/(caseget_seconds(d2-d1) when 0 then &snapper_sleep else get_seconds(d2-d1) end ), s2

(b).stype), 10, ' ')||', ' END|| CASE WHEN output_percent = 1 THEN CASE WHEN s2(b).stype IN ('TIME','WAIT') THEN to_char(delta/CASE get_seconds(d2-d1) WHEN 0 THEN &snapper_sleep ELSE get_seconds(d2-d1) END / 10000, '9999.9')||'%' ELSE ' ' END END||', '

|| CASE WHEN output_pcthist = 1 THEN CASE WHEN s2(b).stype IN ('TIME','WAIT') THEN rpad(rpad('[', ceil(round(delta/CASE get_seconds(d2-d1) WHEN0 THEN &snapper_sleep ELSE get_seconds(d2-d1) END / 100000,1))+1, CASE WHEN s2(b).stype IN ('WAIT') THEN 'W' WHEN sn(s2(b).statistic#).name = 'DB CPU' THEN '@'ELSE '#' END),11,' ')||']' ELSE ' ' END END||', '

|| CASE WHEN output_eventcnt = 1 THEN CASE WHEN s2(b).stype IN ('WAIT') THEN to_char(evcnt, '99999999') ELSE ' ' END END||', '

|| CASE WHEN output_eventcnt_s = 1 THEN CASE WHEN s2(b).stype IN (

'WAIT') THEN lpad(tptformat((evcnt / case get_seconds(d2-d1) when 0 then &snapper_sleep else get_seconds(d2-d1) end ), 'STAT' ), 10, ' ') ELSE ' ' ENDEND||', '

|| CASE WHEN output_eventavg = 1 THEN CASE WHEN s2(b).stype IN ('WAIT') THEN lpad(tptformat(delta / CASE WHEN evcnt = 0 THEN 1 ELSE evcnt END, s2(b).stype), 10, ' ')||' average wait' ELSE get_useful_average(s2(b), s1(a)) ENDEND

);

end;

/*---------------------------------------------------

-- lookup stat delta helper calculator (l2.value - l1.value)---------------------------------------------------*/function get_delta(metric_id in varchar2) return numberis

rec1 srec;rec2 srec;

val1 number;val2 number;


18/52

d number;begin

beginval1 := l1(metric_id).value;

exceptionwhen no_data_found then val1 := 0;

end;

beginval2 := l2(metric_id).value;

exceptionwhen no_data_found then val2 := 0;

end;

d := val2 - NVL(val1, 0);return d;

end get_delta;

/*----------------------------------------------------- delta helper function for convenience - it allows to specify any metric de

lta, if not specified then get current one---------------------------------------------------*/function gd(c in srec, metric_type in varchar2 DEFAULT NULL, metric_name in

varchar2 DEFAULT NULL) return number

is str varchar2(1000);tmp_delta number;

beginif metric_type || metric_name is null then

str := c.stype||','||trim(to_char(c.inst_id))||','||trim(to_char(c.sid))||','||trim(to_char(c.statistic#,'999999999999999999999999'));

elsebegin

str := trim(metric_type)||','||trim(to_char(c.inst_id))||','||trim(to_char(c.sid))||','||trim(to_char(sn_reverse(metric_type||','||metric_name).statistic#));

exception

when no_data_found then return 0;end;end if;tmp_delta := get_delta(str);--output('tmp_delta '||c.stype||' '||tmp_delta);return tmp_delta;-- return get_delta(str);

end;

/*----------------------------------------------------- function for calculating useful averages and ratios between metrics---------------------------------------------------*/function get_useful_average(c in srec /* curr_metric */, p in srec /* all_pr

ev_metrics */) return varchar2isret varchar2(1000);mt varchar2(100) := c.stype; -- metric_typemn varchar2(100) := sn(c.statistic#).name; -- metric_name

begincasewhen mt = 'STAT' thencasewhen mn = 'bytes sent via SQL*Net to client' then ret := l


19/52

pad( tptformat(gd(c) / nullif(gd(c, 'STAT', 'SQL*Net roundtrips to/from client'),0), mt), 10) || ' bytes per roundtrip' ;

when mn = 'bytes receive via SQL*Net from client' then ret := lpad( tptformat(gd(c) / nullif(gd(c, 'STAT', 'SQL*Net roundtrips to/from client'),0), mt), 10) || ' bytes per roundtrip' ;

when mn = 'redo size' then ret := lpad( tptformat(gd(c) / nullif(gd(c, 'STAT', 'user commits' ),0), mt), 10) || ' bytes per user commit';

when mn = 'execute count' then ret := lpad( tptformat(gd(c) / nullif(gd(c, 'STAT', 'parse count (total)' ),0), mt), 10) || ' executions per parse';

when mn = 'parse count (total)' then ret := lpad( tptformat(gd(c) / nullif(gd(c, 'STAT', 'parse count (hard)' ),0), mt), 10) || ' softparses per hardparse';

when mn = 'session cursor cache hits' then ret := lpad( tptformat(gd(c) - (gd(c, 'STAT', 'parse count (total)' )), mt), 10) || ' softparses avoided thanks to cursor cache';

when mn = 'session logical reads' then ret := lpad( tptformat(gd(c) + (gd(c, 'STAT', 'buffer is pinned count' )), mt), 10) || ' total buffer visits';

when mn = 'buffer is pinned count' then ret := lpad( tptformat(gd(c) / nullif(gd(c) + gd(c, 'STAT', 'session logical reads'),0)* 100, mt), 10) || ' % buffer gets avoided thanks to buffer pin caching';

else ret := l

pad( tptformat(gd(c) / nullif(gd(c, 'STAT', 'execute count'),0), mt), 10) || ' per execution' ;end case; -- mt=stat, mn

when mt = 'TIME' then-- this is ugly and wrong at the moment - will refactor some daycasewhen mn = 'DB time' then ret := l

pad(tptformat(get_seconds(d2 - d1)*1000000 - gd(c) - nullif(gd(c, 'DB CPU', 'TIME')

- gd(c, 'WAIT', 'pmon timer')

- gd(c, 'WAIT', 'VKTM Logical Idle Wait')

- gd(c, 'WAIT', 'VKTM Init Wait for GSGA')

- gd(c, 'WAIT', 'IORM Scheduler Slave Idle Wait')

- gd(c, 'WAIT', 'rdbms ipc message')

- gd(c, 'WAIT', 'i/o slave wait')

- gd(c, 'WAIT', 'VKRM Idle')

- gd(c, 'WAIT', 'wait for unread message on broadcast channel')

- gd(c, 'WAIT', 'wait for unread message on multiplebroadcast channels')

- gd(c, 'WAIT', 'class slave wait')

- gd(c, 'WAIT', 'KSV master wait')

- gd(c, 'WAIT', 'PING')


20/52

- gd(c, 'WAIT', 'watchdog main loop')

- gd(c, 'WAIT', 'DIAG idle wait')

- gd(c, 'WAIT', 'ges remote message')

- gd(c, 'WAIT', 'gcs remote message')

- gd(c, 'WAIT', 'heartbeat monitor sleep')

- gd(c, 'WAIT', 'GCR sleep')

- gd(c, 'WAIT', 'SGA: MMAN sleep for component shrink')

- gd(c, 'WAIT', 'MRP redo arrival')

- gd(c, 'WAIT', 'LNS ASYNC archive log')

- gd(c, 'WAIT', 'LNS ASYNC dest activation')

- gd(c, 'WAIT', 'LNS ASYNC end of log')

- gd(c, 'WAIT', 'simulated log write delay')

- gd(c, 'WAIT', 'LGWR real time apply sync')

- gd(c, 'WAIT', 'parallel recovery slave idle wait')

- gd(c, 'WAIT', 'LogMiner builder: idle')

- gd(c, 'WAIT', 'LogMiner builder: branch')

- gd(c, 'WAIT', 'LogMiner preparer: idle')

- gd(c, 'WAIT', 'LogMiner reader: log (idle)')

- gd(c, 'WAIT', 'LogMiner reader: redo (idle)')- gd(c, 'WAIT', 'LogMiner client: transaction')

- gd(c, 'WAIT', 'LogMiner: other')

- gd(c, 'WAIT', 'LogMiner: activate')

- gd(c, 'WAIT', 'LogMiner: reset')

- gd(c, 'WAIT', 'LogMiner: find session')

- gd(c, 'WAIT', 'LogMiner: internal')

- gd(c, 'WAIT', 'Logical Standby Apply Delay')

- gd(c, 'WAIT', 'parallel recovery coordinator waitsfor slave cleanup')

- gd(c, 'WAIT', 'parallel recovery control message reply')

- gd(c, 'WAIT', 'parallel recovery slave next change


21/52

')

- gd(c, 'WAIT', 'PX Deq: Txn Recovery Start')

- gd(c, 'WAIT', 'PX Deq: Txn Recovery Reply')

- gd(c, 'WAIT', 'fbar timer')

- gd(c, 'WAIT', 'smon timer')

- gd(c, 'WAIT', 'PX Deq: Metadata Update')

- gd(c, 'WAIT', 'Space Manager: slave idle wait')

- gd(c, 'WAIT', 'PX Deq: Index Merge Reply')

- gd(c, 'WAIT', 'PX Deq: Index Merge Execute')

- gd(c, 'WAIT', 'PX Deq: Index Merge Close')

- gd(c, 'WAIT', 'PX Deq: kdcph_mai')

- gd(c, 'WAIT', 'PX Deq: kdcphc_ack')

- gd(c, 'WAIT', 'shared server idle wait')- gd(c, 'WAIT', 'dispatcher timer')

- gd(c, 'WAIT', 'cmon timer')

- gd(c, 'WAIT', 'pool server timer')

- gd(c, 'WAIT', 'JOX Jit Process Sleep')

- gd(c, 'WAIT', 'jobq slave wait')

- gd(c, 'WAIT', 'pipe get')

- gd(c, 'WAIT', 'PX Deque wait')

- gd(c, 'WAIT', 'PX Idle Wait')

- gd(c, 'WAIT', 'PX Deq: Join ACK')

- gd(c, 'WAIT', 'PX Deq Credit: need buffer')

- gd(c, 'WAIT', 'PX Deq Credit: send blkd')

- gd(c, 'WAIT', 'PX Deq: Msg Fragment')

- gd(c, 'WAIT', 'PX Deq: Parse Reply')- gd(c, 'WAIT', 'PX Deq: Execute Reply')

- gd(c, 'WAIT', 'PX Deq: Execution Msg')

- gd(c, 'WAIT', 'PX Deq: Table Q Normal')

- gd(c, 'WAIT', 'PX Deq: Table Q Sample')


22/52

- gd(c, 'WAIT', 'Streams fetch slave: waiting for txns')

- gd(c, 'WAIT', 'Streams: waiting for messages')

- gd(c, 'WAIT', 'Streams capture: waiting for archive log')

- gd(c, 'WAIT', 'single-task message')

- gd(c, 'WAIT', 'SQL*Net message from client')

- gd(c, 'WAIT', 'SQL*Net vector message from client')

- gd(c, 'WAIT', 'SQL*Net vector message from dblink')

- gd(c, 'WAIT', 'PL/SQL lock timer')

- gd(c, 'WAIT', 'Streams AQ: emn coordinator idle wait')

- gd(c, 'WAIT', 'EMON slave idle wait')

- gd(c, 'WAIT', 'Streams AQ: waiting for messages inthe queue')

- gd(c, 'WAIT', 'Streams AQ: waiting for time management or cleanup tasks')

- gd(c, 'WAIT', 'Streams AQ: delete acknowledged messages')

- gd(c, 'WAIT', 'Streams AQ: deallocate messages from Streams Pool')

- gd(c, 'WAIT', 'Streams AQ: qmn coordinator idle wait')

- gd(c, 'WAIT', 'Streams AQ: qmn slave idle wait')

- gd(c, 'WAIT', 'Streams AQ: RAC qmn coordinator idle wait')

- gd(c, 'WAIT', 'HS message to agent')

- gd(c, 'WAIT', 'ASM background timer')

- gd(c, 'WAIT', 'auto-sqltune: wait graph update')

- gd(c, 'WAIT', 'WCR: replay client notify')

- gd(c, 'WAIT', 'WCR: replay clock')

- gd(c, 'WAIT', 'WCR: replay paused')

- gd(c, 'WAIT', 'JS external job')

- gd(c, 'WAIT', 'cell worker idle')


23/52

,0) , mt), 10) || ' unaccounted time' ;

else null;end case; -- mt=time, mn

else null;end case; -- mt

return ret;end get_useful_average;

/*----------------------------------------------------- function for converting large numbers to human-readable format---------------------------------------------------*/function tptformat( p_num in number,

p_stype in varchar2 default 'STAT',p_precision in number default 2,p_base in number default 10, -- for KiB/MiB formattin

g usep_grouplen in number default 3 -- p_base=2 and p_groupl

en=10)return varchar2

isbegin

if p_num = 0 then return '0'; end if;

if p_num IS NULL then return '~'; end if;if p_stype in ('WAIT','TIME') then

returnround(

p_num / power( p_base , trunc(log(p_base,abs(p_num)))-trunc(mod(log(p_base,abs(p_num)),p_grouplen)) ), p_precision

)|| case trunc(log(p_base,abs(p_num)))-trunc(mod(log(p_base,abs(p

_num)),p_grouplen))when 0 then 'us'when 1 then 'us'

when p_grouplen*1 then 'ms'when p_grouplen*2 then 's'when p_grouplen*3 then 'ks'when p_grouplen*4 then 'Ms'else '*'||p_base||'^'||to_char( trunc(log(p_base,abs(p_nu

m)))-trunc(mod(log(p_base,abs(p_num)),p_grouplen)) )||' us'end;

else

returnround(

p_num / power( p_base , trunc(log(p_base,abs(p_num)))-trunc(

mod(log(p_base,abs(p_num)),p_grouplen)) ), p_precision)|| case trunc(log(p_base,abs(p_num)))-trunc(mod(log(p_base,abs(p

_num)),p_grouplen))when 0 then ''when 1 then ''when p_grouplen*1 then 'k'when p_grouplen*2 then 'M'when p_grouplen*3 then 'G'when p_grouplen*4 then 'T'


24/52

when p_grouplen*5 then 'P'when p_grouplen*6 then 'E'else '*'||p_base||'^'||to_char( trunc(log(p_base,abs(p_nu

m)))-trunc(mod(log(p_base,abs(p_num)),p_grouplen)) )end;

end if;

end; -- tptformat

/*----------------------------------------------------- simple function for parsing arguments from parameter string---------------------------------------------------*/function getopt( p_parvalues in varchar2,

p_extract in varchar2,p_delim in varchar2 default ','

) return varchar2is

ret varchar(1000) := NULL;begin

-- dbms_output.put('p_parvalues = ['||p_parvalues||'] ' );-- dbms_output.put('p_extract = ['||p_extract||'] ' );

if lower(p_parvalues) like lower(p_extract)||'%'or lower(p_parvalues) like '%'||p_delim||lower(p_extract)||'%' then

ret :=nvl (

substr(p_parvalues,instr(p_parvalues, p_extract)+length(p_extract),case

instr(substr(p_parvalues,

instr(p_parvalues, p_extract)+length(p_extract)

)

, p_delim)when 0 then length(p_parvalues)else

instr(substr(p_parvalues,

instr(p_parvalues, p_extract)+length(p_extract)

), p_delim

) - 1end

)

, chr(0) -- in case parameter was specified but with no value);

elseret := null; -- no parameter found

end if;

-- dbms_output.put_line('ret = ['||replace(ret,chr(0),'\0')||']');


25/52

return ret;

end; -- getopt

/*----------------------------------------------------- proc for getting session list with username, osuser, machine etc---------------------------------------------------*/procedure get_sessions is

tmp_sessions tmp_sestab;begin

select /*+ unnest */ /* get_session_list:1 */*

bulk collect intotmp_sessions

fromgv$session s

where1=1

and (&sid_filter

) ;--(inst_id,sid) in (&snapper_sid);

g_sessions := g_empty_sessions;for i in 1..tmp_sessions.count loop

g_sessions(tmp_sessions(i).inst_id||','||tmp_sessions(i).sid) := tmp_sessions(i);

end loop;

end; -- get_sessions

/*----------------------------------------------------- function for getting session list with username, osuser, machine etc-- this func does not update the g_sessions global array but returns session

info as return value

---------------------------------------------------*/function get_sessions return sestab istmp_sessions tmp_sestab;l_return_sessions sestab;

begin

select /*+ unnest */ /* get_session_list:2 */*

bulk collect intotmp_sessions

fromgv$session s

where

1=1and (&sid_filter) ;--(inst_id,sid) in (&snapper_sid);

for i in 1..tmp_sessions.count loop--output('get_sessions i='||i||' sid='||tmp_sessions(i).sid);l_return_sessions(tmp_sessions(i).inst_id||','||tmp_sessions(i).sid)

:= tmp_sessions(i);end loop;


26/52

return l_return_sessions;

end; -- get_sessions

/*----------------------------------------------------- functions for extracting and converting gv$session-- records to varchar2---------------------------------------------------*/function sitem(p in varchar2) return varchar2 asbegin

return '';end; -- sitem varchar2

function sitem(p in number) return varchar2 asbegin

return '';end; -- sitem number

function sitem(p in date) return varchar2 asbegin

return '';end; -- sitem date

function sitem_raw(p in raw) return varchar2 asbegin

return '';end; -- sitem_raw

/*----------------------------------------------------- proc for resetting the snapper ash array---------------------------------------------------*/procedure reset_ash isbegin

g_ash_samples_taken := 0;

-- clear g_ashg_ash := new sys.dbms_debug_vc2coll();end; -- reset_ash

/*----------------------------------------------------- proc for getting ash style samples from gv$session---------------------------------------------------*/procedure extract_ash is

ash_i varchar2(30);s gv$session%rowtype;

begin

-- keep track how many times we sampled gv$session so we could calculateaverages later ong_ash_samples_taken := g_ash_samples_taken + 1;--output('g_sessions.count='||g_sessions.count);ash_i := g_sessions.first;

while ash_i is not null loop

s := g_sessions(ash_i);if -- active, on cpu


27/52

(s.status = 'ACTIVE' and s.state != 'WAITING' and s.sid != g_mysid)

or -- active, waiting for non-idle wait(s.status = 'ACTIVE' and s.state = 'WAITING' and s.wait_class != '

Idle' and s.sid != g_mysid)then

--output('extract_ash: i='||i||' sid='||s.sid||' hv='||s.sql_hash_value||' sqlid='||s.sql_id);

-- if not actually waiting for anything, clear the past wait eventdetails

if s.state != 'WAITING' thens.state:='ON CPU';s.event:='ON CPU';s.wait_class:='ON CPU'; --TODO: What do we need to do for 9i he

re?s.p1:=NULL;s.p2:=NULL;s.p3:=NULL;

end if;

g_ash.extend;

-- max length 1000 bytes (due to dbms_debug_vc2coll)g_ash(g_ash.count) := substr(

sitem(s.inst_id) -- 1||sitem(s.sid) -- 2||sitem(s.username) -- 3 -- 30 byte

s||sitem(s.machine) -- 4 -- 64 byte

s||sitem(s.terminal) -- 5 -- 30 byte

s||sitem(s.program) -- 6 -- 48 byte

s||sitem(s.event) -- 7 -- 64 byte

s||sitem(s.wait_class) -- 8 -- 64 byte

s, 10g+ ||sitem(s.state) -- 9||sitem(s.p1) -- 10||sitem(s.p2) -- 11||sitem(s.p3) -- 12||sitem(s.row_wait_obj#) -- 13||sitem(s.row_wait_file#) -- 14||sitem(s.row_wait_block#) -- 15||sitem(s.row_wait_row#) -- 16||sitem(s.blocking_session_status) -- 17 -- 10g+

&_NO_BLK_INST ||sitem('N/A') -- 17 -- 10gR2+&_YES_BLK_INST ||sitem(s.blocking_instance) -- 18 -- 10gR2+

||sitem(s.blocking_session) -- 19 -- 10g+

||sitem(s.sql_hash_value) -- 20||sitem(s.sql_id) -- 21 -- 10g+||sitem(s.sql_child_number) -- 22 -- 10g+

&_NO_PLSQL_OBJ_ID ||sitem('N/A') -- 23&_NO_PLSQL_OBJ_ID ||sitem('N/A') -- 24&_NO_PLSQL_OBJ_ID ||sitem('N/A') -- 25&_NO_PLSQL_OBJ_ID ||sitem('N/A') -- 22&_YES_PLSQL_OBJ_ID ||sitem(s.plsql_entry_object_id) -- 23&_YES_PLSQL_OBJ_ID ||sitem(s.plsql_entry_subprogram_id) -- 24&_YES_PLSQL_OBJ_ID ||sitem(s.plsql_object_id) -- 25


28/52

&_YES_PLSQL_OBJ_ID ||sitem(s.plsql_subprogram_id) -- 26||sitem(s.module) -- 27 -- 48 byte

s||sitem(s.action) -- 28 -- 32 byte

s||sitem(s.client_identifier) -- 29 -- 64 byte

s||sitem(s.service_name) -- 30 -- 64 byte

s, 10g+, 1, 1000);

end if; -- sample is of an active session

ash_i := g_sessions.next(ash_i);

end loop;

exceptionwhen no_data_found then output('error in extract_ash(): no_data_found for

item '||i);end; -- extract_ash

/*---------------------------------------------------

-- proc for querying performance data into collections---------------------------------------------------*/procedure snap( p_snapdate out timestamp, p_stats out stab, l_stats out ltab,

p_stats_string out sys.dbms_debug_vc2coll) is

lv_include_stat varchar2(1000) := nvl( lower(getopt('&snapper_options','sinclude=' )), '%');

lv_include_latch varchar2(1000) := nvl( lower(getopt('&snapper_options','linclude=' )), '%');

lv_include_time varchar2(1000) := nvl( lower(getopt('&snapper_options','tinclude=' )), '%');

lv_include_wait varchar2(1000) := nvl( lower(getopt('&snapper_options','winclude=' )), '%');

lstr varchar2(1000);

begin

p_snapdate := systimestamp;

select /* get_session_stats */ p_snapdate ts, snapper_stats.*bulk collect into p_statsfrom (

select 'STAT' stype, s.inst_id, s.sid,ss.statistic# - pls_adjust statistic#, ss.value, null event_count

from gv$session s, gv$sesstat ss

where &sid_filter --(inst_id,sid) in (&snapper_sid)and s.inst_id = ss.inst_idand s.sid = ss.sidand (lv_gather like '%s%' or lv_gather

like '%a%')and ss.statistic# in (select /*+ no_unn

est */ statistic# from v$statnamewhere lower(name) li

ke '%'||lv_include_stat||'%'


29/52

or regexp_like (name, lv_include_stat, 'i')

)--union allselect

'WAIT', s.inst_id, s.sid,en.event# + (select count(*) fro

m v$statname) + 1 - pls_adjust,nvl(se.time_waited_micro,0) + (

decode(se.event||s.state, s.event||'WAITING', s.seconds_in_wait, 0) * 1000000 )value, total_waits event_count

from gv$session s, gv$session_event se,v$event_name en

where &sid_filterand s.sid = se.sidand s.inst_id = se.inst_idand se.event = en.name--and (se.inst_id, se.sid) in (&snapp

er_sid)and (lv_gather like '%w%' or lv_gathe

r like '%a%')and en.event# in (select event# from

v$event_name

where lower(name) like '%'||lv_include_wait||'%'or regexp_like (n

ame, lv_include_wait, 'i'))

--union allselect 'TIME' stype, s.inst_id, s.sid,

st.stat_id - pls_adjust statistic#, st.value, null event_countfrom gv$session s, gv$sess_time_model s

twhere &sid_filter --(inst_id,sid) in (&

snapper_sid)

and s.inst_id = st.inst_idand s.sid = st.sidand (lv_gather like '%t%' or lv_gathe

r like '%a%')and st.stat_id in (select stat_id from

gv$sys_time_modelwhere lower(stat_nam

e) like '%'||lv_include_time||'%'or regexp_like (s

tat_name, lv_include_time, 'i'))

--union all

select 'LATG', s.inst_id, -1 sid,s.latch# +(select count(*) from v$statn

ame) +(select count(*) from v$event

_name) +1 - pls_adjust statistic#,

s.gets + s.immediate_gets value,null event_count

from gv$latch s


30/52

where &inst_filterand (lv_gather like '%l%' or lv_gather

like '%a%')and latch# in (select latch# from v$lat

chnamewhere lower(name) like '

%'||lv_include_latch||'%'or regexp_like (name,

lv_include_latch, 'i'))

--&_IF_X_ACCESSIBLE &_IF_LOWER_THAN_ORA11 union all&_IF_X_ACCESSIBLE &_IF_LOWER_THAN_ORA11 select 'BUFG', to_number(sys_context('userenv', 'instance')), -1 sid,&_IF_X_ACCESSIBLE &_IF_LOWER_THAN_ORA11 s.indx +&_IF_X_ACCESSIBLE &_IF_LOWER_THAN_ORA11 (select count(*) from v$statname) +&_IF_X_ACCESSIBLE &_IF_LOWER_THAN_ORA11 (select count(*) from v$event

_name) +&_IF_X_ACCESSIBLE &_IF_LOWER_THAN_ORA11 (select count(*) from gv$latch) +&_IF_X_ACCESSIBLE &_IF_LOWER_THAN_ORA11 1 - pls_adjust statistic#,&_IF_X_ACCESSIBLE &_IF_LOWER_THAN_ORA11 s.why0+s.why1+s.why2 value, nullevent_count

&_IF_X_ACCESSIBLE &_IF_LOWER_THAN_ORA11 from x$kcbsw s, x$kcbwh w&_IF_X_ACCESSIBLE &_IF_LOWER_THAN_ORA11 where&_IF_X_ACCESSIBLE &_IF_LOWER_THAN_ORA11 s.indx = w.indx&_IF_X_ACCESSIBLE &_IF_LOWER_THAN_ORA11 and s.why0+s.why1+s.why2 > 0&_IF_X_ACCESSIBLE &_IF_LOWER_THAN_ORA11 and (lv_gather like '%b%' or lv_gather like '%a%')

--&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER union all&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER select 'BUFG', to_number(sys_context('userenv', 'instance')), -1 sid,&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER sw.indx +&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER (select count(*) from v$statname) +

&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER (select count(*) from v$event_name) +&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER (select count(*) from gv$latch) +&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER 1 - pls_adjust statistic#,&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER why.why0+why.why1+why.why2+sw.other_wait value, null event_count&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER from&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER x$kcbuwhy why,&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER x$kcbwh dsc,&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER x$kcbsw sw&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER where&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER why.indx = dsc.indx

&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER and why.inst_id = dsc.inst_id&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER and dsc.inst_id = sw.inst_id&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER and why.inst_id = sw.inst_id&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER and why.why0 + why.why1 + why.why2 +sw.other_wait > 0&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER and dsc.indx = sw.indx&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER and why.indx = sw.indx&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER -- deliberate cartesian join&_IF_X_ACCESSIBLE &_IF_ORA11_OR_HIGHER and (lv_gather like '%b%' or lv_gather like '%a%')


31/52

--union allselect 'ENQG', s.inst_id, -1 sid,

ascii(substr(s.eq_type,1,1))*256+ ascii(substr(s.eq_type,2,1)) +

(select count(*) from v$statname) +

(select count(*) from v$event_name) +

(select count(*) from gv$latch) +&_IF_X_ACCESSIBLE (select count(*) from x$kcbwh

) +1 - pls_adjust statistic#,

s.total_req# value, null event_count

from gv$enqueue_stat swhere &inst_filterand (lv_gather like '%e%' or lv_gathe

r like '%a%')) snapper_statsorder by inst_id, sid, stype, statistic#;

if p_stats.COUNT > 0 then

-- l_stats is an associative array for stats lookup, used for the useful averages calculation-- p_stats_string is a dbms_debug_vc2coll collection datatype for "p

ersisting" stats values across snapper DB calls (for "before" and "after" snaps)p_stats_string := sys.dbms_debug_vc2coll();for s in p_stats.first..p_stats.last loop

-- type srec is record (stype varchar2(4), sid number, statistic# number, value number, event_count number );

lstr := p_stats(s).stype||','||trim(to_char(p_stats(s).inst_id))||','||trim(to_char(p_stats(s).sid))||','||trim(to_char(p_stats(s).statistic#,'999999999999999999999999'));

l_stats(lstr) := p_stats(s);

if g_snap_begin is not null thenp_stats_string.extend();p_stats_string(s) := TO_CHAR(p_stats(s).ts, 'YYYY-MM-DD HH24

:MI:SS.FF') ||','||p_stats(s).stype

||','||TO_CHAR(p_stats(s).inst_id)

||','||TO_CHAR(p_stats(s).sid)

||','||TRIM(TO_CHAR(p_stats(s).statistic#, '99

9999999999999999999999'))||','||TRIM(TO_CHAR(p_stats(s).value, '99

9999999999999999999999'))||','|| TRIM(TO_CHAR(p_stats(s).event_count,'999999999999999999999999'));

--output('p_stats.p_stats_string='||p_stats_string(s));end if;

end loop; -- s in (p_stats)end if; -- p.stats.COUNT > 0

end snap;


32/52

/*----------------------------------------------------- proc for reversing the string-normalized-- stats array into lookup tables/collections---------------------------------------------------*/procedure snap_from_stats_string (p_string_stats in sys.dbms_debug_vc2coll, p

_snapdate out timestamp, p_stats out stab, l_stats out ltab)islstr varchar2(1000);lv_rec srec;

beginp_snapdate := NULL;--type srec is record (stype varchar2(4), sid number, statistic# number,

value number, event_count number );for s in p_string_stats.first .. p_string_stats.last loop

lv_rec.ts := TO_TIMESTAMP(replace(regexp_substr(p_string_stats(s)||',', '(.*?),', 1, 1),',',''), 'YYYY-MM-DD HH24:MI:SS.FF');

lv_rec.stype := replace(regexp_substr(p_string_stats(s)||',', '(.*?),', 1, 2),',','');

lv_rec.inst_id := TO_NUMBER(replace(regexp_substr(p_string_stats(s)||',', '(.*?),', 1, 3),',',''));

lv_rec.sid := TO_NUMBER(replace(regexp_substr(p_string_stats(s)||',', '(.*?),', 1, 4),',',''));

lv_rec.statistic# := TO_NUMBER(replace(regexp_substr(p_string_stats(s)||',', '(.*?),', 1, 5),',',''));

lv_rec.value := TO_NUMBER(replace(regexp_substr(p_string_stats(s)||',', '(.*?),', 1, 6),',',''));lv_rec.event_count := TO_NUMBER(replace(regexp_substr(p_string_sta

ts(s)||',', '(.*?),', 1, 7),',',''));--output('snap_from_stats_string.event_count = '||to_char(lv_rec.even

t_count));

p_stats(s) := lv_rec;lstr := p_stats(s).stype||','||trim(to_char(p_stats(s).inst_id))||','

||trim(to_char(p_stats(s).sid))||','||trim(to_char(p_stats(s).statistic#,'999999999999999999999999'));

l_stats(lstr) := p_stats(s);end loop;

p_snapdate := lv_rec.ts;end snap_from_stats_string;

/*----------------------------------------------------- proc for dumping ASH data out in grouped-- and ordered fashion---------------------------------------------------*/procedure out_ash( p_ash_columns in varchar2, p_topn in number := 10 ) as

-- whether to print given column or notp_inst_id number := 0;p_sid number := 0;

p_username number := 0;p_machine number := 0;p_terminal number := 0;p_program number := 0;p_event number := 0;p_wait_class number := 0;p_state number := 0;p_p1 number := 0;p_p2 number := 0;p_p3 number := 0;


33/52

p_row_wait_obj# number := 0;p_row_wait_file# number := 0;p_row_wait_block# number := 0;p_row_wait_row# number := 0;p_blocking_session_status number := 0;p_blocking_instance number := 0;p_blocking_session number := 0;p_sql_hash_value number := 0;p_sql_id number := 0;p_sql_child_number number := 0;p_plsql_entry_object_id number := 0;p_plsql_entry_subprogram_id number := 0;p_plsql_object_id number := 0;p_plsql_subprogram_id number := 0;p_module number := 0;p_action number := 0;p_client_identifier number := 0;p_service_name number := 0;

-- temporary variables for holding session details (for later formatting)

o_inst_id varchar2(100);o_sid varchar2(100);o_username varchar2(100);

o_machine varchar2(100);o_terminal varchar2(100);o_program varchar2(100);o_event varchar2(100);o_wait_class varchar2(100);o_state varchar2(100);o_p1 varchar2(100);o_p2 varchar2(100);o_p3 varchar2(100);o_row_wait_obj# varchar2(100);o_row_wait_file# varchar2(100);o_row_wait_block# varchar2(100);o_row_wait_row# varchar2(100);

o_blocking_session_status varchar2(100);o_blocking_instance varchar2(100);o_blocking_session varchar2(100);o_sql_hash_value varchar2(100);o_sql_id varchar2(100);o_sql_child_number varchar2(100);o_plsql_entry_object_id varchar2(100);o_plsql_entry_subprogram_id varchar2(100);o_plsql_object_id varchar2(100);o_plsql_subprogram_id varchar2(100);o_module varchar2(100);o_action varchar2(100);o_client_identifier varchar2(100);

o_service_name varchar2(100);

-- helper local varsl_ash_grouping number := 0;l_output_line varchar2(4000);l_ash_header_line varchar2(4000);

begin

-- bail out if no ASH samples recorded


34/52

if g_ash.count = 0 thenoutput(' ')

;return;

end if;

l_ash_header_line := 'Active%';

-- ash,ash1,ash2,ash3 parameter column group tokenizerfor s in (

SELECT LEVEL, SUBSTR( TOKEN, DECODE(LEVEL, 1, 1, INSTR(TOKEN, DELIMITER, 1, LEVEL-1)+1), INSTR(TOKEN, DELIMITER, 1, LEVEL) -DECODE(LEVEL, 1, 1, INSTR(TOKEN, DELIMITER, 1, LEVEL-1)+1)) TOKEN

FROM ( SELECT REPLACE( LOWER(p_ash_columns) ,' ','')||'+' AS TOKEN, '+' AS DELIMITERFROM DUAL

)CONNECT BY

INSTR(TOKEN, DELIMITER, 1, LEVEL)>0

ORDER BYLEVEL ASC) loop

case s.token-- actual column names in gv$sessionwhen 'inst_id' then l_ash_grouping := l_ash_g

rouping + c_inst_id ; l_ash_header_line := l_ash_header_line ||' | ' || lpad('INST_ID' , w_inst_id , ' ');

when 'sid' then l_ash_grouping := l_ash_grouping + c_sid ; l_ash_header_line := l_ash_header_line ||' | ' || lpad('SID' , w_sid , ' ');

when 'username' then l_ash_grouping := l_ash_g

rouping + c_username ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('USERNAME' , w_username , ' ');when 'machine' then l_ash_grouping := l_ash_g

rouping + c_machine ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('MACHINE' , w_machine , ' ');

when 'terminal' then l_ash_grouping := l_ash_grouping + c_terminal ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('TERMINAL' , w_terminal , ' ');

when 'program' then l_ash_grouping := l_ash_grouping + c_program ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('PROGRAM' , w_program , ' ');

when 'event' then l_ash_grouping := l_ash_grouping + c_event ; l_ash_header_line := l_ash_header_line ||

' | ' || rpad('EVENT' , w_event , ' ');when 'wait_class' then l_ash_grouping := l_ash_grouping + c_wait_class ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('WAIT_CLASS' , w_wait_class , ' ');

when 'state' then l_ash_grouping := l_ash_grouping + c_state ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('STATE' , w_state , ' ');

when 'p1' then l_ash_grouping := l_ash_grouping + c_p1 ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('P1' , w_p1 , ' ');


35/52



when 'row_wait_obj#' then l_ash_grouping := l_ash_grouping + c_row_wait_obj# ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('ROW_WAIT_OBJ#' , w_row_wait_obj# , ' ');

when 'row_wait_file#' then l_ash_grouping := l_ash_grouping + c_row_wait_file# ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('ROW_WAIT_FILE#' , w_row_wait_file# , ' ');

when 'row_wait_block#' then l_ash_grouping := l_ash_grouping + c_row_wait_block# ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('ROW_WAIT_BLOCK#' , w_row_wait_block# , ' ');

when 'row_wait_row#' then l_ash_grouping := l_ash_grouping + c_row_wait_row# ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('ROW_WAIT_ROW#' , w_row_wait_row# , ' ');

when 'blocking_session_status' then l_ash_grouping := l_ash_grouping + c_blocking_session_status ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('BLOCKING_SESSION_STATUS' , w_blocking_session_status , ' ');

when 'blocking_instance' then l_ash_grouping := l_ash_grouping + c_blocking_instance ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('BLOCKING_INSTANCE' , w_blocking_instance , ' ');

when 'blocking_session' then l_ash_grouping := l_ash_grouping + c_blocking_session ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('BLOCKING_SESSION' , w_blocking_session , ' ');

when 'sql_hash_value' then l_ash_grouping := l_ash_grouping + c_sql_hash_value ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('SQL_HASH_VALUE' , w_sql_hash_value , ' ');

when 'sql_id' then l_ash_grouping := l_ash_grouping + c_sql_id ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('SQL_ID' , w_sql_id , ' ');

when 'sql_child_number' then l_ash_grouping := l_ash_grouping + c_sql_child_number ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('SQL_CHILD_NUMBER' , w_sql_child_number , ' ');

when 'plsql_entry_object_id' then l_ash_grouping := l_ash_g

rouping + c_plsql_entry_object_id ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('PLSQL_ENTRY_OBJECT_ID' , w_plsql_entry_object_id , ' ');when 'plsql_entry_subprogram_id' then l_ash_grouping := l_ash_g

rouping + c_plsql_entry_subprogram_id; l_ash_header_line := l_ash_header_line ||' | ' || rpad('PLSQL_ENTRY_SUBPROGRAM_ID' , w_plsql_entry_subprogram_id, ' ');

when 'plsql_object_id' then l_ash_grouping := l_ash_grouping + c_plsql_object_id ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('PLSQL_OBJECT_ID' , w_plsql_object_id , ' ');

when 'plsql_subprogram_id' then l_ash_grouping := l_ash_grouping + c_plsql_subprogram_id ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('PLSQL_SUBPROGRAM_ID' , w_plsql_subprogram_id , ' ');

when 'module' then l_ash_grouping := l_ash_grouping + c_module ; l_ash_header_line := l_ash_header_line ||

' | ' || rpad('MODULE' , w_module , ' ');when 'action' then l_ash_grouping := l_ash_grouping + c_action ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('ACTION' , w_action , ' ');

when 'client_identifier' then l_ash_grouping := l_ash_grouping + c_client_identifier ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('CLIENT_IDENTIFIER' , w_client_identifier , ' ');

when 'service_name' then l_ash_grouping := l_ash_grouping + c_service_name ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('SERVICE_NAME' , w_service_name , ' ');


36/52

-- aliases for convenience (only either real name or alias shouldbe used together at the same time)

when 'user' then l_ash_grouping := l_ash_grouping + c_username ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('USERNAME' , w_username , ' ');

when 'obj' then l_ash_grouping := l_ash_grouping + c_row_wait_obj# ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('ROW_WAIT_OBJ#' , w_row_wait_obj# , ' ');

when 'file' then l_ash_grouping := l_ash_grouping + c_row_wait_file# ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('ROW_WAIT_FILE#' , w_row_wait_file# , ' ');

when 'block' then l_ash_grouping := l_ash_grouping + c_row_wait_block# ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('ROW_WAIT_BLOCK#' , w_row_wait_block# , ' ');

when 'row' then l_ash_grouping := l_ash_grouping + c_row_wait_row# ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('ROW_WAIT_ROW#' , w_row_wait_row# , ' ');

when 'bss' then l_ash_grouping := l_ash_grouping + c_blocking_session_status ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('BLOCKING_SESSION_STATUS' , w_blocking_session_status , ' ');

when 'bsi' then l_ash_grouping := l_ash_grouping + c_blocking_instance ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('BLOCKING_INSTANCE' , w_blocking_instance , ' ');

when 'bs' then l_ash_grouping := l_ash_g

rouping + c_blocking_session ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('BLOCKING_SESSION' , w_blocking_session , ' ');when 'sql' then l_ash_grouping := l_ash_g

rouping + c_sql_hash_value ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('SQL_HASH_VALUE' , w_sql_hash_value , ' ');

when 'sqlid' then l_ash_grouping := l_ash_grouping + c_sql_id ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('SQL_ID' , w_sql_id , ' ');

when 'child' then l_ash_grouping := l_ash_grouping + c_sql_child_number ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('SQL_CHILD_NUMBER' , w_sql_child_number , ' ');

when 'plsql_eoid' then l_ash_grouping := l_ash_grouping + c_plsql_entry_object_id ; l_ash_header_line := l_ash_header_line ||

' | ' || rpad('PLSQL_ENTRY_OBJECT_ID' , w_plsql_entry_object_id , ' ');when 'plsql_esubpid' then l_ash_grouping := l_ash_grouping + c_plsql_entry_subprogram_id; l_ash_header_line := l_ash_header_line ||' | ' || rpad('PLSQL_ENTRY_SUBPROGRAM_ID' , w_plsql_entry_subprogram_id, ' ');

when 'plsql_oid' then l_ash_grouping := l_ash_grouping + c_plsql_object_id ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('PLSQL_OBJECT_ID' , w_plsql_object_id , ' ');

when 'plsql_subpid' then l_ash_grouping := l_ash_grouping + c_plsql_subprogram_id ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('PLSQL_SUBPROGRAM_ID' , w_plsql_subprogram_id , ' ');

when 'mod' then l_ash_grouping := l_ash_grouping + c_module ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('MODULE' , w_module , ' ');

when 'act' then l_ash_grouping := l_ash_grouping + c_action ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('ACTION' , w_action , ' ');

when 'cid' then l_ash_grouping := l_ash_grouping + c_client_identifier ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('CLIENT_IDENTIFIER' , w_client_identifier , ' ');

when 'service' then l_ash_grouping := l_ash_grouping + c_service_name ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('SERVICE_NAME' , w_service_name , ' ');

when 'wait_event' then l_ash_grouping := l_ash_g


37/52

rouping + c_event ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('EVENT' , w_event , ' ');

when 'wait_state' then l_ash_grouping := l_ash_grouping + c_state ; l_ash_header_line := l_ash_header_line ||' | ' || rpad('STATE' , w_state , ' ');

elsenull;-- raise_application_error(-20000, 'Invalid ASH column name');

end case; -- case s.token

end loop; -- tokenizer

output(' ');output(lpad('-',length(l_ash_header_line),'-'));output(l_ash_header_line);output(lpad('-',length(l_ash_header_line),'-'));

-- this is needed for "easy" sorting and group by ops (without any customstored object types!)

for i in (with /* get_aggregates_from_ash */ raw_records as (

select column_value rec from table(cast(g_ash as sys.dbms_debug_vc2coll))

),

ash_records as (selectsubstr(r.rec, instr(r.rec, '


38/52

, substr(r.rec, instr(r.rec, '


39/52

, decode(bitand(l_ash_grouping, power(2, s_p2)), 0, chr(0), p2 ) as p2

, decode(bitand(l_ash_grouping, power(2, s_p3)), 0, chr(0), p3 ) as p3

, decode(bitand(l_ash_grouping, power(2, s_row_wait_obj#)), 0, chr(0), row_wait_obj# ) as row_wait_obj#

, decode(bitand(l_ash_grouping, power(2, s_row_wait_file#)), 0, chr(0), row_wait_file# ) as row_wait_file#

, decode(bitand(l_ash_grouping, power(2, s_row_wait_block#)), 0, chr(0), row_wait_block# ) as row_wait_block#

, decode(bitand(l_ash_grouping, power(2, s_row_wait_row#)), 0, chr(0), row_wait_row# ) as row_wait_row#

, decode(bitand(l_ash_grouping, power(2, s_blocking_session_status)), 0, chr(0), blocking_session_status ) as blocking_session_status

, decode(bitand(l_ash_grouping, power(2, s_blocking_instance)), 0, chr(0), blocking_instance ) as blocking_instance

, decode(bitand(l_ash_grouping, power(2, s_blocking_session)), 0, chr(0), blocking_session ) as blocking_session

, decode(bitand(l_ash_grouping, power(2, s_sql_hash_value)), 0, chr(0), sql_hash_value ) as sql_hash_value

, decode(bitand(l_ash_grouping, power(2, s_sql_id)), 0, chr(0), sql_id ) as sql_id

, decode(bitand(l_ash_grouping, power(2, s_sql_child_number)), 0, chr(0), sql_child_number ) as sql_child_number

, decode(bitand(l_ash_grouping, power(2, s_plsql_entry_object_id

)), 0, chr(0), plsql_entry_object_id ) as plsql_entry_object_id

, decode(bitand(l_ash_grouping, power(2, s_plsql_entry_subprogram_id )), 0, chr(0), plsql_entry_subprogram_id ) as plsql_entry_subprogram_id

, decode(bitand(l_ash_grouping, power(2, s_plsql_object_id)), 0, chr(0), plsql_object_id ) as plsql_object_id

, decode(bitand(l_ash_grouping, power(2, s_plsql_subprogram_id)), 0, chr(0), plsql_subprogram_id ) as plsql_subprogram_id

, decode(bitand(l_ash_grouping, power(2, s_module)), 0, chr(0), module ) as module

, decode(bitand(l_ash_grouping, power(2, s_action)), 0, chr(0), action ) as action

, decode(bitand(l_ash_grouping, power(2, s_client_identifier)), 0, chr(0), client_identifier ) as client_identifier

, decode(bitand(l_ash_grouping, power(2, s_service_name)), 0, chr(0), service_name ) as service_name


40/52

, count(*)/g_ash_samples_taken average_active_samplesfrom

ash_records agroup by

decode(bitand(l_ash_grouping, power(2, s_inst_id)), 0, chr(0), inst_id ) -- inst_id

, decode(bitand(l_ash_grouping, power(2, s_sid)), 0, chr(0), sid ) -- sid

, decode(bitand(l_ash_grouping, power(2, s_username)), 0, chr(0), username ) -- username

, decode(bitand(l_ash_grouping, power(2, s_machine)), 0, chr(0), machine ) -- machine

, decode(bitand(l_ash_grouping, power(2, s_terminal)), 0, chr(0), terminal ) -- terminal

, decode(bitand(l_ash_grouping, power(2, s_program)), 0, chr(0), program ) -- program

, decode(bitand(l_ash_grouping, power(2, s_event)), 0, chr(0), event ) -- event

, decode(bitand(l_ash_grouping, power(2, s_wait_class)), 0, chr(0), wait_class ) -- wait_class

, decode(bitand(l_ash_grouping, power(2, s_state)), 0, chr(0), state ) -- state

, decode(bitand(l_ash_grouping, power(2, s_p1)), 0, chr(0), p1 ) -- p1



, decode(bitand(l_ash_grouping, power(2, s_row_wait_obj#)), 0, chr(0), row_wait_obj# ) -- row_wait_obj#

, decode(bitand(l_ash_grouping, power(2, s_row_wait_file#)), 0, chr(0), row_wait_file# ) -- row_wait_file#

, decode(bitand(l_ash_grouping, power(2, s_row_wait_block#)), 0, chr(0), row_wait_block# ) -- row_wait_block#

, decode(bitand(l_ash_grouping, power(2, s_row_wait_row#

)), 0, chr(0), row_wait_row# ) -- row_wait_row#

, decode(bitand(l_ash_grouping, power(2, s_blocking_session_status)), 0, chr(0), blocking_session_status ) -- blocking_session_status

, decode(bitand(l_ash_grouping, power(2, s_blocking_instance)), 0, chr(0), blocking_instance ) -- blocking_instance

, decode(bitand(l_ash_grouping, power(2, s_blocking_session)), 0, chr(0), blocking_session ) -- blocking_session


41/52

, decode(bitand(l_ash_grouping, power(2, s_sql_hash_value

)), 0, chr(0), sql_hash_value ) -- sql_hash_value

, decode(bitand(l_ash_grouping, power(2, s_sql_id)), 0, chr(0), sql_id ) -- sql_id

, decode(bitand(l_ash_grouping, power(2, s_sql_child_number)), 0, chr(0), sql_child_number ) -- sql_child_number

, decode(bitand(l_ash_grouping, power(2, s_plsql_entry_object_id)), 0, chr(0), plsql_entry_object_id ) -- plsql_entry_object_id

, decode(bitand(l_ash_grouping, power(2, s_plsql_entry_subprogram_id )), 0, chr(0), plsql_entry_subprogram_id ) -- plsql_entry_subprogram_id

, decode(bitand(l_ash_grouping, power(2, s_plsql_object_id)), 0, chr(0), plsql_object_id ) -- plsql_object_id

, decode(bitand(l_ash_grouping, power(2, s_plsql_subprogram_id)), 0, chr(0), plsql_subprogram_id ) -- plsql_subprogram_id

, decode(bitand(l_ash_grouping, power(2, s_module)), 0, chr(0), module ) -- module

, decode(bitand(l_ash_grouping, power(2, s_action)), 0, chr(0), action ) -- action

, decode(bitand(l_ash_grouping, power(2, s_client_identifier)), 0, chr(0), client_identifier ) -- client_identifier

, decode(bitand(l_ash_grouping, power(2, s_service_name)), 0, chr(0), service_name ) -- service_name

order bycount(*)/g_ash_samples_taken desc

)

where rownum


42/52

o_p1 := CASE WHEN i.p1= chr(0) THEN null ELSE nvl(i.p1 , ' ') END;



o_row_wait_obj# := CASE WHEN i.row_wait_obj#= chr(0) THEN null ELSE nvl(i.row_wait_obj# , ' ') END;

o_row_wait_file# := CASE WHEN i.row_wait_file#= chr(0) THEN null ELSE nvl(i.row_wait_file# , ' ') END;

o_row_wait_block# := CASE WHEN i.row_wait_block#= chr(0) THEN null ELSE nvl(i.row_wait_block# , ' ') END;

o_row_wait_row# := CASE WHEN i.row_wait_row#= chr(0) THEN null ELSE nvl(i.row_wait_row# , ' ') END;

o_blocking_session_status := CASE WHEN i.blocking_session_status= chr(0) THEN null ELSE nvl(i.blocking_session_status , ' ') END;

o_blocking_instance := CASE WHEN i.blocking_instance= chr(0) THEN null ELSE nvl(i.blocking_instance , ' ') END;

o_blocking_session := CASE WHEN i.blocking_session= chr(0) THEN null ELSE nvl(i.blocking_session , ' ') END;

o_sql_hash_value := CASE WHEN i.sql_hash_value= chr(0) THEN null ELSE nvl(i.sql_hash_value , ' ') END;

o_sql_id := CASE WHEN i.sql_id= chr(0) THEN null ELSE nvl(i.sql_id , ' ') END;

o_sql_child_number := CASE WHEN i.sql_child_number= chr(0) THEN null ELSE nvl(i.sql_child_number , ' ') END;o_plsql_entry_object_id := CASE WHEN i.plsql_entry_object_id

= chr(0) THEN null ELSE nvl(i.plsql_entry_object_id , ' ') END;o_plsql_entry_subprogram_id := CASE WHEN i.plsql_entry_subprogram_id

= chr(0) THEN null ELSE nvl(i.plsql_entry_subprogram_id , ' ') END;o_plsql_object_id := CASE WHEN i.plsql_object_id

= chr(0) THEN null ELSE nvl(i.plsql_object_id , ' ') END;o_plsql_subprogram_id := CASE WHEN i.plsql_subprogram_id

= chr(0) THEN null ELSE nvl(i.plsql_subprogram_id , ' ') END;o_module := CASE WHEN i.module

= chr(0) THEN null ELSE nvl(i.module , ' ') END;o_action := CASE WHEN i.action

= chr(0) THEN null ELSE nvl(i.action , ' ') END;o_client_identifier := CASE WHEN i.client_identifier= chr(0) THEN null ELSE nvl(i.client_identifier , ' ') END;

o_service_name := CASE WHEN i.service_name= chr(0) THEN null ELSE nvl(i.service_name , ' ') END;

-- print the activity % as the first columnl_output_line := lpad(to_char(round(i.average_active_samples*100))||'%

', w_activity_pct, ' ');

-- loop through ash columns to find what to print and in which orderfor s in (

SELECT LEVEL, SUBSTR( TOKEN, DECODE(LEVEL, 1, 1, INSTR(TOKEN, DELIMITER, 1, LEVEL-1

)+1), INSTR(TOKEN, DELIMITER, 1, LEVEL) -DECODE(LEVEL, 1, 1, INSTR(TOKEN, DELIMITER, 1, LEVEL-1)+1

)) TOKEN

FROM ( SELECT REPLACE( LOWER(p_ash_columns) ,' ','')||'+' AS TOK


43/52

EN, '+' AS DELIMITERFROM DUAL

)CONNECT BY

INSTR(TOKEN, DELIMITER, 1, LEVEL)>0ORDER BY

LEVEL ASC) loop

l_output_line := l_output_line || ' | ' ||case s.token

-- actual column names in gv$sessionwhen 'inst_id' then lpad(o_inst_id

, w_inst_id , ' ')when 'sid' then lpad(o_sid

, w_sid , ' ')when 'username' then rpad(o_username

, w_username , ' ')when 'machine' then rpad(o_machine

, w_machine , ' ')when 'terminal' then rpad(o_terminal

, w_terminal , ' ')when 'program' then rpad(o_program

, w_program , ' ')

when 'event' then rpad(o_event, w_event , ' ')when 'wait_class' then rpad(o_wait_class

, w_wait_class , ' ')when 'state' then rpad(o_state

, w_state , ' ')when 'p1' then rpad(o_p1

, w_p1 , ' ')when 'p2' then rpad(o_p2

, w_p2 , ' ')when 'p3' then rpad(o_p3

, w_p3 , ' ')when 'row_wait_obj#' then rpad(o_row_wait_o

bj# , w_row_wait_obj# , ' ')when 'row_wait_file#' then rpad(o_row_wait_file# , w_row_wait_file# , ' ')

when 'row_wait_block#' then rpad(o_row_wait_block# , w_row_wait_block# , ' ')

when 'row_wait_row#' then rpad(o_row_wait_row# , w_row_wait_row# , ' ')

when 'blocking_session_status' then rpad(o_blocking_session_status , w_blocking_session_status , ' ')

when 'blocking_instance' then rpad(o_blocking_instance , w_blocking_instance , ' ')

when 'blocking_session' then rpad(o_blocking_session , w_blocking_session , ' ')

when 'sql_hash_value' then rpad(o_sql_hash_value , w_sql_hash_value , ' ')when 'sql_id' then rpad(o_sql_id

, w_sql_id , ' ')when 'sql_child_number' then rpad(o_sql_child_

number , w_sql_child_number , ' ')when 'plsql_entry_object_id' then rpad(o_plsql_entr

y_object_id , w_plsql_entry_object_id , ' ')when 'plsql_entry_subprogram_id' then rpad(o_plsql_entr

y_subprogram_id , w_plsql_entry_subprogram_id, ' ')


44/52

when 'plsql_object_id' then rpad(o_plsql_object_id , w_plsql_object_id , ' ')

when 'plsql_subprogram_id' then rpad(o_plsql_subprogram_id , w_plsql_subprogram_id , ' ')

when 'module' then rpad(o_module, w_module , ' ')

when 'action' then rpad(o_action, w_action , ' ')

when 'client_identifier' then rpad(o_client_identifier , w_client_identifier , ' ')

when 'service_name' then rpad(o_service_name , w_service_name , ' ')

-- aliases for convenience (only either real name or aliasshould be used together at the same time)

when 'user' then rpad(o_username, w_username , ' ')

when 'obj' then rpad(o_row_wait_obj# , w_row_wait_obj# , ' ')

when 'file' then rpad(o_row_wait_file# , w_row_wait_file# , ' ')

when 'block' then rpad(o_row_wait_block# , w_row_wait_block# , ' ')

when 'row' then rpad(o_row_wait_row# , w_row_wait_row# , ' ')

when 'bss' then rpad(o_blocking_session_status , w_blocking_session_status , ' ')when 'bsi' then rpad(o_blocking_i

nstance , w_blocking_instance , ' ')when 'bs' then rpad(o_blocking_s

ession , w_blocking_session , ' ')when 'sql' then rpad(o_sql_hash_v

alue , w_sql_hash_value , ' ')when 'sqlid' then rpad(o_sql_id

, w_sql_id , ' ')when 'child' then rpad(o_sql_child_

number , w_sql_child_number , ' ')when 'plsql_eoid' then rpad(o_plsql_entr

y_object_id , w_plsql_entry_object_id , ' ')when 'plsql_esubpid' then rpad(o_plsql_entry_subprogram_id , w_plsql_entry_subprogram_id, ' ')

when 'plsql_oid' then rpad(o_plsql_object_id , w_plsql_object_id , ' ')

when 'plsql_subpid' then rpad(o_plsql_subprogram_id , w_plsql_subprogram_id , ' ')

when 'mod' then rpad(o_module, w_module , ' ')

when 'act' then rpad(o_action, w_action , ' ')

when 'cid' the

snapper4.sql

Documents

Transcript of snapper4.sql