Oracle DBA Scripts All in One Place!
To Identify the high CPU usage:
===============================
SELECT se.username, ss.sid, ROUND (value/100) "CPU Usage"
FROM v$session se, v$sesstat ss, v$statname st
WHERE ss.statistic# = st.statistic#
AND name LIKE '%CPU used by this session%'
AND se.sid = ss.SID
AND se.username IS NOT NULL
ORDER BY value DESC;
SELECT a.username, a.osuser, a.terminal,a.program, spid, SID, a.serial#,a.last_call_et,a.logon_time
FROM v$session a, v$process b WHERE a.paddr = b.addr AND a.status = 'INACTIVE' and a.type = 'USER';
Which user session is utilizing more memory:
===========================================
SELECT USERNAME, round(VALUE/1024/1024) || 'MB' "Current UGA memory"
FROM V$SESSION sess, V$SESSTAT stat, V$STATNAME name
WHERE sess.SID = stat.SID
AND stat.STATISTIC# = name.STATISTIC#
AND name.NAME = 'session uga memory';
How To Get Tablespace Quota Details Of An User In Oracle:
========================================================
TABLESPACE QUOTA DETAILS OF ALL THE USERS:
==========================================
set pagesize 200
set lines 200
col ownr format a20 justify c heading 'Owner'
col name format a20 justify c heading 'Tablespace' trunc
col qota format a12 justify c heading 'Quota (KB)'
col used format 999,999,990 justify c heading 'Used (KB)'
set colsep '|'
SELECT username
ownr,
tablespace_name
name,
Decode(Greatest(max_bytes, -1), -1, 'UNLIMITED',
To_char(max_bytes / 1024, '999,999,990'))
qota,
bytes / 1024
used
FROM dba_ts_quotas
WHERE max_bytes != 0
OR bytes != 0
ORDER BY 1,2
/
TABLESPAE QUOTA DETAILS FOR A PARTICULAR USER:
==============================================
set pagesize 200
set lines 200
col ownr format a20 justify c heading 'Owner'
col name format a20 justify c heading 'Tablespace' trunc
col qota format a12 justify c heading 'Quota (KB)'
col used format 999,999,990 justify c heading 'Used (KB)'
set colsep '|'
SELECT username
ownr,
tablespace_name
name,
Decode(Greatest(max_bytes, -1), -1, 'UNLIMITED',
To_char(max_bytes / 1024, '999,999,990'))
qota,
bytes / 1024
used
FROM dba_ts_quotas
WHERE ( max_bytes != 0
OR bytes != 0 )
AND username = '&USERNAME'
ORDER BY 1,2
/
How To Monitor Parallel Queries In Oracle DB:
=============================================
col username for a9
col sid for a8
set lines 299
SELECT s.inst_id,
Decode(px.qcinst_id, NULL, s.username, ' - ' ||Lower(Substr(s.program, Length(s.program) - 4, 4))) "Username",
Decode(px.qcinst_id, NULL, 'QC',
'(Slave)') "QC/Slave",
To_char(px.server_set) "Slave Set",
To_char(s.sid) "SID",
Decode(px.qcinst_id, NULL, To_char(s.sid),
px.qcsid) "QC SID",
px.req_degree "Requested DOP",
px.degree "Actual DOP",
p.spid
FROM gv$px_session px,
gv$session s,
gv$process p
WHERE px.sid = s.sid (+)
AND px.serial# = s.serial#
AND px.inst_id = s.inst_id
AND p.inst_id = s.inst_id
AND p.addr = s.paddr
ORDER BY 5, 1 DESC
/
Find Pending Distributed Pending Transactions In Oracle:
========================================================
COL local_tran_id FORMAT a13
COL in_out FORMAT a6
COL database FORMAT a25
COL dbuser_owner FORMAT a15
COL interface FORMAT a3
SELECT local_tran_id, in_out, database, dbuser_owner, interface
FROM dba_2pc_neighbors
/
How To Find Execution History Of An Sql_id:
===========================================
Below script will display execution history of an sql_id from AWR. It will join dba_hist_sqlstat and dba_hist_sqlsnapshot table to get the required information.
SELECT a.instance_number inst_id,
a.snap_id,
a.plan_hash_value,
To_char(begin_interval_time, 'dd-mon-yy hh24:mi') btime,
Abs(Extract(minute FROM ( end_interval_time - begin_interval_time )) +
Extract (hour FROM ( end_interval_time - begin_interval_time )) *
60 +
Extract(day FROM ( end_interval_time - begin_interval_time )) * 24 *
60)
minutes,
executions_delta executions,
Round(elapsed_time_delta / 1000000 / Greatest(executions_delta, 1), 4)
"avg duration (sec)"
FROM dba_hist_sqlstat a,
dba_hist_snapshot b
WHERE sql_id = '&sql_id'
AND a.snap_id = b.snap_id
AND a.instance_number = b.instance_number
ORDER BY snap_id DESC,
a.instance_number;
Script To Get Cpu Usage And Wait Event Information In Oracle Database:
======================================================================
Below script will give information about the CPU usage and wait events class information of every minute for last 2 hours. As this query uses gv$active_session_history, so make sure you have TUNING license pack of oracle, before using this.
set lines 288
col sample_time for a14
col CONFIGURATION head "CONFIG" for 99.99
col ADMINISTRATIVE head "ADMIN" for 99.99
col OTHER for 99.99
SELECT To_char(sample_time, 'HH24:MI ') AS sample_time,
Round(other / 60, 3) AS other,
Round(clust / 60, 3) AS clust,
Round(queueing / 60, 3) AS queueing,
Round(network / 60, 3) AS network,
Round(administrative / 60, 3) AS administrative,
Round(configuration / 60, 3) AS configuration,
Round(COMMIT / 60, 3) AS COMMIT,
Round(application / 60, 3) AS application,
Round(concurrency / 60, 3) AS concurrency,
Round(sio / 60, 3) AS system_io,
Round(uio / 60, 3) AS user_io,
Round(scheduler / 60, 3) AS scheduler,
Round(cpu / 60, 3) AS cpu,
Round(bcpu / 60, 3) AS background_cpu
FROM (
SELECT Trunc(sample_time, 'MI') AS sample_time,
Decode(session_state,
'ON CPU', Decode(session_type,
'BACKGROUND', 'BCPU',
'ON CPU'),
wait_class) AS wait_class
FROM v$active_session_history
WHERE sample_time > SYSDATE - interval '2' hour
AND sample_time <= Trunc(SYSDATE, 'MI')) ash pivot(count(*) FOR wait_class IN('ON CPU' AS cpu,
'BCPU' AS bcpu,
'Scheduler' AS scheduler,
'User I/O' AS uio,
'System I/O' AS sio,
'Concurrency' AS concurrency,
'Application' AS application,
'Commit' AS COMMIT,
'Configuration' AS configuration,
'Administrative' AS administrative,
'Network' AS network,
'Queueing' AS queueing,
'Cluster' AS clust,
'Other' AS other))
/
How To Find Cpu And Memory Information Of Oracle Database Server:
=================================================================
Below script is useful in getting CPU, memory and core, socket information of a database server from SQL prompt.
set pagesize 299
set lines 299
SELECT stat_name,
To_char(value) AS VALUE,
comments
FROM v$osstat
WHERE stat_name IN ( 'NUM_CPUS', 'NUM_CPU_CORES', 'NUM_CPU_SOCKETS' )
UNION
SELECT stat_name,
value / 1024 / 1024 / 1024
|| ' GB',
comments
FROM v$osstat
WHERE stat_name IN ( 'PHYSICAL_MEMORY_BYTES' )
/
Find Sessions Consuming Lot Of CPU:
====================================
col program form a30 heading "PROGRAM"
col CPUMins form 99990 heading "CPU in Mins"
SELECT ROWNUM AS rank, a.*
FROM (SELECT v.sid,s.serial#,s.username,s.osuser,s.machine,s.program,s.logon_time,s.sql_id,s.status,
v.value / ( 100 * 60 ) CPUMins
FROM v$statname n,
v$sesstat v,
v$session s
WHERE n.name = 'CPU used by this session'
AND s.sid = v.sid
AND v.statistic# = n.statistic#
AND v.value > 0
ORDER BY v.value DESC) a
WHERE ROWNUM < 11;
SQL> select
2 ss.username,
3 se.SID,
4 VALUE/100 cpu_usage_seconds
5 from
6 v$session ss,
7 v$sesstat se,
8 v$statname sn
9 where
10 se.STATISTIC# = sn.STATISTIC#
11 and
12 NAME like '%CPU used by this session%'
13 and
14 se.SID = ss.SID
and
15 16 ss.status='ACTIVE'
17 and
18 ss.username is not null order by VALUE desc;
Oracle scripts:
select sess.username, stat.sid, name.name name, sum(stat.value)/100 valuesum_seconds from v$sesstat stat, v$statname name, v$session sess
where stat.sid = sess.sid and stat.statistic# = name.statistic# and name.name like '%CPU%' group by sess.username, stat.sid, name.name;
select s.username, s.sid, s.serial#, p.pid ppid, s.status, s.osuser, substr(s.program,1,20) client_program, s.process client_process,
substr(p.program,1,20) server_program, p.spid server_pid from v$session s, v$process p where s.username is not null
and p.addr(+) = s.paddr and userenv('SESSIONID') = s.audsid
order by username, sid
select s.username "Oracle User",s.osuser "OS User",i.consistent_gets "Consistent Gets",
i.physical_reads "Physical Reads",s.status "Status",s.sid "SID",s.serial# "Serial#",
s.machine "Machine",s.program "Program",to_char(logon_time, 'DD/MM/YYYY HH24:MI:SS') "Logon Time",
w.seconds_in_wait "Idle Time", P.SPID "PROC",
name "Stat CPU", value
from v$session s, v$sess_io i, v$session_wait w, V$PROCESS P, v$statname n, v$sesstat t
where s.sid = i.sid
and s.sid = w.sid (+)
and 'SQL*Net message from client' = w.event(+)
and s.osuser is not null
and s.username is not null
and s.paddr=p.addr
and n.statistic# = t.statistic#
and n.name like '%cpu%'
and t.SID = s.sid
order by 6 asc, 3 desc, 4 desc;
select
ss.username,
se.SID,
ss.status,
VALUE/100 cpu_usage_seconds
from
v$session ss,
v$sesstat se,
v$statname sn
where
se.STATISTIC# = sn.STATISTIC#
and
NAME like '%CPU used by this session%'
and
se.SID = ss.SID
and
ss.status in ('ACTIVE','INACTIVE')
and
ss.username is not null
order by VALUE desc;
6> Kill the inactive sessions that are consuming space.
Top memory consuming sessions in database:
==========================================
SQL> SELECT a.username, a.osuser, a.program, b.spid,b.pga_used_mem/1024/1024 "PGA USED (MB)", a.sid, a.serial# ,a.module,a.logon_time,a.terminal,a.status FROM v$session a, v$process b WHERE a.paddr = b.addr order by b.pga_used_mem desc;
with x as (select s.osuser osuser , s.username
, s.status
, se.sid
, s.serial# serial
, n.name
, round(max(se.value)/1024/1024, 2) maxmem_mb
, max(se.value) as maxmem
from v$sesstat se , v$statname n , v$session s
where n.statistic# = se.statistic#
and n.name in ('session pga memory','session pga memory max', 'session uga memory','session uga memory max')
and s.sid = se.sid
group by s.osuser, s.username, s.status, se.sid, s.serial#, n.name
order by maxmem desc
)
select * from x where rownum < 11;
SELECT to_char(ssn.sid, '9999') || ' - ' || nvl(ssn.username, nvl(bgp.name, 'background')) ||
nvl(lower(ssn.machine), ins.host_name) "SESSION",
to_char(prc.spid, '999999999') "PID/THREAD",
to_char((se1.value/1024)/1024, '999G999G990D00') || ' MB' " CURRENT SIZE",
to_char((se2.value/1024)/1024, '999G999G990D00') || ' MB' " MAXIMUM SIZE"
FROM v$sesstat se1, v$sesstat se2, v$session ssn, v$bgprocess bgp, v$process prc,
v$instance ins, v$statname stat1, v$statname stat2
WHERE se1.statistic# = stat1.statistic# and stat1.name = 'session pga memory'
AND se2.statistic# = stat2.statistic# and stat2.name = 'session pga memory max'
AND se1.sid = ssn.sid
AND se2.sid = ssn.sid
AND ssn.paddr = bgp.paddr (+)
AND ssn.paddr = prc.addr (+);
SELECT a.username, a.osuser, a.program, b.spid,b.pga_used_mem/1024/1024 “PGA USED (MB)”, a.sid, a.serial# ,a.module,a.logon_time,a.terminal FROM v$session a, v$process b WHERE a.paddr = b.addr
order by b.pga_used_mem desc;
Get Ospid From SID:
===================
set lines 123
col USERNAME for a15
col OSUSER for a8
col MACHINE for a15
col PROGRAM for a20
SELECT b.spid,
a.username,
a.program,
a.osuser,
a.machine,
a.sid,
a.serial#,
a.status
FROM gv$session a,
gv$process b
WHERE addr = paddr(+)
AND status='KILLED';
Get Sid From Ospid:
===================
col sid format 999999
col username format a20
col osuser format a15
SELECT b.spid,
a.sid,
a.serial#,
a.username,
a.osuser,
a.machine,
a.program,
a.logon_time,
a.sql_id,
a.status
FROM v$session a,
v$process b
WHERE a.paddr = b.addr
AND b.spid = '&spid'
ORDER BY b.spid;
SELECT 'ALTER SYSTEM KILL SESSION '''''sid','serial#''''' immediate;'
FROM v$session
WHERE status ='INACTIVE';
To find out long running session and ACTIVE/INACTIVE sessions:
===============================================================
select 'alter system kill session '''||sid||','||serial#||'''immediate;' as script from v$session where username in ='SYS','SYSTEM';
select sid,serial#,username,osuser,program,machine,logon_time,sql_id,status from v$session where username in ('SYS','SYSTEM') and status='ACTIVE';
How to find out Expected Time of Completion for an Oracle Query:
================================================================
SELECT
opname,
target,
ROUND( ( sofar/totalwork ), 4 ) * 100 Percentage_Complete,
start_time,
CEIL( time_remaining / 60 ) Max_Time_Remaining_In_Min,
FLOOR( elapsed_seconds / 60 ) Time_Spent_In_Min
FROM v$session_longops
WHERE username='SYS' and sofar != totalwork;
SELECT AR.parsing_schema_name,target,AR.sql_id,AR.module "CLIENT_TOOL",opname,AR.sql_fulltext,start_time,
CEIL( time_remaining / 60 ) "TIME_REMAINING",FLOOR( elapsed_seconds / 60 ) "TIME_SPENT",ROUND( ( sofar / totalwork ), 4 ) * 100 "%_COMPLETE"
FROM v$session_longops L, v$sqlarea AR
WHERE L.sql_id = AR.sql_id
AND totalwork > 0
AND AR.users_executing > 0 and AR.sql_id='383dzn46q7vp4'
AND sofar != totalwork;
How to find out Which User is Running what SQL Query in Oracle database?:
=========================================================================
SELECT
SUBSTR(SS.USERNAME,1,8) USERNAME,
SS.OSUSER "USER",
AR.MODULE || ' @ ' || SS.MACHINE CLIENT,
SS.PROCESS PID,
TO_CHAR(AR.LAST_LOAD_TIME, 'DD-Mon HH24:MM:SS') LOAD_TIME,
AR.DISK_READS DISK_READS,
AR.BUFFER_GETS BUFFER_GETS,
SUBSTR(SS.LOCKWAIT,1,10) LOCKWAIT,
W.EVENT EVENT,
SS.STATUS,
AR.SQL_fullTEXT SQL
FROM V$SESSION_WAIT W,
V$SQLAREA AR,
V$SESSION SS,
v$TIMER T
WHERE SS.SQL_ADDRESS = AR.ADDRESS
AND SS.SQL_HASH_VALUE = AR.HASH_VALUE
AND SS.SID = W.SID (+)
AND SS.STATUS = 'ACTIVE'
AND W.EVENT != 'client message'
ORDER BY SS.LOCKWAIT ASC, SS.USERNAME, AR.DISK_READS DESC;
To find out SQL query start time and end time:
==============================================
alter session set nls_date_format='YYYY/MM/DD HH24:MI:SS';
alter session set nls_timestamp_format='YYYY/MM/DD HH24:MI:SS';
select USER_ID,sql_id,
starting_time,
end_time,
(EXTRACT(HOUR FROM run_time) * 3600
+ EXTRACT(MINUTE FROM run_time) * 60
+ EXTRACT(SECOND FROM run_time)) run_time_sec,
READ_IO_BYTES,
PGA_ALLOCATED PGA_ALLOCATED_BYTES,
TEMP_ALLOCATED TEMP_ALLOCATED_BYTES
from (select USER_ID,
sql_id,
max(sample_time - sql_exec_start) run_time,
max(sample_time) end_time,
sql_exec_start starting_time,
sum(DELTA_READ_IO_BYTES) READ_IO_BYTES,
sum(DELTA_PGA) PGA_ALLOCATED,
sum(DELTA_TEMP) TEMP_ALLOCATED
from
( select sql_id, USER_ID,
sample_time,
sql_exec_start,
DELTA_READ_IO_BYTES,
sql_exec_id,
greatest(PGA_ALLOCATED - first_value(PGA_ALLOCATED) over (partition by sql_id,sql_exec_id order by sample_time rows 1 preceding),0) DELTA_PGA,
greatest(TEMP_SPACE_ALLOCATED - first_value(TEMP_SPACE_ALLOCATED) over (partition by sql_id,sql_exec_id order by sample_time rows 1 preceding),0) DELTA_TEMP
from
dba_hist_active_sess_history
where
sample_time >= to_date ('2018/06/28 00:00:00','YYYY/MM/DD HH24:MI:SS')
and sample_time < to_date ('2018/06/28 23:59:00','YYYY/MM/DD HH24:MI:SS')
and sql_exec_start is not null
and IS_SQLID_CURRENT='Y')
group by sql_id,SQL_EXEC_ID,sql_exec_start,USER_ID
order by sql_id)
where sql_id = '8117w9uckwpwz'
order by sql_id, run_time_sec desc;
To find out user_id belongs to which username:
===============================================
select a.USER_ID,b.USERNAME,a.SAMPLE_TIME,a.SQL_ID,a.SESSION_ID,a.SESSION_SERIAL#,a.MACHINE from DBA_HIST_ACTIVE_SESS_HISTORY a ,dba_users b where SQL_ID in (
'grwydz59pu6mc') and SAMPLE_TIME like '28-JUN-18%' and a.USER_ID=b.USER_ID;
SQL execution times from ASH:
=============================
col mx for 999999
col mn for 999999
col av for 999999.9
select
sql_id,
count(*),
max(tm) mx,
avg(tm) av,
min(tm) min
from (
select
sql_id,
sql_exec_id,
max(tm) tm
from ( select
sql_id,
sql_exec_id,
((cast(sample_time as date)) -
(cast(sql_exec_start as date))) * (3600*24) tm
from
dba_hist_active_sess_history
where sql_exec_id is not null
)
group by sql_id,sql_exec_id
)
group by sql_id
having count(*) > 10
order by mx,av
/
Response times of SQLs - Elapsed-Avg-Min-Max:
=============================================
select user_id,sql_id,
run_time run_time_timestamp,
(EXTRACT(HOUR FROM run_time) * 3600
+ EXTRACT(MINUTE FROM run_time) * 60
+ EXTRACT(SECOND FROM run_time)) run_time_sec
from (
select
user_id,sql_id,
max(sample_time - sql_exec_start) run_time
from
dba_hist_active_sess_history
where
sql_exec_start is not null
group by sql_id,SQL_EXEC_ID,user_id
order by sql_id
)
-- where rownum < 100
where sql_id = 'gy6j5kg641saa'
order by sql_id, run_time desc
/
select user_id,sql_id,
count(*),
round(avg(EXTRACT(HOUR FROM run_time) * 3600
+ EXTRACT(MINUTE FROM run_time) * 60
+ EXTRACT(SECOND FROM run_time)),2) avg ,
round(min(EXTRACT(HOUR FROM run_time) * 3600
+ EXTRACT(MINUTE FROM run_time) * 60
+ EXTRACT(SECOND FROM run_time)),2) min ,
round(max(EXTRACT(HOUR FROM run_time) * 3600
+ EXTRACT(MINUTE FROM run_time) * 60
+ EXTRACT(SECOND FROM run_time)),2) max
from (
select
user_id,sql_id,
max(sample_time - sql_exec_start) run_time
from
dba_hist_active_sess_history
where
sql_exec_start is not null
and sql_id = 'gy6j5kg641saa'
group by sql_id,SQL_EXEC_ID,user_id
order by sql_id
)
-- where rownum < 100
group by sql_id,user_id
order by avg desc
/
Find User Commits Per Minute In Oracle Database:
================================================
Below script is useful in getting user commit statistics information in the oracle database. user commits is the number of commits happening the database. It will be helpful in tracking the number of transactions in the database.
col STAT_NAME for a20
col VALUE_DIFF for 9999,999,999
col STAT_PER_MIN for 9999,999,999
set lines 200 pages 1500 long 99999999
col BEGIN_INTERVAL_TIME for a30
col END_INTERVAL_TIME for a30
set pagesize 40
set pause on
SELECT hsys.snap_id,
hsnap.begin_interval_time,
hsnap.end_interval_time,
hsys.stat_name,
hsys.value,
hsys.value - Lag(hsys.value, 1, 0)
over (
ORDER BY hsys.snap_id) AS "VALUE_DIFF",
Round(( hsys.value - Lag(hsys.value, 1, 0)
over (
ORDER BY hsys.snap_id) ) / Round(Abs(Extract(
hour FROM ( hsnap.end_interval_time -
hsnap.begin_interval_time )) * 60
+ Extract(minute FROM
( hsnap.end_interval_time -
hsnap.begin_interval_time )) +
Extract(second FROM
(
hsnap.end_interval_time
-
hsnap.begin_interval_time )) / 60), 1)) "STAT_PER_MIN"
FROM dba_hist_sysstat hsys,
dba_hist_snapshot hsnap
WHERE hsys.snap_id = hsnap.snap_id
AND hsnap.instance_number IN (SELECT instance_number
FROM v$instance)
AND hsnap.instance_number = hsys.instance_number
AND hsys.stat_name = 'user commits'
ORDER BY 1;
Find The Active Transactions In Oracle Database:
================================================
col name format a10
col username format a8
col osuser format a8
col start_time format a17
col status format a12
tti 'Active transactions'
SELECT s.sid,
username,
t.start_time,
r.name,
t.used_ublk
"USED BLKS",
Decode(t.SPACE, 'YES', 'SPACE TX',
Decode(t.recursive, 'YES', 'RECURSIVE TX',
Decode(t.noundo, 'YES', 'NO UNDO TX',
t.status))) status
FROM sys.v_$transaction t,
sys.v_$rollname r,
sys.v_$session s
WHERE t.xidusn = r.usn
AND t.ses_addr = s.saddr
/
Script for Space Re-Claim:
==========================
SET linesize 1000 pagesize 0 feedback off trimspool ON WITH hwm AS (
-- get highest block id from each datafiles ( from x$ktfbue as we don't need all joins from dba_extents )
SELECT /*+ materialize */ ktfbuesegtsn ts#, ktfbuefno relative_fno, max(
ktfbuebno+ktfbueblks-1) hwm_blocks FROM sys.x$ktfbue GROUP BY ktfbuefno,
ktfbuesegtsn ), hwmts AS (
-- join ts# with tablespace_name
SELECT name tablespace_name, relative_fno, hwm_blocks FROM hwm JOIN v$tablespace
USING(ts#) ), hwmdf AS (
-- join with datafiles, put 5M minimum for datafiles with no extents
SELECT file_name, nvl(hwm_blocks*(bytes/blocks), 5*1024*1024) hwm_bytes, bytes,
autoextensible, maxbytes FROM hwmts RIGHT JOIN dba_data_files USING(
tablespace_name, relative_fno) ) SELECT CASE WHEN autoextensible='YES' AND
maxbytes>=bytes THEN
-- we generate resize statements only if autoextensible can grow back to current size
'/* reclaim '||to_char(ceil((bytes-hwm_bytes)/1024/1024), 999999) ||'M from '||
to_char(ceil(bytes/1024/1024), 999999)||'M */ ' ||'alter database datafile '''||
file_name||''' resize '||ceil(hwm_bytes/1024/1024)||'M;' ELSE
-- generate only a comment when autoextensible is off
'/* reclaim '||to_char(ceil((bytes-hwm_bytes)/1024/1024), 999999) ||'M from '||
to_char(ceil(bytes/1024/1024), 999999) ||
'M after setting autoextensible maxsize higher than current size for file ' ||
file_name||' */' end SQL FROM hwmdf WHERE bytes-hwm_bytes>1024*1024
-- resize only if at least 1MB can be reclaimed
ORDER BY bytes-hwm_bytes DESC
/
how to monitor OS usage in RAC:
===============================
select to_char(min(begin_time),'hh24:mi:ss')||' /'||round(avg(intsize_csec/100),0)||'s' "Time+Delta",
metric_name||' - '||metric_unit "Metric",
sum(value_inst1) inst1, sum(value_inst2) inst2, sum(value_inst3) inst3, sum(value_inst4) inst4,
sum(value_inst5) inst5, sum(value_inst6) inst6
from
( select begin_time,intsize_csec,metric_name,metric_unit,metric_id,group_id,
case inst_id when 1 then round(value,1) end value_inst1,
case inst_id when 2 then round(value,1) end value_inst2,
case inst_id when 3 then round(value,1) end value_inst3,
case inst_id when 4 then round(value,1) end value_inst4,
case inst_id when 5 then round(value,1) end value_inst5,
case inst_id when 6 then round(value,1) end value_inst6
from gv$sysmetric
where metric_name in ('Host CPU Utilization (%)','Current OS Load', 'Physical Write Total IO Requests Per Sec',
'Physical Write Total Bytes Per Sec', 'Global Cache Average Current Get Time', 'Global Cache Average CR Get Time',
'Physical Read Total Bytes Per Sec', 'Physical Read Total IO Requests Per Sec',
'CPU Usage Per Sec','Network Traffic Volume Per Sec','Logons Per Sec','Redo Generated Per Sec',
'User Transaction Per Sec','Database CPU Time Ratio','Database Wait Time Ratio','Database Time Per Sec')
)
group by metric_id,group_id,metric_name,metric_unit
order by metric_name;
DBA Metric related Views:
=========================
"V$METRIC"
"V$METRIC_HISTORY"
"V$SYSMETRIC"
"V$SYSMETRIC_HISTORY"
"V$METRICNAME"
"V$METRICGROUP"
"V$SYSMETRIC_SUMMARY"
"V$SESSMETRIC"
"V$FILEMETRIC"
"V$FILEMETRIC_HISTORY"
"V$EVENTMETRIC"
"V$WAITCLASSMETRIC"
"V$WAITCLASSMETRIC_HISTORY"
"V$SERVICEMETRIC"
"V$SERVICEMETRIC_HISTORY"
select distinct metric_name
from v$metric;
To query the PGA cache hit percentage, you can query:
select value, metric_unit,metric_name
from v$metric
where metric_name = 'PGA Cache Hit %'
You can get a quick overview of all metrics by query'ing v$SYSMETRIC_SUMMARY:
select * from
v$SYSMETRIC_SUMMARY
Finding SQL with Performance changing over time:
================================================
SPO sql_performance_changed.txt;
DEF days_of_history_accessed = '31';
DEF captured_at_least_x_times = '10';
DEF captured_at_least_x_days_apart = '5';
DEF med_elap_microsecs_threshold = '1e4';
DEF min_slope_threshold = '0.1';
DEF max_num_rows = '20';
SET lin 200 ver OFF;
COL row_n FOR A2 HEA '#';
COL med_secs_per_exec HEA 'Median Secs|Per Exec';
COL std_secs_per_exec HEA 'Std Dev Secs|Per Exec';
COL avg_secs_per_exec HEA 'Avg Secs|Per Exec';
COL min_secs_per_exec HEA 'Min Secs|Per Exec';
COL max_secs_per_exec HEA 'Max Secs|Per Exec';
COL plans FOR 9999;
COL sql_text_80 FOR A80;
PRO SQL Statements with "Elapsed Time per Execution" changing over time
WITH
per_time AS (
SELECT h.dbid,
h.sql_id,
SYSDATE - CAST(s.end_interval_time AS DATE) days_ago,
SUM(h.elapsed_time_total) / SUM(h.executions_total) time_per_exec
FROM dba_hist_sqlstat h,
dba_hist_snapshot s
WHERE h.executions_total > 0
AND s.snap_id = h.snap_id
AND s.dbid = h.dbid
AND s.instance_number = h.instance_number
AND CAST(s.end_interval_time AS DATE) > SYSDATE - &&days_of_history_accessed.
GROUP BY
h.dbid,
h.sql_id,
SYSDATE - CAST(s.end_interval_time AS DATE)
),
avg_time AS (
SELECT dbid,
sql_id,
MEDIAN(time_per_exec) med_time_per_exec,
STDDEV(time_per_exec) std_time_per_exec,
AVG(time_per_exec) avg_time_per_exec,
MIN(time_per_exec) min_time_per_exec,
MAX(time_per_exec) max_time_per_exec
FROM per_time
GROUP BY
dbid,
sql_id
HAVING COUNT(*) >= &&captured_at_least_x_times.
AND MAX(days_ago) - MIN(days_ago) >= &&captured_at_least_x_days_apart.
AND MEDIAN(time_per_exec) > &&med_elap_microsecs_threshold.
),
time_over_median AS (
SELECT h.dbid,
h.sql_id,
h.days_ago,
(h.time_per_exec / a.med_time_per_exec) time_per_exec_over_med,
a.med_time_per_exec,
a.std_time_per_exec,
a.avg_time_per_exec,
a.min_time_per_exec,
a.max_time_per_exec
FROM per_time h, avg_time a
WHERE a.sql_id = h.sql_id
),
ranked AS (
SELECT RANK () OVER (ORDER BY ABS(REGR_SLOPE(t.time_per_exec_over_med, t.days_ago)) DESC) rank_num,
t.dbid,
t.sql_id,
CASE WHEN REGR_SLOPE(t.time_per_exec_over_med, t.days_ago) > 0 THEN 'IMPROVING' ELSE 'REGRESSING' END change,
ROUND(REGR_SLOPE(t.time_per_exec_over_med, t.days_ago), 3) slope,
ROUND(AVG(t.med_time_per_exec)/1e6, 3) med_secs_per_exec,
ROUND(AVG(t.std_time_per_exec)/1e6, 3) std_secs_per_exec,
ROUND(AVG(t.avg_time_per_exec)/1e6, 3) avg_secs_per_exec,
ROUND(MIN(t.min_time_per_exec)/1e6, 3) min_secs_per_exec,
ROUND(MAX(t.max_time_per_exec)/1e6, 3) max_secs_per_exec
FROM time_over_median t
GROUP BY
t.dbid,
t.sql_id
HAVING ABS(REGR_SLOPE(t.time_per_exec_over_med, t.days_ago)) > &&min_slope_threshold.
)
SELECT LPAD(ROWNUM, 2) row_n,
r.sql_id,
r.change,
TO_CHAR(r.slope, '990.000MI') slope,
TO_CHAR(r.med_secs_per_exec, '999,990.000') med_secs_per_exec,
TO_CHAR(r.std_secs_per_exec, '999,990.000') std_secs_per_exec,
TO_CHAR(r.avg_secs_per_exec, '999,990.000') avg_secs_per_exec,
TO_CHAR(r.min_secs_per_exec, '999,990.000') min_secs_per_exec,
TO_CHAR(r.max_secs_per_exec, '999,990.000') max_secs_per_exec,
(SELECT COUNT(DISTINCT p.plan_hash_value) FROM dba_hist_sql_plan p WHERE p.dbid = r.dbid AND p.sql_id = r.sql_id) plans,
REPLACE((SELECT DBMS_LOB.SUBSTR(s.sql_text, 80) FROM dba_hist_sqltext s WHERE s.dbid = r.dbid AND s.sql_id = r.sql_id), CHR(10)) sql_text_80
FROM ranked r
WHERE r.rank_num <= &&max_num_rows.
ORDER BY
r.rank_num
/
SPO OFF;
Once you get the output of this script above, you can use the one below to actually list the time series for one of the SQL statements of interest:
===================================================================================================================================================
SPO one_sql_time_series.txt;
SET lin 200 ver OFF;
COL instance_number FOR 9999 HEA 'Inst';
COL end_time HEA 'End Time';
COL plan_hash_value HEA 'Plan|Hash Value';
COL executions_total FOR 999,999 HEA 'Execs|Total';
COL rows_per_exec HEA 'Rows Per Exec';
COL et_secs_per_exec HEA 'Elap Secs|Per Exec';
COL cpu_secs_per_exec HEA 'CPU Secs|Per Exec';
COL io_secs_per_exec HEA 'IO Secs|Per Exec';
COL cl_secs_per_exec HEA 'Clus Secs|Per Exec';
COL ap_secs_per_exec HEA 'App Secs|Per Exec';
COL cc_secs_per_exec HEA 'Conc Secs|Per Exec';
COL pl_secs_per_exec HEA 'PLSQL Secs|Per Exec';
COL ja_secs_per_exec HEA 'Java Secs|Per Exec';
SELECT h.instance_number,
To_char(Cast(s.end_interval_time AS DATE), 'YYYY-MM-DD HH24:MI') end_time, h.plan_hash_value, h.executions_total,
To_char(Round(h.rows_processed_total / h.executions_total), '999,999,999,999') rows_per_exec,
To_char(Round(h.elapsed_time_total / h.executions_total / 1e6, 3), '999,990.000') et_secs_per_exec,
To_char(Round(h.cpu_time_total / h.executions_total / 1e6, 3), '999,990.000') cpu_secs_per_exec,
To_char(Round(h.iowait_total / h.executions_total / 1e6, 3), '999,990.000') io_secs_per_exec,
To_char(Round(h.clwait_total / h.executions_total / 1e6, 3), '999,990.000') cl_secs_per_exec,
To_char(Round(h.apwait_total / h.executions_total / 1e6, 3), '999,990.000') ap_secs_per_exec,
To_char(Round(h.ccwait_total / h.executions_total / 1e6, 3), '999,990.000') cc_secs_per_exec,
To_char(Round(h.plsexec_time_total / h.executions_total / 1e6, 3), '999,990.000') pl_secs_per_exec,
To_char(Round(h.javexec_time_total / h.executions_total / 1e6, 3), '999,990.000') ja_secs_per_exec
FROM dba_hist_sqlstat h,
dba_hist_snapshot s
WHERE h.sql_id = &sql_id.'
/
SPO OFF;
Monitoring execution plan changes:
==================================
set sqlblanklines on
set lines 800
set pages 1000
/* statements captured during last days */
with samples as
(select *
from dba_hist_sqlstat st
join dba_hist_snapshot sn
using (snap_id, instance_number)
where parsing_schema_name = '&schema_name'
and module 'DBMS_SCHEDULER' -- no sql tuning task
and executions_delta > 0
and begin_interval_time between sysdate - '&num_days' and sysdate),
/* just statements that had at least 2 different plans during that time */
sql_ids as
(select sql_id,
count(distinct plan_hash_value) plancount
from samples
group by sql_id
having count(distinct plan_hash_value) > 2),
/* per combination of sql_id and plan_hash_value, elapsed times per execution */
plan_stats as
(select sql_id,
plan_hash_value,
count(snap_id) snap_count,
max(end_interval_time) last_seen,
sum(executions_delta) total_execs,
sum(elapsed_time_delta) / sum(executions_delta) elapsed_per_exec_thisplan
from sql_ids
join samples
using (sql_id)
group by sql_id, plan_hash_value),
/* how much different is the elapsed time most recently encountered from other elapsed times in the measurement interval? */
elapsed_time_diffs as
(select p.*,
elapsed_per_exec_thisplan - first_value(elapsed_per_exec_thisplan)
over(partition by sql_id order by last_seen desc) elapsed_per_exec_diff,
(elapsed_per_exec_thisplan - first_value(elapsed_per_exec_thisplan)
over(partition by sql_id order by last_seen desc)) / elapsed_per_exec_thisplan elapsed_per_exec_diff_ratio
from plan_stats p),
/* consider just statements for which the difference is bigger than our configured threshold */
impacted_sql_ids as
(select *
from elapsed_time_diffs
where abs(elapsed_per_exec_diff_ratio) > &threshold),
/* for those statements, get all required information */
all_info as
(select sql_id,
plan_hash_value,
snap_count,
last_seen,
round(elapsed_per_exec_thisplan / 1e6, 2) elapsed_per_exec_thisplan,
round(elapsed_per_exec_diff / 1e6, 2) elapsed_per_exec_diff,
round(100 * elapsed_per_exec_diff_ratio, 2) elapsed_per_exec_diff_pct,
round(max(abs(elapsed_per_exec_diff_ratio))
over(partition by sql_id), 2) * 100 max_abs_diff,
round(max(elapsed_per_exec_diff_ratio) over(partition by sql_id), 2) * 100 max_diff,
'select * from table(dbms_xplan.display_awr(sql_id=>''' || sql_id ||
''', plan_hash_value=>' || plan_hash_value || '));' xplan
from elapsed_time_diffs
where sql_id in (select sql_id from impacted_sql_ids))
/* format the output */
select case sign(elapsed_per_exec_diff)
when 0 then max_abs_diff ||
case when max_abs_diff max_diff then
'% worse than another plan found during the last 7 days'
else
'% better than the next best plan during the last 7 days'
end
end status,
a.sql_id,
a.snap_count,
to_char(last_seen, 'yy-mm-dd hh24:mi:ss') last_seen,
to_char(a.elapsed_per_exec_thisplan, '999999.99') elapsed_per_exec_thisplan,
to_char(a.elapsed_per_exec_diff, '999999.99') elapsed_per_exec_diff,
to_char(a.elapsed_per_exec_diff_pct, '999999.99') elapsed_per_exec_diff_pct,
xplan
from all_info a
order by sql_id, last_seen desc;
select case sign(elapsed_per_exec_diff)
when 0 then max_abs_diff ||
case when max_abs_diff max_diff then
‘% worse than another plan found during the last 7 days’
else
How to find long running queries:
=================================
SELECT sid,
inst_id,
opname,
totalwork,
sofar,
start_time,
time_remaining
FROM gv$session_longops
WHERE totalwork <> sofar
/
How To Connect To Another User Without Knowing The Password In Oracle:
======================================================================
Suppose you want to do some activity under another user, But you don’t know the password of that user. Then how you will do it?
There is a way you can do it. See the below demo.
Suppose a user TEST1 wants to connect to TEST2 user and create a table and we don’t know the password of TEST2.
For this TEST1 user need one privilege i.e grant connect through
Conn / as sysdba
SQL >alter user TEST2 grant connect through TEST1;
User altered.
SQL >conn TEST1[TEST2]
Enter password:< Give password for TEST1>
SQL >show user
USER is "TEST2"
SQL >create table emp_test1 as select * from emp_test;
Table created.
SQL > conn / as sysdba
connected
SQL > select owner from dba_tables where table_name='EMP_TEST';
OWNER
------
TEST2
This method is usually helpful, when you want to drop/create a private db_link and you don’t know the password of that db_link owner.
Once activity is done, revoke the privilege as below.
SQL >conn / as sysdba
Connected.
SQL> alter user TEST2 revoke connect through TEST1;
User altered.
Create Sql Baseline From Cursor Cache:
======================================
If you have the sql_id of the sql query, then you can create a baseline of that using below code.
DECLARE
l_plans_loaded PLS_INTEGER;
BEGIN
l_plans_loaded := DBMS_SPM.load_plans_from_cursor_cache(
sql_id => '&sql_id');
END;
/
Suppose you have multiple plan hash value of the sql_id and you wish to create baseline with a particular plan hash value , then below one can be used.
DECLARE
l_plans_loaded PLS_INTEGER;
BEGIN
l_plans_loaded := DBMS_SPM.load_plans_from_cursor_cache(
sql_id => '&sql_id', plan_hash_value => '&plan_hash_value');
END;
/
Find utilization of redo logs:
==============================
Below is the script to find the utilizations of redo logs
SELECT le.leseq "Current log sequence No",
100 * cp.cpodr_bno / le.lesiz "Percent Full",
cp.cpodr_bno "Current Block No",
le.lesiz "Size of Log in Blocks"
FROM x$kcccp cp,
x$kccle le
WHERE le.leseq = CP.cpodr_seq
AND Bitand(le.leflg, 24) = 8
/
Get hourly database growth report:
==================================
Below script will generate the database size for past few days(per hour)
set serveroutput on
Declare
v_BaselineSize number(20);
v_CurrentSize number(20);
v_TotalGrowth number(20);
v_Space number(20);
cursor usageHist is
select a.snap_id,
TIMESTAMP,
sum(TOTAL_SPACE_ALLOCATED_DELTA) over ( order by a.SNAP_ID) ProgSum
from
(select SNAP_ID,
sum(SPACE_ALLOCATED_DELTA) TOTAL_SPACE_ALLOCATED_DELTA
from DBA_HIST_SEG_STAT
group by SNAP_ID
having sum(SPACE_ALLOCATED_TOTAL) <> 0
order by 1 ) a,
(select distinct SNAP_ID,
to_char(END_INTERVAL_TIME,'DD-Mon-YYYY HH24:Mi') TIMESTAMP
from DBA_HIST_SNAPSHOT) b
where a.snap_id=b.snap_id;
Begin
select sum(SPACE_ALLOCATED_DELTA) into v_TotalGrowth from DBA_HIST_SEG_STAT;
select sum(bytes) into v_CurrentSize from dba_segments;
v_BaselineSize := v_CurrentSize - v_TotalGrowth ;
dbms_output.put_line('TIMESTAMP Database Size(GB)');
for row in usageHist loop
v_Space := (v_BaselineSize + row.ProgSum)/(1024*1024*1024);
dbms_output.put_line(row.TIMESTAMP || ' ' || to_char(v_Space) );
end loop;
end;
/
Find who locked your account:
Below script is used to find, how a user account got locked.
============================================================
-- Return code 1017 ( INVALID LOGIN ATTEMPT)
-- Return code 28000 ( ACCOUNT LOCKED)
set pagesize 1299
set lines 299
col username for a15
col userhost for a13
col timestamp for a39
col terminal for a23
SELECT username,userhost,terminal,timestamp,returncode
FROM dba_audit_session
WHERE username='&USER_NAME' and returncode in (1017,28000);
Find row count of all partitions of a table:
============================================
Below script is for finding the row counts of all partitions of a table in Oracle.
set serverout on size 1000000
set verify off
declare
sql_stmt varchar2(1024);
row_count number;
cursor get_tab is
select table_name,partition_name
from dba_tab_partitions
where table_owner=upper('&&TABLE_OWNER') and table_name='&&TABLE_NAME';
begin
dbms_output.put_line('Checking Record Counts for table_name');
dbms_output.put_line('Log file to numrows_part_&&TABLE_OWNER.lst ....');
dbms_output.put_line('....');
for get_tab_rec in get_tab loop
BEGIN
sql_stmt := 'select count(*) from &&TABLE_OWNER..'||get_tab_rec.table_name
||' partition ( '||get_tab_rec.partition_name||' )';
EXECUTE IMMEDIATE sql_stmt INTO row_count;
dbms_output.put_line('Table '||rpad(get_tab_rec.table_name
||'('||get_tab_rec.partition_name||')',50)
||' '||TO_CHAR(row_count)||' rows.');
exception when others then
dbms_output.put_line
('Error counting rows for table '||get_tab_rec.table_name);
END;
end loop;
end;
/
set verify on
How to find the I/O usage of tempfiles:
=======================================
Below scripts are useful to find the i/o usage of tempfiles
SELECT Substr(t.name, 1, 50) AS file_name,
f.phyblkrd AS blocks_read,
f.phyblkwrt AS blocks_written,
f.phyblkrd + f.phyblkwrt AS total_io
FROM v$tempstat f,
v$tempfile t
WHERE t.file# = f.file#
ORDER BY f.phyblkrd + f.phyblkwrt DESC;
SELECT *
FROM (SELECT u.tablespace,
s.username,
s.sid,
s.serial#,
s.logon_time,
program,
u.extents,
( ( u.blocks * 8 ) / 1024 ) AS MB,
i.inst_id,
i.host_name
FROM gv$session s,
gv$sort_usage u,
gv$instance i
WHERE s.saddr = u.session_addr
AND u.inst_id = i.inst_id
ORDER BY mb DESC) a
WHERE ROWNUM < 10;
Find High water mark of a table:
================================
Below is the script for finding high water mark of a table.
--
-- Show the High Water Mark for a given table, or all tables if ALL is specified for Table_Name.
--
SET LINESIZE 300
SET SERVEROUTPUT ON
SET VERIFY OFF
DECLARE
CURSOR cu_tables IS
SELECT a.owner,
a.table_name
FROM all_tables a
WHERE a.table_name = Decode(Upper('&&Table_Name'),'ALL',a.table_name,Upper('&&Table_Name'))
AND a.owner = Upper('&&Table_Owner')
AND a.partitioned='NO'
AND a.logging='YES'
order by table_name;
op1 NUMBER;
op2 NUMBER;
op3 NUMBER;
op4 NUMBER;
op5 NUMBER;
op6 NUMBER;
op7 NUMBER;
BEGIN
Dbms_Output.Disable;
Dbms_Output.Enable(1000000);
Dbms_Output.Put_Line('TABLE UNUSED BLOCKS TOTAL BLOCKS HIGH WATER MARK');
Dbms_Output.Put_Line('------------------------------ --------------- --------------- ---------------');
FOR cur_rec IN cu_tables LOOP
Dbms_Space.Unused_Space(cur_rec.owner,cur_rec.table_name,'TABLE',op1,op2,op3,op4,op5,op6,op7);
Dbms_Output.Put_Line(RPad(cur_rec.table_name,30,' ') ||
LPad(op3,15,' ') ||
LPad(op1,15,' ') ||
LPad(Trunc(op1-op3-1),15,' '));
END LOOP;
END;
Find sessions holding library cache lock:
========================================
Below are the scripts for finding the sessions holding libary cache lock: For standalone db:
SELECT sid Waiter,
p1raw,
Substr(Rawtohex(p1), 1, 30) Handle,
Substr(Rawtohex(p2), 1, 30) Pin_addr
FROM v$session_wait
WHERE wait_time = 0
AND event LIKE '%library cache%';
For RAC DB:
SELECT a.sid Waiter,
b.serial#,
a.event,
a.p1raw,
Substr(Rawtohex(a.p1), 1, 30) Handle,
Substr(Rawtohex(a.p2), 1, 30) Pin_addr
FROM v$session_wait a,
v$session b
WHERE a.sid = b.sid
AND a.wait_time = 0
AND a.event LIKE 'library cache%';
or
set lines 152
col sid for a9999999999999
col name for a40
SELECT a.sid,
b.name,
a.value,
b.class
FROM gv$sesstat a,
gv$statname b
WHERE a.statistic# = b.statistic#
AND name LIKE '%library cache%';
How to get the bind values of a sql query:
==========================================
If you have the sql_id of the sql query , then you can get the bind values of the bind variables, from v$sql_bind_capture. Script:
SELECT sql_id,
b. last_captured,
t.sql_text sql_text,
b.hash_value,
b.name bind_name,
b.value_string bind_value
FROM gv$sql t
join gv$sql_bind_capture b USING (sql_id)
WHERE b.value_string IS NOT NULL
AND sql_id = '&sqlid'
/
Top 5 wait events from v$active_session_history:
================================================
select * from (
select
WAIT_CLASS ,
EVENT,
count(sample_time) as EST_SECS_IN_WAIT
from v$active_session_history
where sample_time between sysdate - interval '1' hour and sysdate
group by WAIT_CLASS,EVENT
order by count(sample_time) desc
)
where rownum <6;
Top 10 SQL queries from v$active_session_history
================================================
select * from (
select
SQL_ID ,
sum(decode(session_state,'ON CPU',1,0)) as CPU,
sum(decode(session_state,'WAITING',1,0)) - sum(decode(session_state,'WAITING', decode(wait_class, 'User I/O',1,0),0)) as WAIT,
sum(decode(session_state,'WAITING', decode(wait_class, 'User I/O',1,0),0)) as IO,
sum(decode(session_state,'ON CPU',1,1)) as TOTAL
from v$active_session_history
where SQL_ID is not NULL
group by sql_id
order by sum(decode(session_state,'ON CPU',1,1)) desc
)
where rownum <11;
Average Active Sessions from v$active_session_history:
======================================================
select round((count(ash.sample_id) / ((CAST(end_time.sample_time AS DATE) - CAST(start_time.sample_time AS DATE))*24*60*60)),2) as AAS
from
(select min(sample_time) sample_time
from v$active_session_history ash
) start_time,
(select max(sample_time) sample_time
from v$active_session_history
) end_time,
v$active_session_history ash
where ash.sample_time between start_time.sample_time and end_time.sample_time
group by end_time.sample_time,start_time.sample_time;
You can restrict period of time analyzed by filtering with the sample_time column. Here is AAS from the last hour :
select round((count(ash.sample_id) / ((CAST(end_time.sample_time AS DATE) - CAST(start_time.sample_time AS DATE))*24*60*60)),2) as AAS
from
(select min(sample_time) sample_time
from v$active_session_history ash
where sample_time between sysdate-1/24 and sysdate) start_time,
(select max(sample_time) sample_time
from v$active_session_history
where sample_time between sysdate-1/24 and sysdate) end_time,
v$active_session_history ash
where ash.sample_time between start_time.sample_time and end_time.sample_time
group by end_time.sample_time,start_time.sample_time;
Top 10 SQL Activity:
====================
SELECT trunc(sample_time,'MI'),
sql_id,
count(sql_id) as TOTAL
FROM v$active_session_history
WHERE sample_time between sysdate - interval '1' hour and sysdate
AND sql_id in (select sql_id from (
select
SQL_ID ,
sum(decode(session_state,'WAITING',1,1)) as TOTAL_ACTIVITY
from v$active_session_history
WHERE sample_time between sysdate - interval '1' hour and sysdate
group by sql_id
order by sum(decode(session_state,'WAITING',1,1)) desc)
where rownum < 11)
group by trunc(sample_time,'MI'),sql_id
order by trunc(sample_time,'MI') desc
Top 10 sessions from v$active_session_history
=============================================
select * from (
select
session_id,
session_serial#,
program,
module,
action,
sum(decode(session_state,'WAITING',0,1)) "CPU",
sum(decode(session_state,'WAITING',1,0)) - sum(decode(session_state,'WAITING',decode(wait_class,'User I/O',1,0),0)) "WAITING" ,
sum(decode(session_state,'WAITING',decode(wait_class,'User I/O',1,0),0)) "IO" ,
sum(decode(session_state,'WAITING',1,1)) "TOTAL"
from v$active_session_history
where session_type='FOREGROUND'
group by session_id,session_serial#,module,action,program
order by sum(decode(session_state,'WAITING',1,1)) desc)
where rownum <11;
select * from (
select
session_id,
session_serial#,
program,
module,
action,
sum(decode(session_state,'WAITING',0,1)) "CPU",
sum(decode(session_state,'WAITING',1,0)) - sum(decode(session_state,'WAITING',decode(wait_class,'User I/O',1,0),0)) "WAITING" ,
sum(decode(session_state,'WAITING',decode(wait_class,'User I/O',1,0),0)) "IO" ,
sum(decode(session_state,'WAITING',1,1)) "TOTAL"
from v$active_session_history
where session_type='FOREGROUND'
group by session_id,session_serial#,module,action,program
order by sum(decode(session_state,'WAITING',1,1)) desc)
where rownum <11;
How to find current running sqls in oracle:
===========================================
Use below script to get the current running sql details.
select sesion.sid,
sesion.username,
optimizer_mode,
hash_value,
address,
cpu_time,
elapsed_time,
sql_text
from v$sqlarea sqlarea, v$session sesion
where sesion.sql_hash_value = sqlarea.hash_value
and sesion.sql_address = sqlarea.address
and sesion.username is not null;
column status format a10
set feedback off
set serveroutput on
select username, sid, serial#, process, status
from v$session
where username is not null
/
column username format a20
column sql_text format a55 word_wrapped
set serveroutput on size 1000000
declare
x number;
begin
for x in
( select username||'('||sid||','||serial#||
') ospid = ' || process ||
' program = ' || program username,
to_char(LOGON_TIME,' Day HH24:MI') logon_time,
to_char(sysdate,' Day HH24:MI') current_time,
sql_address, LAST_CALL_ET
from v$session
where status = 'ACTIVE'
and rawtohex(sql_address) <> '00'
and username is not null order by last_call_et )
loop
for y in ( select max(decode(piece,0,sql_text,null)) ||
max(decode(piece,1,sql_text,null)) ||
max(decode(piece,2,sql_text,null)) ||
max(decode(piece,3,sql_text,null))
sql_text
from v$sqltext_with_newlines
where address = x.sql_address
and piece < 4)
loop
if ( y.sql_text not like '%listener.get_cmd%' and
y.sql_text not like '%RAWTOHEX(SQL_ADDRESS)%')
then
dbms_output.put_line( '--------------------' );
dbms_output.put_line( x.username );
dbms_output.put_line( x.logon_time || ' ' ||
x.current_time||
' last et = ' ||
x.LAST_CALL_ET);
dbms_output.put_line(
substr( y.sql_text, 1, 250 ) );
end if;
end loop;
end loop;
end;
/
column username format a15 word_wrapped
column module format a15 word_wrapped
column action format a15 word_wrapped
column client_info format a30 word_wrapped
select username||'('||sid||','||serial#||')' username,
module,
action,
client_info
from v$session
where module||action||client_info is not null;
If you frequently need to collect all indexes of a partioned table (local and global indexes), this is a quick script that make the task a little bit easier:
=============================================================================================================================================================
begin
-- local indexes
for i in (select p.index_owner owner, p.index_name, p.partition_name
from dba_indexes i, dba_ind_partitions p
where i.owner='&OWNER'
and i.table_name='&TABLE'
and i.partitioned='YES'
and i.visibility='VISIBLE' -- Rebuild only of the visible indexes, to get real effect :)
and p.index_name=i.index_name
and p.index_owner=i.owner
order by 1,2) loop
execute immediate 'alter index '||i.owner||'.'||i.index_name||' rebuild partition '||i.partition_name||' online parallel 12'; -- parallel 12 solve most of the problems
execute immediate 'alter index '||i.owner||'.'||i.index_name||' parallel 1'; -- If you don't use parallel indexes in your database, or the default parallel of the index, or what you want...
end loop;
-- global indexes
for i in (select i.owner owner, i.index_name
from dba_indexes i
where i.owner='&OWNER'
and i.table_name='&TABLE'
and i.partitioned='NO'
and i.visibility='VISIBLE' -- same comment
order by 1,2) loop
execute immediate 'alter index '||i.owner||'.'||i.index_name||' rebuild online parallel 12'; -- same
execute immediate 'alter index '||i.owner||'.'||i.index_name||' parallel 1'; -- same :)
end loop;
end;
/
Tablespace monitoring in oracle 12c multitenant database.:
==========================================================
You can use this script to check tablespace space details in 12c Multitenant database. It will provide information of both root CDB and PDB.
SET LINES 132 PAGES 100
COL con_name FORM A15 HEAD "Container|Name"
COL tablespace_name FORM A15
COL fsm FORM 999,999,999,999 HEAD "Free|Space Meg."
COL apm FORM 999,999,999,999 HEAD "Alloc|Space Meg."
--
COMPUTE SUM OF fsm apm ON REPORT
BREAK ON REPORT ON con_id ON con_name ON tablespace_name
--
WITH x AS (SELECT c1.con_id, cf1.tablespace_name, SUM(cf1.bytes)/1024/1024 fsm
FROM cdb_free_space cf1
,v$containers c1
WHERE cf1.con_id = c1.con_id
GROUP BY c1.con_id, cf1.tablespace_name),
y AS (SELECT c2.con_id, cd.tablespace_name, SUM(cd.bytes)/1024/1024 apm
FROM cdb_data_files cd
,v$containers c2
WHERE cd.con_id = c2.con_id
GROUP BY c2.con_id
,cd.tablespace_name)
SELECT x.con_id, v.name con_name, x.tablespace_name, x.fsm, y.apm
FROM x, y, v$containers v
WHERE x.con_id = y.con_id
AND x.tablespace_name = y.tablespace_name
AND v.con_id = y.con_id
UNION
SELECT vc2.con_id, vc2.name, tf.tablespace_name, null, SUM(tf.bytes)/1024/1024
FROM v$containers vc2, cdb_temp_files tf
WHERE vc2.con_id = tf.con_id
GROUP BY vc2.con_id, vc2.name, tf.tablespace_name
ORDER BY 1, 2;
Realtime monitoring of sql query using v$sql_plan_monitor:
==========================================================
V$SQL_PLAN_MONITOR displays real time plan level monitoring statistics for the currently running sql queries.. Each row in V$SQL_PLAN_MONITOR corresponds to an operation of the execution plan being monitored.
--- sql_is from v$sql_monitor
SELECT sql_id FROM v$sql_monitor;
SQL_ID
-------
00tr6c6tngp4x
Use below query to get the plan details:
SELECT sid, sql_id, plan_line_id,SQL_PLAN_HASH_VALUE,STARTS,LAST_REFRESH_TIME,LAST_CHANGE_TIME,PLAN_CPU_COST,PLAN_IO_COST,plan_operation || ' ' || plan_options operation, output_rows,status
FROM v$sql_plan_monitor
WHERE status NOT LIKE '%DONE%'
ORDER BY 1,4;
Top 5 cached sql statements by elapsed time in oracle:
======================================================
Get the Top 10 cached sql statements details
SELECT sql_id,
child_number,
sql_text,
elapsed_time
FROM (SELECT sql_id,
child_number,
sql_text,
elapsed_time,
cpu_time,
disk_reads,
Rank ()
over (
ORDER BY elapsed_time DESC) AS elapsed_rank
FROM v$sql)
WHERE elapsed_rank <= 10;
Active session query:
=====================
select S.USERNAME, s.sid, s.osuser, t.sql_id, sql_text
from v$sqltext_with_newlines t,V$SESSION s
where t.address =s.sql_address
and t.hash_value = s.sql_hash_value
and s.status = 'ACTIVE'
and s.username in ('SYS','SYSTEM','DBSNMP')
order by s.sid,t.piece
/
Find out long running queries:
==============================
select s.username,s.sid,s.serial#,s.last_call_et/60 mins_running,q.sql_text from v$session s
join v$sqltext_with_newlines q
on s.sql_address = q.address
where status='ACTIVE'
and type <>'BACKGROUND'
and last_call_et> 600
order by sid,serial#,q.piece
column username format 'a10'
column osuser format 'a10'
column module format 'a16'
column program_name format 'a20'
column program format 'a20'
column machine format 'a20'
column action format 'a20'
column sid format '9999'
column serial# format '99999'
column spid format '99999'
set linesize 200
set pagesize 30
select
a.sid,a.serial#,a.username,a.osuser,c.start_time,
b.spid,a.status,a.machine,
a.action,a.module,a.program
from
v$session a, v$process b, v$transaction c,
v$sqlarea s
Where
a.paddr = b.addr
and a.saddr = c.ses_addr
and a.sql_address = s.address (+)
and to_date(c.start_time,'mm/dd/yy hh24:mi:ss') <= sysdate - (15/1440) -- running for 15 minutes
order by c.start_time
/
Step 2: desc v$session
Step 3:select sid, serial#,SQL_ADDRESS, status,PREV_SQL_ADDR from v$session where sid='xxxx' //(enter the sid value)
Step 4: select sql_text from v$sqltext where address='XXXXXXXX';
Locks in database:
==================
select
object_name,
object_type,
session_id,
type, -- Type or system/user lock
lmode, -- lock mode in which session holds lock
request,
block,
ctime -- Time since current mode was granted
from
v$locked_object, all_objects, v$lock
where
v$locked_object.object_id = all_objects.object_id AND
v$lock.id1 = all_objects.object_id AND
v$lock.sid = v$locked_object.session_id
order by
session_id, ctime desc, object_name
/
Long operations query percentage:
=================================
COLUMN percent FORMAT 999.99
SELECT sid, to_char(start_time,'hh24:mi:ss') stime,
message,( sofar/totalwork)* 100 percent
FROM v$session_longops
WHERE sofar/totalwork < 1
/
How to find sql text from a sid:
================================
Use below query to get the sql text of a particular sid. When the below script asks for input, enter the SID.
col sql_text FORM a80
set lines 120
SELECT sql_text
FROM gv$sqltext
WHERE hash_value = (SELECT sql_hash_value
FROM gv$session
WHERE sid = &1)
ORDER BY piece
/
How to find active sessions in oracle database:
==============================================
Use below script to find active sessions in oracle database.
set echo OFF
set linesize 95
set head ON
set feedback ON
col sid head "Sid" FORM 9999 trunc
col serial# FORM 99999 trunc head "Ser#"
col username FORM a8 trunc
col osuser FORM a7 trunc
col machine FORM a20 trunc head "Client|Machine"
col program FORM a15 trunc head "Client|Program"
col login FORM a11
col "last call" FORM 9999999 trunc head "Last Call|In Secs"
col status FORM a6 trunc
SELECT sid,
serial#,
Substr(username, 1, 10) username,
Substr(osuser, 1, 10) osuser,
Substr(program
||MODULE, 1, 15) program,
Substr(machine, 1, 22) machine,
To_char(logon_time, 'ddMon hh24:mi') login,
last_call_et "last call",
status
FROM v$session
WHERE status = 'ACTIVE'
ORDER BY 1
/
How to get the size of an oracle database:
==========================================
Use below query to get the size of a database.
col "Database Size" format a20
col "Free space" format a20
col "Used space" format a20
SELECT Round(SUM(used.bytes) / 1024 / 1024 / 1024)
|| ' GB' "Database Size",
Round(SUM(used.bytes) / 1024 / 1024 / 1024) - Round(
free.p / 1024 / 1024 / 1024)
|| ' GB' "Used space",
Round(free.p / 1024 / 1024 / 1024)
|| ' GB' "Free space"
FROM (SELECT bytes
FROM v$datafile
UNION ALL
SELECT bytes
FROM v$tempfile
UNION ALL
SELECT bytes
FROM v$log) used,
(SELECT SUM(bytes) AS p
FROM dba_free_space) free
GROUP BY free.p
/
Query to get child table and foreign key status:
===============================================
Use below query to get child key and foreign key status:
col owner FORM a10
col fk_column FORM a15
col table_name FORM a30
SELECT b.owner,
b.table_name child_table,
b.status,
c.column_name FK_column,
b.constraint_name
FROM dba_constraints a,
dba_constraints b,
dba_cons_columns c
WHERE a.owner = b.r_owner
AND b.owner = c.owner
AND b.table_name = c.table_name
AND b.constraint_name = c.constraint_name
AND a.constraint_name = b.r_constraint_name
AND b.constraint_type = 'R'
AND a.owner = '&OWNER'
AND a.table_name = '&TABLE_NAME'
AND a.constraint_type = 'P';
Enable constraints:
===================
alter table FDR.MDT_RM_CALL_CLOSEOUT_METER disable constraints MDT_RM_CALL_CLOSEOUT_METER_FK;
Find the parent table of child table:
====================================
SELECT owner,
table_name
FROM dba_constraints
WHERE constraint_name IN (SELECT r_constraint_name
FROM dba_constraints
WHERE table_name = 'PUROLATOR_ACCOUNTS'
AND constraint_type = 'R');
scripts to monitor standby database:
====================================
FIND THE ARCHIVE LAG BETWEEN PRIMARY AND STANDBY:
=================================================
select LOG_ARCHIVED-LOG_APPLIED "LOG_GAP" from
(SELECT MAX(SEQUENCE#) LOG_ARCHIVED
FROM V$ARCHIVED_LOG WHERE DEST_ID=1 AND ARCHIVED='YES'),
(SELECT MAX(SEQUENCE#) LOG_APPLIED
FROM V$ARCHIVED_LOG WHERE DEST_ID=2 AND APPLIED='YES');
CHECK THE STATUS OF DIFFERENT PROCESS:
======================================
SQL> SELECT PROCESS, STATUS, THREAD#, SEQUENCE#, BLOCK#, BLOCKS FROM V$MANAGED_STANDBY ;
LAST SEQUENCE RECEIVED AND LAST SEQUENCE APPLIED:
=================================================
SQL> SELECT al.thrd "Thread", almax "Last Seq Received", lhmax "Last Seq Applied" FROM
2 (select thread# thrd, MAX(sequence#) almax FROM v$archived_log WHERE resetlogs_change#=(SELECT resetlogs_change#
3 FROM v$database) GROUP BY thread#) al, (SELECT thread# thrd, MAX(sequence#) lhmax FROM v$log_history
WHERE resetlogs_change#=(SELECT resetlogs_change# FROM v$database) GROUP BY thread#) lh WHERE al.thrd = lh.thrd; 4
CHECK THE MESSAGES/ERRORS IN STNADBY DATABASE:
==============================================
set pagesize 2000
set lines 2000
col MESSAGE for a90
select message,timestamp from V$DATAGUARD_STATUS where timestamp > sysdate - 1/6;
CHECK THE NUMBER OF ARCHIVES GETTING GENERATING ON HOURLY BASIS:
================================================================
SELECT TO_CHAR(TRUNC(FIRST_TIME),'Mon DD') "DG Date",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'00',1,0)),'9999') "12AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'01',1,0)),'9999') "01AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'02',1,0)),'9999') "02AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'03',1,0)),'9999') "03AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'04',1,0)),'9999') "04AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'05',1,0)),'9999') "05AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'06',1,0)),'9999') "06AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'07',1,0)),'9999') "07AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'08',1,0)),'9999') "08AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'09',1,0)),'9999') "09AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'10',1,0)),'9999') "10AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'11',1,0)),'9999') "11AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'12',1,0)),'9999') "12PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'13',1,0)),'9999') "1PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'14',1,0)),'9999') "2PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'15',1,0)),'9999') "3PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'16',1,0)),'9999') "4PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'17',1,0)),'9999') "5PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'18',1,0)),'9999') "6PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'19',1,0)),'9999') "7PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'20',1,0)),'9999') "8PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'21',1,0)),'9999') "9PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'22',1,0)),'9999') "10PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'23',1,0)),'9999') "11PM"
FROM V$LOG_HISTORY
WHERE to_date(first_time) > sysdate -8
GROUP BY TRUNC(FIRST_TIME)
ORDER BY TRUNC(FIRST_TIME) DESC
/
SELECT to_date(first_time) DAY,
to_char(sum(decode(to_char(first_time,'HH24'),'00',1,0)),'9999') "00",
to_char(sum(decode(to_char(first_time,'HH24'),'01',1,0)),'9999') "01",
to_char(sum(decode(to_char(first_time,'HH24'),'02',1,0)),'9999') "02",
to_char(sum(decode(to_char(first_time,'HH24'),'03',1,0)),'9999') "03",
to_char(sum(decode(to_char(first_time,'HH24'),'04',1,0)),'9999') "04",
to_char(sum(decode(to_char(first_time,'HH24'),'05',1,0)),'9999') "05",
to_char(sum(decode(to_char(first_time,'HH24'),'06',1,0)),'9999') "06",
to_char(sum(decode(to_char(first_time,'HH24'),'07',1,0)),'9999') "07",
to_char(sum(decode(to_char(first_time,'HH24'),'08',1,0)),'9999') "08",
to_char(sum(decode(to_char(first_time,'HH24'),'09',1,0)),'9999') "09",
to_char(sum(decode(to_char(first_time,'HH24'),'10',1,0)),'9999') "10",
to_char(sum(decode(to_char(first_time,'HH24'),'11',1,0)),'9999') "11",
to_char(sum(decode(to_char(first_time,'HH24'),'12',1,0)),'9999') "12",
to_char(sum(decode(to_char(first_time,'HH24'),'13',1,0)),'9999') "13",
to_char(sum(decode(to_char(first_time,'HH24'),'14',1,0)),'9999') "14",
to_char(sum(decode(to_char(first_time,'HH24'),'15',1,0)),'9999') "15",
to_char(sum(decode(to_char(first_time,'HH24'),'16',1,0)),'9999') "16",
to_char(sum(decode(to_char(first_time,'HH24'),'17',1,0)),'9999') "17",
to_char(sum(decode(to_char(first_time,'HH24'),'18',1,0)),'9999') "18",
to_char(sum(decode(to_char(first_time,'HH24'),'19',1,0)),'9999') "19",
to_char(sum(decode(to_char(first_time,'HH24'),'20',1,0)),'9999') "20",
to_char(sum(decode(to_char(first_time,'HH24'),'21',1,0)),'9999') "21",
to_char(sum(decode(to_char(first_time,'HH24'),'22',1,0)),'9999') "22",
to_char(sum(decode(to_char(first_time,'HH24'),'23',1,0)),'9999') "23"
from
v$log_history
where to_date(first_time) > sysdate -8
GROUP by
to_char(first_time,'YYYY-MON-DD'), to_date(first_time)
order by to_date(first_time);
How to get ddl of all tablespaces in oracle:
===========================================
Below script will generate the DDLs of all the tablespaces in oracle.
SQL>set heading off;
SQL>set echo off;
SQL>Set pages 999;
SQL>set long 90000;
SQL>spool ddl_list.sql
SQL>select dbms_metadata.get_ddl('TABLESPACE',tb.tablespace_name) from dba_tablespaces tb;
SQL>spool off
Query to check tablespace free space:
=====================================
Use below query to check all the space related details of tablespaces.
set feedback off
set pagesize 2000;
set linesize 300
set head on
COLUMN Tablespace format a25 heading 'Tablespace Name'
COLUMN autoextensible format a11 heading 'AutoExtend'
COLUMN files_in_tablespace format 999 heading 'Files'
COLUMN total_tablespace_space format 99999999 heading 'TotalSpace'
COLUMN total_used_space format 99999999 heading 'UsedSpace'
COLUMN total_tablespace_free_space format 99999999 heading 'FreeSpace'
COLUMN total_used_pct format 9999 heading '%Used'
COLUMN total_free_pct format 9999 heading '%Free'
COLUMN max_size_of_tablespace format 99999999 heading 'ExtendUpto'
COLUM total_auto_used_pct format 999.99 heading 'Max%Used'
COLUMN total_auto_free_pct format 999.99 heading 'Max%Free'
WITH tbs_auto AS
(SELECT DISTINCT tablespace_name, autoextensible
FROM dba_data_files
WHERE autoextensible = 'YES'),
files AS
(SELECT tablespace_name, COUNT (*) tbs_files,
SUM (BYTES/1024/1024) total_tbs_bytes
FROM dba_data_files
GROUP BY tablespace_name),
fragments AS
(SELECT tablespace_name, COUNT (*) tbs_fragments,
SUM (BYTES)/1024/1024 total_tbs_free_bytes,
MAX (BYTES)/1024/1024 max_free_chunk_bytes
FROM dba_free_space
GROUP BY tablespace_name),
AUTOEXTEND AS
(SELECT tablespace_name, SUM (size_to_grow) total_growth_tbs
FROM (SELECT tablespace_name, SUM (maxbytes)/1024/1024 size_to_grow
FROM dba_data_files
WHERE autoextensible = 'YES'
GROUP BY tablespace_name
UNION
SELECT tablespace_name, SUM (BYTES)/1024/1024 size_to_grow
FROM dba_data_files
WHERE autoextensible = 'NO'
GROUP BY tablespace_name)
GROUP BY tablespace_name)
SELECT c.instance_name,a.tablespace_name Tablespace,
CASE tbs_auto.autoextensible
WHEN 'YES'
THEN 'YES'
ELSE 'NO'
END AS autoextensible,
files.tbs_files files_in_tablespace,
files.total_tbs_bytes total_tablespace_space,
(files.total_tbs_bytes - fragments.total_tbs_free_bytes
) total_used_space,
fragments.total_tbs_free_bytes total_tablespace_free_space,
round(( ( (files.total_tbs_bytes - fragments.total_tbs_free_bytes)
/ files.total_tbs_bytes
)
* 100
)) total_used_pct,
round(((fragments.total_tbs_free_bytes / files.total_tbs_bytes) * 100
)) total_free_pct
FROM dba_tablespaces a,v$instance c , files, fragments, AUTOEXTEND, tbs_auto
WHERE a.tablespace_name = files.tablespace_name
AND a.tablespace_name = fragments.tablespace_name
AND a.tablespace_name = AUTOEXTEND.tablespace_name
AND a.tablespace_name = tbs_auto.tablespace_name(+)
AND a.tablespace_name in ('EPICIXLARGE','EPICIXMEDIUM','EPICLARGE','EPICMEDIUM')
order by total_free_pct;
How to find log gap between primary and standby db:
===================================================
Use the below query to find the applied archive log gap between primary and standby oracle database.
SELECT log_archived - log_applied "LOG_GAP"
FROM (SELECT Max(sequence#) LOG_ARCHIVED
FROM v$archived_log
WHERE dest_id = 1
AND archived = 'YES'),
(SELECT Max(sequence#) LOG_APPLIED
FROM v$archived_log
WHERE dest_id = 2
AND applied = 'YES');
How to find free space in UNDO tablespace:
==========================================
Use below script to get the details about undo tablespace usage.
SELECT a.tablespace_name,
sizemb,
usagemb,
( sizemb - usagemb ) FREEMB
FROM (SELECT SUM(bytes) / 1024 / 1024 SIZEMB,
b.tablespace_name
FROM dba_data_files a,
dba_tablespaces b
WHERE a.tablespace_name = b.tablespace_name
AND b.CONTENTS = 'UNDO'
GROUP BY b.tablespace_name) a,
(SELECT c.tablespace_name,
SUM(bytes) / 1024 / 1024 USAGEMB
FROM dba_undo_extents c
WHERE status <> 'EXPIRED'
GROUP BY c.tablespace_name) b
WHERE a.tablespace_name = b.tablespace_name;
How To Check Undo Tablespace Usage and the Free Space:
=====================================================
This section provides the various scripts that can be used to check Undo space usage.
Note: “The Undo Space once allocated won’t be deallocated to the OS, by default.
But the space can be reused by other transactions once the UNDO_RETENION is met.”
Query 1. To check the current size of the Undo tablespace:
Select sum(a.bytes) as undo_size from v$datafile a, v$tablespace b, dba_tablespaces c
where c.contents = 'UNDO'
and c.status = 'ONLINE'
and b.name = c.tablespace_name
and a.ts# = b.ts#;
Query 2. To check the free space (unallocated) space within Undo tablespace:
select sum(bytes)/1024/1024 "mb" from dba_free_space
where tablespace_name ='<tablespace name>';
Query 3.To Check the space available within the allocated Undo tablespace:
select tablespace_name,sum(blocks)*8/(1024) reusable_space from dba_undo_extents
where status='EXPIRED' group by tablespace_name;
Query 4. To Check the space allocated in the Undo tablespace:
select tablespace_name , sum(blocks)*8/(1024) space_in_use from dba_undo_extents
where status IN ('ACTIVE','UNEXPIRED') group by tablespace_name;
How to find the temp tablespace usage:
======================================
Run the below scripts to get the temp tablespace usage.
SELECT a.tablespace_name
tablespace,
d.temp_total_mb,
SUM (a.used_blocks * d.block_size) / 1024 / 1024
TEMP_USED_MB,
d.temp_total_mb - SUM (a.used_blocks * d.block_size) / 1024 / 1024
TEMP_FREE_MB
FROM v$sort_segment a,
(SELECT b.name,
c.block_size,
SUM (c.bytes) / 1024 / 1024 TEMP_TOTAL_MB
FROM v$tablespace b,
v$tempfile c
WHERE b.ts# = c.ts#
GROUP BY b.name,
c.block_size) d
WHERE a.tablespace_name = d.name
GROUP BY a.tablespace_name,
d.temp_total_mb;
monitor rman backup progress:
=============================
Use the below query to monitor the currently running rman backup status.
SELECT sid,
serial#,
message,
sofar,
totalwork,
Round(sofar / totalwork * 100, 2) "%_COMPLETE"
FROM v$session_longops
WHERE opname LIKE 'RMAN%'
AND opname NOT LIKE '%aggregate%'
AND totalwork != 0
AND sofar <> totalwork;
set serveroutput on
set linesize 150
set pagesize 300
col time_taken_display for a9
select session_key,
input_type,
to_char(start_time,'yyyy-mm-dd hh24:mi') start_time,
to_char(end_time,'yyyy-mm-dd hh24:mi') end_time,
time_taken_display,
status
from v$rman_backup_job_details where status='RUNNING'
order by session_key desc;
Monitoring RMAN jobs:
SELECT sid, serial#, context, sofar, totalwork,
round(sofar/totalwork*100,2) "% Complete"
FROM v$session_longops
WHERE opname LIKE 'RMAN%'
AND opname NOT LIKE '%aggregate%'
AND totalwork != 0
AND sofar <> totalwork;
SELECT TRUNC(FIRST_TIME)
, COUNT(*)
FROM V$ARCHIVED_LOG
WHERE FIRST_TIME BETWEEN ADD_MONTHS(SYSDATE,-1) AND SYSDATE
AND DEST_ID = 1
GROUP BY TRUNC(FIRST_TIME)
ORDER BY 1;
SELECT TO_CHAR (COMPLETION_TIME, 'DD/MM/YYYY') DAY,
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '00', 1, NULL))
"00-01",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '01', 1, NULL))
"01-02",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '02', 1, NULL))
"02-03",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '03', 1, NULL))
"03-04",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '04', 1, NULL))
"04-05",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '05', 1, NULL))
"05-06",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '06', 1, NULL))
"06-07",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '07', 1, NULL))
"07-08",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '08', 1, NULL))
"08-09",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '09', 1, NULL))
"09-10",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '10', 1, NULL))
"10-11",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '11', 1, NULL))
"11-12",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '12', 1, NULL))
"12-13",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '13', 1, NULL))
"13-14",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '14', 1, NULL))
"14-15",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '15', 1, NULL))
"15-16",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '16', 1, NULL))
"16-17",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '17', 1, NULL))
"17-18",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '18', 1, NULL))
"18-19",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '19', 1, NULL))
"19-20",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '20', 1, NULL))
"20-21",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '21', 1, NULL))
"21-22",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '22', 1, NULL))
"22-23",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '23', 1, NULL))
"23-00",
COUNT (*) TOTAL
FROM V$ARCHIVED_LOG
WHERE ARCHIVED='YES'
GROUP BY TO_CHAR (COMPLETION_TIME, 'DD/MM/YYYY')
ORDER BY TO_DATE (DAY, 'DD/MM/YYYY');
SCRIPT – CHECK RMAN BACKUP STATUS
=================================
This script will report on all backups – full, incremental and archivelog backups –
col STATUS format a9
col hrs format 999.99
select
SESSION_KEY, INPUT_TYPE, STATUS,
to_char(START_TIME,'mm/dd/yy hh24:mi') start_time,
to_char(END_TIME,'mm/dd/yy hh24:mi') end_time,
elapsed_seconds/3600 hrs
from V$RMAN_BACKUP_JOB_DETAILS
order by session_key;
This script will report all on full and incremental backups, not archivelog backups –
col STATUS format a9
col hrs format 999.99
select
SESSION_KEY, INPUT_TYPE, STATUS,
to_char(START_TIME,'mm/dd/yy hh24:mi') start_time,
to_char(END_TIME,'mm/dd/yy hh24:mi') end_time,
elapsed_seconds/3600 hrs
from V$RMAN_BACKUP_JOB_DETAILS
where input_type='DB INCR'
order by session_key;
col STATUS format a9
col hrs format 999.99
select
SESSION_KEY, INPUT_TYPE, STATUS,
to_char(START_TIME,'mm/dd/yy hh24:mi') start_time,
to_char(END_TIME,'mm/dd/yy hh24:mi') end_time,
elapsed_seconds/3600 hrs
from V$RMAN_BACKUP_JOB_DETAILS
where input_type in ('DB FULL','DB INCR')
order by session_key;
How to find the wait events present in database:
================================================
Below query will results the current wait event details in oracle database.
SELECT a.sid,
Substr(b.username, 1, 10) username,
Substr(b.osuser, 1, 10) osuser,
Substr(b.program
||b.MODULE, 1, 15) program,
Substr(b.machine, 1, 22) machine,
a.event,
a.p1,
b.sql_hash_value
FROM v$session_wait a,
v$session b
WHERE b.sid = a.sid
AND a.event NOT IN( 'SQL*Net message from client',
'SQL*Net message to client',
'smon timer',
'pmon timer' )
AND username IS NOT NULL
ORDER BY 6
/
select ss.snap_id,
ss.instance_number node,
begin_interval_time,
sql_id,
plan_hash_value,
nvl(executions_delta,0) execs,
round((elapsed_time_delta/decode(nvl(executions_delta,0),0,1,executions_delta))/1000000,2) avg_etime,
round((buffer_gets_delta/decode(nvl(buffer_gets_delta,0),0,1,executions_delta)),2) avg_lio
from DBA_HIST_SQLSTAT S,
DBA_HIST_SNAPSHOT SS
where sql_id = 'xxxxxxxx'
and ss.snap_id = S.snap_id
and ss.instance_number = S.instance_number
and executions_delta > 0
order by 1 desc, 2, 3;
How to find the session using lot of undo:
==========================================
Below query will show the current sessions undo usage.
select a.sid, a.serial#, a.username, b.used_urec used_undo_record, b.used_ublk used_undo_blocks
from v$session a, v$transaction b
where a.saddr=b.ses_addr ;
How to find the locks present in oracle database:
=================================================
Below query will help you in providing sessions causing lock in the database.
col session_id head 'Sid' form 9999
col object_name head "Table|Locked" form a30
col oracle_username head "Oracle|Username" form a10 truncate
col os_user_name head "OS|Username" form a10 truncate
col process head "Client|Process|ID" form 99999999
col mode_held form a15
select lo.session_id,lo.oracle_username,lo.os_user_name,
lo.process,do.object_name,
decode(lo.locked_mode,0, 'None',1, 'Null',2, 'Row Share (SS)',
3, 'Row Excl (SX)',4, 'Share',5, 'Share Row Excl (SSX)',6, 'Exclusive',
to_char(lo.locked_mode)) mode_held
from v$locked_object lo, dba_objects do
where lo.object_id = do.object_id
order by 1,5
/
How to find the sessions using lot of temp:
===========================================
Below query will display the the list of sessions using lot of temps including their usage.
SELECT b.TABLESPACE
, b.segfile#
, b.segblk#
, ROUND ( ( ( b.blocks * p.VALUE ) / 1024 / 1024 ), 2 ) size_mb
, a.SID
, a.serial#
, a.username
, a.osuser
, a.program
, a.status
FROM v$session a
, v$sort_usage b
, v$process c
, v$parameter p
WHERE p.NAME = 'db_block_size'
AND a.saddr = b.session_addr
AND a.paddr = c.addr
ORDER BY b.TABLESPACE, b.segfile#, b.segblk#, b.blocks;
How to find the sessions generating lot of logs:
================================================
We can use below sql query to find the current sessions or queries generating lot of logs
set lines 2000
set pages 1000
col sid for 99999
col name for a09
col username for a14
col PROGRAM for a21
col MODULE for a25
select s.sid,sn.SERIAL#,n.name, round(value/1024/1024,2) redo_mb, sn.username,sn.status,substr (sn.program,1,21) "program", sn.type, sn.module,sn.sql_id
from v$sesstat s join v$statname n on n.statistic# = s.statistic#
join v$session sn on sn.sid = s.sid where n.name like 'redo size' and s.value!=0 order by
redo_mb desc;
How to check the Oracle database restore status datafile wise - Size of the file to restore and where are we now?
Query to find the database restore status - datafile wise
==========================================================
select SID,OPEN_TIME, (sysdate-open_time)*24*60 ela_time_minutes,close_time,filename,(EFFECTIVE_BYTES_PER_SECOND/1024/1024/1024)*3600 SPEED_GBPERHR,(TOTAL_BYTES/1024/1024/1024) GBTOBEREAD_FROM_FIL
E,(bytes)/1024/1024/1024 GB_Written_sofar from V$BACKUP_ASYNC_IO;
or
select SID,OPEN_TIME, (sysdate-open_time)*24*60 ela_time_minutes,close_time,filename,(EFFECTIVE_BYTES_PER_SECOND/1024/1024/1024)*3600 SPEED_GBPERHR,(TOTAL_BYTES/1024/1024/1024) GBTOBEREAD_FROM_FIL
E,(bytes)/1024/1024/1024 GB_Written_sofar from V$BACKUP_SYNC_IO;
Calculate the space used by a single object:
============================================
SELECT s.owner,
s.segment_name,
s.bytes/1024/1024 "Size(MB)"
FROM dba_segments s,
dba_lobs l
WHERE s.owner = '&schema_name'
AND s.owner=l.owner(+)
AND s.segment_name =
CASE WHEN s.segment_type = 'LOBSEGMENT'
THEN L.SEGMENT_NAME(+)
WHEN s.segment_type = 'LOBINDEX'
THEN L.INDEX_NAME(+)
END
AND s.SEGMENT_NAME='&segment_name';
Calculate the space used by a whole schema:
===========================================
SELECT s.owner,
SUM(s.bytes/1024/1024) "Size(MB)"
FROM dba_segments s,
dba_lobs l
WHERE s.owner = '&schema_name'
AND s.owner=l.owner(+)
AND s.segment_name =
CASE WHEN s.segment_type = 'LOBSEGMENT'
THEN L.SEGMENT_NAME(+)
WHEN s.segment_type = 'LOBINDEX'
THEN L.INDEX_NAME(+)
END
group by s.owner
order by 2;
TOP 10 SEGMENTS/OBJECTS IN ORACLE DATABASE:
===========================================
col owner format a15
col segment_name format a30
col segment_type format a15
col mb format 999, 999, 999
SELECT owner,
segment_name,
segment_type,
mb
FROM (SELECT owner,
segment_name,
segment_type,
bytes / 1024 / 1024 "MB"
FROM dba_segments
ORDER BY bytes DESC)
WHERE ROWNUM < 11;
COLUMN segment_nm format a45
COLUMN used_size format a16
Set lines 999
SELECT segment_nm,
segment_type,
Lpad(CASE
WHEN bytes < 1024 THEN Round(bytes, 2)
|| 'B'
WHEN bytes < Power(1024, 2) THEN Round(( bytes / 1024 ), 2)
|| 'KB'
WHEN bytes < Power(1024, 3) THEN Round(( bytes / 1024 / 1024 ), 2)
|| 'MB'
WHEN bytes < Power(1024, 4) THEN Round((
bytes / 1024 / 1024 / 1024 ), 2)
|| 'GB'
ELSE Round(( bytes / 1024 / 1024 / 1024 / 1024 ), 2)
|| 'TB'
END, 15) AS used_size,
tablespace_name
FROM (SELECT owner
|| '.'
|| Lower(segment_name) AS segment_nm,
segment_type,
bytes,
tablespace_name,
Dense_rank()
over (
ORDER BY bytes DESC ) AS dr
FROM dba_segments) A
WHERE dr <= 10 /* top-10 may have more then 10 */
ORDER BY /* lots of ordering in cases of ties */
bytes DESC,
dr ASC,
segment_nm ASC;
SELECT a.owner,
a.table_name,
b.size_gb,
( ( a.blocks * 8192 / 1024 / 1024 / 1024 ) - (
a.num_rows * avg_row_len / 1024 / 1024 / 1024 ) )
AS ACTUAL_GB,
( b.size_gb - ( ( a.blocks * 8192 / 1024 / 1024 / 1024 ) - (
a.num_rows * avg_row_len / 1024 / 1024 / 1024 ) ) )
Savings,
a.tablespace_name,
b.segment_type
TABLE_TYPE,
a.last_analyzed
FROM dba_tables a,
(SELECT *
FROM (SELECT owner,
segment_name,
segment_type,
tablespace_name,
SUM(bytes / 1024 / 1024 / 1024) Size_GB
FROM dba_segments
WHERE owner = '&schema_name'
AND segment_type LIKE '%TABLE%'
GROUP BY segment_name,
owner,
segment_type,
tablespace_name
ORDER BY 5 DESC)
WHERE ROWNUM < 11) b
WHERE a.table_name = b.segment_name
AND a.owner = b.owner
ORDER BY size_gb DESC;
Largest Database Objects in a Tablespace: - The following query shows 10 Largest database objects in a specific Tablespace
=========================================
col owner format a15
col segment_name format a30
col segment_type format a15
col mb format 999, 999, 999
SELECT owner,
segment_name,
segment_type,
mb
FROM (SELECT owner,
segment_name,
segment_type,
bytes / 1024 / 1024 "MB"
FROM dba_segments
WHERE tablespace_name = '&name'
ORDER BY bytes DESC)
WHERE ROWNUM < 11
Database Growth Checking:
=========================
SET LINESIZE 200
SET PAGESIZE 200
COL "Database Size" FORMAT a13
COL "Used Space" FORMAT a11
COL "Used in %" FORMAT a11
COL "Free in %" FORMAT a11
COL "Database Name" FORMAT a13
COL "Free Space" FORMAT a12
COL "Growth DAY" FORMAT a11
COL "Growth WEEK" FORMAT a12
COL "Growth DAY in %" FORMAT a16
COL "Growth WEEK in %" FORMAT a16
SELECT
(select min(creation_time) from v$datafile) "Create Time",
(select name from v$database) "Database Name",
ROUND((SUM(USED.BYTES) / 1024 / 1024 / 1024 ),2) || ' GB' "Database Size",
ROUND((SUM(USED.BYTES) / 1024 / 1024 / 1024 ) - ROUND(FREE.P / 1024 / 1024 / 1024),2) || ' GB' "Used Space",
ROUND(((SUM(USED.BYTES) / 1024 / 1024 / 1024) - (FREE.P / 1024 / 1024 / 1024)) / ROUND(SUM(USED.BYTES) / 1024 / 1024 / 1024,2)*100,2) || '% GB' "Used in %",
ROUND((FREE.P / 1024 / 1024 / 1024 ),2) || ' GB' "Free Space",
ROUND(((SUM(USED.BYTES) / 1024 / 1024 / 1024 ) - ((SUM(USED.BYTES) / 1024 / 1024 / 1024) - ROUND(FREE.P / 1024 / 1024 / 1024)))/ROUND(SUM(USED.BYTES) / 1024 / 1024 / 1024,2 )*100,2) || '% GB' "Free in %",
ROUND(((SUM(USED.BYTES) / 1024 / 1024 / 1024 ) - (FREE.P / 1024 / 1024 / 1024))/(select sysdate-min(creation_time) from v$datafile),2) || ' GB' "Growth DAY",
ROUND(((SUM(USED.BYTES) / 1024 / 1024 / 1024) - (FREE.P / 1024 / 1024 / 1024))/(select sysdate-min(creation_time) from v$datafile)/ROUND((SUM(USED.BYTES) / 1024 / 1024 / 1024),2)*100,3) || '% GB' "Growth DAY in %",
ROUND(((SUM(USED.BYTES) / 1024 / 1024 / 1024) - (FREE.P / 1024 / 1024 / 1024))/(select sysdate-min(creation_time) from v$datafile)*7,2) || ' GB' "Growth WEEK",
ROUND((((SUM(USED.BYTES) / 1024 / 1024 / 1024) - (FREE.P / 1024 / 1024 / 1024))/(select sysdate-min(creation_time) from v$datafile)/ROUND((SUM(USED.BYTES) / 1024 / 1024 / 1024),2)*100)*7,3) || '% GB' "Growth WEEK in %"
FROM (SELECT BYTES FROM V$DATAFILE
UNION ALL
SELECT BYTES FROM V$TEMPFILE
UNION ALL
SELECT BYTES FROM V$LOG) USED,
(SELECT SUM(BYTES) AS P FROM DBA_FREE_SPACE) FREE
GROUP BY FREE.P;
select to_char(creation_time, 'MM-RRRR') "Month", sum(bytes)/1024/1024/1024 "Growth in GB"
from sys.v_$datafile
where to_char(creation_time,'RRRR')='2018'
group by to_char(creation_time, 'MM-RRRR')
order by to_char(creation_time, 'MM-RRRR');
1) DROP USER OBJECTS:
=====================
conn username/password --->>> MANDATORY to connect as a user
declare
cursor fkc is select table_name,
constraint_name
from user_constraints
where constraint_type ='R';
tname user_constraints.table_name%TYPE;
cname user_constraints.constraint_name%TYPE;
begin
open fkc;
loop
fetch fkc into tname, cname;
exit when fkc%NOTFOUND;
dbms_output.put_line('alter table '||tname||' drop constraint '||cname);
execute immediate 'alter table '||tname||' drop constraint '||cname;
end loop;
close fkc;
end;
/
declare
cursor fkc is select object_name,
object_type
from user_objects
where object_name not in
('INDEX','PACKAGE BODY');
obj_name user_objects.object_name%TYPE;
obj_type user_objects.object_type%TYPE;
begin
open fkc;
loop
fetch fkc into obj_name, obj_type;
exit when fkc%NOTFOUND;
dbms_output.put_line('Drop '||obj_type||' '||obj_name);
begin
execute immediate 'Drop '||obj_type||' '||obj_name;
exception
when others then null;
end;
end loop;
close fkc;
end;
/
PURGE RECYCLEBIN;
DECLARE
the_job user_jobs.job%TYPE;
cursor c1 is select job from user_jobs;
BEGIN
open c1;
loop
fetch c1 into the_job;
exit when c1%NOTFOUND;
dbms_job.remove(the_job);
end loop;
close c1;
END;
/
VERIFY :
set heading off
SQL > select 'Objects left in schema : ' from dual;
SQL> select object_name,object_type from user_objects;
SQL> select 'Jobs left in schema: ' from dual;
SQL> select job,what from user_jobs;
2) User privileges & Grantee :
==============================
SELECT grantee, privilege, admin_option
FROM sys.dba_sys_privs
WHERE (privilege LIKE '% ANY %'
OR privilege IN ('BECOME USER', 'UNLIMITED TABLESPACE')
OR admin_option = 'YES')
AND grantee NOT IN ('SYS', 'SYSTEM', 'OUTLN', 'AQ_ADMINISTRATOR_ROLE',
'DBA', 'EXP_FULL_DATABASE', 'IMP_FULL_DATABASE',
'OEM_MONITOR', 'CTXSYS', 'DBSNMP', 'IFSSYS',
'IFSSYS$CM', 'MDSYS', 'ORDPLUGINS', 'ORDSYS',
'TIMESERIES_DBA')
3) Free Space :
===============
//** This script lists all Tablespaces and its datafiles with their free and used space **//
SET SERVEROUTPUT ON
SET PAGESIZE 1000
SET LINESIZE 255
SET FEEDBACK OFF
col "Used%" for 9999999999
SELECT Substr(df.tablespace_name,1,20) "Tablespace Name",
Substr(df.file_name,1,40) "File Name",
Round(df.bytes/1024/1024,2) "Size (M)",
Round(e.used_bytes/1024/1024,2) "Used (M)",
Round(f.free_bytes/1024/1024,2) "Free (M)",
Rpad(' '|| Rpad ('X',Round(e.used_bytes*10/df.bytes,0), 'X'),11,'-') "Used%"
FROM DBA_DATA_FILES df,
(SELECT file_id, Sum(Decode(bytes,NULL,0,bytes)) used_bytes
FROM dba_extents GROUP by file_id) e,
(SELECT Max(bytes) free_bytes, file_id
FROM dba_free_space GROUP BY file_id) f
WHERE e.file_id (+) = df.file_id
AND df.file_id = f.file_id (+)
AND df.tablespace_name='EPICIXLARGE'
ORDER BY df.tablespace_name, df.file_name;
4) Tablespaces :
================
//** This script lists all Tablespaces with their Sizes **//
SELECT /* + RULE */ df.tablespace_name "Tablespace",
df.bytes / (1024 * 1024) "Size (MB)",
SUM(fs.bytes) / (1024 * 1024) "Free (MB)",
Nvl(Round(SUM(fs.bytes) * 100 / df.bytes),1) "% Free",
Round((df.bytes - SUM(fs.bytes)) * 100 / df.bytes) "% Used"
FROM dba_free_space fs,
(SELECT tablespace_name,SUM(bytes) bytes
FROM dba_data_files
GROUP BY tablespace_name) df
WHERE fs.tablespace_name (+) = df.tablespace_name
GROUP BY df.tablespace_name,df.bytes
UNION ALL
SELECT /* + RULE */ df.tablespace_name tspace,
fs.bytes / (1024 * 1024),
SUM(df.bytes_free) / (1024 * 1024),
Nvl(Round((SUM(fs.bytes) - df.bytes_used) * 100 / fs.bytes), 1),
Round((SUM(fs.bytes) - df.bytes_free) * 100 / fs.bytes)
FROM dba_temp_files fs,
(SELECT tablespace_name,bytes_free,bytes_used
FROM v$temp_space_header
GROUP BY tablespace_name,bytes_free,bytes_used) df
WHERE fs.tablespace_name (+) = df.tablespace_name
GROUP BY df.tablespace_name,fs.bytes,df.bytes_free,df.bytes_used
ORDER BY 4 DESC;
select
a.tablespace_name,
round(SUM(a.bytes)/(1024*1024*1024)) CURRENT_GB,
round(SUM(decode(b.maxextend, null, A.BYTES/(1024*1024*1024),
b.maxextend*8192/(1024*1024*1024)))) MAX_GB,
(SUM(a.bytes)/(1024*1024*1024) - round(c.Free/1024/1024/1024)) USED_GB,
round((SUM(decode(b.maxextend, null, A.BYTES/(1024*1024*1024),
b.maxextend*8192/(1024*1024*1024))) - (SUM(a.bytes)/(1024*1024*1024) -
round(c.Free/1024/1024/1024))),2) FREE_GB,
round(100*(SUM(a.bytes)/(1024*1024*1024) -
round(c.Free/1024/1024/1024))/(SUM(decode(b.maxextend, null, A.BYTES/(1024*1024*1024),
b.maxextend*8192/(1024*1024*1024))))) USED_PCT
from
dba_data_files a,
sys.filext$ b,
(SELECT
d.tablespace_name ,sum(nvl(c.bytes,0)) Free
FROM
dba_tablespaces d,
DBA_FREE_SPACE c
WHERE
d.tablespace_name = c.tablespace_name(+)
group by d.tablespace_name) c
WHERE
a.file_id = b.file#(+)
and a.tablespace_name = c.tablespace_name
and a.tablespace_name in ('EPICIXLARGE','EPICIXMEDIUM','EPICLARGE','EPICMEDIUM')
GROUP BY a.tablespace_name, c.Free/1024
ORDER BY tablespace_name;
File I/O Operations
===================
SET PAGESIZE 14
SET VERIFY ON
select snap_id,begintime,endtime,filename,sum(Phy_Reads),sum(Phy_Read_Time),sum(Phy_Writes),sum(Phy_write_time) from
(select nm.snap_id,
to_char(begin_interval_time,'DD-MON-YYYY HH24:MI') begintime,
to_char(end_interval_time,'DD-MON-YYYY HH24:MI') endtime, filename,
nvl(decode(greatest(PHYBLKRD, nvl(lag(PHYBLKRD) over (partition by dba_hist_filestatxs.dbid,
dba_hist_filestatxs.instance_number, tsname, filename order by dba_hist_filestatxs.snap_id),0)),
PHYBLKRD, PHYBLKRD - lag(PHYBLKRD) over (partition by dba_hist_filestatxs.dbid, dba_hist_filestatxs.instance_number,
tsname, filename order by dba_hist_filestatxs.snap_id),PHYBLKRD), 0) Phy_Reads,
nvl(decode(greatest(READTIM, nvl(lag(READTIM) over (partition by dba_hist_filestatxs.dbid,
dba_hist_filestatxs.instance_number, tsname, filename order by dba_hist_filestatxs.snap_id),0)),
READTIM, READTIM - lag(READTIM) over (partition by dba_hist_filestatxs.dbid, dba_hist_filestatxs.instance_number,
tsname, filename order by dba_hist_filestatxs.snap_id),READTIM), 0) Phy_Read_Time,
nvl(decode(greatest(PHYBLKWRT, nvl(lag(PHYBLKWRT) over (partition by dba_hist_filestatxs.dbid,
dba_hist_filestatxs.instance_number, tsname, filename order by dba_hist_filestatxs.snap_id),0)),
PHYBLKWRT, PHYBLKWRT - lag(PHYBLKWRT) over (partition by dba_hist_filestatxs.dbid, dba_hist_filestatxs.instance_number,
tsname, filename order by dba_hist_filestatxs.snap_id),PHYBLKWRT), 0) Phy_Writes,
nvl(decode(greatest(WRITETIM, nvl(lag(WRITETIM) over (partition by dba_hist_filestatxs.dbid,
dba_hist_filestatxs.instance_number, tsname, filename order by dba_hist_filestatxs.snap_id),0)),
WRITETIM, WRITETIM - lag(WRITETIM) over (partition by dba_hist_filestatxs.dbid, dba_hist_filestatxs.instance_number, tsname,
filename order by dba_hist_filestatxs.snap_id),WRITETIM), 0) Phy_Write_Time
from
dba_hist_filestatxs,
dba_hist_snapshot nm
where
dba_hist_filestatxs.snap_id = nm.snap_id
and begin_interval_time >= sysdate - 1
and filename like '%'
order by
nm.begin_interval_time) iodetail
group by snap_id,begintime,endtime,filename;
UNDO Usage:
===========
select s.snap_id,s.start_time,s.end_time,
x.tablespace_name,
(x.tablespace_size*x.block_size/1024/1024)*.8,
x.tablespace_usedsize*x.block_size/1024/1024
from
(select
dhtsu.snap_id,dbat.tablespace_name,dhtsu.tablespace_size,dhtsu.tablespace_maxsize,
dhtsu.tablespace_usedsize ,dbat.block_size
from DBA_HIST_TBSPC_SPACE_USAGE dhtsu,v$tablespace vt,dba_tablespaces dbat
where
dhtsu.tablespace_id = vt.ts# and
vt.name in
(
select value from v$parameter where upper(name)= 'UNDO_TABLESPACE'
) and
vt.name = dbat.TABLESPACE_NAME
)x,
(
select snap_id,
max(to_char((trunc(begin_interval_time,'mi')),'DD/MON/YYYY HH24:MI:SS')) as start_time,
max(to_char((trunc(end_interval_time, 'mi')),'DD/MON/YYYY HH24:MI:SS')) as end_time
from dba_hist_snapshot
where begin_interval_time >= sysdate - 60
group by snap_id
) s
where s.snap_id = x.snap_id
order by x.tablespace_name,snap_id
Datafile Details:
=================
select df.tablespace_name,ts.block_size,ts.initial_extent,ts.next_extent,
ts.min_extents,ts.max_extents,ts.pct_increase,ts.min_extlen,ts.status,ts.contents,
ts.logging,ts.force_logging,ts.extent_management,ts.allocation_type,ts.plugged_in,
ts.segment_space_management,ts.def_tab_compression,ts.retention,ts.bigfile,
df.file_name,df.file_id,df.bytes,df.blocks,df.status,df.relative_fno,
df.autoextensible,df.maxbytes,df.maxblocks,df.increment_by,df.user_bytes,
df.user_blocks,df.online_status
from dba_tablespaces ts, dba_data_files df where
upper(ts.tablespace_name) like '%'
and upper(df.file_name) like '%'
and df.tablespace_name = ts.tablespace_name
union
select tf.tablespace_name,ts.block_size,ts.initial_extent,ts.next_extent,
ts.min_extents,ts.max_extents,ts.pct_increase,ts.min_extlen,ts.status,ts.contents,
ts.logging,ts.force_logging,ts.extent_management,ts.allocation_type,ts.plugged_in,
ts.segment_space_management,ts.def_tab_compression,ts.retention,'',
tf.file_name,tf.file_id,tf.bytes,tf.blocks,tf.status,tf.relative_fno,
tf.autoextensible,tf.maxbytes,tf.maxblocks,tf.increment_by,tf.user_bytes,
tf.user_blocks, ''
from dba_tablespaces ts, dba_temp_files tf where
upper(ts.tablespace_name) like '%'
and upper(tf.file_name) like '%'
and tf.tablespace_name = ts.tablespace_name
order by 1,2
Segment Growth Trend:
=====================
SELECT to_char(timepoint,'DD-MON-YYYY HH24:MI'),space_usage,space_alloc,quality
FROM
table(
DBMS_SPACE.OBJECT_GROWTH_TREND (
object_owner => 'SYSTEM',
object_name => 'REPCAT$_REPSCHEMA',
object_type => 'TABLE',
partition_name => '',
start_time =>SYSDATE-360,
end_time =>SYSDATE+360,
interval =>to_dsinterval( '0 12:00:00') ,
skip_interpolated => 'FALSE',
timeout_seconds =>NULL,
single_datapoint_flag =>'TRUE')
);
Data Growth Trend:
==================
select s.snap_id,s.start_time,s.end_time,x.tablespace_maxsize*x.block_size/1024/1024,
x.tablespace_size*x.block_size/1024/1024,x.tablespace_usedsize*x.block_size/1024/1024
from
(select dhtsu.snap_id,dhtsu.tablespace_size,dhtsu.tablespace_maxsize,dhtsu.tablespace_usedsize ,dbat.block_size
from DBA_HIST_TBSPC_SPACE_USAGE dhtsu,v$tablespace vt,dba_tablespaces dbat where
dhtsu.tablespace_id = vt.ts# and
vt.name = 'CALYPSO_DATA' and
vt.name = dbat.TABLESPACE_NAME
)x,
(
select snap_id,
max(to_char((trunc(begin_interval_time, 'mi')),'DD/MON/YYYY HH24:MI:SS')) as start_time,
max(to_char((trunc(end_interval_time, 'mi')),'DD/MON/YYYY HH24:MI:SS')) as end_time
from dba_hist_snapshot
where begin_interval_time >= sysdate - 30
group by snap_id
) s
where s.snap_id = x.snap_id
order by snap_id;
5) Locked_objects :
===================
SET LINESIZE 500
SET PAGESIZE 1000
SET VERIFY OFF
COLUMN owner FORMAT A20
COLUMN username FORMAT A20
COLUMN object_owner FORMAT A20
COLUMN object_name FORMAT A30
COLUMN locked_mode FORMAT A15
SELECT b.session_id AS sid,
NVL(b.oracle_username, '(oracle)') AS username,
a.owner AS object_owner,
a.object_name,
Decode(b.locked_mode, 0, 'None',
1, 'Null (NULL)',
2, 'Row-S (SS)',
3, 'Row-X (SX)',
4, 'Share (S)',
5, 'S/Row-X (SSX)',
6, 'Exclusive (X)',
b.locked_mode) locked_mode,
b.os_user_name
FROM dba_objects a,
v$locked_object b
WHERE a.object_id = b.object_id
ORDER BY 1, 2, 3, 4;
Locking Information:
====================
select
sid, lt.name,
decode(lmode,
0, 'None',
1, 'Null',
2, 'Row-S (SS)',
3, 'Row-X (SX)',
4, 'Share',
5, 'S/Row-X (SSX)',
6, 'Exclusive',
to_char(lmode)) mode_held,
decode(request,
0, 'None',
1, 'Null',
2, 'Row-S (SS)',
3, 'Row-X (SX)',
4, 'Share',
5, 'S/Row-X (SSX)',
6, 'Exclusive',
to_char(request)) mode_requested,
lt.id1_tag||':'||to_char(l.id1) ID1, lt.id2_tag||':'||to_char(l.id2) ID2,
ctime last_convert,
decode(block,
0, 'Not Blocking',
1, 'Blocking',
2, 'Global',
to_char(block)) blocking_others
from v$lock l , v$lock_type lt where
l.type = lt.type
order by lt.name,sid;
6) Data Pump Monitoring Script :
================================
select sid, serial#, sofar, totalwork, dp.owner_name, dp.operation, dp.workers, dp.job_mode, dp.state from gv$session_longops sl, gv$datapump_job dp
where sl.opname = dp.job_name and sofar != totalwork;
select a.service_name, a.sid, sql_text ,target, sofar, totalwork, time_remaining still, elapsed_seconds tillnow from gv$session a , gv$sql b, gv$session_longops c where a.sid=c.sid and a.sql_address = b.address and a.sql_address = c.sql_address and status = 'ACTIVE' and a.username='&USERNAME';
7) RMAN Job Monitoring Script :
===============================
SQL > SELECT SID, SERIAL#, CONTEXT, SOFAR, TOTALWORK,ROUND(SOFAR/TOTALWORK*100,2) "%_COMPLETE"
FROM V$SESSION_LONGOPS
WHERE OPNAME LIKE 'RMAN%' AND OPNAME NOT LIKE '%aggregate%'
AND TOTALWORK != 0 AND SOFAR <> TOTALWORK ;
To see the Rman status and SID:
SQL > SELECT s.SID, p.SPID, s.CLIENT_INFO FROM V$PROCESS p, V$SESSION s
WHERE p.ADDR = s.PADDR AND CLIENT_INFO LIKE 'rman%';
8) To see what USERS are Running :
==================================
SELECT a.sid, a.serial#, a.username, b.sql_text FROM v$session a, v$sqlarea b
WHERE a.sql_address=b.address;
**** To see for a particular USER, what he is running *******
SELECT a.sid, a.serial#, a.username, b.sql_text FROM v$session a, v$sqlarea b
WHERE a.sql_address=b.address and a.username = '<username>';
9) Find FREE/USED/TOTAL size of oracle database :
=================================================
(used space):
----------------
SQL> select sum(bytes)/1024/1024/1024 GB from dba_segments;
(free space):
---------------
SQL> select sum(bytes)/1024/1024/1024 GB from dba_free_space;
(Total database size):
---------------------------
SQL> select sum(bytes)/1024/1024/1024 GB from dba_data_files;
+
(Temp size):
---------------
SQL> select SUM(bytes_used)/1024/1024/1024 GBused, SUM(bytes_free)/1024/1024/1024 GBfree from v$temp_space_header;
(or)
SELECT SUM (a.log_space + b.data_space + c.tempspace) "Total_DB_Size (G)"
FROM (SELECT ROUND (SUM (BYTES/1024/1024/1024), 2) data_space FROM dba_data_files) b,(SELECT ROUND (SUM (BYTES*members/1024/1024/1024), 2) log_space FROM v$log) a, (SELECT NVL(ROUND(SUM(BYTES/1024/1024/1024),2), 0) tempspace FROM dba_temp_files) c;
10) RMAN Cold Backup :
======================
Rman target / nocatalog
Rman > configure controlfile autobackup on;
Rman > run {
2> allocate channel d1 type disk;
3> Backup full tag full_offline_bkup
4> Format ‘/var/backup/corppsdb/rman/db_t%t_s%s_p%p’
5> Database plus archivelog;
6> Release channel d1;
}
SGA + PGA Memory Details:
=========================
spool memory_details.log
show parameter sga
show parameter pga
show parameter memo
select inst_id,sum(bytes/1024/1024/1024) SGA_gb from gv$sgastat group by inst_id;
select inst_id,sum(bytes/1024/1024) SGA_Mb from gv$sgastat group by inst_id;
select sum(bytes/1024/1024/1024) SGA_gb from v$sgastat;
select sum(bytes/1024/1024) SGA_Mb from v$sgastat;
SELECT s.inst_id,sum(s.value/1024/1024/1024) PGA_GB FROM gv$sesstat s, gv$statname n WHERE s.statistic# = n.statistic# AND n.name = 'session pga memory' GROUP BY S.INST_ID;
SELECT s.inst_id,sum(s.value/1024/1024) PGA_MB FROM gv$sesstat s, gv$statname n WHERE s.statistic# = n.statistic# AND n.name = 'session pga memory' GROUP BY S.INST_ID;
SELECT sum(s.value/1024/1024/1024) PGA_GB FROM v$sesstat s, v$statname n WHERE s.statistic# = n.statistic# AND n.name = 'session pga memory';
SELECT sum(s.value/1024/1024) PGA_MB FROM v$sesstat s, v$statname n WHERE s.statistic# = n.statistic# AND n.name = 'session pga memory';
/
Individual Process memory
------------------------
select a.sid,a.serial#,a.username,osuser,machine,round(value/(1024*1024)),program from v$session a, v$sesstat b where a.sid=b.sid and b.statistic#=(select statistic# from v$statname where name='session pga memory');
Performance Scripts:
=====================
Real Time SQL Performance:
===========================
SELECT
sess.inst_id,
sess.sid,
sess.serial#,
sess.sql_id||'::'||vsa.plan_hash_value,
sess.STATUS,
sess.username,
sess.type,
sess.program,
sum(case when statn.name = 'CPU used by this session' then nvl(sql.value/1000000,0) end) as "cpu",
sum(case when statn.name = 'user I/O wait time' then nvl(sql.value/1000000,0) end) as "I/O",
sum(case when statn.name = 'application wait time' then nvl(sql.value/1000000,0) end) as "App",
sum(case when statn.name = 'concurrency wait time' then nvl(sql.value/1000000,0) end) as "Conc",
sum(case when statn.name = 'cluster wait time' then nvl(sql.value/1000000,0) end) as "Clus",
sum(case when statn.name = 'redo synch time' then nvl(sql.value/1000000,0) end) as "RedoSync",
sum(case when statn.name = 'parse time elapsed' then nvl(sql.value/1000000,0) end) as "Parse"
FROM gV$SESSION sess, gv$sesstat sql, gv$sqlarea vsa, gv$statname statn
where
Sess.AUDSID <> userenv('SESSIONID') and
sess.inst_id = sql.inst_id and
sess.sid = sql.sid and
sql.statistic# = statn.statistic# and
statn.name in
(
'CPU used by this session',
'cluster wait time',
'concurrency wait time',
'application wait time',
'user I/O wait time',
'redo synch time',
'parse time elapsed') and
sess.sql_address=vsa.address(+) and
sess.inst_id = vsa.inst_id(+)
group by
sess.inst_id,
sess.sid,
sess.serial#,
sess.sql_id||'::'||vsa.plan_hash_value,
sess.STATUS,
sess.username,
sess.type,
sess.program
having sess.status = max(sess.status)
order by sess.inst_id,
sess.sid,
sess.serial#;
Historical SQL Wait Events:
===========================
select x.session_id,x.SESSION_SERIAL#,x.sql_id||'::'||x.SQL_PLAN_HASH_VALUE,
min(x.sample_time), max(x.sample_time),x.event
,count(*) , sum(x.time_waited)/1000000 from
(select snap_id,SESSION_ID,SESSION_SERIAL#,sql_id,SQL_PLAN_HASH_VALUE,
event,sample_time,time_waited,p1text,p1,p2text,p2,p3text,p3 from dba_hist_active_sess_history where
sql_id = '87gaftwrm2h68'
) x,
(select snap_id from dba_hist_snapshot
where begin_interval_time >= sysdate - 1
group by snap_id ) s
where s.snap_id = x.snap_id
group by x.session_id,x.SESSION_SERIAL#,x.sql_id||'::'||x.SQL_PLAN_HASH_VALUE,x.event
order by x.session_id,x.SESSION_SERIAL#,x.sql_id||'::'||x.SQL_PLAN_HASH_VALUE,x.event;
Historcal SQL Execution Plan Usage:
===================================
SELECT sql_text from dba_hist_sqltext where
sql_id = '<SQLID Here>';
SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY_AWR('<SQLID Here>','<Plan Hash Value Here>',null,'ALL +OUTLINE'));
Database Wide SQL Performance
==============================
select x.sql_id||'::'||x.plan_hash_value,
sum(x.executions_delta),
sum(x.elapsed_time_delta)/1000000,
sum(x.cpu_time_delta)/1000000,
sum(x.sorts_delta),
sum(x.rows_processed_delta),
sum(x.disk_reads_delta),
sum(x.IOWAIT_DELTA)/1000000,
sum(x.CLWAIT_DELTA)/1000000,
sum(x.APWAIT_DELTA)/1000000,
sum(x.CCWAIT_DELTA)/1000000
from
(select snap_id,
sql_id,
plan_hash_value,
executions_delta,
elapsed_time_delta,
cpu_time_delta,
sorts_delta,
rows_processed_delta,
disk_reads_delta,
IOWAIT_DELTA,
CLWAIT_DELTA,
APWAIT_DELTA,
CCWAIT_DELTA
from dba_hist_sqlstat) x,
(select snap_id,
max(to_char((trunc(begin_interval_time, 'mi')),'DD/MON/YYYY HH24:MI')) as start_time,
max(to_char((trunc(end_interval_time, 'mi')),'DD/MON/YYYY HH24:MI')) as end_time
from dba_hist_snapshot
where begin_interval_time >= sysdate - 1
group by snap_id ) s
where s.snap_id = x.snap_id
group by x.sql_id||'::'||x.plan_hash_value
having sum(x.elapsed_time_delta) > 0
order by x.sql_id||'::'||x.plan_hash_value;
System Topology:
================
SELECT snap_id,TO_CHAR(begin_interval_time, 'DD-MON-YYYY HH24:MI'),TO_CHAR(end_interval_time, 'DD-MON-YYYY HH24:MI'),d.name||instance_number,
ROUND(MAX(ela),2) "Elapse Time (s)",
ROUND(MAX(case when stat_name='logons current' then (value) else 0 end),3) "Sess# Start",
ROUND(MAX(case when stat_name='total PGA allocated' then (value)/1024/1024 else 0 end),3) "pga (mb)",
ROUND(MAX(case when stat_name='total PGA allocated' then (value)/1024/1024 else 0 end)
/MAX(case when stat_name='logons current' then (value) else 0 end),3) "pga (mb/sess)",
ROUND(SUM(case when stat_name='NUM_VCPUS' then value else 0 end),2) "CPU Cores",
ROUND(MAX(case when stat_name='NUM_CPUS' then value else 0 end),2) "CPU Threads",
ROUND(MAX(case when stat_name='DB time' then diff_val else 0 end),2) "Active Sessions/Sec",
ROUND(MAX(case when stat_name='NUM_VCPUS' then value*ela else 0 end),2) "Total Core Time",
ROUND(SUM(case when stat_name='BUSY_TIME' then diff_val else 0 end)/max(ela),2) "Host Core Util",
ROUND(SUM(case when stat_name='USER_TIME' then diff_val else 0 end)/max(ela),2) "Host User Util",
ROUND(SUM(case when stat_name='SYS_TIME' then diff_val else 0 end)/max(ela),2) "Host SYS Util",
ROUND(SUM(case when stat_name='LOAD' then value else 0 end),2) "LOAD(# Active Process)",
ROUND(SUM(case when stat_name='DB CPU' or stat_name='background cpu time' then diff_val else 0 end),2) "DB+BG Time (s)",
ROUND(SUM(case when stat_name='DB CPU' or stat_name='background cpu time' then diff_val else 0 end)/max(ela),2) "DB Cores Util",
ROUND(MAX(case when stat_name='background cpu time' then diff_val else 0 end)/max(ela),2) "BG Time Core",
ROUND(MAX(case when stat_name='RMAN cpu time (backup/restore)' then diff_val else 0 end)/max(ela),2) "RMAN Core",
ROUND(MAX(case when stat_name='physical read IO requests' then diff_val/ela else 0 end),3) "IOPs r",
ROUND(MAX(case when stat_name='physical read total IO requests' then (diff_val)/ela else 0 end),3) "IOPs r total",
ROUND(MAX(case when stat_name='physical read total multi block requests' then (diff_val)/ela else 0 end),3) "IOPs r Sequential",
ROUND(SUM(case when stat_name='physical read total IO requests' then (diff_val)/ela
when stat_name='physical read total multi block requests' then -1*(diff_val)/ela else 0 end),3) "IOPs r Random(single)",
ROUND(MAX(case when stat_name='redo blocks read for recovery' then (diff_val)/ela else 0 end),3) "redo recovery blocks/s",
ROUND(MAX(case when stat_name='physical write IO requests' then diff_val/ela else 0 end),3) "IOPs w",
ROUND(MAX(case when stat_name='physical write total IO requests' then (diff_val)/ela else 0 end),3) "IOPs w total",
ROUND(MAX(case when stat_name='physical write total multi block requests' then (diff_val)/ela else 0 end),3) "IOPs w Sequential",
ROUND(SUM(case when stat_name='physical write total IO requests' then (diff_val)/ela
when stat_name='physical write total multi block requests' then -1*(diff_val)/ela else 0 end),3) "IOPs w Random(single)",
ROUND(MAX(case when stat_name='DBWR undo block writes' then (diff_val)/ela else 0 end),3) "Undo Blocks/s",
ROUND(SUM(case when stat_name='redo blocks written' then diff_val/ela else 0 end),5) "redo blocks written/s",
ROUND(SUM(case when stat_name='redo writes' then diff_val/ela else 0 end),5) "redo write/s",
ROUND(SUM(case when stat_name='redo blocks written' then diff_val else 0 end)/
SUM(case when stat_name='redo writes' then diff_val else 1 end),5) "Redo Blocks/w",
ROUND(MAX(case when stat_name='physical read bytes' then (diff_val)/ela else 0 end),3) "IO r (bytes)/s",
ROUND(MAX(case when stat_name='physical read total bytes' then (diff_val)/ela else 0 end),3) "IO_Tot r (bytes)/s",
ROUND(MAX(case when stat_name='physical write bytes' then (diff_val)/ela else 0 end),3) "IO w (bytes)/s",
ROUND(MAX(case when stat_name='physical write total bytes' then (diff_val)/ela else 0 end),3) "IO_Tot w (bytes)/s",
ROUND(MAX(case when stat_name='redo size' then (diff_val)/ela else 0 end),3) "Redo (bytes)/s",
ROUND(MAX(case when stat_name='bytes sent via SQL*Net to client' then (diff_val)/ela else 0 end),3) "SQL*Net Sent (bytes)/s",
ROUND(MAX(case when stat_name='bytes received via SQL*Net from client' then (diff_val)/ela else 0 end),3) "SQL*Net received (bytes)/s",
ROUND (((SUM (CASE WHEN stat_name = 'gc cr blocks received' OR stat_name = 'gc current blocks received'
OR stat_name = 'gc cr blocks served' OR stat_name = 'gc current blocks served'
THEN diff_val ELSE 0 END) * (SELECT TO_NUMBER (VALUE) FROM v$parameter WHERE name = 'db_block_size'))
+ (SUM (CASE WHEN stat_name = 'gcs messages sent' OR stat_name = 'ges messages sent'
OR stat_name = 'gcs msgs received' OR stat_name = 'ges msgs received' THEN diff_val ELSE 0 END) * 200)
) / 1024 / MAX (ela), 3) "Estd Interconnect traffic (KB)"
FROM (
SELECT s.instance_number, s.snap_id, s.begin_interval_time begin_interval_time, s.end_interval_time end_interval_time,
round((CAST (s.end_interval_time AS DATE) - CAST (s.begin_interval_time AS DATE)) * 24 * 3600) ela, sy.stat_name stat_name,
(CASE WHEN s.begin_interval_time = s.startup_time THEN sy.VALUE
ELSE sy.VALUE - LAG (sy.VALUE, 1) OVER
(PARTITION BY sy.stat_id, s.dbid, s.instance_number, s.startup_time ORDER BY s.snap_id)
END) / 1000000 diff_val, sy.VALUE value
FROM dba_hist_snapshot s, dba_hist_sys_time_model sy
WHERE s.dbid = sy.dbid (+)
AND s.instance_number = sy.instance_number (+)
AND s.snap_id = sy.snap_id (+)
AND sy.stat_name in ('DB CPU','DB time','background cpu time','RMAN cpu time (backup/restore)')
union all
SELECT s.instance_number, s.snap_id, s.begin_interval_time begin_interval_time, s.end_interval_time end_interval_time,
round((CAST (s.end_interval_time AS DATE) - CAST (s.begin_interval_time AS DATE)) * 24 * 3600) ela, os.stat_name stat_name,
(CASE WHEN s.begin_interval_time = s.startup_time THEN os.VALUE
ELSE os.VALUE - LAG (os.VALUE, 1) OVER
(PARTITION BY os.stat_id, s.dbid, s.instance_number, s.startup_time ORDER BY s.snap_id)
END) / 100 diff_val, os.VALUE value
FROM dba_hist_snapshot s, dba_hist_osstat os
WHERE s.dbid = os.dbid (+)
AND s.instance_number = os.instance_number (+)
AND s.snap_id = os.snap_id (+)
AND os.stat_name in ('BUSY_TIME','USER_TIME','SYS_TIME','NUM_CPUS','NUM_VCPUS','LOAD')
union all
SELECT s.instance_number, s.snap_id, s.begin_interval_time begin_interval_time, s.end_interval_time end_interval_time,
round((CAST (s.end_interval_time AS DATE) - CAST (s.begin_interval_time AS DATE)) * 24 * 3600) ela, ps.name stat_name,
(CASE WHEN s.begin_interval_time = s.startup_time THEN ps.VALUE
ELSE ps.VALUE - LAG (ps.VALUE, 1) OVER
(PARTITION BY ps.name, s.dbid, s.instance_number, s.startup_time ORDER BY s.snap_id)
END) diff_val, ps.VALUE value
FROM dba_hist_snapshot s, dba_hist_pgastat ps
WHERE s.dbid = ps.dbid (+)
AND s.instance_number = ps.instance_number (+)
AND s.snap_id = ps.snap_id (+)
AND ps.name in ('total PGA allocated')
union all
SELECT s.instance_number, s.snap_id, s.begin_interval_time begin_interval_time, s.end_interval_time end_interval_time,
round((CAST (s.end_interval_time AS DATE) - CAST (s.begin_interval_time AS DATE)) * 24 * 3600) ela, ss.stat_name stat_name,
(CASE WHEN s.begin_interval_time = s.startup_time THEN ss.VALUE
ELSE ss.VALUE - LAG (ss.VALUE, 1) OVER
(PARTITION BY ss.stat_id, s.dbid, s.instance_number, s.startup_time ORDER BY s.snap_id)
END) diff_val, ss.VALUE value
FROM dba_hist_snapshot s, dba_hist_sysstat ss
WHERE s.dbid = ss.dbid (+)
AND s.instance_number = ss.instance_number (+)
AND s.snap_id = ss.snap_id (+)
AND ss.stat_name in ('logons current','execute count',
'physical reads','physical writes',
'physical read total bytes','physical read bytes',
'physical write total bytes','physical write bytes',
'redo writes','redo size','redo blocks written',
'physical read IO requests','physical read total IO requests','physical read total multi block requests',
'physical read total IO multi block requests',
'physical write IO requests','physical write total IO requests','physical write total multi block requests',
'physical write total IO multi block requests',
'DBWR undo block writes','redo blocks read for recovery',
'bytes sent via SQL*Net to client','bytes received via SQL*Net from client','Estd Interconnect traffic',
'session logical reads',
'gc cr blocks received','gc current blocks received','gc cr blocks served','gc current blocks served',
'gcs messages sent','ges messages sent')
union all
SELECT s.instance_number, s.snap_id, s.begin_interval_time begin_interval_time, s.end_interval_time end_interval_time,
round((CAST (s.end_interval_time AS DATE) - CAST (s.begin_interval_time AS DATE)) * 24 * 3600) ela, dm.name stat_name,
(CASE WHEN s.begin_interval_time = s.startup_time THEN dm.VALUE
ELSE dm.VALUE - LAG (dm.VALUE, 1) OVER
(PARTITION BY dm.name, s.dbid, s.instance_number, s.startup_time ORDER BY s.snap_id)
END) diff_val, dm.VALUE value
FROM dba_hist_snapshot s, dba_hist_dlm_misc dm
WHERE s.dbid = dm.dbid (+)
AND s.instance_number = dm.instance_number (+)
AND s.snap_id = dm.snap_id (+)
AND dm.name in ('gcs msgs received','ges msgs received')
order by instance_number,snap_id desc,stat_name
), v$database d
Where TO_CHAR(end_interval_time, 'DD-MON-YYYY HH24:MI') > '2014-08-14 00:00:00'
GROUP BY snap_id,TO_CHAR(begin_interval_time, 'DD-MON-YYYY HH24:MI'),TO_CHAR(end_interval_time, 'DD-MON-YYYY HH24:MI'),d.name||instance_number
order by d.name||instance_number , snap_id;
Real Time Wait Events:
=====================
Wait Event Time
===============
select INST_ID||':'||EVENT,time_waited from gv$system_event
order by 1,2;
?
Wait Event Count
================
select INST_ID||':'||EVENT, TOTAL_WAITS from gv$system_event
order by 1,2;
Historical Wait Events:
=======================
select s.start_time,
instance_number||':'||event_name,
sum(nvl(total_waits,0)),
sum(nvl(TIME_WAITED_MICRO,0))
from
(select snap_id,
instance_number,
event_name,
total_waits,
time_waited_micro
from dba_hist_system_event) x,
(select snap_id,
max(to_char((trunc(begin_interval_time, 'mi')),'DD-MON-YYYY HH24:MI')) as start_time,
max(to_char((trunc(end_interval_time, 'mi')),'DD-MON-YYYY HH24:MI')) as end_time
from dba_hist_snapshot
where begin_interval_time >= sysdate -1
group by snap_id
) s
where s.snap_id = x.snap_id
group by s.snap_id,s.start_time,
instance_number||':'||event_name
order by s.snap_id;
Instance Latching:
select inst_id||':'||name, SLEEPS from gv$latch order by sleeps desc;
Buffer Cache Content:
=====================
select
t1.owner c0, object_name c1,
case when object_type = 'TABLE PARTITION' then 'TAB PART'
when object_type = 'INDEX PARTITION' then 'IDX PART'
else object_type end c2,
sum(num_blocks) c3,
(sum(num_blocks)/greatest(sum(blocks), .001))*100 c4,
buffer_pool c5,sum(bytes)/sum(blocks) c6
from
(select o.owner owner,o.object_name object_name,o.subobject_name subobject_name,o.object_type object_type,
count(distinct file# || block#) num_blocks
from
dba_objects o, v$bh bh
where
o.data_object_id = bh.objd and
o.owner not in ('SYS','SYSTEM') and
bh.status != 'free'
group by
o.owner,o.object_name,o.subobject_name,o.object_type
order by
count(distinct file# || block#) desc) t1, dba_segments s
where
s.segment_name = t1.object_name and
s.owner = t1.owner and
s.segment_type = t1.object_type and
nvl(s.partition_name,'-') = nvl(t1.subobject_name,'-')
group by
t1.owner,object_name,object_type,buffer_pool
having sum(num_blocks) > 10
order by sum(num_blocks) desc
SGA Hit Ratios:
===============
Data Dictionary
---------------
SELECT Parameter,SUM(getmisses), SUM(gets)
FROM v$rowcache group by parameter
Buffer Cache
------------
SELECT name,value from v$sysstat where
name in
('db block gets',
'consistent gets',
'physical reads')
Library Cache
-------------
select
namespace,
gets,
gethitratio*100 gethitratio,
pins,
pinhitratio*100 pinhitratio,
reloads,
invalidations
from
v$librarycache;
Tablespace monitoring in oracle 12c multitenant database:
=========================================
SET LINES 300 PAGES 100000
COL con_name FORM A15 HEAD "Container|Name"
COL tablespace_name FORM A15
COL fsm FORM 999,999,999,999 HEAD "Free|Space Meg."
COL apm FORM 999,999,999,999 HEAD "Alloc|Space Meg."
--
COMPUTE SUM OF fsm apm ON REPORT
BREAK ON REPORT ON con_id ON con_name ON tablespace_name
--
WITH x AS (SELECT c1.con_id, cf1.tablespace_name, SUM(cf1.bytes)/1024/1024/1024 fsm
FROM cdb_free_space cf1
,v$containers c1
WHERE cf1.con_id = c1.con_id
GROUP BY c1.con_id, cf1.tablespace_name),
y AS (SELECT c2.con_id, cd.tablespace_name, SUM(cd.bytes)/1024/1024/1024 apm
FROM cdb_data_files cd
,v$containers c2
WHERE cd.con_id = c2.con_id
GROUP BY c2.con_id
,cd.tablespace_name)
SELECT x.con_id, v.name con_name, x.tablespace_name, x.fsm, y.apm
FROM x, y, v$containers v
WHERE x.con_id = y.con_id
AND x.tablespace_name = y.tablespace_name
AND v.con_id = y.con_id
UNION
SELECT vc2.con_id, vc2.name, tf.tablespace_name, null, SUM(tf.bytes)/1024/1024/1024
FROM v$containers vc2, cdb_temp_files tf
WHERE vc2.con_id = tf.con_id
GROUP BY vc2.con_id, vc2.name, tf.tablespace_name
ORDER BY 1, 2;
Top 5 cached sql statements by elapsed time in oracle:
=======================================
set lines 300 pages 20000
SELECT sql_id,child_number,sql_text, elapsed_time
FROM (SELECT sql_id, child_number, sql_text, elapsed_time, cpu_time,
disk_reads,
RANK () OVER (ORDER BY elapsed_time DESC) AS elapsed_rank
FROM v$sql)
WHERE elapsed_rank <= 5
/
Query to get child table and foreign key status:
=================================
col owner form a10
col FK_column form a15
col table_name form a30
select b.owner, b.table_name child_table,b.status,
c.column_name FK_column, b.constraint_name
from dba_constraints a, dba_constraints b, dba_cons_columns c
where a.owner=b.r_owner
and b.owner=c.owner
and b.table_name=c.table_name
and b.constraint_name=c.constraint_name
and a.constraint_name=b.r_constraint_name
and b.constraint_type='R'
and a.owner='&OWNER'
and a.table_name='&TABLE_NAME'
and a.CONSTRAINT_TYPE='P';
How to find the sessions generating lot of logs:
==================================
set lines 2000
set pages 1000
col sid for 99999
col name for a09
col username for a14
col PROGRAM for a21
col MODULE for a25
select s.sid,sn.SERIAL#,n.name, round(value/1024/1024,2) redo_mb, sn.username,sn.status,substr (sn.program,1,21) "program", sn.type, sn.module,sn.sql_id
from v$sesstat s join v$statname n on n.statistic# = s.statistic#
join v$session sn on sn.sid = s.sid where n.name like 'redo size' and s.value!=0 order by
redo_mb desc;
Use below query to check all the space related details of tablespaces:
=================================================
set feedback off
set pagesize 70;
set linesize 2000
set head on
COLUMN Tablespace format a25 heading 'Tablespace Name'
COLUMN autoextensible format a11 heading 'AutoExtend'
COLUMN files_in_tablespace format 999 heading 'Files'
COLUMN total_tablespace_space format 99999999 heading 'TotalSpace'
COLUMN total_used_space format 99999999 heading 'UsedSpace'
COLUMN total_tablespace_free_space format 99999999 heading 'FreeSpace'
COLUMN total_used_pct format 9999 heading '%Used'
COLUMN total_free_pct format 9999 heading '%Free'
COLUMN max_size_of_tablespace format 99999999 heading 'ExtendUpto'
COLUM total_auto_used_pct format 999.99 heading 'Max%Used'
COLUMN total_auto_free_pct format 999.99 heading 'Max%Free'
WITH tbs_auto AS
(SELECT DISTINCT tablespace_name, autoextensible
FROM dba_data_files
WHERE autoextensible = 'YES'),
files AS
(SELECT tablespace_name, COUNT (*) tbs_files,
SUM (BYTES/1024/1024) total_tbs_bytes
FROM dba_data_files
GROUP BY tablespace_name),
fragments AS
(SELECT tablespace_name, COUNT (*) tbs_fragments,
SUM (BYTES)/1024/1024 total_tbs_free_bytes,
MAX (BYTES)/1024/1024 max_free_chunk_bytes
FROM dba_free_space
GROUP BY tablespace_name),
AUTOEXTEND AS
(SELECT tablespace_name, SUM (size_to_grow) total_growth_tbs
FROM (SELECT tablespace_name, SUM (maxbytes)/1024/1024 size_to_grow
FROM dba_data_files
WHERE autoextensible = 'YES'
GROUP BY tablespace_name
UNION
SELECT tablespace_name, SUM (BYTES)/1024/1024 size_to_grow
FROM dba_data_files
WHERE autoextensible = 'NO'
GROUP BY tablespace_name)
GROUP BY tablespace_name)
SELECT c.instance_name,a.tablespace_name Tablespace,
CASE tbs_auto.autoextensible
WHEN 'YES'
THEN 'YES'
ELSE 'NO'
END AS autoextensible,
files.tbs_files files_in_tablespace,
files.total_tbs_bytes total_tablespace_space,
(files.total_tbs_bytes - fragments.total_tbs_free_bytes
) total_used_space,
fragments.total_tbs_free_bytes total_tablespace_free_space,
round(( ( (files.total_tbs_bytes - fragments.total_tbs_free_bytes)
/ files.total_tbs_bytes
)
* 100
)) total_used_pct,
round(((fragments.total_tbs_free_bytes / files.total_tbs_bytes) * 100
)) total_free_pct
FROM dba_tablespaces a,v$instance c , files, fragments, AUTOEXTEND, tbs_auto
WHERE a.tablespace_name = files.tablespace_name
AND a.tablespace_name = fragments.tablespace_name
AND a.tablespace_name = AUTOEXTEND.tablespace_name
AND a.tablespace_name = tbs_auto.tablespace_name(+)
order by total_free_pct;
How to find log gap between primary and standby db:
======================================
select LOG_ARCHIVED-LOG_APPLIED "LOG_GAP" from
(SELECT MAX(SEQUENCE#) LOG_ARCHIVED
FROM V$ARCHIVED_LOG WHERE DEST_ID=1 AND ARCHIVED='YES'),
(SELECT MAX(SEQUENCE#) LOG_APPLIED
FROM V$ARCHIVED_LOG WHERE DEST_ID=2 AND APPLIED='YES');
How to find free space in UNDO tablespace:
================================
select a.tablespace_name, SIZEMB, USAGEMB, (SIZEMB - USAGEMB) FREEMB
from (select sum(bytes) / 1024 / 1024 SIZEMB, b.tablespace_name
from dba_data_files a, dba_tablespaces b
where a.tablespace_name = b.tablespace_name
and b.contents = 'UNDO'
group by b.tablespace_name) a,
(select c.tablespace_name, sum(bytes) / 1024 / 1024 USAGEMB
from DBA_UNDO_EXTENTS c
where status <> 'EXPIRED'
group by c.tablespace_name) b
where a.tablespace_name = b.tablespace_name;
How to find the temp tablespace usage:
============================
select a.tablespace_name tablespace,
d.TEMP_TOTAL_MB,
sum (a.used_blocks * d.block_size) / 1024 / 1024 TEMP_USED_MB,
d.TEMP_TOTAL_MB - sum (a.used_blocks * d.block_size) / 1024 / 1024 TEMP_FREE_MB
from v$sort_segment a,
(
select b.name, c.block_size, sum (c.bytes) / 1024 / 1024 TEMP_TOTAL_MB
from v$tablespace b, v$tempfile c
where b.ts#= c.ts#
group by b.name, c.block_size
) d
where a.tablespace_name = d.name
group by a.tablespace_name, d.TEMP_TOTAL_MB;
How to find the wait events present in database:
==================================
select a.sid,substr(b.username,1,10) username,substr(b.osuser,1,10) osuser,
substr(b.program||b.module,1,15) program,substr(b.machine,1,22) machine,
a.event,a.p1,b.sql_hash_value
from v$session_wait a,V$session b
where b.sid=a.sid
and a.event not in('SQL*Net message from client','SQL*Net message to client',
'smon timer','pmon timer')
and username is not null
order by 6
/
How to find the session using lot of undo:
==============================
select a.sid, a.serial#, a.username, b.used_urec used_undo_record, b.used_ublk used_undo_blocks
from v$session a, v$transaction b
where a.saddr=b.ses_addr ;
How to find the locks present in oracle database:
===================================
col session_id head 'Sid' form 9999
col object_name head "Table|Locked" form a30
col oracle_username head "Oracle|Username" form a10 truncate
col os_user_name head "OS|Username" form a10 truncate
col process head "Client|Process|ID" form 99999999
col mode_held form a15
select lo.session_id,lo.oracle_username,lo.os_user_name,
lo.process,do.object_name,
decode(lo.locked_mode,0, 'None',1, 'Null',2, 'Row Share (SS)',
3, 'Row Excl (SX)',4, 'Share',5, 'Share Row Excl (SSX)',6, 'Exclusive',
to_char(lo.locked_mode)) mode_held
from v$locked_object lo, dba_objects do
where lo.object_id = do.object_id
order by 1,5
/
How to find the sessions generating lot of logs:
==================================
set lines 2000
set pages 1000
col sid for 99999
col name for a09
col username for a14
col PROGRAM for a21
col MODULE for a25
select s.sid,sn.SERIAL#,n.name, round(value/1024/1024,2) redo_mb, sn.username,sn.status,substr (sn.program,1,21) "program", sn.type, sn.module,sn.sql_id
from v$sesstat s join v$statname n on n.statistic# = s.statistic#
join v$session sn on sn.sid = s.sid where n.name like 'redo size' and s.value!=0 order by
redo_mb desc;
How to find the sessions using lot of temp:
==============================
SELECT b.TABLESPACE
, b.segfile#
, b.segblk#
, ROUND ( ( ( b.blocks * p.VALUE ) / 1024 / 1024 ), 2 ) size_mb
, a.SID
, a.serial#
, a.username
, a.osuser
, a.program
, a.status
FROM v$session a
, v$sort_usage b
, v$process c
, v$parameter p
WHERE p.NAME = 'db_block_size'
AND a.saddr = b.session_addr
AND a.paddr = c.addr
ORDER BY b.TABLESPACE, b.segfile#, b.segblk#, b.blocks;
How to find current running sqls in oracle:
==============================
select sesion.sid,
sesion.username,
optimizer_mode,
hash_value,
address,
cpu_time,
elapsed_time,
sql_text
from v$sqlarea sqlarea, v$session sesion
where sesion.sql_hash_value = sqlarea.hash_value
and sesion.sql_address = sqlarea.address
and sesion.username is not null;
Realtime monitoring of sql query using v$sql_plan_monitor:
===========================================
V$SQL_PLAN_MONITOR displays real time plan level monitoring statistics for the currently running sql queries.
Each row in V$SQL_PLAN_MONITOR corresponds to an operation of the execution plan being monitored.
SELECT sql_id FROM v$sql_monitor;
SELECT sid, sql_id, status, plan_line_id,
plan_operation || ' ' || plan_options operation, output_rows
FROM v$sql_plan_monitor
WHERE status not like '%DONE%'
ORDER BY 1,4;
How to find active sessions in oracle database:
=================================
set echo off
set linesize 95
set head on
set feedback on
col sid head "Sid" form 9999 trunc
col serial# form 99999 trunc head "Ser#"
col username form a8 trunc
col osuser form a7 trunc
col machine form a20 trunc head "Client|Machine"
col program form a15 trunc head "Client|Program"
col login form a11
col "last call" form 9999999 trunc head "Last Call|In Secs"
col status form a6 trunc
select sid,serial#,substr(username,1,10) username,substr(osuser,1,10) osuser,
substr(program||module,1,15) program,substr(machine,1,22) machine,
to_char(logon_time,'ddMon hh24:mi') login,
last_call_et "last call",status
from v$session where status='ACTIVE'
order by 1
/
Query to get child table and foreign key status:
=================================
col owner form a10
col FK_column form a15
col table_name form a30
select b.owner, b.table_name child_table,b.status,
c.column_name FK_column, b.constraint_name
from dba_constraints a, dba_constraints b, dba_cons_columns c
where a.owner=b.r_owner
and b.owner=c.owner
and b.table_name=c.table_name
and b.constraint_name=c.constraint_name
and a.constraint_name=b.r_constraint_name
and b.constraint_type='R'
and a.owner='&OWNER'
and a.table_name='&TABLE_NAME'
and a.CONSTRAINT_TYPE='P';
Enable constraints:
=============
alter table FDR.MDT_RM_CALL_CLOSEOUT_METER disable constraints MDT_RM_CALL_CLOSEOUT_METER_FK;
Find the parent table of child table:
=========================
SELECT owner,
table_name
FROM dba_constraints
WHERE constraint_name IN (SELECT r_constraint_name
FROM dba_constraints WHERE
table_name = 'PUROLATOR_ACCOUNTS' AND constraint_type = 'R');
Get hourly database growth report:
=========================
set serveroutput on
Declare
v_BaselineSize number(20);
v_CurrentSize number(20);
v_TotalGrowth number(20);
v_Space number(20);
cursor usageHist is
select a.snap_id,
TIMESTAMP,
sum(TOTAL_SPACE_ALLOCATED_DELTA) over ( order by a.SNAP_ID) ProgSum
from
(select SNAP_ID,
sum(SPACE_ALLOCATED_DELTA) TOTAL_SPACE_ALLOCATED_DELTA
from DBA_HIST_SEG_STAT
group by SNAP_ID
having sum(SPACE_ALLOCATED_TOTAL) <> 0
order by 1 ) a,
(select distinct SNAP_ID,
to_char(END_INTERVAL_TIME,'DD-Mon-YYYY HH24:Mi') TIMESTAMP
from DBA_HIST_SNAPSHOT) b
where a.snap_id=b.snap_id;
Begin
select sum(SPACE_ALLOCATED_DELTA) into v_TotalGrowth from DBA_HIST_SEG_STAT;
select sum(bytes) into v_CurrentSize from dba_segments;
v_BaselineSize := v_CurrentSize - v_TotalGrowth ;
dbms_output.put_line('TIMESTAMP Database Size(GB)');
for row in usageHist loop
v_Space := (v_BaselineSize + row.ProgSum)/(1024*1024*1024);
dbms_output.put_line(row.TIMESTAMP || ' ' || to_char(v_Space) );
end loop;
end;
/
Find who locked your account:
=============================
-- Return code 1017 ( INVALID LOGIN ATTEMPT)
-- Return code 28000 ( ACCOUNT LOCKED)
set pagesize 1299
set lines 299
col username for a15
col userhost for a13
col timestamp for a39
col terminal for a23
SELECT username,userhost,terminal,timestamp,returncode
FROM dba_audit_session
WHERE username='&USER_NAME' and returncode in (1017,28000);
Find row count of all partitions of a table:
=============================
set serverout on size 1000000
set verify off
declare
sql_stmt varchar2(1024);
row_count number;
cursor get_tab is
select table_name,partition_name
from dba_tab_partitions
where table_owner=upper('&&TABLE_OWNER') and table_name='&&TABLE_NAME';
begin
dbms_output.put_line('Checking Record Counts for table_name');
dbms_output.put_line('Log file to numrows_part_&&TABLE_OWNER.lst ....');
dbms_output.put_line('....');
for get_tab_rec in get_tab loop
BEGIN
sql_stmt := 'select count(*) from &&TABLE_OWNER..'||get_tab_rec.table_name
||' partition ( '||get_tab_rec.partition_name||' )';
EXECUTE IMMEDIATE sql_stmt INTO row_count;
dbms_output.put_line('Table '||rpad(get_tab_rec.table_name
||'('||get_tab_rec.partition_name||')',50)
||' '||TO_CHAR(row_count)||' rows.');
exception when others then
dbms_output.put_line
('Error counting rows for table '||get_tab_rec.table_name);
END;
end loop;
end;
/
set verify on
How to find the I/O usage of tempfiles:
============================
SELECT SUBSTR(t.name,1,50) AS file_name,
f.phyblkrd AS blocks_read,
f.phyblkwrt AS blocks_written,
f.phyblkrd + f.phyblkwrt AS total_io
FROM v$tempstat f,v$tempfile t
WHERE t.file# = f.file#
ORDER BY f.phyblkrd + f.phyblkwrt DESC;
select * from (SELECT u.tablespace, s.username, s.sid, s.serial#, s.logon_time, program, u.extents, ((u.blocks*8)/1024) as MB,
i.inst_id,i.host_name
FROM gv$session s, gv$sort_usage u ,gv$instance i
WHERE s.saddr=u.session_addr and u.inst_id=i.inst_id order by MB DESC) a where rownum<10;
Find High water mark of a table:
=======================
--
-- Show the High Water Mark for a given table, or all tables if ALL is specified for Table_Name.
--
SET LINESIZE 300
SET SERVEROUTPUT ON
SET VERIFY OFF
DECLARE
CURSOR cu_tables IS
SELECT a.owner,
a.table_name
FROM all_tables a
WHERE a.table_name = Decode(Upper('&&Table_Name'),'ALL',a.table_name,Upper('&&Table_Name'))
AND a.owner = Upper('&&Table_Owner')
AND a.partitioned='NO'
AND a.logging='YES'
order by table_name;
op1 NUMBER;
op2 NUMBER;
op3 NUMBER;
op4 NUMBER;
op5 NUMBER;
op6 NUMBER;
op7 NUMBER;
BEGIN
Dbms_Output.Disable;
Dbms_Output.Enable(1000000);
Dbms_Output.Put_Line('TABLE UNUSED BLOCKS TOTAL BLOCKS HIGH WATER MARK');
Dbms_Output.Put_Line('------------------------------ --------------- --------------- ---------------');
FOR cur_rec IN cu_tables LOOP
Dbms_Space.Unused_Space(cur_rec.owner,cur_rec.table_name,'TABLE',op1,op2,op3,op4,op5,op6,op7);
Dbms_Output.Put_Line(RPad(cur_rec.table_name,30,' ') ||
LPad(op3,15,' ') ||
LPad(op1,15,' ') ||
LPad(Trunc(op1-op3-1),15,' '));
END LOOP;
END;
Find sessions holding library cache lock:
=============================
select sid Waiter, p1raw,
substr(rawtohex(p1),1,30) Handle,
substr(rawtohex(p2),1,30) Pin_addr
from v$session_wait where wait_time=0 and event like '%library cache%';
For RAC DB:
==========
select a.sid Waiter,b.SERIAL#,a.event,a.p1raw,
substr(rawtohex(a.p1),1,30) Handle,
substr(rawtohex(a.p2),1,30) Pin_addr
from v$session_wait a,v$session b where a.sid=b.sid
and a.wait_time=0 and a.event like 'library cache%';
set lines 152
col sid for a9999999999999
col name for a40
select a.sid,b.name,a.value,b.class
from gv$sesstat a , gv$statname b
where a.statistic#=b.statistic#
and name like '%library cache%';
How to get the bind values of a sql query:
==============================
SELECT
sql_id,
b. LAST_CAPTURED,
t.sql_text sql_text,
b.HASH_VALUE,
b.name bind_name,
b.value_string bind_value
FROM
gv$sql t
JOIN
gv$sql_bind_capture b using (sql_id)
WHERE
b.value_string is not null
AND
sql_id='&sqlid'
/
How to get tablespace quota details of an user in oracle:
========================================
set pagesize 200
set lines 200
col ownr format a20 justify c heading 'Owner'
col name format a20 justify c heading 'Tablespace' trunc
col qota format a12 justify c heading 'Quota (KB)'
col used format 999,999,990 justify c heading 'Used (KB)'
set colsep '|'
select
username ownr,
tablespace_name name,
decode(greatest(max_bytes, -1),
-1, 'UNLIMITED',
to_char(max_bytes/1024, '999,999,990')
) qota,
bytes/1024 used
from
dba_ts_quotas
where
max_bytes!=0
or
bytes!=0
order by
1,2
/
set pagesize 200
set lines 200
col ownr format a20 justify c heading 'Owner'
col name format a20 justify c heading 'Tablespace' trunc
col qota format a12 justify c heading 'Quota (KB)'
col used format 999,999,990 justify c heading 'Used (KB)'
set colsep '|'
select
username ownr,
tablespace_name name,
decode(greatest(max_bytes, -1),
-1, 'UNLIMITED',
to_char(max_bytes/1024, '999,999,990')
) qota,
bytes/1024 used
from
dba_ts_quotas
where
( max_bytes!=0
or
bytes!=0) and username='&USERNAME'
order by
1,2
/
How to monitor parallel queries in oracle db:
================================
col username for a9
col sid for a8
set lines 299
select
s.inst_id,
decode(px.qcinst_id,NULL,s.username,
' - '||lower(substr(s.program,length(s.program)-4,4) ) ) "Username",
decode(px.qcinst_id,NULL, 'QC', '(Slave)') "QC/Slave" ,
to_char( px.server_set) "Slave Set",
to_char(s.sid) "SID",
decode(px.qcinst_id, NULL ,to_char(s.sid) ,px.qcsid) "QC SID",
px.req_degree "Requested DOP",
px.degree "Actual DOP", p.spid
from
gv$px_session px,
gv$session s, gv$process p
where
px.sid=s.sid (+) and
px.serial#=s.serial# and
px.inst_id = s.inst_id
and p.inst_id = s.inst_id
and p.addr=s.paddr
order by 5 , 1 desc
/
Find pending distributed pending transactions in oracle:
=======================================
COL local_tran_id FORMAT a13
COL in_out FORMAT a6
COL database FORMAT a25
COL dbuser_owner FORMAT a15
COL interface FORMAT a3
SELECT local_tran_id, in_out, database, dbuser_owner, interface
FROM dba_2pc_neighbors
/
How to find execution history of an sql_id:
==============================
select a.instance_number inst_id, a.snap_id,a.plan_hash_value, to_char(begin_interval_time,'dd-mon-yy hh24:mi') btime, abs(extract(minute from (end_interval_time-begin_interval_time)) + extract(hour from (end_interval_time-begin_interval_time))*60 + extract(day from (end_interval_time-begin_interval_time))*24*60) minutes,
executions_delta executions, round(ELAPSED_TIME_delta/1000000/greatest(executions_delta,1),4) "avg duration (sec)" from dba_hist_SQLSTAT a, dba_hist_snapshot b
where sql_id='&sql_id' and a.snap_id=b.snap_id
and a.instance_number=b.instance_number
order by snap_id desc, a.instance_number;
Script to get cpu usage and wait event information in oracle database:
=================================================
set lines 288
col sample_time for a14
col CONFIGURATION head "CONFIG" for 99.99
col ADMINISTRATIVE head "ADMIN" for 99.99
col OTHER for 99.99
SELECT TO_CHAR(SAMPLE_TIME, 'HH24:MI ') AS SAMPLE_TIME,
ROUND(OTHER / 60, 3) AS OTHER,
ROUND(CLUST / 60, 3) AS CLUST,
ROUND(QUEUEING / 60, 3) AS QUEUEING,
ROUND(NETWORK / 60, 3) AS NETWORK,
ROUND(ADMINISTRATIVE / 60, 3) AS ADMINISTRATIVE,
ROUND(CONFIGURATION / 60, 3) AS CONFIGURATION,
ROUND(COMMIT / 60, 3) AS COMMIT,
ROUND(APPLICATION / 60, 3) AS APPLICATION,
ROUND(CONCURRENCY / 60, 3) AS CONCURRENCY,
ROUND(SIO / 60, 3) AS SYSTEM_IO,
ROUND(UIO / 60, 3) AS USER_IO,
ROUND(SCHEDULER / 60, 3) AS SCHEDULER,
ROUND(CPU / 60, 3) AS CPU,
ROUND(BCPU / 60, 3) AS BACKGROUND_CPU
FROM (SELECT TRUNC(SAMPLE_TIME, 'MI') AS SAMPLE_TIME,
DECODE(SESSION_STATE,
'ON CPU',
DECODE(SESSION_TYPE, 'BACKGROUND', 'BCPU', 'ON CPU'),
WAIT_CLASS) AS WAIT_CLASS
FROM V$ACTIVE_SESSION_HISTORY
WHERE SAMPLE_TIME > SYSDATE - INTERVAL '2'
HOUR
AND SAMPLE_TIME <= TRUNC(SYSDATE, 'MI')) ASH PIVOT(COUNT(*)
FOR WAIT_CLASS IN('ON CPU' AS CPU,'BCPU' AS BCPU,
'Scheduler' AS SCHEDULER,
'User I/O' AS UIO,
'System I/O' AS SIO,
'Concurrency' AS CONCURRENCY,
'Application' AS APPLICATION,
'Commit' AS COMMIT,
'Configuration' AS CONFIGURATION,
'Administrative' AS ADMINISTRATIVE,
'Network' AS NETWORK,
'Queueing' AS QUEUEING,
'Cluster' AS CLUST,
'Other' AS OTHER))
/
How to find cpu and memory information of oracle database server:
================================================
set pagesize 299
set lines 299
select STAT_NAME,to_char(VALUE) as VALUE ,COMMENTS from v$osstat where stat_name IN ('NUM_CPUS','NUM_CPU_CORES','NUM_CPU_SOCKETS')
union
select STAT_NAME,VALUE/1024/1024/1024 || ' GB' ,COMMENTS from v$osstat where stat_name IN ('PHYSICAL_MEMORY_BYTES')
/
Find user commits per minute in oracle database:
===================================
col STAT_NAME for a20
col VALUE_DIFF for 9999,999,999
col STAT_PER_MIN for 9999,999,999
set lines 200 pages 1500 long 99999999
col BEGIN_INTERVAL_TIME for a30
col END_INTERVAL_TIME for a30
set pagesize 40
set pause on
select hsys.SNAP_ID,
hsnap.BEGIN_INTERVAL_TIME,
hsnap.END_INTERVAL_TIME,
hsys.STAT_NAME,
hsys.VALUE,
hsys.VALUE - LAG(hsys.VALUE,1,0) OVER (ORDER BY hsys.SNAP_ID) AS "VALUE_DIFF",
round((hsys.VALUE - LAG(hsys.VALUE,1,0) OVER (ORDER BY hsys.SNAP_ID)) /
round(abs(extract(hour from (hsnap.END_INTERVAL_TIME - hsnap.BEGIN_INTERVAL_TIME))*60 +
extract(minute from (hsnap.END_INTERVAL_TIME - hsnap.BEGIN_INTERVAL_TIME)) +
extract(second from (hsnap.END_INTERVAL_TIME - hsnap.BEGIN_INTERVAL_TIME))/60),1)) "STAT_PER_MIN"
from dba_hist_sysstat hsys, dba_hist_snapshot hsnap
where hsys.snap_id = hsnap.snap_id
and hsnap.instance_number in (select instance_number from v$instance)
and hsnap.instance_number = hsys.instance_number
and hsys.STAT_NAME='user commits'
order by 1;
Find the active transactions in oracle database:
=================================
col name format a10
col username format a8
col osuser format a8
col start_time format a17
col status format a12
tti 'Active transactions'
select s.sid,username,t.start_time, r.name, t.used_ublk "USED BLKS",
decode(t.space, 'YES', 'SPACE TX',
decode(t.recursive, 'YES', 'RECURSIVE TX',
decode(t.noundo, 'YES', 'NO UNDO TX', t.status)
)) status
from sys.v_$transaction t, sys.v_$rollname r, sys.v_$session s
where t.xidusn = r.usn
and t.ses_addr = s.saddr
/
===============================
SELECT se.username, ss.sid, ROUND (value/100) "CPU Usage"
FROM v$session se, v$sesstat ss, v$statname st
WHERE ss.statistic# = st.statistic#
AND name LIKE '%CPU used by this session%'
AND se.sid = ss.SID
AND se.username IS NOT NULL
ORDER BY value DESC;
SELECT a.username, a.osuser, a.terminal,a.program, spid, SID, a.serial#,a.last_call_et,a.logon_time
FROM v$session a, v$process b WHERE a.paddr = b.addr AND a.status = 'INACTIVE' and a.type = 'USER';
Which user session is utilizing more memory:
===========================================
SELECT USERNAME, round(VALUE/1024/1024) || 'MB' "Current UGA memory"
FROM V$SESSION sess, V$SESSTAT stat, V$STATNAME name
WHERE sess.SID = stat.SID
AND stat.STATISTIC# = name.STATISTIC#
AND name.NAME = 'session uga memory';
How To Get Tablespace Quota Details Of An User In Oracle:
========================================================
TABLESPACE QUOTA DETAILS OF ALL THE USERS:
==========================================
set pagesize 200
set lines 200
col ownr format a20 justify c heading 'Owner'
col name format a20 justify c heading 'Tablespace' trunc
col qota format a12 justify c heading 'Quota (KB)'
col used format 999,999,990 justify c heading 'Used (KB)'
set colsep '|'
SELECT username
ownr,
tablespace_name
name,
Decode(Greatest(max_bytes, -1), -1, 'UNLIMITED',
To_char(max_bytes / 1024, '999,999,990'))
qota,
bytes / 1024
used
FROM dba_ts_quotas
WHERE max_bytes != 0
OR bytes != 0
ORDER BY 1,2
/
TABLESPAE QUOTA DETAILS FOR A PARTICULAR USER:
==============================================
set pagesize 200
set lines 200
col ownr format a20 justify c heading 'Owner'
col name format a20 justify c heading 'Tablespace' trunc
col qota format a12 justify c heading 'Quota (KB)'
col used format 999,999,990 justify c heading 'Used (KB)'
set colsep '|'
SELECT username
ownr,
tablespace_name
name,
Decode(Greatest(max_bytes, -1), -1, 'UNLIMITED',
To_char(max_bytes / 1024, '999,999,990'))
qota,
bytes / 1024
used
FROM dba_ts_quotas
WHERE ( max_bytes != 0
OR bytes != 0 )
AND username = '&USERNAME'
ORDER BY 1,2
/
How To Monitor Parallel Queries In Oracle DB:
=============================================
col username for a9
col sid for a8
set lines 299
SELECT s.inst_id,
Decode(px.qcinst_id, NULL, s.username, ' - ' ||Lower(Substr(s.program, Length(s.program) - 4, 4))) "Username",
Decode(px.qcinst_id, NULL, 'QC',
'(Slave)') "QC/Slave",
To_char(px.server_set) "Slave Set",
To_char(s.sid) "SID",
Decode(px.qcinst_id, NULL, To_char(s.sid),
px.qcsid) "QC SID",
px.req_degree "Requested DOP",
px.degree "Actual DOP",
p.spid
FROM gv$px_session px,
gv$session s,
gv$process p
WHERE px.sid = s.sid (+)
AND px.serial# = s.serial#
AND px.inst_id = s.inst_id
AND p.inst_id = s.inst_id
AND p.addr = s.paddr
ORDER BY 5, 1 DESC
/
Find Pending Distributed Pending Transactions In Oracle:
========================================================
COL local_tran_id FORMAT a13
COL in_out FORMAT a6
COL database FORMAT a25
COL dbuser_owner FORMAT a15
COL interface FORMAT a3
SELECT local_tran_id, in_out, database, dbuser_owner, interface
FROM dba_2pc_neighbors
/
How To Find Execution History Of An Sql_id:
===========================================
Below script will display execution history of an sql_id from AWR. It will join dba_hist_sqlstat and dba_hist_sqlsnapshot table to get the required information.
SELECT a.instance_number inst_id,
a.snap_id,
a.plan_hash_value,
To_char(begin_interval_time, 'dd-mon-yy hh24:mi') btime,
Abs(Extract(minute FROM ( end_interval_time - begin_interval_time )) +
Extract (hour FROM ( end_interval_time - begin_interval_time )) *
60 +
Extract(day FROM ( end_interval_time - begin_interval_time )) * 24 *
60)
minutes,
executions_delta executions,
Round(elapsed_time_delta / 1000000 / Greatest(executions_delta, 1), 4)
"avg duration (sec)"
FROM dba_hist_sqlstat a,
dba_hist_snapshot b
WHERE sql_id = '&sql_id'
AND a.snap_id = b.snap_id
AND a.instance_number = b.instance_number
ORDER BY snap_id DESC,
a.instance_number;
Script To Get Cpu Usage And Wait Event Information In Oracle Database:
======================================================================
Below script will give information about the CPU usage and wait events class information of every minute for last 2 hours. As this query uses gv$active_session_history, so make sure you have TUNING license pack of oracle, before using this.
set lines 288
col sample_time for a14
col CONFIGURATION head "CONFIG" for 99.99
col ADMINISTRATIVE head "ADMIN" for 99.99
col OTHER for 99.99
SELECT To_char(sample_time, 'HH24:MI ') AS sample_time,
Round(other / 60, 3) AS other,
Round(clust / 60, 3) AS clust,
Round(queueing / 60, 3) AS queueing,
Round(network / 60, 3) AS network,
Round(administrative / 60, 3) AS administrative,
Round(configuration / 60, 3) AS configuration,
Round(COMMIT / 60, 3) AS COMMIT,
Round(application / 60, 3) AS application,
Round(concurrency / 60, 3) AS concurrency,
Round(sio / 60, 3) AS system_io,
Round(uio / 60, 3) AS user_io,
Round(scheduler / 60, 3) AS scheduler,
Round(cpu / 60, 3) AS cpu,
Round(bcpu / 60, 3) AS background_cpu
FROM (
SELECT Trunc(sample_time, 'MI') AS sample_time,
Decode(session_state,
'ON CPU', Decode(session_type,
'BACKGROUND', 'BCPU',
'ON CPU'),
wait_class) AS wait_class
FROM v$active_session_history
WHERE sample_time > SYSDATE - interval '2' hour
AND sample_time <= Trunc(SYSDATE, 'MI')) ash pivot(count(*) FOR wait_class IN('ON CPU' AS cpu,
'BCPU' AS bcpu,
'Scheduler' AS scheduler,
'User I/O' AS uio,
'System I/O' AS sio,
'Concurrency' AS concurrency,
'Application' AS application,
'Commit' AS COMMIT,
'Configuration' AS configuration,
'Administrative' AS administrative,
'Network' AS network,
'Queueing' AS queueing,
'Cluster' AS clust,
'Other' AS other))
/
How To Find Cpu And Memory Information Of Oracle Database Server:
=================================================================
Below script is useful in getting CPU, memory and core, socket information of a database server from SQL prompt.
set pagesize 299
set lines 299
SELECT stat_name,
To_char(value) AS VALUE,
comments
FROM v$osstat
WHERE stat_name IN ( 'NUM_CPUS', 'NUM_CPU_CORES', 'NUM_CPU_SOCKETS' )
UNION
SELECT stat_name,
value / 1024 / 1024 / 1024
|| ' GB',
comments
FROM v$osstat
WHERE stat_name IN ( 'PHYSICAL_MEMORY_BYTES' )
/
Find Sessions Consuming Lot Of CPU:
====================================
col program form a30 heading "PROGRAM"
col CPUMins form 99990 heading "CPU in Mins"
SELECT ROWNUM AS rank, a.*
FROM (SELECT v.sid,s.serial#,s.username,s.osuser,s.machine,s.program,s.logon_time,s.sql_id,s.status,
v.value / ( 100 * 60 ) CPUMins
FROM v$statname n,
v$sesstat v,
v$session s
WHERE n.name = 'CPU used by this session'
AND s.sid = v.sid
AND v.statistic# = n.statistic#
AND v.value > 0
ORDER BY v.value DESC) a
WHERE ROWNUM < 11;
SQL> select
2 ss.username,
3 se.SID,
4 VALUE/100 cpu_usage_seconds
5 from
6 v$session ss,
7 v$sesstat se,
8 v$statname sn
9 where
10 se.STATISTIC# = sn.STATISTIC#
11 and
12 NAME like '%CPU used by this session%'
13 and
14 se.SID = ss.SID
and
15 16 ss.status='ACTIVE'
17 and
18 ss.username is not null order by VALUE desc;
Oracle scripts:
select sess.username, stat.sid, name.name name, sum(stat.value)/100 valuesum_seconds from v$sesstat stat, v$statname name, v$session sess
where stat.sid = sess.sid and stat.statistic# = name.statistic# and name.name like '%CPU%' group by sess.username, stat.sid, name.name;
select s.username, s.sid, s.serial#, p.pid ppid, s.status, s.osuser, substr(s.program,1,20) client_program, s.process client_process,
substr(p.program,1,20) server_program, p.spid server_pid from v$session s, v$process p where s.username is not null
and p.addr(+) = s.paddr and userenv('SESSIONID') = s.audsid
order by username, sid
select s.username "Oracle User",s.osuser "OS User",i.consistent_gets "Consistent Gets",
i.physical_reads "Physical Reads",s.status "Status",s.sid "SID",s.serial# "Serial#",
s.machine "Machine",s.program "Program",to_char(logon_time, 'DD/MM/YYYY HH24:MI:SS') "Logon Time",
w.seconds_in_wait "Idle Time", P.SPID "PROC",
name "Stat CPU", value
from v$session s, v$sess_io i, v$session_wait w, V$PROCESS P, v$statname n, v$sesstat t
where s.sid = i.sid
and s.sid = w.sid (+)
and 'SQL*Net message from client' = w.event(+)
and s.osuser is not null
and s.username is not null
and s.paddr=p.addr
and n.statistic# = t.statistic#
and n.name like '%cpu%'
and t.SID = s.sid
order by 6 asc, 3 desc, 4 desc;
select
ss.username,
se.SID,
ss.status,
VALUE/100 cpu_usage_seconds
from
v$session ss,
v$sesstat se,
v$statname sn
where
se.STATISTIC# = sn.STATISTIC#
and
NAME like '%CPU used by this session%'
and
se.SID = ss.SID
and
ss.status in ('ACTIVE','INACTIVE')
and
ss.username is not null
order by VALUE desc;
6> Kill the inactive sessions that are consuming space.
Top memory consuming sessions in database:
==========================================
SQL> SELECT a.username, a.osuser, a.program, b.spid,b.pga_used_mem/1024/1024 "PGA USED (MB)", a.sid, a.serial# ,a.module,a.logon_time,a.terminal,a.status FROM v$session a, v$process b WHERE a.paddr = b.addr order by b.pga_used_mem desc;
with x as (select s.osuser osuser , s.username
, s.status
, se.sid
, s.serial# serial
, n.name
, round(max(se.value)/1024/1024, 2) maxmem_mb
, max(se.value) as maxmem
from v$sesstat se , v$statname n , v$session s
where n.statistic# = se.statistic#
and n.name in ('session pga memory','session pga memory max', 'session uga memory','session uga memory max')
and s.sid = se.sid
group by s.osuser, s.username, s.status, se.sid, s.serial#, n.name
order by maxmem desc
)
select * from x where rownum < 11;
SELECT to_char(ssn.sid, '9999') || ' - ' || nvl(ssn.username, nvl(bgp.name, 'background')) ||
nvl(lower(ssn.machine), ins.host_name) "SESSION",
to_char(prc.spid, '999999999') "PID/THREAD",
to_char((se1.value/1024)/1024, '999G999G990D00') || ' MB' " CURRENT SIZE",
to_char((se2.value/1024)/1024, '999G999G990D00') || ' MB' " MAXIMUM SIZE"
FROM v$sesstat se1, v$sesstat se2, v$session ssn, v$bgprocess bgp, v$process prc,
v$instance ins, v$statname stat1, v$statname stat2
WHERE se1.statistic# = stat1.statistic# and stat1.name = 'session pga memory'
AND se2.statistic# = stat2.statistic# and stat2.name = 'session pga memory max'
AND se1.sid = ssn.sid
AND se2.sid = ssn.sid
AND ssn.paddr = bgp.paddr (+)
AND ssn.paddr = prc.addr (+);
SELECT a.username, a.osuser, a.program, b.spid,b.pga_used_mem/1024/1024 “PGA USED (MB)”, a.sid, a.serial# ,a.module,a.logon_time,a.terminal FROM v$session a, v$process b WHERE a.paddr = b.addr
order by b.pga_used_mem desc;
Get Ospid From SID:
===================
set lines 123
col USERNAME for a15
col OSUSER for a8
col MACHINE for a15
col PROGRAM for a20
SELECT b.spid,
a.username,
a.program,
a.osuser,
a.machine,
a.sid,
a.serial#,
a.status
FROM gv$session a,
gv$process b
WHERE addr = paddr(+)
AND status='KILLED';
Get Sid From Ospid:
===================
col sid format 999999
col username format a20
col osuser format a15
SELECT b.spid,
a.sid,
a.serial#,
a.username,
a.osuser,
a.machine,
a.program,
a.logon_time,
a.sql_id,
a.status
FROM v$session a,
v$process b
WHERE a.paddr = b.addr
AND b.spid = '&spid'
ORDER BY b.spid;
SELECT 'ALTER SYSTEM KILL SESSION '''''sid','serial#''''' immediate;'
FROM v$session
WHERE status ='INACTIVE';
To find out long running session and ACTIVE/INACTIVE sessions:
===============================================================
select 'alter system kill session '''||sid||','||serial#||'''immediate;' as script from v$session where username in ='SYS','SYSTEM';
select sid,serial#,username,osuser,program,machine,logon_time,sql_id,status from v$session where username in ('SYS','SYSTEM') and status='ACTIVE';
How to find out Expected Time of Completion for an Oracle Query:
================================================================
SELECT
opname,
target,
ROUND( ( sofar/totalwork ), 4 ) * 100 Percentage_Complete,
start_time,
CEIL( time_remaining / 60 ) Max_Time_Remaining_In_Min,
FLOOR( elapsed_seconds / 60 ) Time_Spent_In_Min
FROM v$session_longops
WHERE username='SYS' and sofar != totalwork;
SELECT AR.parsing_schema_name,target,AR.sql_id,AR.module "CLIENT_TOOL",opname,AR.sql_fulltext,start_time,
CEIL( time_remaining / 60 ) "TIME_REMAINING",FLOOR( elapsed_seconds / 60 ) "TIME_SPENT",ROUND( ( sofar / totalwork ), 4 ) * 100 "%_COMPLETE"
FROM v$session_longops L, v$sqlarea AR
WHERE L.sql_id = AR.sql_id
AND totalwork > 0
AND AR.users_executing > 0 and AR.sql_id='383dzn46q7vp4'
AND sofar != totalwork;
How to find out Which User is Running what SQL Query in Oracle database?:
=========================================================================
SELECT
SUBSTR(SS.USERNAME,1,8) USERNAME,
SS.OSUSER "USER",
AR.MODULE || ' @ ' || SS.MACHINE CLIENT,
SS.PROCESS PID,
TO_CHAR(AR.LAST_LOAD_TIME, 'DD-Mon HH24:MM:SS') LOAD_TIME,
AR.DISK_READS DISK_READS,
AR.BUFFER_GETS BUFFER_GETS,
SUBSTR(SS.LOCKWAIT,1,10) LOCKWAIT,
W.EVENT EVENT,
SS.STATUS,
AR.SQL_fullTEXT SQL
FROM V$SESSION_WAIT W,
V$SQLAREA AR,
V$SESSION SS,
v$TIMER T
WHERE SS.SQL_ADDRESS = AR.ADDRESS
AND SS.SQL_HASH_VALUE = AR.HASH_VALUE
AND SS.SID = W.SID (+)
AND SS.STATUS = 'ACTIVE'
AND W.EVENT != 'client message'
ORDER BY SS.LOCKWAIT ASC, SS.USERNAME, AR.DISK_READS DESC;
To find out SQL query start time and end time:
==============================================
alter session set nls_date_format='YYYY/MM/DD HH24:MI:SS';
alter session set nls_timestamp_format='YYYY/MM/DD HH24:MI:SS';
select USER_ID,sql_id,
starting_time,
end_time,
(EXTRACT(HOUR FROM run_time) * 3600
+ EXTRACT(MINUTE FROM run_time) * 60
+ EXTRACT(SECOND FROM run_time)) run_time_sec,
READ_IO_BYTES,
PGA_ALLOCATED PGA_ALLOCATED_BYTES,
TEMP_ALLOCATED TEMP_ALLOCATED_BYTES
from (select USER_ID,
sql_id,
max(sample_time - sql_exec_start) run_time,
max(sample_time) end_time,
sql_exec_start starting_time,
sum(DELTA_READ_IO_BYTES) READ_IO_BYTES,
sum(DELTA_PGA) PGA_ALLOCATED,
sum(DELTA_TEMP) TEMP_ALLOCATED
from
( select sql_id, USER_ID,
sample_time,
sql_exec_start,
DELTA_READ_IO_BYTES,
sql_exec_id,
greatest(PGA_ALLOCATED - first_value(PGA_ALLOCATED) over (partition by sql_id,sql_exec_id order by sample_time rows 1 preceding),0) DELTA_PGA,
greatest(TEMP_SPACE_ALLOCATED - first_value(TEMP_SPACE_ALLOCATED) over (partition by sql_id,sql_exec_id order by sample_time rows 1 preceding),0) DELTA_TEMP
from
dba_hist_active_sess_history
where
sample_time >= to_date ('2018/06/28 00:00:00','YYYY/MM/DD HH24:MI:SS')
and sample_time < to_date ('2018/06/28 23:59:00','YYYY/MM/DD HH24:MI:SS')
and sql_exec_start is not null
and IS_SQLID_CURRENT='Y')
group by sql_id,SQL_EXEC_ID,sql_exec_start,USER_ID
order by sql_id)
where sql_id = '8117w9uckwpwz'
order by sql_id, run_time_sec desc;
To find out user_id belongs to which username:
===============================================
select a.USER_ID,b.USERNAME,a.SAMPLE_TIME,a.SQL_ID,a.SESSION_ID,a.SESSION_SERIAL#,a.MACHINE from DBA_HIST_ACTIVE_SESS_HISTORY a ,dba_users b where SQL_ID in (
'grwydz59pu6mc') and SAMPLE_TIME like '28-JUN-18%' and a.USER_ID=b.USER_ID;
SQL execution times from ASH:
=============================
col mx for 999999
col mn for 999999
col av for 999999.9
select
sql_id,
count(*),
max(tm) mx,
avg(tm) av,
min(tm) min
from (
select
sql_id,
sql_exec_id,
max(tm) tm
from ( select
sql_id,
sql_exec_id,
((cast(sample_time as date)) -
(cast(sql_exec_start as date))) * (3600*24) tm
from
dba_hist_active_sess_history
where sql_exec_id is not null
)
group by sql_id,sql_exec_id
)
group by sql_id
having count(*) > 10
order by mx,av
/
Response times of SQLs - Elapsed-Avg-Min-Max:
=============================================
select user_id,sql_id,
run_time run_time_timestamp,
(EXTRACT(HOUR FROM run_time) * 3600
+ EXTRACT(MINUTE FROM run_time) * 60
+ EXTRACT(SECOND FROM run_time)) run_time_sec
from (
select
user_id,sql_id,
max(sample_time - sql_exec_start) run_time
from
dba_hist_active_sess_history
where
sql_exec_start is not null
group by sql_id,SQL_EXEC_ID,user_id
order by sql_id
)
-- where rownum < 100
where sql_id = 'gy6j5kg641saa'
order by sql_id, run_time desc
/
select user_id,sql_id,
count(*),
round(avg(EXTRACT(HOUR FROM run_time) * 3600
+ EXTRACT(MINUTE FROM run_time) * 60
+ EXTRACT(SECOND FROM run_time)),2) avg ,
round(min(EXTRACT(HOUR FROM run_time) * 3600
+ EXTRACT(MINUTE FROM run_time) * 60
+ EXTRACT(SECOND FROM run_time)),2) min ,
round(max(EXTRACT(HOUR FROM run_time) * 3600
+ EXTRACT(MINUTE FROM run_time) * 60
+ EXTRACT(SECOND FROM run_time)),2) max
from (
select
user_id,sql_id,
max(sample_time - sql_exec_start) run_time
from
dba_hist_active_sess_history
where
sql_exec_start is not null
and sql_id = 'gy6j5kg641saa'
group by sql_id,SQL_EXEC_ID,user_id
order by sql_id
)
-- where rownum < 100
group by sql_id,user_id
order by avg desc
/
Find User Commits Per Minute In Oracle Database:
================================================
Below script is useful in getting user commit statistics information in the oracle database. user commits is the number of commits happening the database. It will be helpful in tracking the number of transactions in the database.
col STAT_NAME for a20
col VALUE_DIFF for 9999,999,999
col STAT_PER_MIN for 9999,999,999
set lines 200 pages 1500 long 99999999
col BEGIN_INTERVAL_TIME for a30
col END_INTERVAL_TIME for a30
set pagesize 40
set pause on
SELECT hsys.snap_id,
hsnap.begin_interval_time,
hsnap.end_interval_time,
hsys.stat_name,
hsys.value,
hsys.value - Lag(hsys.value, 1, 0)
over (
ORDER BY hsys.snap_id) AS "VALUE_DIFF",
Round(( hsys.value - Lag(hsys.value, 1, 0)
over (
ORDER BY hsys.snap_id) ) / Round(Abs(Extract(
hour FROM ( hsnap.end_interval_time -
hsnap.begin_interval_time )) * 60
+ Extract(minute FROM
( hsnap.end_interval_time -
hsnap.begin_interval_time )) +
Extract(second FROM
(
hsnap.end_interval_time
-
hsnap.begin_interval_time )) / 60), 1)) "STAT_PER_MIN"
FROM dba_hist_sysstat hsys,
dba_hist_snapshot hsnap
WHERE hsys.snap_id = hsnap.snap_id
AND hsnap.instance_number IN (SELECT instance_number
FROM v$instance)
AND hsnap.instance_number = hsys.instance_number
AND hsys.stat_name = 'user commits'
ORDER BY 1;
Find The Active Transactions In Oracle Database:
================================================
col name format a10
col username format a8
col osuser format a8
col start_time format a17
col status format a12
tti 'Active transactions'
SELECT s.sid,
username,
t.start_time,
r.name,
t.used_ublk
"USED BLKS",
Decode(t.SPACE, 'YES', 'SPACE TX',
Decode(t.recursive, 'YES', 'RECURSIVE TX',
Decode(t.noundo, 'YES', 'NO UNDO TX',
t.status))) status
FROM sys.v_$transaction t,
sys.v_$rollname r,
sys.v_$session s
WHERE t.xidusn = r.usn
AND t.ses_addr = s.saddr
/
Script for Space Re-Claim:
==========================
SET linesize 1000 pagesize 0 feedback off trimspool ON WITH hwm AS (
-- get highest block id from each datafiles ( from x$ktfbue as we don't need all joins from dba_extents )
SELECT /*+ materialize */ ktfbuesegtsn ts#, ktfbuefno relative_fno, max(
ktfbuebno+ktfbueblks-1) hwm_blocks FROM sys.x$ktfbue GROUP BY ktfbuefno,
ktfbuesegtsn ), hwmts AS (
-- join ts# with tablespace_name
SELECT name tablespace_name, relative_fno, hwm_blocks FROM hwm JOIN v$tablespace
USING(ts#) ), hwmdf AS (
-- join with datafiles, put 5M minimum for datafiles with no extents
SELECT file_name, nvl(hwm_blocks*(bytes/blocks), 5*1024*1024) hwm_bytes, bytes,
autoextensible, maxbytes FROM hwmts RIGHT JOIN dba_data_files USING(
tablespace_name, relative_fno) ) SELECT CASE WHEN autoextensible='YES' AND
maxbytes>=bytes THEN
-- we generate resize statements only if autoextensible can grow back to current size
'/* reclaim '||to_char(ceil((bytes-hwm_bytes)/1024/1024), 999999) ||'M from '||
to_char(ceil(bytes/1024/1024), 999999)||'M */ ' ||'alter database datafile '''||
file_name||''' resize '||ceil(hwm_bytes/1024/1024)||'M;' ELSE
-- generate only a comment when autoextensible is off
'/* reclaim '||to_char(ceil((bytes-hwm_bytes)/1024/1024), 999999) ||'M from '||
to_char(ceil(bytes/1024/1024), 999999) ||
'M after setting autoextensible maxsize higher than current size for file ' ||
file_name||' */' end SQL FROM hwmdf WHERE bytes-hwm_bytes>1024*1024
-- resize only if at least 1MB can be reclaimed
ORDER BY bytes-hwm_bytes DESC
/
how to monitor OS usage in RAC:
===============================
select to_char(min(begin_time),'hh24:mi:ss')||' /'||round(avg(intsize_csec/100),0)||'s' "Time+Delta",
metric_name||' - '||metric_unit "Metric",
sum(value_inst1) inst1, sum(value_inst2) inst2, sum(value_inst3) inst3, sum(value_inst4) inst4,
sum(value_inst5) inst5, sum(value_inst6) inst6
from
( select begin_time,intsize_csec,metric_name,metric_unit,metric_id,group_id,
case inst_id when 1 then round(value,1) end value_inst1,
case inst_id when 2 then round(value,1) end value_inst2,
case inst_id when 3 then round(value,1) end value_inst3,
case inst_id when 4 then round(value,1) end value_inst4,
case inst_id when 5 then round(value,1) end value_inst5,
case inst_id when 6 then round(value,1) end value_inst6
from gv$sysmetric
where metric_name in ('Host CPU Utilization (%)','Current OS Load', 'Physical Write Total IO Requests Per Sec',
'Physical Write Total Bytes Per Sec', 'Global Cache Average Current Get Time', 'Global Cache Average CR Get Time',
'Physical Read Total Bytes Per Sec', 'Physical Read Total IO Requests Per Sec',
'CPU Usage Per Sec','Network Traffic Volume Per Sec','Logons Per Sec','Redo Generated Per Sec',
'User Transaction Per Sec','Database CPU Time Ratio','Database Wait Time Ratio','Database Time Per Sec')
)
group by metric_id,group_id,metric_name,metric_unit
order by metric_name;
DBA Metric related Views:
=========================
"V$METRIC"
"V$METRIC_HISTORY"
"V$SYSMETRIC"
"V$SYSMETRIC_HISTORY"
"V$METRICNAME"
"V$METRICGROUP"
"V$SYSMETRIC_SUMMARY"
"V$SESSMETRIC"
"V$FILEMETRIC"
"V$FILEMETRIC_HISTORY"
"V$EVENTMETRIC"
"V$WAITCLASSMETRIC"
"V$WAITCLASSMETRIC_HISTORY"
"V$SERVICEMETRIC"
"V$SERVICEMETRIC_HISTORY"
select distinct metric_name
from v$metric;
To query the PGA cache hit percentage, you can query:
select value, metric_unit,metric_name
from v$metric
where metric_name = 'PGA Cache Hit %'
You can get a quick overview of all metrics by query'ing v$SYSMETRIC_SUMMARY:
select * from
v$SYSMETRIC_SUMMARY
Finding SQL with Performance changing over time:
================================================
SPO sql_performance_changed.txt;
DEF days_of_history_accessed = '31';
DEF captured_at_least_x_times = '10';
DEF captured_at_least_x_days_apart = '5';
DEF med_elap_microsecs_threshold = '1e4';
DEF min_slope_threshold = '0.1';
DEF max_num_rows = '20';
SET lin 200 ver OFF;
COL row_n FOR A2 HEA '#';
COL med_secs_per_exec HEA 'Median Secs|Per Exec';
COL std_secs_per_exec HEA 'Std Dev Secs|Per Exec';
COL avg_secs_per_exec HEA 'Avg Secs|Per Exec';
COL min_secs_per_exec HEA 'Min Secs|Per Exec';
COL max_secs_per_exec HEA 'Max Secs|Per Exec';
COL plans FOR 9999;
COL sql_text_80 FOR A80;
PRO SQL Statements with "Elapsed Time per Execution" changing over time
WITH
per_time AS (
SELECT h.dbid,
h.sql_id,
SYSDATE - CAST(s.end_interval_time AS DATE) days_ago,
SUM(h.elapsed_time_total) / SUM(h.executions_total) time_per_exec
FROM dba_hist_sqlstat h,
dba_hist_snapshot s
WHERE h.executions_total > 0
AND s.snap_id = h.snap_id
AND s.dbid = h.dbid
AND s.instance_number = h.instance_number
AND CAST(s.end_interval_time AS DATE) > SYSDATE - &&days_of_history_accessed.
GROUP BY
h.dbid,
h.sql_id,
SYSDATE - CAST(s.end_interval_time AS DATE)
),
avg_time AS (
SELECT dbid,
sql_id,
MEDIAN(time_per_exec) med_time_per_exec,
STDDEV(time_per_exec) std_time_per_exec,
AVG(time_per_exec) avg_time_per_exec,
MIN(time_per_exec) min_time_per_exec,
MAX(time_per_exec) max_time_per_exec
FROM per_time
GROUP BY
dbid,
sql_id
HAVING COUNT(*) >= &&captured_at_least_x_times.
AND MAX(days_ago) - MIN(days_ago) >= &&captured_at_least_x_days_apart.
AND MEDIAN(time_per_exec) > &&med_elap_microsecs_threshold.
),
time_over_median AS (
SELECT h.dbid,
h.sql_id,
h.days_ago,
(h.time_per_exec / a.med_time_per_exec) time_per_exec_over_med,
a.med_time_per_exec,
a.std_time_per_exec,
a.avg_time_per_exec,
a.min_time_per_exec,
a.max_time_per_exec
FROM per_time h, avg_time a
WHERE a.sql_id = h.sql_id
),
ranked AS (
SELECT RANK () OVER (ORDER BY ABS(REGR_SLOPE(t.time_per_exec_over_med, t.days_ago)) DESC) rank_num,
t.dbid,
t.sql_id,
CASE WHEN REGR_SLOPE(t.time_per_exec_over_med, t.days_ago) > 0 THEN 'IMPROVING' ELSE 'REGRESSING' END change,
ROUND(REGR_SLOPE(t.time_per_exec_over_med, t.days_ago), 3) slope,
ROUND(AVG(t.med_time_per_exec)/1e6, 3) med_secs_per_exec,
ROUND(AVG(t.std_time_per_exec)/1e6, 3) std_secs_per_exec,
ROUND(AVG(t.avg_time_per_exec)/1e6, 3) avg_secs_per_exec,
ROUND(MIN(t.min_time_per_exec)/1e6, 3) min_secs_per_exec,
ROUND(MAX(t.max_time_per_exec)/1e6, 3) max_secs_per_exec
FROM time_over_median t
GROUP BY
t.dbid,
t.sql_id
HAVING ABS(REGR_SLOPE(t.time_per_exec_over_med, t.days_ago)) > &&min_slope_threshold.
)
SELECT LPAD(ROWNUM, 2) row_n,
r.sql_id,
r.change,
TO_CHAR(r.slope, '990.000MI') slope,
TO_CHAR(r.med_secs_per_exec, '999,990.000') med_secs_per_exec,
TO_CHAR(r.std_secs_per_exec, '999,990.000') std_secs_per_exec,
TO_CHAR(r.avg_secs_per_exec, '999,990.000') avg_secs_per_exec,
TO_CHAR(r.min_secs_per_exec, '999,990.000') min_secs_per_exec,
TO_CHAR(r.max_secs_per_exec, '999,990.000') max_secs_per_exec,
(SELECT COUNT(DISTINCT p.plan_hash_value) FROM dba_hist_sql_plan p WHERE p.dbid = r.dbid AND p.sql_id = r.sql_id) plans,
REPLACE((SELECT DBMS_LOB.SUBSTR(s.sql_text, 80) FROM dba_hist_sqltext s WHERE s.dbid = r.dbid AND s.sql_id = r.sql_id), CHR(10)) sql_text_80
FROM ranked r
WHERE r.rank_num <= &&max_num_rows.
ORDER BY
r.rank_num
/
SPO OFF;
Once you get the output of this script above, you can use the one below to actually list the time series for one of the SQL statements of interest:
===================================================================================================================================================
SPO one_sql_time_series.txt;
SET lin 200 ver OFF;
COL instance_number FOR 9999 HEA 'Inst';
COL end_time HEA 'End Time';
COL plan_hash_value HEA 'Plan|Hash Value';
COL executions_total FOR 999,999 HEA 'Execs|Total';
COL rows_per_exec HEA 'Rows Per Exec';
COL et_secs_per_exec HEA 'Elap Secs|Per Exec';
COL cpu_secs_per_exec HEA 'CPU Secs|Per Exec';
COL io_secs_per_exec HEA 'IO Secs|Per Exec';
COL cl_secs_per_exec HEA 'Clus Secs|Per Exec';
COL ap_secs_per_exec HEA 'App Secs|Per Exec';
COL cc_secs_per_exec HEA 'Conc Secs|Per Exec';
COL pl_secs_per_exec HEA 'PLSQL Secs|Per Exec';
COL ja_secs_per_exec HEA 'Java Secs|Per Exec';
SELECT h.instance_number,
To_char(Cast(s.end_interval_time AS DATE), 'YYYY-MM-DD HH24:MI') end_time, h.plan_hash_value, h.executions_total,
To_char(Round(h.rows_processed_total / h.executions_total), '999,999,999,999') rows_per_exec,
To_char(Round(h.elapsed_time_total / h.executions_total / 1e6, 3), '999,990.000') et_secs_per_exec,
To_char(Round(h.cpu_time_total / h.executions_total / 1e6, 3), '999,990.000') cpu_secs_per_exec,
To_char(Round(h.iowait_total / h.executions_total / 1e6, 3), '999,990.000') io_secs_per_exec,
To_char(Round(h.clwait_total / h.executions_total / 1e6, 3), '999,990.000') cl_secs_per_exec,
To_char(Round(h.apwait_total / h.executions_total / 1e6, 3), '999,990.000') ap_secs_per_exec,
To_char(Round(h.ccwait_total / h.executions_total / 1e6, 3), '999,990.000') cc_secs_per_exec,
To_char(Round(h.plsexec_time_total / h.executions_total / 1e6, 3), '999,990.000') pl_secs_per_exec,
To_char(Round(h.javexec_time_total / h.executions_total / 1e6, 3), '999,990.000') ja_secs_per_exec
FROM dba_hist_sqlstat h,
dba_hist_snapshot s
WHERE h.sql_id = &sql_id.'
/
SPO OFF;
Monitoring execution plan changes:
==================================
set sqlblanklines on
set lines 800
set pages 1000
/* statements captured during last days */
with samples as
(select *
from dba_hist_sqlstat st
join dba_hist_snapshot sn
using (snap_id, instance_number)
where parsing_schema_name = '&schema_name'
and module 'DBMS_SCHEDULER' -- no sql tuning task
and executions_delta > 0
and begin_interval_time between sysdate - '&num_days' and sysdate),
/* just statements that had at least 2 different plans during that time */
sql_ids as
(select sql_id,
count(distinct plan_hash_value) plancount
from samples
group by sql_id
having count(distinct plan_hash_value) > 2),
/* per combination of sql_id and plan_hash_value, elapsed times per execution */
plan_stats as
(select sql_id,
plan_hash_value,
count(snap_id) snap_count,
max(end_interval_time) last_seen,
sum(executions_delta) total_execs,
sum(elapsed_time_delta) / sum(executions_delta) elapsed_per_exec_thisplan
from sql_ids
join samples
using (sql_id)
group by sql_id, plan_hash_value),
/* how much different is the elapsed time most recently encountered from other elapsed times in the measurement interval? */
elapsed_time_diffs as
(select p.*,
elapsed_per_exec_thisplan - first_value(elapsed_per_exec_thisplan)
over(partition by sql_id order by last_seen desc) elapsed_per_exec_diff,
(elapsed_per_exec_thisplan - first_value(elapsed_per_exec_thisplan)
over(partition by sql_id order by last_seen desc)) / elapsed_per_exec_thisplan elapsed_per_exec_diff_ratio
from plan_stats p),
/* consider just statements for which the difference is bigger than our configured threshold */
impacted_sql_ids as
(select *
from elapsed_time_diffs
where abs(elapsed_per_exec_diff_ratio) > &threshold),
/* for those statements, get all required information */
all_info as
(select sql_id,
plan_hash_value,
snap_count,
last_seen,
round(elapsed_per_exec_thisplan / 1e6, 2) elapsed_per_exec_thisplan,
round(elapsed_per_exec_diff / 1e6, 2) elapsed_per_exec_diff,
round(100 * elapsed_per_exec_diff_ratio, 2) elapsed_per_exec_diff_pct,
round(max(abs(elapsed_per_exec_diff_ratio))
over(partition by sql_id), 2) * 100 max_abs_diff,
round(max(elapsed_per_exec_diff_ratio) over(partition by sql_id), 2) * 100 max_diff,
'select * from table(dbms_xplan.display_awr(sql_id=>''' || sql_id ||
''', plan_hash_value=>' || plan_hash_value || '));' xplan
from elapsed_time_diffs
where sql_id in (select sql_id from impacted_sql_ids))
/* format the output */
select case sign(elapsed_per_exec_diff)
when 0 then max_abs_diff ||
case when max_abs_diff max_diff then
'% worse than another plan found during the last 7 days'
else
'% better than the next best plan during the last 7 days'
end
end status,
a.sql_id,
a.snap_count,
to_char(last_seen, 'yy-mm-dd hh24:mi:ss') last_seen,
to_char(a.elapsed_per_exec_thisplan, '999999.99') elapsed_per_exec_thisplan,
to_char(a.elapsed_per_exec_diff, '999999.99') elapsed_per_exec_diff,
to_char(a.elapsed_per_exec_diff_pct, '999999.99') elapsed_per_exec_diff_pct,
xplan
from all_info a
order by sql_id, last_seen desc;
select case sign(elapsed_per_exec_diff)
when 0 then max_abs_diff ||
case when max_abs_diff max_diff then
‘% worse than another plan found during the last 7 days’
else
How to find long running queries:
=================================
SELECT sid,
inst_id,
opname,
totalwork,
sofar,
start_time,
time_remaining
FROM gv$session_longops
WHERE totalwork <> sofar
/
How To Connect To Another User Without Knowing The Password In Oracle:
======================================================================
Suppose you want to do some activity under another user, But you don’t know the password of that user. Then how you will do it?
There is a way you can do it. See the below demo.
Suppose a user TEST1 wants to connect to TEST2 user and create a table and we don’t know the password of TEST2.
For this TEST1 user need one privilege i.e grant connect through
Conn / as sysdba
SQL >alter user TEST2 grant connect through TEST1;
User altered.
SQL >conn TEST1[TEST2]
Enter password:< Give password for TEST1>
SQL >show user
USER is "TEST2"
SQL >create table emp_test1 as select * from emp_test;
Table created.
SQL > conn / as sysdba
connected
SQL > select owner from dba_tables where table_name='EMP_TEST';
OWNER
------
TEST2
This method is usually helpful, when you want to drop/create a private db_link and you don’t know the password of that db_link owner.
Once activity is done, revoke the privilege as below.
SQL >conn / as sysdba
Connected.
SQL> alter user TEST2 revoke connect through TEST1;
User altered.
Create Sql Baseline From Cursor Cache:
======================================
If you have the sql_id of the sql query, then you can create a baseline of that using below code.
DECLARE
l_plans_loaded PLS_INTEGER;
BEGIN
l_plans_loaded := DBMS_SPM.load_plans_from_cursor_cache(
sql_id => '&sql_id');
END;
/
Suppose you have multiple plan hash value of the sql_id and you wish to create baseline with a particular plan hash value , then below one can be used.
DECLARE
l_plans_loaded PLS_INTEGER;
BEGIN
l_plans_loaded := DBMS_SPM.load_plans_from_cursor_cache(
sql_id => '&sql_id', plan_hash_value => '&plan_hash_value');
END;
/
Find utilization of redo logs:
==============================
Below is the script to find the utilizations of redo logs
SELECT le.leseq "Current log sequence No",
100 * cp.cpodr_bno / le.lesiz "Percent Full",
cp.cpodr_bno "Current Block No",
le.lesiz "Size of Log in Blocks"
FROM x$kcccp cp,
x$kccle le
WHERE le.leseq = CP.cpodr_seq
AND Bitand(le.leflg, 24) = 8
/
Get hourly database growth report:
==================================
Below script will generate the database size for past few days(per hour)
set serveroutput on
Declare
v_BaselineSize number(20);
v_CurrentSize number(20);
v_TotalGrowth number(20);
v_Space number(20);
cursor usageHist is
select a.snap_id,
TIMESTAMP,
sum(TOTAL_SPACE_ALLOCATED_DELTA) over ( order by a.SNAP_ID) ProgSum
from
(select SNAP_ID,
sum(SPACE_ALLOCATED_DELTA) TOTAL_SPACE_ALLOCATED_DELTA
from DBA_HIST_SEG_STAT
group by SNAP_ID
having sum(SPACE_ALLOCATED_TOTAL) <> 0
order by 1 ) a,
(select distinct SNAP_ID,
to_char(END_INTERVAL_TIME,'DD-Mon-YYYY HH24:Mi') TIMESTAMP
from DBA_HIST_SNAPSHOT) b
where a.snap_id=b.snap_id;
Begin
select sum(SPACE_ALLOCATED_DELTA) into v_TotalGrowth from DBA_HIST_SEG_STAT;
select sum(bytes) into v_CurrentSize from dba_segments;
v_BaselineSize := v_CurrentSize - v_TotalGrowth ;
dbms_output.put_line('TIMESTAMP Database Size(GB)');
for row in usageHist loop
v_Space := (v_BaselineSize + row.ProgSum)/(1024*1024*1024);
dbms_output.put_line(row.TIMESTAMP || ' ' || to_char(v_Space) );
end loop;
end;
/
Find who locked your account:
Below script is used to find, how a user account got locked.
============================================================
-- Return code 1017 ( INVALID LOGIN ATTEMPT)
-- Return code 28000 ( ACCOUNT LOCKED)
set pagesize 1299
set lines 299
col username for a15
col userhost for a13
col timestamp for a39
col terminal for a23
SELECT username,userhost,terminal,timestamp,returncode
FROM dba_audit_session
WHERE username='&USER_NAME' and returncode in (1017,28000);
Find row count of all partitions of a table:
============================================
Below script is for finding the row counts of all partitions of a table in Oracle.
set serverout on size 1000000
set verify off
declare
sql_stmt varchar2(1024);
row_count number;
cursor get_tab is
select table_name,partition_name
from dba_tab_partitions
where table_owner=upper('&&TABLE_OWNER') and table_name='&&TABLE_NAME';
begin
dbms_output.put_line('Checking Record Counts for table_name');
dbms_output.put_line('Log file to numrows_part_&&TABLE_OWNER.lst ....');
dbms_output.put_line('....');
for get_tab_rec in get_tab loop
BEGIN
sql_stmt := 'select count(*) from &&TABLE_OWNER..'||get_tab_rec.table_name
||' partition ( '||get_tab_rec.partition_name||' )';
EXECUTE IMMEDIATE sql_stmt INTO row_count;
dbms_output.put_line('Table '||rpad(get_tab_rec.table_name
||'('||get_tab_rec.partition_name||')',50)
||' '||TO_CHAR(row_count)||' rows.');
exception when others then
dbms_output.put_line
('Error counting rows for table '||get_tab_rec.table_name);
END;
end loop;
end;
/
set verify on
How to find the I/O usage of tempfiles:
=======================================
Below scripts are useful to find the i/o usage of tempfiles
SELECT Substr(t.name, 1, 50) AS file_name,
f.phyblkrd AS blocks_read,
f.phyblkwrt AS blocks_written,
f.phyblkrd + f.phyblkwrt AS total_io
FROM v$tempstat f,
v$tempfile t
WHERE t.file# = f.file#
ORDER BY f.phyblkrd + f.phyblkwrt DESC;
SELECT *
FROM (SELECT u.tablespace,
s.username,
s.sid,
s.serial#,
s.logon_time,
program,
u.extents,
( ( u.blocks * 8 ) / 1024 ) AS MB,
i.inst_id,
i.host_name
FROM gv$session s,
gv$sort_usage u,
gv$instance i
WHERE s.saddr = u.session_addr
AND u.inst_id = i.inst_id
ORDER BY mb DESC) a
WHERE ROWNUM < 10;
Find High water mark of a table:
================================
Below is the script for finding high water mark of a table.
--
-- Show the High Water Mark for a given table, or all tables if ALL is specified for Table_Name.
--
SET LINESIZE 300
SET SERVEROUTPUT ON
SET VERIFY OFF
DECLARE
CURSOR cu_tables IS
SELECT a.owner,
a.table_name
FROM all_tables a
WHERE a.table_name = Decode(Upper('&&Table_Name'),'ALL',a.table_name,Upper('&&Table_Name'))
AND a.owner = Upper('&&Table_Owner')
AND a.partitioned='NO'
AND a.logging='YES'
order by table_name;
op1 NUMBER;
op2 NUMBER;
op3 NUMBER;
op4 NUMBER;
op5 NUMBER;
op6 NUMBER;
op7 NUMBER;
BEGIN
Dbms_Output.Disable;
Dbms_Output.Enable(1000000);
Dbms_Output.Put_Line('TABLE UNUSED BLOCKS TOTAL BLOCKS HIGH WATER MARK');
Dbms_Output.Put_Line('------------------------------ --------------- --------------- ---------------');
FOR cur_rec IN cu_tables LOOP
Dbms_Space.Unused_Space(cur_rec.owner,cur_rec.table_name,'TABLE',op1,op2,op3,op4,op5,op6,op7);
Dbms_Output.Put_Line(RPad(cur_rec.table_name,30,' ') ||
LPad(op3,15,' ') ||
LPad(op1,15,' ') ||
LPad(Trunc(op1-op3-1),15,' '));
END LOOP;
END;
Find sessions holding library cache lock:
========================================
Below are the scripts for finding the sessions holding libary cache lock: For standalone db:
SELECT sid Waiter,
p1raw,
Substr(Rawtohex(p1), 1, 30) Handle,
Substr(Rawtohex(p2), 1, 30) Pin_addr
FROM v$session_wait
WHERE wait_time = 0
AND event LIKE '%library cache%';
For RAC DB:
SELECT a.sid Waiter,
b.serial#,
a.event,
a.p1raw,
Substr(Rawtohex(a.p1), 1, 30) Handle,
Substr(Rawtohex(a.p2), 1, 30) Pin_addr
FROM v$session_wait a,
v$session b
WHERE a.sid = b.sid
AND a.wait_time = 0
AND a.event LIKE 'library cache%';
or
set lines 152
col sid for a9999999999999
col name for a40
SELECT a.sid,
b.name,
a.value,
b.class
FROM gv$sesstat a,
gv$statname b
WHERE a.statistic# = b.statistic#
AND name LIKE '%library cache%';
How to get the bind values of a sql query:
==========================================
If you have the sql_id of the sql query , then you can get the bind values of the bind variables, from v$sql_bind_capture. Script:
SELECT sql_id,
b. last_captured,
t.sql_text sql_text,
b.hash_value,
b.name bind_name,
b.value_string bind_value
FROM gv$sql t
join gv$sql_bind_capture b USING (sql_id)
WHERE b.value_string IS NOT NULL
AND sql_id = '&sqlid'
/
Top 5 wait events from v$active_session_history:
================================================
select * from (
select
WAIT_CLASS ,
EVENT,
count(sample_time) as EST_SECS_IN_WAIT
from v$active_session_history
where sample_time between sysdate - interval '1' hour and sysdate
group by WAIT_CLASS,EVENT
order by count(sample_time) desc
)
where rownum <6;
Top 10 SQL queries from v$active_session_history
================================================
select * from (
select
SQL_ID ,
sum(decode(session_state,'ON CPU',1,0)) as CPU,
sum(decode(session_state,'WAITING',1,0)) - sum(decode(session_state,'WAITING', decode(wait_class, 'User I/O',1,0),0)) as WAIT,
sum(decode(session_state,'WAITING', decode(wait_class, 'User I/O',1,0),0)) as IO,
sum(decode(session_state,'ON CPU',1,1)) as TOTAL
from v$active_session_history
where SQL_ID is not NULL
group by sql_id
order by sum(decode(session_state,'ON CPU',1,1)) desc
)
where rownum <11;
Average Active Sessions from v$active_session_history:
======================================================
select round((count(ash.sample_id) / ((CAST(end_time.sample_time AS DATE) - CAST(start_time.sample_time AS DATE))*24*60*60)),2) as AAS
from
(select min(sample_time) sample_time
from v$active_session_history ash
) start_time,
(select max(sample_time) sample_time
from v$active_session_history
) end_time,
v$active_session_history ash
where ash.sample_time between start_time.sample_time and end_time.sample_time
group by end_time.sample_time,start_time.sample_time;
You can restrict period of time analyzed by filtering with the sample_time column. Here is AAS from the last hour :
select round((count(ash.sample_id) / ((CAST(end_time.sample_time AS DATE) - CAST(start_time.sample_time AS DATE))*24*60*60)),2) as AAS
from
(select min(sample_time) sample_time
from v$active_session_history ash
where sample_time between sysdate-1/24 and sysdate) start_time,
(select max(sample_time) sample_time
from v$active_session_history
where sample_time between sysdate-1/24 and sysdate) end_time,
v$active_session_history ash
where ash.sample_time between start_time.sample_time and end_time.sample_time
group by end_time.sample_time,start_time.sample_time;
Top 10 SQL Activity:
====================
SELECT trunc(sample_time,'MI'),
sql_id,
count(sql_id) as TOTAL
FROM v$active_session_history
WHERE sample_time between sysdate - interval '1' hour and sysdate
AND sql_id in (select sql_id from (
select
SQL_ID ,
sum(decode(session_state,'WAITING',1,1)) as TOTAL_ACTIVITY
from v$active_session_history
WHERE sample_time between sysdate - interval '1' hour and sysdate
group by sql_id
order by sum(decode(session_state,'WAITING',1,1)) desc)
where rownum < 11)
group by trunc(sample_time,'MI'),sql_id
order by trunc(sample_time,'MI') desc
Top 10 sessions from v$active_session_history
=============================================
select * from (
select
session_id,
session_serial#,
program,
module,
action,
sum(decode(session_state,'WAITING',0,1)) "CPU",
sum(decode(session_state,'WAITING',1,0)) - sum(decode(session_state,'WAITING',decode(wait_class,'User I/O',1,0),0)) "WAITING" ,
sum(decode(session_state,'WAITING',decode(wait_class,'User I/O',1,0),0)) "IO" ,
sum(decode(session_state,'WAITING',1,1)) "TOTAL"
from v$active_session_history
where session_type='FOREGROUND'
group by session_id,session_serial#,module,action,program
order by sum(decode(session_state,'WAITING',1,1)) desc)
where rownum <11;
select * from (
select
session_id,
session_serial#,
program,
module,
action,
sum(decode(session_state,'WAITING',0,1)) "CPU",
sum(decode(session_state,'WAITING',1,0)) - sum(decode(session_state,'WAITING',decode(wait_class,'User I/O',1,0),0)) "WAITING" ,
sum(decode(session_state,'WAITING',decode(wait_class,'User I/O',1,0),0)) "IO" ,
sum(decode(session_state,'WAITING',1,1)) "TOTAL"
from v$active_session_history
where session_type='FOREGROUND'
group by session_id,session_serial#,module,action,program
order by sum(decode(session_state,'WAITING',1,1)) desc)
where rownum <11;
How to find current running sqls in oracle:
===========================================
Use below script to get the current running sql details.
select sesion.sid,
sesion.username,
optimizer_mode,
hash_value,
address,
cpu_time,
elapsed_time,
sql_text
from v$sqlarea sqlarea, v$session sesion
where sesion.sql_hash_value = sqlarea.hash_value
and sesion.sql_address = sqlarea.address
and sesion.username is not null;
column status format a10
set feedback off
set serveroutput on
select username, sid, serial#, process, status
from v$session
where username is not null
/
column username format a20
column sql_text format a55 word_wrapped
set serveroutput on size 1000000
declare
x number;
begin
for x in
( select username||'('||sid||','||serial#||
') ospid = ' || process ||
' program = ' || program username,
to_char(LOGON_TIME,' Day HH24:MI') logon_time,
to_char(sysdate,' Day HH24:MI') current_time,
sql_address, LAST_CALL_ET
from v$session
where status = 'ACTIVE'
and rawtohex(sql_address) <> '00'
and username is not null order by last_call_et )
loop
for y in ( select max(decode(piece,0,sql_text,null)) ||
max(decode(piece,1,sql_text,null)) ||
max(decode(piece,2,sql_text,null)) ||
max(decode(piece,3,sql_text,null))
sql_text
from v$sqltext_with_newlines
where address = x.sql_address
and piece < 4)
loop
if ( y.sql_text not like '%listener.get_cmd%' and
y.sql_text not like '%RAWTOHEX(SQL_ADDRESS)%')
then
dbms_output.put_line( '--------------------' );
dbms_output.put_line( x.username );
dbms_output.put_line( x.logon_time || ' ' ||
x.current_time||
' last et = ' ||
x.LAST_CALL_ET);
dbms_output.put_line(
substr( y.sql_text, 1, 250 ) );
end if;
end loop;
end loop;
end;
/
column username format a15 word_wrapped
column module format a15 word_wrapped
column action format a15 word_wrapped
column client_info format a30 word_wrapped
select username||'('||sid||','||serial#||')' username,
module,
action,
client_info
from v$session
where module||action||client_info is not null;
If you frequently need to collect all indexes of a partioned table (local and global indexes), this is a quick script that make the task a little bit easier:
=============================================================================================================================================================
begin
-- local indexes
for i in (select p.index_owner owner, p.index_name, p.partition_name
from dba_indexes i, dba_ind_partitions p
where i.owner='&OWNER'
and i.table_name='&TABLE'
and i.partitioned='YES'
and i.visibility='VISIBLE' -- Rebuild only of the visible indexes, to get real effect :)
and p.index_name=i.index_name
and p.index_owner=i.owner
order by 1,2) loop
execute immediate 'alter index '||i.owner||'.'||i.index_name||' rebuild partition '||i.partition_name||' online parallel 12'; -- parallel 12 solve most of the problems
execute immediate 'alter index '||i.owner||'.'||i.index_name||' parallel 1'; -- If you don't use parallel indexes in your database, or the default parallel of the index, or what you want...
end loop;
-- global indexes
for i in (select i.owner owner, i.index_name
from dba_indexes i
where i.owner='&OWNER'
and i.table_name='&TABLE'
and i.partitioned='NO'
and i.visibility='VISIBLE' -- same comment
order by 1,2) loop
execute immediate 'alter index '||i.owner||'.'||i.index_name||' rebuild online parallel 12'; -- same
execute immediate 'alter index '||i.owner||'.'||i.index_name||' parallel 1'; -- same :)
end loop;
end;
/
Tablespace monitoring in oracle 12c multitenant database.:
==========================================================
You can use this script to check tablespace space details in 12c Multitenant database. It will provide information of both root CDB and PDB.
SET LINES 132 PAGES 100
COL con_name FORM A15 HEAD "Container|Name"
COL tablespace_name FORM A15
COL fsm FORM 999,999,999,999 HEAD "Free|Space Meg."
COL apm FORM 999,999,999,999 HEAD "Alloc|Space Meg."
--
COMPUTE SUM OF fsm apm ON REPORT
BREAK ON REPORT ON con_id ON con_name ON tablespace_name
--
WITH x AS (SELECT c1.con_id, cf1.tablespace_name, SUM(cf1.bytes)/1024/1024 fsm
FROM cdb_free_space cf1
,v$containers c1
WHERE cf1.con_id = c1.con_id
GROUP BY c1.con_id, cf1.tablespace_name),
y AS (SELECT c2.con_id, cd.tablespace_name, SUM(cd.bytes)/1024/1024 apm
FROM cdb_data_files cd
,v$containers c2
WHERE cd.con_id = c2.con_id
GROUP BY c2.con_id
,cd.tablespace_name)
SELECT x.con_id, v.name con_name, x.tablespace_name, x.fsm, y.apm
FROM x, y, v$containers v
WHERE x.con_id = y.con_id
AND x.tablespace_name = y.tablespace_name
AND v.con_id = y.con_id
UNION
SELECT vc2.con_id, vc2.name, tf.tablespace_name, null, SUM(tf.bytes)/1024/1024
FROM v$containers vc2, cdb_temp_files tf
WHERE vc2.con_id = tf.con_id
GROUP BY vc2.con_id, vc2.name, tf.tablespace_name
ORDER BY 1, 2;
Realtime monitoring of sql query using v$sql_plan_monitor:
==========================================================
V$SQL_PLAN_MONITOR displays real time plan level monitoring statistics for the currently running sql queries.. Each row in V$SQL_PLAN_MONITOR corresponds to an operation of the execution plan being monitored.
--- sql_is from v$sql_monitor
SELECT sql_id FROM v$sql_monitor;
SQL_ID
-------
00tr6c6tngp4x
Use below query to get the plan details:
SELECT sid, sql_id, plan_line_id,SQL_PLAN_HASH_VALUE,STARTS,LAST_REFRESH_TIME,LAST_CHANGE_TIME,PLAN_CPU_COST,PLAN_IO_COST,plan_operation || ' ' || plan_options operation, output_rows,status
FROM v$sql_plan_monitor
WHERE status NOT LIKE '%DONE%'
ORDER BY 1,4;
Top 5 cached sql statements by elapsed time in oracle:
======================================================
Get the Top 10 cached sql statements details
SELECT sql_id,
child_number,
sql_text,
elapsed_time
FROM (SELECT sql_id,
child_number,
sql_text,
elapsed_time,
cpu_time,
disk_reads,
Rank ()
over (
ORDER BY elapsed_time DESC) AS elapsed_rank
FROM v$sql)
WHERE elapsed_rank <= 10;
Active session query:
=====================
select S.USERNAME, s.sid, s.osuser, t.sql_id, sql_text
from v$sqltext_with_newlines t,V$SESSION s
where t.address =s.sql_address
and t.hash_value = s.sql_hash_value
and s.status = 'ACTIVE'
and s.username in ('SYS','SYSTEM','DBSNMP')
order by s.sid,t.piece
/
Find out long running queries:
==============================
select s.username,s.sid,s.serial#,s.last_call_et/60 mins_running,q.sql_text from v$session s
join v$sqltext_with_newlines q
on s.sql_address = q.address
where status='ACTIVE'
and type <>'BACKGROUND'
and last_call_et> 600
order by sid,serial#,q.piece
column username format 'a10'
column osuser format 'a10'
column module format 'a16'
column program_name format 'a20'
column program format 'a20'
column machine format 'a20'
column action format 'a20'
column sid format '9999'
column serial# format '99999'
column spid format '99999'
set linesize 200
set pagesize 30
select
a.sid,a.serial#,a.username,a.osuser,c.start_time,
b.spid,a.status,a.machine,
a.action,a.module,a.program
from
v$session a, v$process b, v$transaction c,
v$sqlarea s
Where
a.paddr = b.addr
and a.saddr = c.ses_addr
and a.sql_address = s.address (+)
and to_date(c.start_time,'mm/dd/yy hh24:mi:ss') <= sysdate - (15/1440) -- running for 15 minutes
order by c.start_time
/
Step 2: desc v$session
Step 3:select sid, serial#,SQL_ADDRESS, status,PREV_SQL_ADDR from v$session where sid='xxxx' //(enter the sid value)
Step 4: select sql_text from v$sqltext where address='XXXXXXXX';
Locks in database:
==================
select
object_name,
object_type,
session_id,
type, -- Type or system/user lock
lmode, -- lock mode in which session holds lock
request,
block,
ctime -- Time since current mode was granted
from
v$locked_object, all_objects, v$lock
where
v$locked_object.object_id = all_objects.object_id AND
v$lock.id1 = all_objects.object_id AND
v$lock.sid = v$locked_object.session_id
order by
session_id, ctime desc, object_name
/
Long operations query percentage:
=================================
COLUMN percent FORMAT 999.99
SELECT sid, to_char(start_time,'hh24:mi:ss') stime,
message,( sofar/totalwork)* 100 percent
FROM v$session_longops
WHERE sofar/totalwork < 1
/
How to find sql text from a sid:
================================
Use below query to get the sql text of a particular sid. When the below script asks for input, enter the SID.
col sql_text FORM a80
set lines 120
SELECT sql_text
FROM gv$sqltext
WHERE hash_value = (SELECT sql_hash_value
FROM gv$session
WHERE sid = &1)
ORDER BY piece
/
How to find active sessions in oracle database:
==============================================
Use below script to find active sessions in oracle database.
set echo OFF
set linesize 95
set head ON
set feedback ON
col sid head "Sid" FORM 9999 trunc
col serial# FORM 99999 trunc head "Ser#"
col username FORM a8 trunc
col osuser FORM a7 trunc
col machine FORM a20 trunc head "Client|Machine"
col program FORM a15 trunc head "Client|Program"
col login FORM a11
col "last call" FORM 9999999 trunc head "Last Call|In Secs"
col status FORM a6 trunc
SELECT sid,
serial#,
Substr(username, 1, 10) username,
Substr(osuser, 1, 10) osuser,
Substr(program
||MODULE, 1, 15) program,
Substr(machine, 1, 22) machine,
To_char(logon_time, 'ddMon hh24:mi') login,
last_call_et "last call",
status
FROM v$session
WHERE status = 'ACTIVE'
ORDER BY 1
/
How to get the size of an oracle database:
==========================================
Use below query to get the size of a database.
col "Database Size" format a20
col "Free space" format a20
col "Used space" format a20
SELECT Round(SUM(used.bytes) / 1024 / 1024 / 1024)
|| ' GB' "Database Size",
Round(SUM(used.bytes) / 1024 / 1024 / 1024) - Round(
free.p / 1024 / 1024 / 1024)
|| ' GB' "Used space",
Round(free.p / 1024 / 1024 / 1024)
|| ' GB' "Free space"
FROM (SELECT bytes
FROM v$datafile
UNION ALL
SELECT bytes
FROM v$tempfile
UNION ALL
SELECT bytes
FROM v$log) used,
(SELECT SUM(bytes) AS p
FROM dba_free_space) free
GROUP BY free.p
/
Query to get child table and foreign key status:
===============================================
Use below query to get child key and foreign key status:
col owner FORM a10
col fk_column FORM a15
col table_name FORM a30
SELECT b.owner,
b.table_name child_table,
b.status,
c.column_name FK_column,
b.constraint_name
FROM dba_constraints a,
dba_constraints b,
dba_cons_columns c
WHERE a.owner = b.r_owner
AND b.owner = c.owner
AND b.table_name = c.table_name
AND b.constraint_name = c.constraint_name
AND a.constraint_name = b.r_constraint_name
AND b.constraint_type = 'R'
AND a.owner = '&OWNER'
AND a.table_name = '&TABLE_NAME'
AND a.constraint_type = 'P';
Enable constraints:
===================
alter table FDR.MDT_RM_CALL_CLOSEOUT_METER disable constraints MDT_RM_CALL_CLOSEOUT_METER_FK;
Find the parent table of child table:
====================================
SELECT owner,
table_name
FROM dba_constraints
WHERE constraint_name IN (SELECT r_constraint_name
FROM dba_constraints
WHERE table_name = 'PUROLATOR_ACCOUNTS'
AND constraint_type = 'R');
scripts to monitor standby database:
====================================
FIND THE ARCHIVE LAG BETWEEN PRIMARY AND STANDBY:
=================================================
select LOG_ARCHIVED-LOG_APPLIED "LOG_GAP" from
(SELECT MAX(SEQUENCE#) LOG_ARCHIVED
FROM V$ARCHIVED_LOG WHERE DEST_ID=1 AND ARCHIVED='YES'),
(SELECT MAX(SEQUENCE#) LOG_APPLIED
FROM V$ARCHIVED_LOG WHERE DEST_ID=2 AND APPLIED='YES');
CHECK THE STATUS OF DIFFERENT PROCESS:
======================================
SQL> SELECT PROCESS, STATUS, THREAD#, SEQUENCE#, BLOCK#, BLOCKS FROM V$MANAGED_STANDBY ;
LAST SEQUENCE RECEIVED AND LAST SEQUENCE APPLIED:
=================================================
SQL> SELECT al.thrd "Thread", almax "Last Seq Received", lhmax "Last Seq Applied" FROM
2 (select thread# thrd, MAX(sequence#) almax FROM v$archived_log WHERE resetlogs_change#=(SELECT resetlogs_change#
3 FROM v$database) GROUP BY thread#) al, (SELECT thread# thrd, MAX(sequence#) lhmax FROM v$log_history
WHERE resetlogs_change#=(SELECT resetlogs_change# FROM v$database) GROUP BY thread#) lh WHERE al.thrd = lh.thrd; 4
CHECK THE MESSAGES/ERRORS IN STNADBY DATABASE:
==============================================
set pagesize 2000
set lines 2000
col MESSAGE for a90
select message,timestamp from V$DATAGUARD_STATUS where timestamp > sysdate - 1/6;
CHECK THE NUMBER OF ARCHIVES GETTING GENERATING ON HOURLY BASIS:
================================================================
SELECT TO_CHAR(TRUNC(FIRST_TIME),'Mon DD') "DG Date",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'00',1,0)),'9999') "12AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'01',1,0)),'9999') "01AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'02',1,0)),'9999') "02AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'03',1,0)),'9999') "03AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'04',1,0)),'9999') "04AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'05',1,0)),'9999') "05AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'06',1,0)),'9999') "06AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'07',1,0)),'9999') "07AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'08',1,0)),'9999') "08AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'09',1,0)),'9999') "09AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'10',1,0)),'9999') "10AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'11',1,0)),'9999') "11AM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'12',1,0)),'9999') "12PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'13',1,0)),'9999') "1PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'14',1,0)),'9999') "2PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'15',1,0)),'9999') "3PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'16',1,0)),'9999') "4PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'17',1,0)),'9999') "5PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'18',1,0)),'9999') "6PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'19',1,0)),'9999') "7PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'20',1,0)),'9999') "8PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'21',1,0)),'9999') "9PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'22',1,0)),'9999') "10PM",
TO_CHAR(SUM(DECODE(TO_CHAR(FIRST_TIME,'HH24'),'23',1,0)),'9999') "11PM"
FROM V$LOG_HISTORY
WHERE to_date(first_time) > sysdate -8
GROUP BY TRUNC(FIRST_TIME)
ORDER BY TRUNC(FIRST_TIME) DESC
/
SELECT to_date(first_time) DAY,
to_char(sum(decode(to_char(first_time,'HH24'),'00',1,0)),'9999') "00",
to_char(sum(decode(to_char(first_time,'HH24'),'01',1,0)),'9999') "01",
to_char(sum(decode(to_char(first_time,'HH24'),'02',1,0)),'9999') "02",
to_char(sum(decode(to_char(first_time,'HH24'),'03',1,0)),'9999') "03",
to_char(sum(decode(to_char(first_time,'HH24'),'04',1,0)),'9999') "04",
to_char(sum(decode(to_char(first_time,'HH24'),'05',1,0)),'9999') "05",
to_char(sum(decode(to_char(first_time,'HH24'),'06',1,0)),'9999') "06",
to_char(sum(decode(to_char(first_time,'HH24'),'07',1,0)),'9999') "07",
to_char(sum(decode(to_char(first_time,'HH24'),'08',1,0)),'9999') "08",
to_char(sum(decode(to_char(first_time,'HH24'),'09',1,0)),'9999') "09",
to_char(sum(decode(to_char(first_time,'HH24'),'10',1,0)),'9999') "10",
to_char(sum(decode(to_char(first_time,'HH24'),'11',1,0)),'9999') "11",
to_char(sum(decode(to_char(first_time,'HH24'),'12',1,0)),'9999') "12",
to_char(sum(decode(to_char(first_time,'HH24'),'13',1,0)),'9999') "13",
to_char(sum(decode(to_char(first_time,'HH24'),'14',1,0)),'9999') "14",
to_char(sum(decode(to_char(first_time,'HH24'),'15',1,0)),'9999') "15",
to_char(sum(decode(to_char(first_time,'HH24'),'16',1,0)),'9999') "16",
to_char(sum(decode(to_char(first_time,'HH24'),'17',1,0)),'9999') "17",
to_char(sum(decode(to_char(first_time,'HH24'),'18',1,0)),'9999') "18",
to_char(sum(decode(to_char(first_time,'HH24'),'19',1,0)),'9999') "19",
to_char(sum(decode(to_char(first_time,'HH24'),'20',1,0)),'9999') "20",
to_char(sum(decode(to_char(first_time,'HH24'),'21',1,0)),'9999') "21",
to_char(sum(decode(to_char(first_time,'HH24'),'22',1,0)),'9999') "22",
to_char(sum(decode(to_char(first_time,'HH24'),'23',1,0)),'9999') "23"
from
v$log_history
where to_date(first_time) > sysdate -8
GROUP by
to_char(first_time,'YYYY-MON-DD'), to_date(first_time)
order by to_date(first_time);
How to get ddl of all tablespaces in oracle:
===========================================
Below script will generate the DDLs of all the tablespaces in oracle.
SQL>set heading off;
SQL>set echo off;
SQL>Set pages 999;
SQL>set long 90000;
SQL>spool ddl_list.sql
SQL>select dbms_metadata.get_ddl('TABLESPACE',tb.tablespace_name) from dba_tablespaces tb;
SQL>spool off
Query to check tablespace free space:
=====================================
Use below query to check all the space related details of tablespaces.
set feedback off
set pagesize 2000;
set linesize 300
set head on
COLUMN Tablespace format a25 heading 'Tablespace Name'
COLUMN autoextensible format a11 heading 'AutoExtend'
COLUMN files_in_tablespace format 999 heading 'Files'
COLUMN total_tablespace_space format 99999999 heading 'TotalSpace'
COLUMN total_used_space format 99999999 heading 'UsedSpace'
COLUMN total_tablespace_free_space format 99999999 heading 'FreeSpace'
COLUMN total_used_pct format 9999 heading '%Used'
COLUMN total_free_pct format 9999 heading '%Free'
COLUMN max_size_of_tablespace format 99999999 heading 'ExtendUpto'
COLUM total_auto_used_pct format 999.99 heading 'Max%Used'
COLUMN total_auto_free_pct format 999.99 heading 'Max%Free'
WITH tbs_auto AS
(SELECT DISTINCT tablespace_name, autoextensible
FROM dba_data_files
WHERE autoextensible = 'YES'),
files AS
(SELECT tablespace_name, COUNT (*) tbs_files,
SUM (BYTES/1024/1024) total_tbs_bytes
FROM dba_data_files
GROUP BY tablespace_name),
fragments AS
(SELECT tablespace_name, COUNT (*) tbs_fragments,
SUM (BYTES)/1024/1024 total_tbs_free_bytes,
MAX (BYTES)/1024/1024 max_free_chunk_bytes
FROM dba_free_space
GROUP BY tablespace_name),
AUTOEXTEND AS
(SELECT tablespace_name, SUM (size_to_grow) total_growth_tbs
FROM (SELECT tablespace_name, SUM (maxbytes)/1024/1024 size_to_grow
FROM dba_data_files
WHERE autoextensible = 'YES'
GROUP BY tablespace_name
UNION
SELECT tablespace_name, SUM (BYTES)/1024/1024 size_to_grow
FROM dba_data_files
WHERE autoextensible = 'NO'
GROUP BY tablespace_name)
GROUP BY tablespace_name)
SELECT c.instance_name,a.tablespace_name Tablespace,
CASE tbs_auto.autoextensible
WHEN 'YES'
THEN 'YES'
ELSE 'NO'
END AS autoextensible,
files.tbs_files files_in_tablespace,
files.total_tbs_bytes total_tablespace_space,
(files.total_tbs_bytes - fragments.total_tbs_free_bytes
) total_used_space,
fragments.total_tbs_free_bytes total_tablespace_free_space,
round(( ( (files.total_tbs_bytes - fragments.total_tbs_free_bytes)
/ files.total_tbs_bytes
)
* 100
)) total_used_pct,
round(((fragments.total_tbs_free_bytes / files.total_tbs_bytes) * 100
)) total_free_pct
FROM dba_tablespaces a,v$instance c , files, fragments, AUTOEXTEND, tbs_auto
WHERE a.tablespace_name = files.tablespace_name
AND a.tablespace_name = fragments.tablespace_name
AND a.tablespace_name = AUTOEXTEND.tablespace_name
AND a.tablespace_name = tbs_auto.tablespace_name(+)
AND a.tablespace_name in ('EPICIXLARGE','EPICIXMEDIUM','EPICLARGE','EPICMEDIUM')
order by total_free_pct;
How to find log gap between primary and standby db:
===================================================
Use the below query to find the applied archive log gap between primary and standby oracle database.
SELECT log_archived - log_applied "LOG_GAP"
FROM (SELECT Max(sequence#) LOG_ARCHIVED
FROM v$archived_log
WHERE dest_id = 1
AND archived = 'YES'),
(SELECT Max(sequence#) LOG_APPLIED
FROM v$archived_log
WHERE dest_id = 2
AND applied = 'YES');
How to find free space in UNDO tablespace:
==========================================
Use below script to get the details about undo tablespace usage.
SELECT a.tablespace_name,
sizemb,
usagemb,
( sizemb - usagemb ) FREEMB
FROM (SELECT SUM(bytes) / 1024 / 1024 SIZEMB,
b.tablespace_name
FROM dba_data_files a,
dba_tablespaces b
WHERE a.tablespace_name = b.tablespace_name
AND b.CONTENTS = 'UNDO'
GROUP BY b.tablespace_name) a,
(SELECT c.tablespace_name,
SUM(bytes) / 1024 / 1024 USAGEMB
FROM dba_undo_extents c
WHERE status <> 'EXPIRED'
GROUP BY c.tablespace_name) b
WHERE a.tablespace_name = b.tablespace_name;
How To Check Undo Tablespace Usage and the Free Space:
=====================================================
This section provides the various scripts that can be used to check Undo space usage.
Note: “The Undo Space once allocated won’t be deallocated to the OS, by default.
But the space can be reused by other transactions once the UNDO_RETENION is met.”
Query 1. To check the current size of the Undo tablespace:
Select sum(a.bytes) as undo_size from v$datafile a, v$tablespace b, dba_tablespaces c
where c.contents = 'UNDO'
and c.status = 'ONLINE'
and b.name = c.tablespace_name
and a.ts# = b.ts#;
Query 2. To check the free space (unallocated) space within Undo tablespace:
select sum(bytes)/1024/1024 "mb" from dba_free_space
where tablespace_name ='<tablespace name>';
Query 3.To Check the space available within the allocated Undo tablespace:
select tablespace_name,sum(blocks)*8/(1024) reusable_space from dba_undo_extents
where status='EXPIRED' group by tablespace_name;
Query 4. To Check the space allocated in the Undo tablespace:
select tablespace_name , sum(blocks)*8/(1024) space_in_use from dba_undo_extents
where status IN ('ACTIVE','UNEXPIRED') group by tablespace_name;
How to find the temp tablespace usage:
======================================
Run the below scripts to get the temp tablespace usage.
SELECT a.tablespace_name
tablespace,
d.temp_total_mb,
SUM (a.used_blocks * d.block_size) / 1024 / 1024
TEMP_USED_MB,
d.temp_total_mb - SUM (a.used_blocks * d.block_size) / 1024 / 1024
TEMP_FREE_MB
FROM v$sort_segment a,
(SELECT b.name,
c.block_size,
SUM (c.bytes) / 1024 / 1024 TEMP_TOTAL_MB
FROM v$tablespace b,
v$tempfile c
WHERE b.ts# = c.ts#
GROUP BY b.name,
c.block_size) d
WHERE a.tablespace_name = d.name
GROUP BY a.tablespace_name,
d.temp_total_mb;
monitor rman backup progress:
=============================
Use the below query to monitor the currently running rman backup status.
SELECT sid,
serial#,
message,
sofar,
totalwork,
Round(sofar / totalwork * 100, 2) "%_COMPLETE"
FROM v$session_longops
WHERE opname LIKE 'RMAN%'
AND opname NOT LIKE '%aggregate%'
AND totalwork != 0
AND sofar <> totalwork;
set serveroutput on
set linesize 150
set pagesize 300
col time_taken_display for a9
select session_key,
input_type,
to_char(start_time,'yyyy-mm-dd hh24:mi') start_time,
to_char(end_time,'yyyy-mm-dd hh24:mi') end_time,
time_taken_display,
status
from v$rman_backup_job_details where status='RUNNING'
order by session_key desc;
Monitoring RMAN jobs:
SELECT sid, serial#, context, sofar, totalwork,
round(sofar/totalwork*100,2) "% Complete"
FROM v$session_longops
WHERE opname LIKE 'RMAN%'
AND opname NOT LIKE '%aggregate%'
AND totalwork != 0
AND sofar <> totalwork;
SELECT TRUNC(FIRST_TIME)
, COUNT(*)
FROM V$ARCHIVED_LOG
WHERE FIRST_TIME BETWEEN ADD_MONTHS(SYSDATE,-1) AND SYSDATE
AND DEST_ID = 1
GROUP BY TRUNC(FIRST_TIME)
ORDER BY 1;
SELECT TO_CHAR (COMPLETION_TIME, 'DD/MM/YYYY') DAY,
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '00', 1, NULL))
"00-01",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '01', 1, NULL))
"01-02",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '02', 1, NULL))
"02-03",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '03', 1, NULL))
"03-04",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '04', 1, NULL))
"04-05",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '05', 1, NULL))
"05-06",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '06', 1, NULL))
"06-07",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '07', 1, NULL))
"07-08",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '08', 1, NULL))
"08-09",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '09', 1, NULL))
"09-10",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '10', 1, NULL))
"10-11",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '11', 1, NULL))
"11-12",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '12', 1, NULL))
"12-13",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '13', 1, NULL))
"13-14",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '14', 1, NULL))
"14-15",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '15', 1, NULL))
"15-16",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '16', 1, NULL))
"16-17",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '17', 1, NULL))
"17-18",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '18', 1, NULL))
"18-19",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '19', 1, NULL))
"19-20",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '20', 1, NULL))
"20-21",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '21', 1, NULL))
"21-22",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '22', 1, NULL))
"22-23",
SUM (DECODE (TO_CHAR (COMPLETION_TIME, 'HH24'), '23', 1, NULL))
"23-00",
COUNT (*) TOTAL
FROM V$ARCHIVED_LOG
WHERE ARCHIVED='YES'
GROUP BY TO_CHAR (COMPLETION_TIME, 'DD/MM/YYYY')
ORDER BY TO_DATE (DAY, 'DD/MM/YYYY');
SCRIPT – CHECK RMAN BACKUP STATUS
=================================
This script will report on all backups – full, incremental and archivelog backups –
col STATUS format a9
col hrs format 999.99
select
SESSION_KEY, INPUT_TYPE, STATUS,
to_char(START_TIME,'mm/dd/yy hh24:mi') start_time,
to_char(END_TIME,'mm/dd/yy hh24:mi') end_time,
elapsed_seconds/3600 hrs
from V$RMAN_BACKUP_JOB_DETAILS
order by session_key;
This script will report all on full and incremental backups, not archivelog backups –
col STATUS format a9
col hrs format 999.99
select
SESSION_KEY, INPUT_TYPE, STATUS,
to_char(START_TIME,'mm/dd/yy hh24:mi') start_time,
to_char(END_TIME,'mm/dd/yy hh24:mi') end_time,
elapsed_seconds/3600 hrs
from V$RMAN_BACKUP_JOB_DETAILS
where input_type='DB INCR'
order by session_key;
col STATUS format a9
col hrs format 999.99
select
SESSION_KEY, INPUT_TYPE, STATUS,
to_char(START_TIME,'mm/dd/yy hh24:mi') start_time,
to_char(END_TIME,'mm/dd/yy hh24:mi') end_time,
elapsed_seconds/3600 hrs
from V$RMAN_BACKUP_JOB_DETAILS
where input_type in ('DB FULL','DB INCR')
order by session_key;
How to find the wait events present in database:
================================================
Below query will results the current wait event details in oracle database.
SELECT a.sid,
Substr(b.username, 1, 10) username,
Substr(b.osuser, 1, 10) osuser,
Substr(b.program
||b.MODULE, 1, 15) program,
Substr(b.machine, 1, 22) machine,
a.event,
a.p1,
b.sql_hash_value
FROM v$session_wait a,
v$session b
WHERE b.sid = a.sid
AND a.event NOT IN( 'SQL*Net message from client',
'SQL*Net message to client',
'smon timer',
'pmon timer' )
AND username IS NOT NULL
ORDER BY 6
/
select ss.snap_id,
ss.instance_number node,
begin_interval_time,
sql_id,
plan_hash_value,
nvl(executions_delta,0) execs,
round((elapsed_time_delta/decode(nvl(executions_delta,0),0,1,executions_delta))/1000000,2) avg_etime,
round((buffer_gets_delta/decode(nvl(buffer_gets_delta,0),0,1,executions_delta)),2) avg_lio
from DBA_HIST_SQLSTAT S,
DBA_HIST_SNAPSHOT SS
where sql_id = 'xxxxxxxx'
and ss.snap_id = S.snap_id
and ss.instance_number = S.instance_number
and executions_delta > 0
order by 1 desc, 2, 3;
How to find the session using lot of undo:
==========================================
Below query will show the current sessions undo usage.
select a.sid, a.serial#, a.username, b.used_urec used_undo_record, b.used_ublk used_undo_blocks
from v$session a, v$transaction b
where a.saddr=b.ses_addr ;
How to find the locks present in oracle database:
=================================================
Below query will help you in providing sessions causing lock in the database.
col session_id head 'Sid' form 9999
col object_name head "Table|Locked" form a30
col oracle_username head "Oracle|Username" form a10 truncate
col os_user_name head "OS|Username" form a10 truncate
col process head "Client|Process|ID" form 99999999
col mode_held form a15
select lo.session_id,lo.oracle_username,lo.os_user_name,
lo.process,do.object_name,
decode(lo.locked_mode,0, 'None',1, 'Null',2, 'Row Share (SS)',
3, 'Row Excl (SX)',4, 'Share',5, 'Share Row Excl (SSX)',6, 'Exclusive',
to_char(lo.locked_mode)) mode_held
from v$locked_object lo, dba_objects do
where lo.object_id = do.object_id
order by 1,5
/
How to find the sessions using lot of temp:
===========================================
Below query will display the the list of sessions using lot of temps including their usage.
SELECT b.TABLESPACE
, b.segfile#
, b.segblk#
, ROUND ( ( ( b.blocks * p.VALUE ) / 1024 / 1024 ), 2 ) size_mb
, a.SID
, a.serial#
, a.username
, a.osuser
, a.program
, a.status
FROM v$session a
, v$sort_usage b
, v$process c
, v$parameter p
WHERE p.NAME = 'db_block_size'
AND a.saddr = b.session_addr
AND a.paddr = c.addr
ORDER BY b.TABLESPACE, b.segfile#, b.segblk#, b.blocks;
How to find the sessions generating lot of logs:
================================================
We can use below sql query to find the current sessions or queries generating lot of logs
set lines 2000
set pages 1000
col sid for 99999
col name for a09
col username for a14
col PROGRAM for a21
col MODULE for a25
select s.sid,sn.SERIAL#,n.name, round(value/1024/1024,2) redo_mb, sn.username,sn.status,substr (sn.program,1,21) "program", sn.type, sn.module,sn.sql_id
from v$sesstat s join v$statname n on n.statistic# = s.statistic#
join v$session sn on sn.sid = s.sid where n.name like 'redo size' and s.value!=0 order by
redo_mb desc;
How to check the Oracle database restore status datafile wise - Size of the file to restore and where are we now?
Query to find the database restore status - datafile wise
==========================================================
select SID,OPEN_TIME, (sysdate-open_time)*24*60 ela_time_minutes,close_time,filename,(EFFECTIVE_BYTES_PER_SECOND/1024/1024/1024)*3600 SPEED_GBPERHR,(TOTAL_BYTES/1024/1024/1024) GBTOBEREAD_FROM_FIL
E,(bytes)/1024/1024/1024 GB_Written_sofar from V$BACKUP_ASYNC_IO;
or
select SID,OPEN_TIME, (sysdate-open_time)*24*60 ela_time_minutes,close_time,filename,(EFFECTIVE_BYTES_PER_SECOND/1024/1024/1024)*3600 SPEED_GBPERHR,(TOTAL_BYTES/1024/1024/1024) GBTOBEREAD_FROM_FIL
E,(bytes)/1024/1024/1024 GB_Written_sofar from V$BACKUP_SYNC_IO;
Calculate the space used by a single object:
============================================
SELECT s.owner,
s.segment_name,
s.bytes/1024/1024 "Size(MB)"
FROM dba_segments s,
dba_lobs l
WHERE s.owner = '&schema_name'
AND s.owner=l.owner(+)
AND s.segment_name =
CASE WHEN s.segment_type = 'LOBSEGMENT'
THEN L.SEGMENT_NAME(+)
WHEN s.segment_type = 'LOBINDEX'
THEN L.INDEX_NAME(+)
END
AND s.SEGMENT_NAME='&segment_name';
Calculate the space used by a whole schema:
===========================================
SELECT s.owner,
SUM(s.bytes/1024/1024) "Size(MB)"
FROM dba_segments s,
dba_lobs l
WHERE s.owner = '&schema_name'
AND s.owner=l.owner(+)
AND s.segment_name =
CASE WHEN s.segment_type = 'LOBSEGMENT'
THEN L.SEGMENT_NAME(+)
WHEN s.segment_type = 'LOBINDEX'
THEN L.INDEX_NAME(+)
END
group by s.owner
order by 2;
TOP 10 SEGMENTS/OBJECTS IN ORACLE DATABASE:
===========================================
col owner format a15
col segment_name format a30
col segment_type format a15
col mb format 999, 999, 999
SELECT owner,
segment_name,
segment_type,
mb
FROM (SELECT owner,
segment_name,
segment_type,
bytes / 1024 / 1024 "MB"
FROM dba_segments
ORDER BY bytes DESC)
WHERE ROWNUM < 11;
COLUMN segment_nm format a45
COLUMN used_size format a16
Set lines 999
SELECT segment_nm,
segment_type,
Lpad(CASE
WHEN bytes < 1024 THEN Round(bytes, 2)
|| 'B'
WHEN bytes < Power(1024, 2) THEN Round(( bytes / 1024 ), 2)
|| 'KB'
WHEN bytes < Power(1024, 3) THEN Round(( bytes / 1024 / 1024 ), 2)
|| 'MB'
WHEN bytes < Power(1024, 4) THEN Round((
bytes / 1024 / 1024 / 1024 ), 2)
|| 'GB'
ELSE Round(( bytes / 1024 / 1024 / 1024 / 1024 ), 2)
|| 'TB'
END, 15) AS used_size,
tablespace_name
FROM (SELECT owner
|| '.'
|| Lower(segment_name) AS segment_nm,
segment_type,
bytes,
tablespace_name,
Dense_rank()
over (
ORDER BY bytes DESC ) AS dr
FROM dba_segments) A
WHERE dr <= 10 /* top-10 may have more then 10 */
ORDER BY /* lots of ordering in cases of ties */
bytes DESC,
dr ASC,
segment_nm ASC;
SELECT a.owner,
a.table_name,
b.size_gb,
( ( a.blocks * 8192 / 1024 / 1024 / 1024 ) - (
a.num_rows * avg_row_len / 1024 / 1024 / 1024 ) )
AS ACTUAL_GB,
( b.size_gb - ( ( a.blocks * 8192 / 1024 / 1024 / 1024 ) - (
a.num_rows * avg_row_len / 1024 / 1024 / 1024 ) ) )
Savings,
a.tablespace_name,
b.segment_type
TABLE_TYPE,
a.last_analyzed
FROM dba_tables a,
(SELECT *
FROM (SELECT owner,
segment_name,
segment_type,
tablespace_name,
SUM(bytes / 1024 / 1024 / 1024) Size_GB
FROM dba_segments
WHERE owner = '&schema_name'
AND segment_type LIKE '%TABLE%'
GROUP BY segment_name,
owner,
segment_type,
tablespace_name
ORDER BY 5 DESC)
WHERE ROWNUM < 11) b
WHERE a.table_name = b.segment_name
AND a.owner = b.owner
ORDER BY size_gb DESC;
Largest Database Objects in a Tablespace: - The following query shows 10 Largest database objects in a specific Tablespace
=========================================
col owner format a15
col segment_name format a30
col segment_type format a15
col mb format 999, 999, 999
SELECT owner,
segment_name,
segment_type,
mb
FROM (SELECT owner,
segment_name,
segment_type,
bytes / 1024 / 1024 "MB"
FROM dba_segments
WHERE tablespace_name = '&name'
ORDER BY bytes DESC)
WHERE ROWNUM < 11
Database Growth Checking:
=========================
SET LINESIZE 200
SET PAGESIZE 200
COL "Database Size" FORMAT a13
COL "Used Space" FORMAT a11
COL "Used in %" FORMAT a11
COL "Free in %" FORMAT a11
COL "Database Name" FORMAT a13
COL "Free Space" FORMAT a12
COL "Growth DAY" FORMAT a11
COL "Growth WEEK" FORMAT a12
COL "Growth DAY in %" FORMAT a16
COL "Growth WEEK in %" FORMAT a16
SELECT
(select min(creation_time) from v$datafile) "Create Time",
(select name from v$database) "Database Name",
ROUND((SUM(USED.BYTES) / 1024 / 1024 / 1024 ),2) || ' GB' "Database Size",
ROUND((SUM(USED.BYTES) / 1024 / 1024 / 1024 ) - ROUND(FREE.P / 1024 / 1024 / 1024),2) || ' GB' "Used Space",
ROUND(((SUM(USED.BYTES) / 1024 / 1024 / 1024) - (FREE.P / 1024 / 1024 / 1024)) / ROUND(SUM(USED.BYTES) / 1024 / 1024 / 1024,2)*100,2) || '% GB' "Used in %",
ROUND((FREE.P / 1024 / 1024 / 1024 ),2) || ' GB' "Free Space",
ROUND(((SUM(USED.BYTES) / 1024 / 1024 / 1024 ) - ((SUM(USED.BYTES) / 1024 / 1024 / 1024) - ROUND(FREE.P / 1024 / 1024 / 1024)))/ROUND(SUM(USED.BYTES) / 1024 / 1024 / 1024,2 )*100,2) || '% GB' "Free in %",
ROUND(((SUM(USED.BYTES) / 1024 / 1024 / 1024 ) - (FREE.P / 1024 / 1024 / 1024))/(select sysdate-min(creation_time) from v$datafile),2) || ' GB' "Growth DAY",
ROUND(((SUM(USED.BYTES) / 1024 / 1024 / 1024) - (FREE.P / 1024 / 1024 / 1024))/(select sysdate-min(creation_time) from v$datafile)/ROUND((SUM(USED.BYTES) / 1024 / 1024 / 1024),2)*100,3) || '% GB' "Growth DAY in %",
ROUND(((SUM(USED.BYTES) / 1024 / 1024 / 1024) - (FREE.P / 1024 / 1024 / 1024))/(select sysdate-min(creation_time) from v$datafile)*7,2) || ' GB' "Growth WEEK",
ROUND((((SUM(USED.BYTES) / 1024 / 1024 / 1024) - (FREE.P / 1024 / 1024 / 1024))/(select sysdate-min(creation_time) from v$datafile)/ROUND((SUM(USED.BYTES) / 1024 / 1024 / 1024),2)*100)*7,3) || '% GB' "Growth WEEK in %"
FROM (SELECT BYTES FROM V$DATAFILE
UNION ALL
SELECT BYTES FROM V$TEMPFILE
UNION ALL
SELECT BYTES FROM V$LOG) USED,
(SELECT SUM(BYTES) AS P FROM DBA_FREE_SPACE) FREE
GROUP BY FREE.P;
select to_char(creation_time, 'MM-RRRR') "Month", sum(bytes)/1024/1024/1024 "Growth in GB"
from sys.v_$datafile
where to_char(creation_time,'RRRR')='2018'
group by to_char(creation_time, 'MM-RRRR')
order by to_char(creation_time, 'MM-RRRR');
1) DROP USER OBJECTS:
=====================
conn username/password --->>> MANDATORY to connect as a user
declare
cursor fkc is select table_name,
constraint_name
from user_constraints
where constraint_type ='R';
tname user_constraints.table_name%TYPE;
cname user_constraints.constraint_name%TYPE;
begin
open fkc;
loop
fetch fkc into tname, cname;
exit when fkc%NOTFOUND;
dbms_output.put_line('alter table '||tname||' drop constraint '||cname);
execute immediate 'alter table '||tname||' drop constraint '||cname;
end loop;
close fkc;
end;
/
declare
cursor fkc is select object_name,
object_type
from user_objects
where object_name not in
('INDEX','PACKAGE BODY');
obj_name user_objects.object_name%TYPE;
obj_type user_objects.object_type%TYPE;
begin
open fkc;
loop
fetch fkc into obj_name, obj_type;
exit when fkc%NOTFOUND;
dbms_output.put_line('Drop '||obj_type||' '||obj_name);
begin
execute immediate 'Drop '||obj_type||' '||obj_name;
exception
when others then null;
end;
end loop;
close fkc;
end;
/
PURGE RECYCLEBIN;
DECLARE
the_job user_jobs.job%TYPE;
cursor c1 is select job from user_jobs;
BEGIN
open c1;
loop
fetch c1 into the_job;
exit when c1%NOTFOUND;
dbms_job.remove(the_job);
end loop;
close c1;
END;
/
VERIFY :
set heading off
SQL > select 'Objects left in schema : ' from dual;
SQL> select object_name,object_type from user_objects;
SQL> select 'Jobs left in schema: ' from dual;
SQL> select job,what from user_jobs;
2) User privileges & Grantee :
==============================
SELECT grantee, privilege, admin_option
FROM sys.dba_sys_privs
WHERE (privilege LIKE '% ANY %'
OR privilege IN ('BECOME USER', 'UNLIMITED TABLESPACE')
OR admin_option = 'YES')
AND grantee NOT IN ('SYS', 'SYSTEM', 'OUTLN', 'AQ_ADMINISTRATOR_ROLE',
'DBA', 'EXP_FULL_DATABASE', 'IMP_FULL_DATABASE',
'OEM_MONITOR', 'CTXSYS', 'DBSNMP', 'IFSSYS',
'IFSSYS$CM', 'MDSYS', 'ORDPLUGINS', 'ORDSYS',
'TIMESERIES_DBA')
3) Free Space :
===============
//** This script lists all Tablespaces and its datafiles with their free and used space **//
SET SERVEROUTPUT ON
SET PAGESIZE 1000
SET LINESIZE 255
SET FEEDBACK OFF
col "Used%" for 9999999999
SELECT Substr(df.tablespace_name,1,20) "Tablespace Name",
Substr(df.file_name,1,40) "File Name",
Round(df.bytes/1024/1024,2) "Size (M)",
Round(e.used_bytes/1024/1024,2) "Used (M)",
Round(f.free_bytes/1024/1024,2) "Free (M)",
Rpad(' '|| Rpad ('X',Round(e.used_bytes*10/df.bytes,0), 'X'),11,'-') "Used%"
FROM DBA_DATA_FILES df,
(SELECT file_id, Sum(Decode(bytes,NULL,0,bytes)) used_bytes
FROM dba_extents GROUP by file_id) e,
(SELECT Max(bytes) free_bytes, file_id
FROM dba_free_space GROUP BY file_id) f
WHERE e.file_id (+) = df.file_id
AND df.file_id = f.file_id (+)
AND df.tablespace_name='EPICIXLARGE'
ORDER BY df.tablespace_name, df.file_name;
4) Tablespaces :
================
//** This script lists all Tablespaces with their Sizes **//
SELECT /* + RULE */ df.tablespace_name "Tablespace",
df.bytes / (1024 * 1024) "Size (MB)",
SUM(fs.bytes) / (1024 * 1024) "Free (MB)",
Nvl(Round(SUM(fs.bytes) * 100 / df.bytes),1) "% Free",
Round((df.bytes - SUM(fs.bytes)) * 100 / df.bytes) "% Used"
FROM dba_free_space fs,
(SELECT tablespace_name,SUM(bytes) bytes
FROM dba_data_files
GROUP BY tablespace_name) df
WHERE fs.tablespace_name (+) = df.tablespace_name
GROUP BY df.tablespace_name,df.bytes
UNION ALL
SELECT /* + RULE */ df.tablespace_name tspace,
fs.bytes / (1024 * 1024),
SUM(df.bytes_free) / (1024 * 1024),
Nvl(Round((SUM(fs.bytes) - df.bytes_used) * 100 / fs.bytes), 1),
Round((SUM(fs.bytes) - df.bytes_free) * 100 / fs.bytes)
FROM dba_temp_files fs,
(SELECT tablespace_name,bytes_free,bytes_used
FROM v$temp_space_header
GROUP BY tablespace_name,bytes_free,bytes_used) df
WHERE fs.tablespace_name (+) = df.tablespace_name
GROUP BY df.tablespace_name,fs.bytes,df.bytes_free,df.bytes_used
ORDER BY 4 DESC;
select
a.tablespace_name,
round(SUM(a.bytes)/(1024*1024*1024)) CURRENT_GB,
round(SUM(decode(b.maxextend, null, A.BYTES/(1024*1024*1024),
b.maxextend*8192/(1024*1024*1024)))) MAX_GB,
(SUM(a.bytes)/(1024*1024*1024) - round(c.Free/1024/1024/1024)) USED_GB,
round((SUM(decode(b.maxextend, null, A.BYTES/(1024*1024*1024),
b.maxextend*8192/(1024*1024*1024))) - (SUM(a.bytes)/(1024*1024*1024) -
round(c.Free/1024/1024/1024))),2) FREE_GB,
round(100*(SUM(a.bytes)/(1024*1024*1024) -
round(c.Free/1024/1024/1024))/(SUM(decode(b.maxextend, null, A.BYTES/(1024*1024*1024),
b.maxextend*8192/(1024*1024*1024))))) USED_PCT
from
dba_data_files a,
sys.filext$ b,
(SELECT
d.tablespace_name ,sum(nvl(c.bytes,0)) Free
FROM
dba_tablespaces d,
DBA_FREE_SPACE c
WHERE
d.tablespace_name = c.tablespace_name(+)
group by d.tablespace_name) c
WHERE
a.file_id = b.file#(+)
and a.tablespace_name = c.tablespace_name
and a.tablespace_name in ('EPICIXLARGE','EPICIXMEDIUM','EPICLARGE','EPICMEDIUM')
GROUP BY a.tablespace_name, c.Free/1024
ORDER BY tablespace_name;
File I/O Operations
===================
SET PAGESIZE 14
SET VERIFY ON
select snap_id,begintime,endtime,filename,sum(Phy_Reads),sum(Phy_Read_Time),sum(Phy_Writes),sum(Phy_write_time) from
(select nm.snap_id,
to_char(begin_interval_time,'DD-MON-YYYY HH24:MI') begintime,
to_char(end_interval_time,'DD-MON-YYYY HH24:MI') endtime, filename,
nvl(decode(greatest(PHYBLKRD, nvl(lag(PHYBLKRD) over (partition by dba_hist_filestatxs.dbid,
dba_hist_filestatxs.instance_number, tsname, filename order by dba_hist_filestatxs.snap_id),0)),
PHYBLKRD, PHYBLKRD - lag(PHYBLKRD) over (partition by dba_hist_filestatxs.dbid, dba_hist_filestatxs.instance_number,
tsname, filename order by dba_hist_filestatxs.snap_id),PHYBLKRD), 0) Phy_Reads,
nvl(decode(greatest(READTIM, nvl(lag(READTIM) over (partition by dba_hist_filestatxs.dbid,
dba_hist_filestatxs.instance_number, tsname, filename order by dba_hist_filestatxs.snap_id),0)),
READTIM, READTIM - lag(READTIM) over (partition by dba_hist_filestatxs.dbid, dba_hist_filestatxs.instance_number,
tsname, filename order by dba_hist_filestatxs.snap_id),READTIM), 0) Phy_Read_Time,
nvl(decode(greatest(PHYBLKWRT, nvl(lag(PHYBLKWRT) over (partition by dba_hist_filestatxs.dbid,
dba_hist_filestatxs.instance_number, tsname, filename order by dba_hist_filestatxs.snap_id),0)),
PHYBLKWRT, PHYBLKWRT - lag(PHYBLKWRT) over (partition by dba_hist_filestatxs.dbid, dba_hist_filestatxs.instance_number,
tsname, filename order by dba_hist_filestatxs.snap_id),PHYBLKWRT), 0) Phy_Writes,
nvl(decode(greatest(WRITETIM, nvl(lag(WRITETIM) over (partition by dba_hist_filestatxs.dbid,
dba_hist_filestatxs.instance_number, tsname, filename order by dba_hist_filestatxs.snap_id),0)),
WRITETIM, WRITETIM - lag(WRITETIM) over (partition by dba_hist_filestatxs.dbid, dba_hist_filestatxs.instance_number, tsname,
filename order by dba_hist_filestatxs.snap_id),WRITETIM), 0) Phy_Write_Time
from
dba_hist_filestatxs,
dba_hist_snapshot nm
where
dba_hist_filestatxs.snap_id = nm.snap_id
and begin_interval_time >= sysdate - 1
and filename like '%'
order by
nm.begin_interval_time) iodetail
group by snap_id,begintime,endtime,filename;
UNDO Usage:
===========
select s.snap_id,s.start_time,s.end_time,
x.tablespace_name,
(x.tablespace_size*x.block_size/1024/1024)*.8,
x.tablespace_usedsize*x.block_size/1024/1024
from
(select
dhtsu.snap_id,dbat.tablespace_name,dhtsu.tablespace_size,dhtsu.tablespace_maxsize,
dhtsu.tablespace_usedsize ,dbat.block_size
from DBA_HIST_TBSPC_SPACE_USAGE dhtsu,v$tablespace vt,dba_tablespaces dbat
where
dhtsu.tablespace_id = vt.ts# and
vt.name in
(
select value from v$parameter where upper(name)= 'UNDO_TABLESPACE'
) and
vt.name = dbat.TABLESPACE_NAME
)x,
(
select snap_id,
max(to_char((trunc(begin_interval_time,'mi')),'DD/MON/YYYY HH24:MI:SS')) as start_time,
max(to_char((trunc(end_interval_time, 'mi')),'DD/MON/YYYY HH24:MI:SS')) as end_time
from dba_hist_snapshot
where begin_interval_time >= sysdate - 60
group by snap_id
) s
where s.snap_id = x.snap_id
order by x.tablespace_name,snap_id
Datafile Details:
=================
select df.tablespace_name,ts.block_size,ts.initial_extent,ts.next_extent,
ts.min_extents,ts.max_extents,ts.pct_increase,ts.min_extlen,ts.status,ts.contents,
ts.logging,ts.force_logging,ts.extent_management,ts.allocation_type,ts.plugged_in,
ts.segment_space_management,ts.def_tab_compression,ts.retention,ts.bigfile,
df.file_name,df.file_id,df.bytes,df.blocks,df.status,df.relative_fno,
df.autoextensible,df.maxbytes,df.maxblocks,df.increment_by,df.user_bytes,
df.user_blocks,df.online_status
from dba_tablespaces ts, dba_data_files df where
upper(ts.tablespace_name) like '%'
and upper(df.file_name) like '%'
and df.tablespace_name = ts.tablespace_name
union
select tf.tablespace_name,ts.block_size,ts.initial_extent,ts.next_extent,
ts.min_extents,ts.max_extents,ts.pct_increase,ts.min_extlen,ts.status,ts.contents,
ts.logging,ts.force_logging,ts.extent_management,ts.allocation_type,ts.plugged_in,
ts.segment_space_management,ts.def_tab_compression,ts.retention,'',
tf.file_name,tf.file_id,tf.bytes,tf.blocks,tf.status,tf.relative_fno,
tf.autoextensible,tf.maxbytes,tf.maxblocks,tf.increment_by,tf.user_bytes,
tf.user_blocks, ''
from dba_tablespaces ts, dba_temp_files tf where
upper(ts.tablespace_name) like '%'
and upper(tf.file_name) like '%'
and tf.tablespace_name = ts.tablespace_name
order by 1,2
Segment Growth Trend:
=====================
SELECT to_char(timepoint,'DD-MON-YYYY HH24:MI'),space_usage,space_alloc,quality
FROM
table(
DBMS_SPACE.OBJECT_GROWTH_TREND (
object_owner => 'SYSTEM',
object_name => 'REPCAT$_REPSCHEMA',
object_type => 'TABLE',
partition_name => '',
start_time =>SYSDATE-360,
end_time =>SYSDATE+360,
interval =>to_dsinterval( '0 12:00:00') ,
skip_interpolated => 'FALSE',
timeout_seconds =>NULL,
single_datapoint_flag =>'TRUE')
);
Data Growth Trend:
==================
select s.snap_id,s.start_time,s.end_time,x.tablespace_maxsize*x.block_size/1024/1024,
x.tablespace_size*x.block_size/1024/1024,x.tablespace_usedsize*x.block_size/1024/1024
from
(select dhtsu.snap_id,dhtsu.tablespace_size,dhtsu.tablespace_maxsize,dhtsu.tablespace_usedsize ,dbat.block_size
from DBA_HIST_TBSPC_SPACE_USAGE dhtsu,v$tablespace vt,dba_tablespaces dbat where
dhtsu.tablespace_id = vt.ts# and
vt.name = 'CALYPSO_DATA' and
vt.name = dbat.TABLESPACE_NAME
)x,
(
select snap_id,
max(to_char((trunc(begin_interval_time, 'mi')),'DD/MON/YYYY HH24:MI:SS')) as start_time,
max(to_char((trunc(end_interval_time, 'mi')),'DD/MON/YYYY HH24:MI:SS')) as end_time
from dba_hist_snapshot
where begin_interval_time >= sysdate - 30
group by snap_id
) s
where s.snap_id = x.snap_id
order by snap_id;
5) Locked_objects :
===================
SET LINESIZE 500
SET PAGESIZE 1000
SET VERIFY OFF
COLUMN owner FORMAT A20
COLUMN username FORMAT A20
COLUMN object_owner FORMAT A20
COLUMN object_name FORMAT A30
COLUMN locked_mode FORMAT A15
SELECT b.session_id AS sid,
NVL(b.oracle_username, '(oracle)') AS username,
a.owner AS object_owner,
a.object_name,
Decode(b.locked_mode, 0, 'None',
1, 'Null (NULL)',
2, 'Row-S (SS)',
3, 'Row-X (SX)',
4, 'Share (S)',
5, 'S/Row-X (SSX)',
6, 'Exclusive (X)',
b.locked_mode) locked_mode,
b.os_user_name
FROM dba_objects a,
v$locked_object b
WHERE a.object_id = b.object_id
ORDER BY 1, 2, 3, 4;
Locking Information:
====================
select
sid, lt.name,
decode(lmode,
0, 'None',
1, 'Null',
2, 'Row-S (SS)',
3, 'Row-X (SX)',
4, 'Share',
5, 'S/Row-X (SSX)',
6, 'Exclusive',
to_char(lmode)) mode_held,
decode(request,
0, 'None',
1, 'Null',
2, 'Row-S (SS)',
3, 'Row-X (SX)',
4, 'Share',
5, 'S/Row-X (SSX)',
6, 'Exclusive',
to_char(request)) mode_requested,
lt.id1_tag||':'||to_char(l.id1) ID1, lt.id2_tag||':'||to_char(l.id2) ID2,
ctime last_convert,
decode(block,
0, 'Not Blocking',
1, 'Blocking',
2, 'Global',
to_char(block)) blocking_others
from v$lock l , v$lock_type lt where
l.type = lt.type
order by lt.name,sid;
6) Data Pump Monitoring Script :
================================
select sid, serial#, sofar, totalwork, dp.owner_name, dp.operation, dp.workers, dp.job_mode, dp.state from gv$session_longops sl, gv$datapump_job dp
where sl.opname = dp.job_name and sofar != totalwork;
select a.service_name, a.sid, sql_text ,target, sofar, totalwork, time_remaining still, elapsed_seconds tillnow from gv$session a , gv$sql b, gv$session_longops c where a.sid=c.sid and a.sql_address = b.address and a.sql_address = c.sql_address and status = 'ACTIVE' and a.username='&USERNAME';
7) RMAN Job Monitoring Script :
===============================
SQL > SELECT SID, SERIAL#, CONTEXT, SOFAR, TOTALWORK,ROUND(SOFAR/TOTALWORK*100,2) "%_COMPLETE"
FROM V$SESSION_LONGOPS
WHERE OPNAME LIKE 'RMAN%' AND OPNAME NOT LIKE '%aggregate%'
AND TOTALWORK != 0 AND SOFAR <> TOTALWORK ;
To see the Rman status and SID:
SQL > SELECT s.SID, p.SPID, s.CLIENT_INFO FROM V$PROCESS p, V$SESSION s
WHERE p.ADDR = s.PADDR AND CLIENT_INFO LIKE 'rman%';
8) To see what USERS are Running :
==================================
SELECT a.sid, a.serial#, a.username, b.sql_text FROM v$session a, v$sqlarea b
WHERE a.sql_address=b.address;
**** To see for a particular USER, what he is running *******
SELECT a.sid, a.serial#, a.username, b.sql_text FROM v$session a, v$sqlarea b
WHERE a.sql_address=b.address and a.username = '<username>';
9) Find FREE/USED/TOTAL size of oracle database :
=================================================
(used space):
----------------
SQL> select sum(bytes)/1024/1024/1024 GB from dba_segments;
(free space):
---------------
SQL> select sum(bytes)/1024/1024/1024 GB from dba_free_space;
(Total database size):
---------------------------
SQL> select sum(bytes)/1024/1024/1024 GB from dba_data_files;
+
(Temp size):
---------------
SQL> select SUM(bytes_used)/1024/1024/1024 GBused, SUM(bytes_free)/1024/1024/1024 GBfree from v$temp_space_header;
(or)
SELECT SUM (a.log_space + b.data_space + c.tempspace) "Total_DB_Size (G)"
FROM (SELECT ROUND (SUM (BYTES/1024/1024/1024), 2) data_space FROM dba_data_files) b,(SELECT ROUND (SUM (BYTES*members/1024/1024/1024), 2) log_space FROM v$log) a, (SELECT NVL(ROUND(SUM(BYTES/1024/1024/1024),2), 0) tempspace FROM dba_temp_files) c;
10) RMAN Cold Backup :
======================
Rman target / nocatalog
Rman > configure controlfile autobackup on;
Rman > run {
2> allocate channel d1 type disk;
3> Backup full tag full_offline_bkup
4> Format ‘/var/backup/corppsdb/rman/db_t%t_s%s_p%p’
5> Database plus archivelog;
6> Release channel d1;
}
SGA + PGA Memory Details:
=========================
spool memory_details.log
show parameter sga
show parameter pga
show parameter memo
select inst_id,sum(bytes/1024/1024/1024) SGA_gb from gv$sgastat group by inst_id;
select inst_id,sum(bytes/1024/1024) SGA_Mb from gv$sgastat group by inst_id;
select sum(bytes/1024/1024/1024) SGA_gb from v$sgastat;
select sum(bytes/1024/1024) SGA_Mb from v$sgastat;
SELECT s.inst_id,sum(s.value/1024/1024/1024) PGA_GB FROM gv$sesstat s, gv$statname n WHERE s.statistic# = n.statistic# AND n.name = 'session pga memory' GROUP BY S.INST_ID;
SELECT s.inst_id,sum(s.value/1024/1024) PGA_MB FROM gv$sesstat s, gv$statname n WHERE s.statistic# = n.statistic# AND n.name = 'session pga memory' GROUP BY S.INST_ID;
SELECT sum(s.value/1024/1024/1024) PGA_GB FROM v$sesstat s, v$statname n WHERE s.statistic# = n.statistic# AND n.name = 'session pga memory';
SELECT sum(s.value/1024/1024) PGA_MB FROM v$sesstat s, v$statname n WHERE s.statistic# = n.statistic# AND n.name = 'session pga memory';
/
Individual Process memory
------------------------
select a.sid,a.serial#,a.username,osuser,machine,round(value/(1024*1024)),program from v$session a, v$sesstat b where a.sid=b.sid and b.statistic#=(select statistic# from v$statname where name='session pga memory');
Performance Scripts:
=====================
Real Time SQL Performance:
===========================
SELECT
sess.inst_id,
sess.sid,
sess.serial#,
sess.sql_id||'::'||vsa.plan_hash_value,
sess.STATUS,
sess.username,
sess.type,
sess.program,
sum(case when statn.name = 'CPU used by this session' then nvl(sql.value/1000000,0) end) as "cpu",
sum(case when statn.name = 'user I/O wait time' then nvl(sql.value/1000000,0) end) as "I/O",
sum(case when statn.name = 'application wait time' then nvl(sql.value/1000000,0) end) as "App",
sum(case when statn.name = 'concurrency wait time' then nvl(sql.value/1000000,0) end) as "Conc",
sum(case when statn.name = 'cluster wait time' then nvl(sql.value/1000000,0) end) as "Clus",
sum(case when statn.name = 'redo synch time' then nvl(sql.value/1000000,0) end) as "RedoSync",
sum(case when statn.name = 'parse time elapsed' then nvl(sql.value/1000000,0) end) as "Parse"
FROM gV$SESSION sess, gv$sesstat sql, gv$sqlarea vsa, gv$statname statn
where
Sess.AUDSID <> userenv('SESSIONID') and
sess.inst_id = sql.inst_id and
sess.sid = sql.sid and
sql.statistic# = statn.statistic# and
statn.name in
(
'CPU used by this session',
'cluster wait time',
'concurrency wait time',
'application wait time',
'user I/O wait time',
'redo synch time',
'parse time elapsed') and
sess.sql_address=vsa.address(+) and
sess.inst_id = vsa.inst_id(+)
group by
sess.inst_id,
sess.sid,
sess.serial#,
sess.sql_id||'::'||vsa.plan_hash_value,
sess.STATUS,
sess.username,
sess.type,
sess.program
having sess.status = max(sess.status)
order by sess.inst_id,
sess.sid,
sess.serial#;
Historical SQL Wait Events:
===========================
select x.session_id,x.SESSION_SERIAL#,x.sql_id||'::'||x.SQL_PLAN_HASH_VALUE,
min(x.sample_time), max(x.sample_time),x.event
,count(*) , sum(x.time_waited)/1000000 from
(select snap_id,SESSION_ID,SESSION_SERIAL#,sql_id,SQL_PLAN_HASH_VALUE,
event,sample_time,time_waited,p1text,p1,p2text,p2,p3text,p3 from dba_hist_active_sess_history where
sql_id = '87gaftwrm2h68'
) x,
(select snap_id from dba_hist_snapshot
where begin_interval_time >= sysdate - 1
group by snap_id ) s
where s.snap_id = x.snap_id
group by x.session_id,x.SESSION_SERIAL#,x.sql_id||'::'||x.SQL_PLAN_HASH_VALUE,x.event
order by x.session_id,x.SESSION_SERIAL#,x.sql_id||'::'||x.SQL_PLAN_HASH_VALUE,x.event;
Historcal SQL Execution Plan Usage:
===================================
SELECT sql_text from dba_hist_sqltext where
sql_id = '<SQLID Here>';
SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY_AWR('<SQLID Here>','<Plan Hash Value Here>',null,'ALL +OUTLINE'));
Database Wide SQL Performance
==============================
select x.sql_id||'::'||x.plan_hash_value,
sum(x.executions_delta),
sum(x.elapsed_time_delta)/1000000,
sum(x.cpu_time_delta)/1000000,
sum(x.sorts_delta),
sum(x.rows_processed_delta),
sum(x.disk_reads_delta),
sum(x.IOWAIT_DELTA)/1000000,
sum(x.CLWAIT_DELTA)/1000000,
sum(x.APWAIT_DELTA)/1000000,
sum(x.CCWAIT_DELTA)/1000000
from
(select snap_id,
sql_id,
plan_hash_value,
executions_delta,
elapsed_time_delta,
cpu_time_delta,
sorts_delta,
rows_processed_delta,
disk_reads_delta,
IOWAIT_DELTA,
CLWAIT_DELTA,
APWAIT_DELTA,
CCWAIT_DELTA
from dba_hist_sqlstat) x,
(select snap_id,
max(to_char((trunc(begin_interval_time, 'mi')),'DD/MON/YYYY HH24:MI')) as start_time,
max(to_char((trunc(end_interval_time, 'mi')),'DD/MON/YYYY HH24:MI')) as end_time
from dba_hist_snapshot
where begin_interval_time >= sysdate - 1
group by snap_id ) s
where s.snap_id = x.snap_id
group by x.sql_id||'::'||x.plan_hash_value
having sum(x.elapsed_time_delta) > 0
order by x.sql_id||'::'||x.plan_hash_value;
System Topology:
================
SELECT snap_id,TO_CHAR(begin_interval_time, 'DD-MON-YYYY HH24:MI'),TO_CHAR(end_interval_time, 'DD-MON-YYYY HH24:MI'),d.name||instance_number,
ROUND(MAX(ela),2) "Elapse Time (s)",
ROUND(MAX(case when stat_name='logons current' then (value) else 0 end),3) "Sess# Start",
ROUND(MAX(case when stat_name='total PGA allocated' then (value)/1024/1024 else 0 end),3) "pga (mb)",
ROUND(MAX(case when stat_name='total PGA allocated' then (value)/1024/1024 else 0 end)
/MAX(case when stat_name='logons current' then (value) else 0 end),3) "pga (mb/sess)",
ROUND(SUM(case when stat_name='NUM_VCPUS' then value else 0 end),2) "CPU Cores",
ROUND(MAX(case when stat_name='NUM_CPUS' then value else 0 end),2) "CPU Threads",
ROUND(MAX(case when stat_name='DB time' then diff_val else 0 end),2) "Active Sessions/Sec",
ROUND(MAX(case when stat_name='NUM_VCPUS' then value*ela else 0 end),2) "Total Core Time",
ROUND(SUM(case when stat_name='BUSY_TIME' then diff_val else 0 end)/max(ela),2) "Host Core Util",
ROUND(SUM(case when stat_name='USER_TIME' then diff_val else 0 end)/max(ela),2) "Host User Util",
ROUND(SUM(case when stat_name='SYS_TIME' then diff_val else 0 end)/max(ela),2) "Host SYS Util",
ROUND(SUM(case when stat_name='LOAD' then value else 0 end),2) "LOAD(# Active Process)",
ROUND(SUM(case when stat_name='DB CPU' or stat_name='background cpu time' then diff_val else 0 end),2) "DB+BG Time (s)",
ROUND(SUM(case when stat_name='DB CPU' or stat_name='background cpu time' then diff_val else 0 end)/max(ela),2) "DB Cores Util",
ROUND(MAX(case when stat_name='background cpu time' then diff_val else 0 end)/max(ela),2) "BG Time Core",
ROUND(MAX(case when stat_name='RMAN cpu time (backup/restore)' then diff_val else 0 end)/max(ela),2) "RMAN Core",
ROUND(MAX(case when stat_name='physical read IO requests' then diff_val/ela else 0 end),3) "IOPs r",
ROUND(MAX(case when stat_name='physical read total IO requests' then (diff_val)/ela else 0 end),3) "IOPs r total",
ROUND(MAX(case when stat_name='physical read total multi block requests' then (diff_val)/ela else 0 end),3) "IOPs r Sequential",
ROUND(SUM(case when stat_name='physical read total IO requests' then (diff_val)/ela
when stat_name='physical read total multi block requests' then -1*(diff_val)/ela else 0 end),3) "IOPs r Random(single)",
ROUND(MAX(case when stat_name='redo blocks read for recovery' then (diff_val)/ela else 0 end),3) "redo recovery blocks/s",
ROUND(MAX(case when stat_name='physical write IO requests' then diff_val/ela else 0 end),3) "IOPs w",
ROUND(MAX(case when stat_name='physical write total IO requests' then (diff_val)/ela else 0 end),3) "IOPs w total",
ROUND(MAX(case when stat_name='physical write total multi block requests' then (diff_val)/ela else 0 end),3) "IOPs w Sequential",
ROUND(SUM(case when stat_name='physical write total IO requests' then (diff_val)/ela
when stat_name='physical write total multi block requests' then -1*(diff_val)/ela else 0 end),3) "IOPs w Random(single)",
ROUND(MAX(case when stat_name='DBWR undo block writes' then (diff_val)/ela else 0 end),3) "Undo Blocks/s",
ROUND(SUM(case when stat_name='redo blocks written' then diff_val/ela else 0 end),5) "redo blocks written/s",
ROUND(SUM(case when stat_name='redo writes' then diff_val/ela else 0 end),5) "redo write/s",
ROUND(SUM(case when stat_name='redo blocks written' then diff_val else 0 end)/
SUM(case when stat_name='redo writes' then diff_val else 1 end),5) "Redo Blocks/w",
ROUND(MAX(case when stat_name='physical read bytes' then (diff_val)/ela else 0 end),3) "IO r (bytes)/s",
ROUND(MAX(case when stat_name='physical read total bytes' then (diff_val)/ela else 0 end),3) "IO_Tot r (bytes)/s",
ROUND(MAX(case when stat_name='physical write bytes' then (diff_val)/ela else 0 end),3) "IO w (bytes)/s",
ROUND(MAX(case when stat_name='physical write total bytes' then (diff_val)/ela else 0 end),3) "IO_Tot w (bytes)/s",
ROUND(MAX(case when stat_name='redo size' then (diff_val)/ela else 0 end),3) "Redo (bytes)/s",
ROUND(MAX(case when stat_name='bytes sent via SQL*Net to client' then (diff_val)/ela else 0 end),3) "SQL*Net Sent (bytes)/s",
ROUND(MAX(case when stat_name='bytes received via SQL*Net from client' then (diff_val)/ela else 0 end),3) "SQL*Net received (bytes)/s",
ROUND (((SUM (CASE WHEN stat_name = 'gc cr blocks received' OR stat_name = 'gc current blocks received'
OR stat_name = 'gc cr blocks served' OR stat_name = 'gc current blocks served'
THEN diff_val ELSE 0 END) * (SELECT TO_NUMBER (VALUE) FROM v$parameter WHERE name = 'db_block_size'))
+ (SUM (CASE WHEN stat_name = 'gcs messages sent' OR stat_name = 'ges messages sent'
OR stat_name = 'gcs msgs received' OR stat_name = 'ges msgs received' THEN diff_val ELSE 0 END) * 200)
) / 1024 / MAX (ela), 3) "Estd Interconnect traffic (KB)"
FROM (
SELECT s.instance_number, s.snap_id, s.begin_interval_time begin_interval_time, s.end_interval_time end_interval_time,
round((CAST (s.end_interval_time AS DATE) - CAST (s.begin_interval_time AS DATE)) * 24 * 3600) ela, sy.stat_name stat_name,
(CASE WHEN s.begin_interval_time = s.startup_time THEN sy.VALUE
ELSE sy.VALUE - LAG (sy.VALUE, 1) OVER
(PARTITION BY sy.stat_id, s.dbid, s.instance_number, s.startup_time ORDER BY s.snap_id)
END) / 1000000 diff_val, sy.VALUE value
FROM dba_hist_snapshot s, dba_hist_sys_time_model sy
WHERE s.dbid = sy.dbid (+)
AND s.instance_number = sy.instance_number (+)
AND s.snap_id = sy.snap_id (+)
AND sy.stat_name in ('DB CPU','DB time','background cpu time','RMAN cpu time (backup/restore)')
union all
SELECT s.instance_number, s.snap_id, s.begin_interval_time begin_interval_time, s.end_interval_time end_interval_time,
round((CAST (s.end_interval_time AS DATE) - CAST (s.begin_interval_time AS DATE)) * 24 * 3600) ela, os.stat_name stat_name,
(CASE WHEN s.begin_interval_time = s.startup_time THEN os.VALUE
ELSE os.VALUE - LAG (os.VALUE, 1) OVER
(PARTITION BY os.stat_id, s.dbid, s.instance_number, s.startup_time ORDER BY s.snap_id)
END) / 100 diff_val, os.VALUE value
FROM dba_hist_snapshot s, dba_hist_osstat os
WHERE s.dbid = os.dbid (+)
AND s.instance_number = os.instance_number (+)
AND s.snap_id = os.snap_id (+)
AND os.stat_name in ('BUSY_TIME','USER_TIME','SYS_TIME','NUM_CPUS','NUM_VCPUS','LOAD')
union all
SELECT s.instance_number, s.snap_id, s.begin_interval_time begin_interval_time, s.end_interval_time end_interval_time,
round((CAST (s.end_interval_time AS DATE) - CAST (s.begin_interval_time AS DATE)) * 24 * 3600) ela, ps.name stat_name,
(CASE WHEN s.begin_interval_time = s.startup_time THEN ps.VALUE
ELSE ps.VALUE - LAG (ps.VALUE, 1) OVER
(PARTITION BY ps.name, s.dbid, s.instance_number, s.startup_time ORDER BY s.snap_id)
END) diff_val, ps.VALUE value
FROM dba_hist_snapshot s, dba_hist_pgastat ps
WHERE s.dbid = ps.dbid (+)
AND s.instance_number = ps.instance_number (+)
AND s.snap_id = ps.snap_id (+)
AND ps.name in ('total PGA allocated')
union all
SELECT s.instance_number, s.snap_id, s.begin_interval_time begin_interval_time, s.end_interval_time end_interval_time,
round((CAST (s.end_interval_time AS DATE) - CAST (s.begin_interval_time AS DATE)) * 24 * 3600) ela, ss.stat_name stat_name,
(CASE WHEN s.begin_interval_time = s.startup_time THEN ss.VALUE
ELSE ss.VALUE - LAG (ss.VALUE, 1) OVER
(PARTITION BY ss.stat_id, s.dbid, s.instance_number, s.startup_time ORDER BY s.snap_id)
END) diff_val, ss.VALUE value
FROM dba_hist_snapshot s, dba_hist_sysstat ss
WHERE s.dbid = ss.dbid (+)
AND s.instance_number = ss.instance_number (+)
AND s.snap_id = ss.snap_id (+)
AND ss.stat_name in ('logons current','execute count',
'physical reads','physical writes',
'physical read total bytes','physical read bytes',
'physical write total bytes','physical write bytes',
'redo writes','redo size','redo blocks written',
'physical read IO requests','physical read total IO requests','physical read total multi block requests',
'physical read total IO multi block requests',
'physical write IO requests','physical write total IO requests','physical write total multi block requests',
'physical write total IO multi block requests',
'DBWR undo block writes','redo blocks read for recovery',
'bytes sent via SQL*Net to client','bytes received via SQL*Net from client','Estd Interconnect traffic',
'session logical reads',
'gc cr blocks received','gc current blocks received','gc cr blocks served','gc current blocks served',
'gcs messages sent','ges messages sent')
union all
SELECT s.instance_number, s.snap_id, s.begin_interval_time begin_interval_time, s.end_interval_time end_interval_time,
round((CAST (s.end_interval_time AS DATE) - CAST (s.begin_interval_time AS DATE)) * 24 * 3600) ela, dm.name stat_name,
(CASE WHEN s.begin_interval_time = s.startup_time THEN dm.VALUE
ELSE dm.VALUE - LAG (dm.VALUE, 1) OVER
(PARTITION BY dm.name, s.dbid, s.instance_number, s.startup_time ORDER BY s.snap_id)
END) diff_val, dm.VALUE value
FROM dba_hist_snapshot s, dba_hist_dlm_misc dm
WHERE s.dbid = dm.dbid (+)
AND s.instance_number = dm.instance_number (+)
AND s.snap_id = dm.snap_id (+)
AND dm.name in ('gcs msgs received','ges msgs received')
order by instance_number,snap_id desc,stat_name
), v$database d
Where TO_CHAR(end_interval_time, 'DD-MON-YYYY HH24:MI') > '2014-08-14 00:00:00'
GROUP BY snap_id,TO_CHAR(begin_interval_time, 'DD-MON-YYYY HH24:MI'),TO_CHAR(end_interval_time, 'DD-MON-YYYY HH24:MI'),d.name||instance_number
order by d.name||instance_number , snap_id;
Real Time Wait Events:
=====================
Wait Event Time
===============
select INST_ID||':'||EVENT,time_waited from gv$system_event
order by 1,2;
?
Wait Event Count
================
select INST_ID||':'||EVENT, TOTAL_WAITS from gv$system_event
order by 1,2;
Historical Wait Events:
=======================
select s.start_time,
instance_number||':'||event_name,
sum(nvl(total_waits,0)),
sum(nvl(TIME_WAITED_MICRO,0))
from
(select snap_id,
instance_number,
event_name,
total_waits,
time_waited_micro
from dba_hist_system_event) x,
(select snap_id,
max(to_char((trunc(begin_interval_time, 'mi')),'DD-MON-YYYY HH24:MI')) as start_time,
max(to_char((trunc(end_interval_time, 'mi')),'DD-MON-YYYY HH24:MI')) as end_time
from dba_hist_snapshot
where begin_interval_time >= sysdate -1
group by snap_id
) s
where s.snap_id = x.snap_id
group by s.snap_id,s.start_time,
instance_number||':'||event_name
order by s.snap_id;
Instance Latching:
select inst_id||':'||name, SLEEPS from gv$latch order by sleeps desc;
Buffer Cache Content:
=====================
select
t1.owner c0, object_name c1,
case when object_type = 'TABLE PARTITION' then 'TAB PART'
when object_type = 'INDEX PARTITION' then 'IDX PART'
else object_type end c2,
sum(num_blocks) c3,
(sum(num_blocks)/greatest(sum(blocks), .001))*100 c4,
buffer_pool c5,sum(bytes)/sum(blocks) c6
from
(select o.owner owner,o.object_name object_name,o.subobject_name subobject_name,o.object_type object_type,
count(distinct file# || block#) num_blocks
from
dba_objects o, v$bh bh
where
o.data_object_id = bh.objd and
o.owner not in ('SYS','SYSTEM') and
bh.status != 'free'
group by
o.owner,o.object_name,o.subobject_name,o.object_type
order by
count(distinct file# || block#) desc) t1, dba_segments s
where
s.segment_name = t1.object_name and
s.owner = t1.owner and
s.segment_type = t1.object_type and
nvl(s.partition_name,'-') = nvl(t1.subobject_name,'-')
group by
t1.owner,object_name,object_type,buffer_pool
having sum(num_blocks) > 10
order by sum(num_blocks) desc
SGA Hit Ratios:
===============
Data Dictionary
---------------
SELECT Parameter,SUM(getmisses), SUM(gets)
FROM v$rowcache group by parameter
Buffer Cache
------------
SELECT name,value from v$sysstat where
name in
('db block gets',
'consistent gets',
'physical reads')
Library Cache
-------------
select
namespace,
gets,
gethitratio*100 gethitratio,
pins,
pinhitratio*100 pinhitratio,
reloads,
invalidations
from
v$librarycache;
Tablespace monitoring in oracle 12c multitenant database:
=========================================
SET LINES 300 PAGES 100000
COL con_name FORM A15 HEAD "Container|Name"
COL tablespace_name FORM A15
COL fsm FORM 999,999,999,999 HEAD "Free|Space Meg."
COL apm FORM 999,999,999,999 HEAD "Alloc|Space Meg."
--
COMPUTE SUM OF fsm apm ON REPORT
BREAK ON REPORT ON con_id ON con_name ON tablespace_name
--
WITH x AS (SELECT c1.con_id, cf1.tablespace_name, SUM(cf1.bytes)/1024/1024/1024 fsm
FROM cdb_free_space cf1
,v$containers c1
WHERE cf1.con_id = c1.con_id
GROUP BY c1.con_id, cf1.tablespace_name),
y AS (SELECT c2.con_id, cd.tablespace_name, SUM(cd.bytes)/1024/1024/1024 apm
FROM cdb_data_files cd
,v$containers c2
WHERE cd.con_id = c2.con_id
GROUP BY c2.con_id
,cd.tablespace_name)
SELECT x.con_id, v.name con_name, x.tablespace_name, x.fsm, y.apm
FROM x, y, v$containers v
WHERE x.con_id = y.con_id
AND x.tablespace_name = y.tablespace_name
AND v.con_id = y.con_id
UNION
SELECT vc2.con_id, vc2.name, tf.tablespace_name, null, SUM(tf.bytes)/1024/1024/1024
FROM v$containers vc2, cdb_temp_files tf
WHERE vc2.con_id = tf.con_id
GROUP BY vc2.con_id, vc2.name, tf.tablespace_name
ORDER BY 1, 2;
Top 5 cached sql statements by elapsed time in oracle:
=======================================
set lines 300 pages 20000
SELECT sql_id,child_number,sql_text, elapsed_time
FROM (SELECT sql_id, child_number, sql_text, elapsed_time, cpu_time,
disk_reads,
RANK () OVER (ORDER BY elapsed_time DESC) AS elapsed_rank
FROM v$sql)
WHERE elapsed_rank <= 5
/
Query to get child table and foreign key status:
=================================
col owner form a10
col FK_column form a15
col table_name form a30
select b.owner, b.table_name child_table,b.status,
c.column_name FK_column, b.constraint_name
from dba_constraints a, dba_constraints b, dba_cons_columns c
where a.owner=b.r_owner
and b.owner=c.owner
and b.table_name=c.table_name
and b.constraint_name=c.constraint_name
and a.constraint_name=b.r_constraint_name
and b.constraint_type='R'
and a.owner='&OWNER'
and a.table_name='&TABLE_NAME'
and a.CONSTRAINT_TYPE='P';
How to find the sessions generating lot of logs:
==================================
set lines 2000
set pages 1000
col sid for 99999
col name for a09
col username for a14
col PROGRAM for a21
col MODULE for a25
select s.sid,sn.SERIAL#,n.name, round(value/1024/1024,2) redo_mb, sn.username,sn.status,substr (sn.program,1,21) "program", sn.type, sn.module,sn.sql_id
from v$sesstat s join v$statname n on n.statistic# = s.statistic#
join v$session sn on sn.sid = s.sid where n.name like 'redo size' and s.value!=0 order by
redo_mb desc;
Use below query to check all the space related details of tablespaces:
=================================================
set feedback off
set pagesize 70;
set linesize 2000
set head on
COLUMN Tablespace format a25 heading 'Tablespace Name'
COLUMN autoextensible format a11 heading 'AutoExtend'
COLUMN files_in_tablespace format 999 heading 'Files'
COLUMN total_tablespace_space format 99999999 heading 'TotalSpace'
COLUMN total_used_space format 99999999 heading 'UsedSpace'
COLUMN total_tablespace_free_space format 99999999 heading 'FreeSpace'
COLUMN total_used_pct format 9999 heading '%Used'
COLUMN total_free_pct format 9999 heading '%Free'
COLUMN max_size_of_tablespace format 99999999 heading 'ExtendUpto'
COLUM total_auto_used_pct format 999.99 heading 'Max%Used'
COLUMN total_auto_free_pct format 999.99 heading 'Max%Free'
WITH tbs_auto AS
(SELECT DISTINCT tablespace_name, autoextensible
FROM dba_data_files
WHERE autoextensible = 'YES'),
files AS
(SELECT tablespace_name, COUNT (*) tbs_files,
SUM (BYTES/1024/1024) total_tbs_bytes
FROM dba_data_files
GROUP BY tablespace_name),
fragments AS
(SELECT tablespace_name, COUNT (*) tbs_fragments,
SUM (BYTES)/1024/1024 total_tbs_free_bytes,
MAX (BYTES)/1024/1024 max_free_chunk_bytes
FROM dba_free_space
GROUP BY tablespace_name),
AUTOEXTEND AS
(SELECT tablespace_name, SUM (size_to_grow) total_growth_tbs
FROM (SELECT tablespace_name, SUM (maxbytes)/1024/1024 size_to_grow
FROM dba_data_files
WHERE autoextensible = 'YES'
GROUP BY tablespace_name
UNION
SELECT tablespace_name, SUM (BYTES)/1024/1024 size_to_grow
FROM dba_data_files
WHERE autoextensible = 'NO'
GROUP BY tablespace_name)
GROUP BY tablespace_name)
SELECT c.instance_name,a.tablespace_name Tablespace,
CASE tbs_auto.autoextensible
WHEN 'YES'
THEN 'YES'
ELSE 'NO'
END AS autoextensible,
files.tbs_files files_in_tablespace,
files.total_tbs_bytes total_tablespace_space,
(files.total_tbs_bytes - fragments.total_tbs_free_bytes
) total_used_space,
fragments.total_tbs_free_bytes total_tablespace_free_space,
round(( ( (files.total_tbs_bytes - fragments.total_tbs_free_bytes)
/ files.total_tbs_bytes
)
* 100
)) total_used_pct,
round(((fragments.total_tbs_free_bytes / files.total_tbs_bytes) * 100
)) total_free_pct
FROM dba_tablespaces a,v$instance c , files, fragments, AUTOEXTEND, tbs_auto
WHERE a.tablespace_name = files.tablespace_name
AND a.tablespace_name = fragments.tablespace_name
AND a.tablespace_name = AUTOEXTEND.tablespace_name
AND a.tablespace_name = tbs_auto.tablespace_name(+)
order by total_free_pct;
How to find log gap between primary and standby db:
======================================
select LOG_ARCHIVED-LOG_APPLIED "LOG_GAP" from
(SELECT MAX(SEQUENCE#) LOG_ARCHIVED
FROM V$ARCHIVED_LOG WHERE DEST_ID=1 AND ARCHIVED='YES'),
(SELECT MAX(SEQUENCE#) LOG_APPLIED
FROM V$ARCHIVED_LOG WHERE DEST_ID=2 AND APPLIED='YES');
How to find free space in UNDO tablespace:
================================
select a.tablespace_name, SIZEMB, USAGEMB, (SIZEMB - USAGEMB) FREEMB
from (select sum(bytes) / 1024 / 1024 SIZEMB, b.tablespace_name
from dba_data_files a, dba_tablespaces b
where a.tablespace_name = b.tablespace_name
and b.contents = 'UNDO'
group by b.tablespace_name) a,
(select c.tablespace_name, sum(bytes) / 1024 / 1024 USAGEMB
from DBA_UNDO_EXTENTS c
where status <> 'EXPIRED'
group by c.tablespace_name) b
where a.tablespace_name = b.tablespace_name;
How to find the temp tablespace usage:
============================
select a.tablespace_name tablespace,
d.TEMP_TOTAL_MB,
sum (a.used_blocks * d.block_size) / 1024 / 1024 TEMP_USED_MB,
d.TEMP_TOTAL_MB - sum (a.used_blocks * d.block_size) / 1024 / 1024 TEMP_FREE_MB
from v$sort_segment a,
(
select b.name, c.block_size, sum (c.bytes) / 1024 / 1024 TEMP_TOTAL_MB
from v$tablespace b, v$tempfile c
where b.ts#= c.ts#
group by b.name, c.block_size
) d
where a.tablespace_name = d.name
group by a.tablespace_name, d.TEMP_TOTAL_MB;
How to find the wait events present in database:
==================================
select a.sid,substr(b.username,1,10) username,substr(b.osuser,1,10) osuser,
substr(b.program||b.module,1,15) program,substr(b.machine,1,22) machine,
a.event,a.p1,b.sql_hash_value
from v$session_wait a,V$session b
where b.sid=a.sid
and a.event not in('SQL*Net message from client','SQL*Net message to client',
'smon timer','pmon timer')
and username is not null
order by 6
/
How to find the session using lot of undo:
==============================
select a.sid, a.serial#, a.username, b.used_urec used_undo_record, b.used_ublk used_undo_blocks
from v$session a, v$transaction b
where a.saddr=b.ses_addr ;
How to find the locks present in oracle database:
===================================
col session_id head 'Sid' form 9999
col object_name head "Table|Locked" form a30
col oracle_username head "Oracle|Username" form a10 truncate
col os_user_name head "OS|Username" form a10 truncate
col process head "Client|Process|ID" form 99999999
col mode_held form a15
select lo.session_id,lo.oracle_username,lo.os_user_name,
lo.process,do.object_name,
decode(lo.locked_mode,0, 'None',1, 'Null',2, 'Row Share (SS)',
3, 'Row Excl (SX)',4, 'Share',5, 'Share Row Excl (SSX)',6, 'Exclusive',
to_char(lo.locked_mode)) mode_held
from v$locked_object lo, dba_objects do
where lo.object_id = do.object_id
order by 1,5
/
How to find the sessions generating lot of logs:
==================================
set lines 2000
set pages 1000
col sid for 99999
col name for a09
col username for a14
col PROGRAM for a21
col MODULE for a25
select s.sid,sn.SERIAL#,n.name, round(value/1024/1024,2) redo_mb, sn.username,sn.status,substr (sn.program,1,21) "program", sn.type, sn.module,sn.sql_id
from v$sesstat s join v$statname n on n.statistic# = s.statistic#
join v$session sn on sn.sid = s.sid where n.name like 'redo size' and s.value!=0 order by
redo_mb desc;
How to find the sessions using lot of temp:
==============================
SELECT b.TABLESPACE
, b.segfile#
, b.segblk#
, ROUND ( ( ( b.blocks * p.VALUE ) / 1024 / 1024 ), 2 ) size_mb
, a.SID
, a.serial#
, a.username
, a.osuser
, a.program
, a.status
FROM v$session a
, v$sort_usage b
, v$process c
, v$parameter p
WHERE p.NAME = 'db_block_size'
AND a.saddr = b.session_addr
AND a.paddr = c.addr
ORDER BY b.TABLESPACE, b.segfile#, b.segblk#, b.blocks;
How to find current running sqls in oracle:
==============================
select sesion.sid,
sesion.username,
optimizer_mode,
hash_value,
address,
cpu_time,
elapsed_time,
sql_text
from v$sqlarea sqlarea, v$session sesion
where sesion.sql_hash_value = sqlarea.hash_value
and sesion.sql_address = sqlarea.address
and sesion.username is not null;
Realtime monitoring of sql query using v$sql_plan_monitor:
===========================================
V$SQL_PLAN_MONITOR displays real time plan level monitoring statistics for the currently running sql queries.
Each row in V$SQL_PLAN_MONITOR corresponds to an operation of the execution plan being monitored.
SELECT sql_id FROM v$sql_monitor;
SELECT sid, sql_id, status, plan_line_id,
plan_operation || ' ' || plan_options operation, output_rows
FROM v$sql_plan_monitor
WHERE status not like '%DONE%'
ORDER BY 1,4;
How to find active sessions in oracle database:
=================================
set echo off
set linesize 95
set head on
set feedback on
col sid head "Sid" form 9999 trunc
col serial# form 99999 trunc head "Ser#"
col username form a8 trunc
col osuser form a7 trunc
col machine form a20 trunc head "Client|Machine"
col program form a15 trunc head "Client|Program"
col login form a11
col "last call" form 9999999 trunc head "Last Call|In Secs"
col status form a6 trunc
select sid,serial#,substr(username,1,10) username,substr(osuser,1,10) osuser,
substr(program||module,1,15) program,substr(machine,1,22) machine,
to_char(logon_time,'ddMon hh24:mi') login,
last_call_et "last call",status
from v$session where status='ACTIVE'
order by 1
/
Query to get child table and foreign key status:
=================================
col owner form a10
col FK_column form a15
col table_name form a30
select b.owner, b.table_name child_table,b.status,
c.column_name FK_column, b.constraint_name
from dba_constraints a, dba_constraints b, dba_cons_columns c
where a.owner=b.r_owner
and b.owner=c.owner
and b.table_name=c.table_name
and b.constraint_name=c.constraint_name
and a.constraint_name=b.r_constraint_name
and b.constraint_type='R'
and a.owner='&OWNER'
and a.table_name='&TABLE_NAME'
and a.CONSTRAINT_TYPE='P';
Enable constraints:
=============
alter table FDR.MDT_RM_CALL_CLOSEOUT_METER disable constraints MDT_RM_CALL_CLOSEOUT_METER_FK;
Find the parent table of child table:
=========================
SELECT owner,
table_name
FROM dba_constraints
WHERE constraint_name IN (SELECT r_constraint_name
FROM dba_constraints WHERE
table_name = 'PUROLATOR_ACCOUNTS' AND constraint_type = 'R');
Get hourly database growth report:
=========================
set serveroutput on
Declare
v_BaselineSize number(20);
v_CurrentSize number(20);
v_TotalGrowth number(20);
v_Space number(20);
cursor usageHist is
select a.snap_id,
TIMESTAMP,
sum(TOTAL_SPACE_ALLOCATED_DELTA) over ( order by a.SNAP_ID) ProgSum
from
(select SNAP_ID,
sum(SPACE_ALLOCATED_DELTA) TOTAL_SPACE_ALLOCATED_DELTA
from DBA_HIST_SEG_STAT
group by SNAP_ID
having sum(SPACE_ALLOCATED_TOTAL) <> 0
order by 1 ) a,
(select distinct SNAP_ID,
to_char(END_INTERVAL_TIME,'DD-Mon-YYYY HH24:Mi') TIMESTAMP
from DBA_HIST_SNAPSHOT) b
where a.snap_id=b.snap_id;
Begin
select sum(SPACE_ALLOCATED_DELTA) into v_TotalGrowth from DBA_HIST_SEG_STAT;
select sum(bytes) into v_CurrentSize from dba_segments;
v_BaselineSize := v_CurrentSize - v_TotalGrowth ;
dbms_output.put_line('TIMESTAMP Database Size(GB)');
for row in usageHist loop
v_Space := (v_BaselineSize + row.ProgSum)/(1024*1024*1024);
dbms_output.put_line(row.TIMESTAMP || ' ' || to_char(v_Space) );
end loop;
end;
/
Find who locked your account:
=============================
-- Return code 1017 ( INVALID LOGIN ATTEMPT)
-- Return code 28000 ( ACCOUNT LOCKED)
set pagesize 1299
set lines 299
col username for a15
col userhost for a13
col timestamp for a39
col terminal for a23
SELECT username,userhost,terminal,timestamp,returncode
FROM dba_audit_session
WHERE username='&USER_NAME' and returncode in (1017,28000);
Find row count of all partitions of a table:
=============================
set serverout on size 1000000
set verify off
declare
sql_stmt varchar2(1024);
row_count number;
cursor get_tab is
select table_name,partition_name
from dba_tab_partitions
where table_owner=upper('&&TABLE_OWNER') and table_name='&&TABLE_NAME';
begin
dbms_output.put_line('Checking Record Counts for table_name');
dbms_output.put_line('Log file to numrows_part_&&TABLE_OWNER.lst ....');
dbms_output.put_line('....');
for get_tab_rec in get_tab loop
BEGIN
sql_stmt := 'select count(*) from &&TABLE_OWNER..'||get_tab_rec.table_name
||' partition ( '||get_tab_rec.partition_name||' )';
EXECUTE IMMEDIATE sql_stmt INTO row_count;
dbms_output.put_line('Table '||rpad(get_tab_rec.table_name
||'('||get_tab_rec.partition_name||')',50)
||' '||TO_CHAR(row_count)||' rows.');
exception when others then
dbms_output.put_line
('Error counting rows for table '||get_tab_rec.table_name);
END;
end loop;
end;
/
set verify on
How to find the I/O usage of tempfiles:
============================
SELECT SUBSTR(t.name,1,50) AS file_name,
f.phyblkrd AS blocks_read,
f.phyblkwrt AS blocks_written,
f.phyblkrd + f.phyblkwrt AS total_io
FROM v$tempstat f,v$tempfile t
WHERE t.file# = f.file#
ORDER BY f.phyblkrd + f.phyblkwrt DESC;
select * from (SELECT u.tablespace, s.username, s.sid, s.serial#, s.logon_time, program, u.extents, ((u.blocks*8)/1024) as MB,
i.inst_id,i.host_name
FROM gv$session s, gv$sort_usage u ,gv$instance i
WHERE s.saddr=u.session_addr and u.inst_id=i.inst_id order by MB DESC) a where rownum<10;
Find High water mark of a table:
=======================
--
-- Show the High Water Mark for a given table, or all tables if ALL is specified for Table_Name.
--
SET LINESIZE 300
SET SERVEROUTPUT ON
SET VERIFY OFF
DECLARE
CURSOR cu_tables IS
SELECT a.owner,
a.table_name
FROM all_tables a
WHERE a.table_name = Decode(Upper('&&Table_Name'),'ALL',a.table_name,Upper('&&Table_Name'))
AND a.owner = Upper('&&Table_Owner')
AND a.partitioned='NO'
AND a.logging='YES'
order by table_name;
op1 NUMBER;
op2 NUMBER;
op3 NUMBER;
op4 NUMBER;
op5 NUMBER;
op6 NUMBER;
op7 NUMBER;
BEGIN
Dbms_Output.Disable;
Dbms_Output.Enable(1000000);
Dbms_Output.Put_Line('TABLE UNUSED BLOCKS TOTAL BLOCKS HIGH WATER MARK');
Dbms_Output.Put_Line('------------------------------ --------------- --------------- ---------------');
FOR cur_rec IN cu_tables LOOP
Dbms_Space.Unused_Space(cur_rec.owner,cur_rec.table_name,'TABLE',op1,op2,op3,op4,op5,op6,op7);
Dbms_Output.Put_Line(RPad(cur_rec.table_name,30,' ') ||
LPad(op3,15,' ') ||
LPad(op1,15,' ') ||
LPad(Trunc(op1-op3-1),15,' '));
END LOOP;
END;
Find sessions holding library cache lock:
=============================
select sid Waiter, p1raw,
substr(rawtohex(p1),1,30) Handle,
substr(rawtohex(p2),1,30) Pin_addr
from v$session_wait where wait_time=0 and event like '%library cache%';
For RAC DB:
==========
select a.sid Waiter,b.SERIAL#,a.event,a.p1raw,
substr(rawtohex(a.p1),1,30) Handle,
substr(rawtohex(a.p2),1,30) Pin_addr
from v$session_wait a,v$session b where a.sid=b.sid
and a.wait_time=0 and a.event like 'library cache%';
set lines 152
col sid for a9999999999999
col name for a40
select a.sid,b.name,a.value,b.class
from gv$sesstat a , gv$statname b
where a.statistic#=b.statistic#
and name like '%library cache%';
How to get the bind values of a sql query:
==============================
SELECT
sql_id,
b. LAST_CAPTURED,
t.sql_text sql_text,
b.HASH_VALUE,
b.name bind_name,
b.value_string bind_value
FROM
gv$sql t
JOIN
gv$sql_bind_capture b using (sql_id)
WHERE
b.value_string is not null
AND
sql_id='&sqlid'
/
How to get tablespace quota details of an user in oracle:
========================================
set pagesize 200
set lines 200
col ownr format a20 justify c heading 'Owner'
col name format a20 justify c heading 'Tablespace' trunc
col qota format a12 justify c heading 'Quota (KB)'
col used format 999,999,990 justify c heading 'Used (KB)'
set colsep '|'
select
username ownr,
tablespace_name name,
decode(greatest(max_bytes, -1),
-1, 'UNLIMITED',
to_char(max_bytes/1024, '999,999,990')
) qota,
bytes/1024 used
from
dba_ts_quotas
where
max_bytes!=0
or
bytes!=0
order by
1,2
/
set pagesize 200
set lines 200
col ownr format a20 justify c heading 'Owner'
col name format a20 justify c heading 'Tablespace' trunc
col qota format a12 justify c heading 'Quota (KB)'
col used format 999,999,990 justify c heading 'Used (KB)'
set colsep '|'
select
username ownr,
tablespace_name name,
decode(greatest(max_bytes, -1),
-1, 'UNLIMITED',
to_char(max_bytes/1024, '999,999,990')
) qota,
bytes/1024 used
from
dba_ts_quotas
where
( max_bytes!=0
or
bytes!=0) and username='&USERNAME'
order by
1,2
/
How to monitor parallel queries in oracle db:
================================
col username for a9
col sid for a8
set lines 299
select
s.inst_id,
decode(px.qcinst_id,NULL,s.username,
' - '||lower(substr(s.program,length(s.program)-4,4) ) ) "Username",
decode(px.qcinst_id,NULL, 'QC', '(Slave)') "QC/Slave" ,
to_char( px.server_set) "Slave Set",
to_char(s.sid) "SID",
decode(px.qcinst_id, NULL ,to_char(s.sid) ,px.qcsid) "QC SID",
px.req_degree "Requested DOP",
px.degree "Actual DOP", p.spid
from
gv$px_session px,
gv$session s, gv$process p
where
px.sid=s.sid (+) and
px.serial#=s.serial# and
px.inst_id = s.inst_id
and p.inst_id = s.inst_id
and p.addr=s.paddr
order by 5 , 1 desc
/
Find pending distributed pending transactions in oracle:
=======================================
COL local_tran_id FORMAT a13
COL in_out FORMAT a6
COL database FORMAT a25
COL dbuser_owner FORMAT a15
COL interface FORMAT a3
SELECT local_tran_id, in_out, database, dbuser_owner, interface
FROM dba_2pc_neighbors
/
How to find execution history of an sql_id:
==============================
select a.instance_number inst_id, a.snap_id,a.plan_hash_value, to_char(begin_interval_time,'dd-mon-yy hh24:mi') btime, abs(extract(minute from (end_interval_time-begin_interval_time)) + extract(hour from (end_interval_time-begin_interval_time))*60 + extract(day from (end_interval_time-begin_interval_time))*24*60) minutes,
executions_delta executions, round(ELAPSED_TIME_delta/1000000/greatest(executions_delta,1),4) "avg duration (sec)" from dba_hist_SQLSTAT a, dba_hist_snapshot b
where sql_id='&sql_id' and a.snap_id=b.snap_id
and a.instance_number=b.instance_number
order by snap_id desc, a.instance_number;
Script to get cpu usage and wait event information in oracle database:
=================================================
set lines 288
col sample_time for a14
col CONFIGURATION head "CONFIG" for 99.99
col ADMINISTRATIVE head "ADMIN" for 99.99
col OTHER for 99.99
SELECT TO_CHAR(SAMPLE_TIME, 'HH24:MI ') AS SAMPLE_TIME,
ROUND(OTHER / 60, 3) AS OTHER,
ROUND(CLUST / 60, 3) AS CLUST,
ROUND(QUEUEING / 60, 3) AS QUEUEING,
ROUND(NETWORK / 60, 3) AS NETWORK,
ROUND(ADMINISTRATIVE / 60, 3) AS ADMINISTRATIVE,
ROUND(CONFIGURATION / 60, 3) AS CONFIGURATION,
ROUND(COMMIT / 60, 3) AS COMMIT,
ROUND(APPLICATION / 60, 3) AS APPLICATION,
ROUND(CONCURRENCY / 60, 3) AS CONCURRENCY,
ROUND(SIO / 60, 3) AS SYSTEM_IO,
ROUND(UIO / 60, 3) AS USER_IO,
ROUND(SCHEDULER / 60, 3) AS SCHEDULER,
ROUND(CPU / 60, 3) AS CPU,
ROUND(BCPU / 60, 3) AS BACKGROUND_CPU
FROM (SELECT TRUNC(SAMPLE_TIME, 'MI') AS SAMPLE_TIME,
DECODE(SESSION_STATE,
'ON CPU',
DECODE(SESSION_TYPE, 'BACKGROUND', 'BCPU', 'ON CPU'),
WAIT_CLASS) AS WAIT_CLASS
FROM V$ACTIVE_SESSION_HISTORY
WHERE SAMPLE_TIME > SYSDATE - INTERVAL '2'
HOUR
AND SAMPLE_TIME <= TRUNC(SYSDATE, 'MI')) ASH PIVOT(COUNT(*)
FOR WAIT_CLASS IN('ON CPU' AS CPU,'BCPU' AS BCPU,
'Scheduler' AS SCHEDULER,
'User I/O' AS UIO,
'System I/O' AS SIO,
'Concurrency' AS CONCURRENCY,
'Application' AS APPLICATION,
'Commit' AS COMMIT,
'Configuration' AS CONFIGURATION,
'Administrative' AS ADMINISTRATIVE,
'Network' AS NETWORK,
'Queueing' AS QUEUEING,
'Cluster' AS CLUST,
'Other' AS OTHER))
/
How to find cpu and memory information of oracle database server:
================================================
set pagesize 299
set lines 299
select STAT_NAME,to_char(VALUE) as VALUE ,COMMENTS from v$osstat where stat_name IN ('NUM_CPUS','NUM_CPU_CORES','NUM_CPU_SOCKETS')
union
select STAT_NAME,VALUE/1024/1024/1024 || ' GB' ,COMMENTS from v$osstat where stat_name IN ('PHYSICAL_MEMORY_BYTES')
/
Find user commits per minute in oracle database:
===================================
col STAT_NAME for a20
col VALUE_DIFF for 9999,999,999
col STAT_PER_MIN for 9999,999,999
set lines 200 pages 1500 long 99999999
col BEGIN_INTERVAL_TIME for a30
col END_INTERVAL_TIME for a30
set pagesize 40
set pause on
select hsys.SNAP_ID,
hsnap.BEGIN_INTERVAL_TIME,
hsnap.END_INTERVAL_TIME,
hsys.STAT_NAME,
hsys.VALUE,
hsys.VALUE - LAG(hsys.VALUE,1,0) OVER (ORDER BY hsys.SNAP_ID) AS "VALUE_DIFF",
round((hsys.VALUE - LAG(hsys.VALUE,1,0) OVER (ORDER BY hsys.SNAP_ID)) /
round(abs(extract(hour from (hsnap.END_INTERVAL_TIME - hsnap.BEGIN_INTERVAL_TIME))*60 +
extract(minute from (hsnap.END_INTERVAL_TIME - hsnap.BEGIN_INTERVAL_TIME)) +
extract(second from (hsnap.END_INTERVAL_TIME - hsnap.BEGIN_INTERVAL_TIME))/60),1)) "STAT_PER_MIN"
from dba_hist_sysstat hsys, dba_hist_snapshot hsnap
where hsys.snap_id = hsnap.snap_id
and hsnap.instance_number in (select instance_number from v$instance)
and hsnap.instance_number = hsys.instance_number
and hsys.STAT_NAME='user commits'
order by 1;
Find the active transactions in oracle database:
=================================
col name format a10
col username format a8
col osuser format a8
col start_time format a17
col status format a12
tti 'Active transactions'
select s.sid,username,t.start_time, r.name, t.used_ublk "USED BLKS",
decode(t.space, 'YES', 'SPACE TX',
decode(t.recursive, 'YES', 'RECURSIVE TX',
decode(t.noundo, 'YES', 'NO UNDO TX', t.status)
)) status
from sys.v_$transaction t, sys.v_$rollname r, sys.v_$session s
where t.xidusn = r.usn
and t.ses_addr = s.saddr
/
Capture SQL Statements from AWR into a SQL Tuning Set:
=======================================================
SET SERVEROUT ON
SET PAGESIZE 1000
SET LONG 2000000
SET LINESIZE 400
--
-- Drop the SQL Tuning SET if it exists
--
DECLARE
sts_exists number;
stmt_count number;
cur sys_refcursor;
begin_id number;
end_id number;
BEGIN
SELECT count(*)
INTO sts_exists
FROM DBA_SQLSET
WHERE rownum = 1 AND
name = 'STS_CaptureAWR';
IF sts_exists = 1 THEN
SYS.DBMS_SQLTUNE.DROP_SQLSET(
sqlset_name=>'STS_CaptureAWR'
);
ELSE
DBMS_OUTPUT.PUT_LINE('SQL Tuning Set does not exist - will be created ...');
END IF;
--
-- Create a SQL Tuning SET 'STS_CaptureCursorCache'
--
SYS.DBMS_SQLTUNE.CREATE_SQLSET(
sqlset_name=>'STS_CaptureAWR',
description=>'Statements from AWR Before-Change'
);
DBMS_WORKLOAD_REPOSITORY.CREATE_SNAPSHOT;
SELECT min(snap_id)
INTO begin_id
FROM dba_hist_snapshot;
SELECT max(snap_id)
INTO end_id
FROM dba_hist_snapshot;
DBMS_OUTPUT.PUT_LINE('Snapshot Range between ' || begin_id || ' and ' || end_id || '.');
open cur for
select value(p) from table(dbms_sqltune.select_workload_repository(
begin_snap => begin_id,
end_snap => end_id,
basic_filter => 'parsing_schema_name not in (''DBSNMP'',''SYS'',''ORACLE_OCM'')',
ranking_measure1 => 'elapsed_time',
result_limit => 5000)) p;
dbms_sqltune.load_sqlset('STS_CaptureAWR', cur);
close cur;
--
-- Display the amount of statements collected in the STS
--
SELECT statement_count
INTO stmt_count
FROM dba_sqlset
WHERE name = 'STS_CaptureAWR';
DBMS_OUTPUT.PUT_LINE('There are ' || stmt_count || ' SQL Statements in STS_CaptureAWR.');
--
-- If you need more details please use:
--
-- SELECT sql_text,cpu_time,elapsed_time, executions, buffer_gets
-- FROM dba_sqlset_statements
-- WHERE sqlset_name='STS_CaptureAWR';
--
END;
/19c - Displays contents of the patches (BP/PSU) registry and history:
SET LINESIZE 500
SET PAGESIZE 1000
SET SERVEROUT ON
SET LONG 2000000
COLUMN action_time FORMAT A20
COLUMN action FORMAT A10
COLUMN status FORMAT A10
COLUMN description FORMAT A40
COLUMN source_version FORMAT A10
COLUMN target_version FORMAT A10
alter session set "_exclude_seed_cdb_view"=FALSE;
spool check_patches_19.txt
select CON_ID,
TO_CHAR(action_time, 'YYYY-MM-DD') AS action_time,
PATCH_ID,
PATCH_TYPE,
ACTION,
DESCRIPTION,
SOURCE_VERSION,
TARGET_VERSION
from CDB_REGISTRY_SQLPATCH
order by CON_ID, action_time, patch_id;
spool off18c - Displays contents of the patches (BP/PSU) registry and history:
SET LINESIZE 500
SET PAGESIZE 1000
SET SERVEROUT ON
SET LONG 2000000
COLUMN action_time FORMAT A12
COLUMN action FORMAT A10
COLUMN patch_type FORMAT A10
COLUMN description FORMAT A32
COLUMN status FORMAT A10
COLUMN version FORMAT A10
alter session set "_exclude_seed_cdb_view"=FALSE;
spool check_patches_18.txt
select CON_ID,
TO_CHAR(action_time, 'YYYY-MM-DD') AS action_time,
PATCH_ID,
PATCH_TYPE,
ACTION,
DESCRIPTION,
SOURCE_VERSION,
TARGET_VERSION
from CDB_REGISTRY_SQLPATCH
order by CON_ID, action_time, patch_id;spool off;
12c - Displays contents of the patches (BP/PSU) registry and history:
SET LINESIZE 500 SET PAGESIZE 1000 SET SERVEROUT ON SET LONG 2000000 COLUMN action_time FORMAT A12 COLUMN action FORMAT A10 COLUMN bundle_series FORMAT A4 COLUMN comments FORMAT A30 COLUMN description FORMAT A40 COLUMN namespace FORMAT A20 COLUMN status FORMAT A10 COLUMN version FORMAT A10 spool check_patches.txt SELECT TO_CHAR(action_time, 'YYYY-MM-DD') AS action_time, action, status, description, version, patch_id, bundle_series FROM sys.dba_registry_sqlpatch ORDER by action_time;
spool off;
12c - Displays installed components from DBA_REGISTRY:
set line 200 set pages 1000 col COMP_ID format a8 col COMP_NAME format a34 col SCHEMA format a12 col STATUS format a10 col VERSION format a12 col CON_ID format 99 select CON_ID, COMP_ID, comp_name, schema, status, version from CDB_REGISTRY order by 1,2;
12c - Shows invalid objects CDB-wide per CON_ID:
set line 200 set pages 1000 col owner format a12 col object_type format a12 col object_name format a30 col STATUS format a8 col CON_ID format 9 select con_id, owner, object_type, object_name, status from CDB_OBJECTS where status='INVALID' order by 1,2,3;
11g/12c - Capture SQL Statements from Cursor Cache into a SQL Tuning Set:
SET SERVEROUT ON
SET PAGESIZE 1000
SET LONG 2000000
SET LINESIZE 400
--
-- Drop the SQL Tuning SET if it exists
--
DECLARE
sts_exists number;
stmt_count number;
BEGIN
SELECT count(*)
INTO sts_exists
FROM DBA_SQLSET
WHERE rownum = 1 AND
name = 'STS_CaptureCursorCache';
IF sts_exists = 1 THEN
SYS.DBMS_SQLTUNE.DROP_SQLSET(
sqlset_name=>'STS_CaptureCursorCache'
);
ELSE
DBMS_OUTPUT.PUT_LINE('SQL Tuning Set does not exist - will be created ...');
END IF;
--
-- Create a SQL Tuning SET 'STS_CaptureCursorCache'
--
SYS.DBMS_SQLTUNE.CREATE_SQLSET(
sqlset_name=>'STS_CaptureCursorCache',
description=>'Statements from Before-Change'
);
--
-- Poll the Cursor Cache
-- time_limit: The total amount of time, in seconds, to execute
-- repeat_interval: The amount of time, in seconds, to pause between sampling
-- Adjust both settings based on needs
--
DBMS_OUTPUT.PUT_LINE('Now polling the cursor cache for 30 seconds every 5 seconds ...');
DBMS_SQLTUNE.CAPTURE_CURSOR_CACHE_SQLSET(
sqlset_name => 'STS_CaptureCursorCache',
time_limit => 30,
repeat_interval => 5,
capture_option => 'MERGE',
capture_mode => DBMS_SQLTUNE.MODE_ACCUMULATE_STATS,
basic_filter => NULL,
sqlset_owner => NULL,
recursive_sql => 'HAS_RECURSIVE_SQL');
--
-- Display the amount of statements collected in the STS
--
SELECT statement_count
INTO stmt_count
FROM dba_sqlset
WHERE name = 'STS_CaptureCursorCache';
DBMS_OUTPUT.PUT_LINE('There are now ' || stmt_count || ' SQL Statements in this STS.');
--
-- If you need more details please use:
--
-- SELECT sql_text,cpu_time,elapsed_time, executions, buffer_gets
-- FROM dba_sqlset_statements
-- WHERE sqlset_name='STS_CaptureCursorCache';
--
END;
/
Post a Comment: