Saturday, October 17, 2015

Handy Scripts for database performance troubleshooting

1-Check VMSTAT status.
vmstat (virtual memory statistics) is a computer system monitoring tool that collects and displays summary information about operating system memory, processes, interrupts, paging and block I/O.

vmstat 2 6
procs -----------memory---------- ---swap-- -----io---- --system-- ----cpu----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in    cs us sy id wa
 0  0   2536  21496 185684 1353000    0    0     0    14    1     2  0  0 100  0
 0  0   2536  21496 185684 1353000    0    0     0    28 1030   145  0  0 100  0
 0  0   2536  21496 185684 1353000    0    0     0     0 1026   132  0  0 100  0
 0  0   2536  21520 185684 1353000    0    0     0     0 1033   186  1  0 99  0
 0  0   2536  21520 185684 1353000    0    0     0     0 1024   141  0  0 100  0
 0  0   2536  21584 185684 1353000    0    0     0     0 1025   131  0  0 100  0

2-Check server memory usages using top command.

3-Check System activity report using sar command.

sar -u Displays CPU usage for the current day that was collected until that point.
sar -u 1 3 Displays real time CPU usage every 1 second for 3 times.

$ sar -u 1 3
Linux 2.6.18-194.el5PAE (dev-db)        03/26/2011      _i686_  (8 CPU)

01:27:32 PM       CPU     %user     %nice   %system   %iowait    %steal     %idle
01:27:33 PM       all      0.00      0.00      0.00      0.00      0.00    100.00
01:27:34 PM       all      0.25      0.00      0.25      0.00      0.00     99.50
01:27:35 PM       all      0.75      0.00      0.25      0.00      0.00     99.00
Average:          all      0.33      0.00      0.17      0.00      0.00     99.50

4-Check Alert log for any ORA- errors

5-Run AWR(automatic workload repository) report for specified time period.

sql> @?/rdbms/admin/awrrpt.sql

6-Run ADDM recommendation for specified time period.

sql> @?/rdbms/admin/addmrpt.sql

7-Check Long running sessions.

#LONG RUNNING SESSION#
-------------------------------------------------------

SELECT
  SQL_ID,
  SQL_ADDRESS,
  SQL_HASH_VALUE
  OPNAME,
  TARGET,
  TARGET_DESC,
  TIME_REMAINING,
  SID,
  SERIAL#
  FROM
  V$SESSION_LONGOPS
WHERE
  TIME_REMAINING>0;

//

Long running session: (RAC)
=======================

Select username, sid, serial#, command, sql_id, last_call_et/60 running_minutes
From gv$session
Where status = 'ACTIVE'
And last_call_et/60 > 30
and username is not null
 ;


Long Running (Pay attention on the RUN_MINUTES)
===========================================

select ses.username, ses.status, ses.sid, ses.serial#,
ses.osuser, ses.process, to_char(ses.logon_time,'hh24:mi:ss'),
s.disk_reads, s.buffer_gets, s.sorts, last_call_et/60 run_minutes,s.SQL_ID,s.plan_hash_value,
sql_text
from v$session ses, v$sql s
where  ses.username is not null
 and ses.username not in ('SYS') and ses.sql_address = s.address
order by run_minutes desc;

Check long running session status

# Long Session '%' completed
==========================

select sid,serial#,opname,sofar,totalwork,((sofar/totalwork)*100) "Completed %",sql_address from v$session_longops where sofar<totalwork;

select sid,serial#,opname,sofar,totalwork,((sofar/totalwork)*100) "Completed %",sql_address from v$session_longops where sql_hash_value='1474587846';

select sid,serial#,opname,message,sofar,totalwork,((sofar/totalwork)*100) "Completed %",sql_address from v$session_longops where sql_id='gj9qpg6p71206';

//
## "%" completed using SID ##
========================

COLUMN opname FORMAT A30
COLUMN target_desc FORMAT A30
COLUMN units FORMAT A10
col username for a10

 SELECT
    sid,
    opname,
    target_desc,
    sofar,
    totalwork,
    time_remaining,
     units,username,elapsed_seconds,time_remaining
 FROM
v$session_longops
where sid='&1'
order by 10;

//
Please use below sql to monitor number of rows committed or deleted.  Column to monitor is rows_processed and executions.
===========================================================================================================

select SQL_ID, ROWS_PROCESSED,to_char(LAST_ACTIVE_TIME,' dd-Mon-YYYY HH24:mi:ss'),EXECUTIONS,Elapsed_time from v$sql where sql_id in('7h7t58m07pdgw');
8-Check for any blocking sessions in database.

select 'SID '||l1.sid||'--'||s1.username || ' IS BLOCKING SID ' || l2.sid||'--'||s2.username blocking_report from gv$lock l1, gv$lock l2,v$session s1,v$session s2
where l1.block =1 and l2.request > 0 and
l1.id1=l2.id1 and l1.id2=l2.id2 and s1.sid=l1.sid and s2.sid=l2.sid;

Session Using Table :
======================

SELECT * FROM v$lock WHERE id1 = (SELECT object_id FROM all_objects WHERE owner ='owner_name' AND object_name ='table_name');

SELECT * FROM v$session WHERE sid =<above query result>

Kill all blocking sessions sid's
----------------------------------

SELECT 'ALTER SYSTEM KILL SESSION ''' || sid || ',' || serial# || ''' IMMEDIATE ;' from v$session where username='

9-Check Stale stats ,last analyzed stats,stats locks.


# DML counts #
----------------------------------
//

select table_owner,table_name,inserts,updates,deletes,timestamp from dba_tab_modifications where table_name='PO_VERSIONS';


select owner,table_name,last_analyzed,stale_stats from dba_tab_statistics where table_name='


select table_name,partition_name,last_analyzed,stattype_locked,stale_stats from dba_tab_statistics where owner='HR';


select table_name, tablespace_name, num_rows, blocks, empty_blocks, avg_space, chain_cnt, avg_row_len, last_analyzed from dba_TABLES where owner='PAY';

10-If there is stale stats or if table last analyzed is not up to date gather the stats accordingly.

**STATISTIC GATHERING**
==========================

Table stats gathering
=================

execute dbms_stats.gather_table_stats(ownname => 'SCOTT', tabname => 'PRICE', estimate_percent => DBMS_STATS.AUTO_SAMPLE_SIZE ,method_opt => 'FOR ALL COLUMNS SIZE AUTO', degree => dbms_stats.default_degree, no_invalidate => FALSE, granularity => 'ALL', block_sample=>FALSE, cascade => TRUE);

##When granularity => 'AUTO' oracle decides which segment to collect stats depending on whether the stats are important for the optimizer, whether they are stale etc. Currently we don't collect stats for hash sub partitions since it is not going to help a lot in optimizer cost estimation per Bug 6918217 .##


Database Stats gathering
=====================

EXEC DBMS_STATS.gather_database_stats(estimate_percent => DBMS_STATS.AUTO_SAMPLE_SIZE ,method_opt => 'FOR ALL COLUMNS SIZE AUTO', degree => dbms_stats.default_degree, no_invalidate => FALSE, granularity => 'ALL', block_sample=>FALSE, cascade => TRUE);



Schema Stats Gather
==================

set time on
BEGIN
dbms_stats.GATHER_SCHEMA_STATS
 (
ownname => 'SCOTT',
estimate_percent => DBMS_STATS.AUTO_SAMPLE_SIZE ,
method_opt => 'FOR ALL COLUMNS SIZE AUTO',
degree => dbms_stats.default_degree,
no_invalidate => FALSE,
granularity => 'ALL',
block_sample=>FALSE,
cascade => TRUE
);
END;
/



Index Gather  Stats
================

exec dbms_stats.gather_index_stats(ownname=>'SCOTT',indname=>'PRC_TRADE',estimate_percent=>DBMS_STATS.AUTO_SAMPLE_SIZE,degree=>DBMS_STATS.AUTO_DEGREE);




11-Check for any sql plan change for the long running sql_id's

sql plan change:-
==================

col execs for 999,999,999
col avg_etime for 999,999.999
col avg_lio for 999,999,999.9
col begin_interval_time for a30
col node for 99999
break on plan_hash_value on startup_time skip 1

select ss.snap_id, ss.instance_number node, begin_interval_time, sql_id, plan_hash_value,
nvl(executions_delta,0) execs,
(elapsed_time_delta/decode(nvl(executions_delta,0),0,1,executions_delta))/1000000 avg_etime,
(buffer_gets_delta/decode(nvl(buffer_gets_delta,0),0,1,executions_delta)) avg_lio
from DBA_HIST_SQLSTAT S, DBA_HIST_SNAPSHOT SS
where sql_id = '&sql_id'
and ss.snap_id = S.snap_id
and ss.instance_number = S.instance_number
and executions_delta > 0
order by 1, 2, 3
/


12-Check top wait events in database .

TOP WAIT EVENTS ##
====================

set linesize 120
col event format a30

select * from (
select  event, total_waits, total_timeouts, time_waited
from v$system_event
where event not like 'SQL*Net%'
and event not in ('pmon timer','rdbms ipc message','dispatcher timer','smon timer')
order by time_waited desc )
where rownum < 6;

//

//

set lines 200
set pages 2000
col execs for 999,999,999
col avg_etime for 999,999.999
col avg_lio for 999,999,999.9
col begin_interval_time for a30
col node for 99999
break on plan_hash_value on startup_time skip 1

select ss.snap_id, ss.instance_number node, begin_interval_time, sql_id, plan_hash_value,
nvl(executions_delta,0) execs,
(elapsed_time_delta/decode(nvl(executions_delta,0),0,1,executions_delta))/1000000 avg_etime,
(buffer_gets_delta/decode(nvl(buffer_gets_delta,0),0,1,executions_delta)) avg_lio
from DBA_HIST_SQLSTAT S, DBA_HIST_SNAPSHOT SS
where sql_id = '&sql_id'
and ss.snap_id = S.snap_id
and ss.instance_number = S.instance_number
and executions_delta > 0
order by 1, 2, 3

//

13-Look for sql execution plan.

SELECT * FROM TABLE (DBMS_XPLAN.DISPLAY_AWR('7d85p8rb39hg0',174907159,NULL,'ALL'));

select * from table(dbms_xplan.display_awr('0pnkz8nrwgvw5'));

14-Checking Table Fragmentation.

set linesize 800
set pages 1000
select owner,table_name,round((blocks*8),2) "size (kb)" ,
                            round((num_rows*avg_row_len/1024),2) "actual_data (kb)",
                            (round((blocks*8),2) - round((num_rows*avg_row_len/1024),2)) "wasted_space (kb)"
from dba_tables
where (round((blocks*8),2) > round((num_rows*avg_row_len/1024),2))
and owner not in('SYS','SYSTEM') and table_name=upper('&table_name')
order by 5 desc;

//

select table_name,round((blocks*8),2) "size (kb)" from dba_tables where owner='SCOTT';


*If table is highly fragmented then perform table defragmentation using below steps

15-Table defragmentation steps


## De_FRAGMENT Table ##
=========================

Step 1:

alter index CUSTOMER.BAM_MFRS_TX_IDX shrink space cascade;

Step 2:

alter index CUSTOMER.BAM_MFRS_TX_IDX deallocate unused;

Step 3:

alter table CUSTOMER.BAM_MFRS_TX enable row movement;

Step 4:

alter table CUSTOMER.BAM_MFRS_TX shrink space cascade;


Step 5:

alter table CUSTOMER.BAM_MFRS_TX deallocate unused;


Step 6:

alter tablespace CUST_DEFAULT coalesce;

16-

Friday, October 16, 2015

Script to check Redo generation

REDO_Archive Checks
================== 

Script to  check Daily Count and Size of Redo Log Space (Single Instance)
-============================================================


SELECT A.*,
Round(A.Count#*B.AVG#/1024/1024) Daily_Avg_Mb
FROM
(
   SELECT
   To_Char(First_Time,'YYYY-MM-DD') DAY,
   Count(1) Count#,
   Min(RECID) Min#,
   Max(RECID) Max#
FROM
   v$log_history
GROUP BY
   To_Char(First_Time,'YYYY-MM-DD')
ORDER
BY 1 DESC
) A,
(
SELECT
Avg(BYTES) AVG#,
Count(1) Count#,
Max(BYTES) Max_Bytes,
Min(BYTES) Min_Bytes
FROM
v$log
) B
;


Script to analyze hourly generated log :
=================================


set lines 120;
set pages 999;
SELECT
to_char(first_time,'YYYY-MON-DD') day,
to_char(sum(decode(to_char(first_time,'HH24'),'00',1,0)),'99') "00",
to_char(sum(decode(to_char(first_time,'HH24'),'01',1,0)),'99') "01",
to_char(sum(decode(to_char(first_time,'HH24'),'02',1,0)),'99') "02",
to_char(sum(decode(to_char(first_time,'HH24'),'03',1,0)),'99') "03",
to_char(sum(decode(to_char(first_time,'HH24'),'04',1,0)),'99') "04",
to_char(sum(decode(to_char(first_time,'HH24'),'05',1,0)),'99') "05",
to_char(sum(decode(to_char(first_time,'HH24'),'06',1,0)),'99') "06",
to_char(sum(decode(to_char(first_time,'HH24'),'07',1,0)),'99') "07",
to_char(sum(decode(to_char(first_time,'HH24'),'08',1,0)),'99') "08",
to_char(sum(decode(to_char(first_time,'HH24'),'09',1,0)),'99') "09",
to_char(sum(decode(to_char(first_time,'HH24'),'10',1,0)),'99') "10",
to_char(sum(decode(to_char(first_time,'HH24'),'11',1,0)),'99') "11",
to_char(sum(decode(to_char(first_time,'HH24'),'12',1,0)),'99') "12",
to_char(sum(decode(to_char(first_time,'HH24'),'13',1,0)),'99') "13",
to_char(sum(decode(to_char(first_time,'HH24'),'14',1,0)),'99') "14",
to_char(sum(decode(to_char(first_time,'HH24'),'15',1,0)),'99') "15",
to_char(sum(decode(to_char(first_time,'HH24'),'16',1,0)),'99') "16",
to_char(sum(decode(to_char(first_time,'HH24'),'17',1,0)),'99') "17",
to_char(sum(decode(to_char(first_time,'HH24'),'18',1,0)),'99') "18",
to_char(sum(decode(to_char(first_time,'HH24'),'19',1,0)),'99') "19",
to_char(sum(decode(to_char(first_time,'HH24'),'20',1,0)),'99') "20",
to_char(sum(decode(to_char(first_time,'HH24'),'21',1,0)),'99') "21",
to_char(sum(decode(to_char(first_time,'HH24'),'22',1,0)),'99') "22",
to_char(sum(decode(to_char(first_time,'HH24'),'23',1,0)),'99') "23"
from
   v$log_history
GROUP by
   to_char(first_time,'YYYY-MON-DD');



Script to know which SQL’s are generating redo:
========================================

SELECT when, sql, SUM(sx) executions, sum (sd) rows_processed
FROM (
      SELECT to_char(begin_interval_time,’YYYY_MM_DD HH24') when,
             dbms_lob.substr(sql_text,4000,1) sql,
             dhss.instance_number inst_id,
             dhss.sql_id,
             sum(executions_delta) exec_delta,
             sum(rows_processed_delta) rows_proc_delta
        FROM dba_hist_sqlstat dhss,
             dba_hist_snapshot dhs,
             dba_hist_sqltext dhst
        WHERE upper(dhst.sql_text) LIKE ‘%Z_PLACENO%’
          AND ltrim(upper(dhst.sql_text)) NOT LIKE ‘SELECT%’
          AND dhss.snap_id=dhs.snap_id
          AND dhss.instance_Number=dhs.instance_number
          AND dhss.sql_id = dhst.sql_id
          AND begin_interval_time BETWEEN to_date(’12-02-07 12:00',’YY-MM-DD HH24:MI’)
                                      AND to_date(’12-02-07 16:00',’YY-MM-DD HH24:MI’)
        GROUP BY to_char(begin_interval_time,’YYYY_MM_DD HH24'),
            dbms_lob.substr(sql_text,4000,1),
              dhss.instance_number,
             dhss.sql_id
)
group by when, sql;


Script to identify users generating more redo :
======================================


col machine for a15
col username for a10
col redo_MB for 999G990 heading “Redo |Size MB”
column sid_serial for a13;
 

select b.inst_id,
       lpad((b.SID || ‘,’ || lpad(b.serial#,5)),11) sid_serial,
       b.username,
       machine,
       b.osuser,
       b.status,
       a.redo_mb  
from (select n.inst_id, sid,
             round(value/1024/1024) redo_mb
        from gv$statname n, gv$sesstat s
        where n.inst_id=s.inst_id
              and n.name = ‘redo size’
              and s.statistic# = n.statistic#
        order by value desc
     ) a,
     gv$session b
where b.inst_id=a.inst_id  and a.sid = b.sid  and   rownum <= 10  and b.username is not null;


Script to check Invalid object counts in database

----->INVALID_OBJECT_CHECK
*******************************

#Full_Invalid_object_Details
=======================

set lines 300 pages 300
col owner for a10
col OBJECT_NAME for a30
select count(*),OBJECT_NAME,object_type,owner,status,timestamp from dba_objects where
status='INVALID' group by object_name,object_type,owner,status,timestamp order by timestamp desc;

#Invalid object count under schema#
================================

select count(*),object_type,owner from dba_objects where status='INVALID' group by object_type,owner;

#Only_count
===========

 select count(*),status from dba_objects group by status;

#Last_DDL_Time
==============

select owner,object_name,object_type,status,last_ddl_time from dba_objects where object_name in
('CALCULATE_GAIN_LOSS')


select owner,object_type,count(*) from dba_objects where owner='&1' group by object_type,owner;

Script to check Locking and Blocking in oracle database

#Locking#
===========

select session_id "sid",SERIAL#  "Serial",
    substr(object_name,1,20) "Object",
      substr(os_user_name,1,10) "Terminal",
      substr(oracle_username,1,10) "Locker",
      nvl(lockwait,'active') "Wait",
      decode(locked_mode,
        2, 'row share',
        3, 'row exclusive',
        4, 'share',
        5, 'share row exclusive',
        6, 'exclusive',  'unknown') "Lockmode",
      OBJECT_TYPE "Type"
    FROM
      SYS.V_$LOCKED_OBJECT A,
      SYS.ALL_OBJECTS B,
      SYS.V_$SESSION c
    WHERE
      A.OBJECT_ID = B.OBJECT_ID AND
      C.SID = A.SESSION_ID
    ORDER BY 1 ASC, 5 Desc;

##Blocking##
=============

select 'SID '||l1.sid||'--'||s1.username || ' IS BLOCKING SID ' || l2.sid||'--'||s2.username blocking_report from v$lock l1, v$lock l2,v$session s1,v$session s2 where
l1.block =1 and l2.request > 0 and l1.id1=l2.id1 and l1.id2=l2.id2 and s1.sid=l1.sid and s2.sid=l2.sid;


#Blocking_count#
=================

select count(*) from   v$lock a, v$session s, all_objects ob, v$locked_object lo where  s.sid = a.sid and lo.session_id = a.sid and ob.object_id = lo.object_id and  a.block = 1


## LOCKED_OBJ ##
=================


select o.object_name as "object_name",
       s.sid as "sid",
       s.serial# as "serial#",
       s.username as "username",
       sq.sql_fulltext as "sql_fulltext"
  from v$locked_object l, dba_objects o, v$session s,
       v$process p, v$sql sq
  where l.object_id = o.object_id
    and l.session_id = s.sid and s.paddr = p.addr
    and s.sql_address = sq.address;


Session Using Table :
======================

SELECT * FROM v$lock WHERE id1 = (SELECT object_id FROM all_objects WHERE owner ='owner_name' AND object_name ='table_name');

SELECT * FROM v$session WHERE sid =<above query result>


TO FIND SQL TEXT FROM SID:
============================

select a.sid,a.program,b.sql_text from gv$session a, v$sqltext b where a.sql_hash_value = b.hash_value and a.sid=68 order by a.sid,hash_value,piece;


Find SID from PID
=================

col sid format 999999
col username format a20
col osuser format a15
select b.spid,a.sid, a.serial#,a.username, a.osuser
from v$session a, v$process b
where a.paddr= b.addr
and b.spid='&spid'
order by b.spid;
/


select p.spid,s.sid,s.serial#,s.username,s.status,s.last_call_et,p.program,p.terminal,logon_time,module,s.osuser
from V$process p,V$session s
where s.paddr = p.addr and s.status = 'ACTIVE' and s.username not like '%SYS%';
/


## SID_Checks ##
 ==============
set lines 300
col OSUSER for a15
col PROGRAM for a30
col MACHINE for a25
col SQL_ID for a20
col STATUS for a15
col username for a20

select sid,serial#,sql_id,program,username,osuser,state,status,logon_time from gv$session where sid ='&1';

select sql_text from v$sql where sql_id='&1';


select sid, serial#, username, status, osuser, machine, terminal, LOGON_TIME
from v$session
where status='INACTIVE' --and logon_time < sysdate-1
order by logon_time ;


Get SID from PID :
==============

select sid,serial#,sql_id,program,username,osuser,state,status,logon_time from gv$session where paddr in (select addr from v$process where spid ='50678');


//
SET LINESIZE 100
COLUMN spid FORMAT A10
COLUMN username FORMAT A10
COLUMN program FORMAT A45

SELECT s.inst_id,
       s.sid,
       s.serial#,
       p.spid,
       s.username,
       s.program
FROM   gv$session s
       JOIN gv$process p ON p.addr = s.paddr AND p.inst_id = s.inst_id
WHERE  s.type != 'BACKGROUND';

//
Enq: TX - row lock contention Issue
==============================


## The “enq: TX - row lock contention” event often indicates an application level locking problem. The TX enqueue is the transaction enqueue (a.k.a. enq: TX – contention) and can also be related to buffer busy waits, in conditions where multiple transaction attempt to update the same data blocks. TX enqueue is issued when a transaction makes its first change, and released when the transaction performs a COMMIT or ROLLBACK.

To troubleshoot the wait event “enq: TX – row lock contention”, use the following SQL:

 For which SQL is currently waiting on:

select
    sid,
    sql_text
from
    v$session s,
    v$sql q
where
    sid in
    (select
       sid
    from
       v$session
   where
       state in ('WAITING')
   and
       wait_class != 'Idle'
   and
       event='enq: TX - row lock contention'
   and
      (q.sql_id = s.sql_id or q.sql_id = s.prev_sql_id));

The blocking session is:
====================

select
    blocking_session,
    sid,    serial#,
    wait_class,
    seconds_in_wait
from
    v$session
where
    blocking_session is not NULL
order by
    blocking_session;

Script to check SQL wise CPU usage

By using these script you can check which SQL queries are using how much CPU.

# SQL wise CPU usage #:
======================
//

col type for a15
select * from (
select
ash.SQL_ID , ash.SQL_PLAN_HASH_VALUE Plan_hash, aud.name type,
sum(decode(ash.session_state,'ON CPU',1,0)) "CPU",
sum(decode(ash.session_state,'WAITING',1,0)) -
sum(decode(ash.session_state,'WAITING', decode(wait_class, 'User I/O',1,0),0)) "WAIT" ,
sum(decode(ash.session_state,'WAITING', decode(wait_class, 'User I/O',1,0),0)) "IO" ,
sum(decode(ash.session_state,'ON CPU',1,1)) "TOTAL"
from v$active_session_history ash,
audit_actions aud
where SQL_ID is not NULL
and ash.sql_opcode=aud.action
and ash.sample_time > sysdate - &minutes /( 60*24)
group by sql_id, SQL_PLAN_HASH_VALUE , aud.name
order by sum(decode(session_state,'ON CPU',1,1)) desc
) where rownum < 10;

//

# SQL wise CPU usage (2)#:
=====================
//

select
   ss.username,
   se.SID,
   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='ACTIVE'
and   ss.username is not null
order by VALUE desc;

//

UNDO tablespace size checks

# undo size check #
---------------------------
//

SELECT d.undo_size/(1024*1024) "ACTUAL UNDO SIZE [MByte]",
SUBSTR(e.value,1,25) "UNDO RETENTION [Sec]",
ROUND((d.undo_size / (to_number(f.value) *
g.undo_block_per_sec))) "OPTIMAL UNDO RETENTION [Sec]"
FROM ( SELECT SUM(a.bytes) 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#
) d,
v$parameter e,
v$parameter f,
( SELECT MAX(undoblks/((end_time-begin_time)*3600*24))
undo_block_per_sec
FROM v$undostat
) g
WHERE e.name = 'undo_retention'
AND f.name = 'db_block_size';

//

SELECT MAX(undoblks/((end_time-begin_time)*3600*24))"UNDO_BLOCK_PER_SEC"FROM v$undostat;

//

# Which user using how much UNDO #
-------------------------------------------
//

select s.sid,
       s.username,
       sum(ss.value) / 1024 / 1024 as undo_size_mb
from  v$sesstat ss
  join v$session s on s.sid = ss.sid
  join v$statname stat on stat.statistic# = ss.statistic#
where stat.name = 'undo change vector size'
and s.type <> 'BACKGROUND'
and s.username IS NOT NULL
group by s.sid, s.username;

//

TEMP Tablespace size checks

# Run the following statement to check the free space within the used portion of TEMPFILE #

//

SELECT   A.tablespace_name tablespace, D.mb_total,
         SUM (A.used_blocks * D.block_size) / 1024 / 1024 mb_used,
         D.mb_total - SUM (A.used_blocks * D.block_size) / 1024 / 1024 mb_free
FROM     v$sort_segment A,
         (
         SELECT   B.name, C.block_size, SUM (C.bytes) / 1024 / 1024 mb_total
         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.mb_total;

//

#  The query below will display which sessions are using TEMP tablespace and how much space is being used by each session: #


//

set line 300 pagesize 300
col TABLESPACE for a10
col OSUSER for a10
col STATUS for a15
col PROGRAM for a30
col USERNAME for a30
SELECT   b.TABLESPACE
       , b.segfile#
       , b.segblk#
       , ROUND (  (  ( b.blocks * p.VALUE ) / 1024 / 1024 ), 2 ) used_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;


//


# Temp usage #real time
======================
//

col USERNAME for a20
col MODULE for a30
col SPID for a10
SELECT S.sid , S.serial# sid_serial, S.username, S.osuser, P.spid, S.module,
P.program, SUM (T.blocks) * TBS.block_size / 1024 / 1024 mb_used, T.tablespace,
COUNT(*) statements
FROM v$sort_usage T, v$session S, dba_tablespaces TBS, v$process P
WHERE T.session_addr = S.saddr
AND S.paddr = P.addr
AND T.tablespace = TBS.tablespace_name
GROUP BY S.sid, S.serial#, S.username, S.osuser, P.spid, S.module,
P.program, TBS.block_size, T.tablespace
ORDER BY sid_serial;

//

TEMP_Usage_history
==================

select  thedate,
 gbsize,
 prev_gbsize,
 gbsize-prev_gbsize diff
from        (
 select  thedate,
 gbsize,
 lag(gbsize,1) over (order by r) prev_gbsize
 from    (
 select  rownum r,
 thedate,
 gbsize
 from    (
 select  trunc(thedate) thedate,
 max(gbsize) gbsize
 from    (
 select  to_date(to_char(snapshot.begin_interval_time,'YYYY-MON-DD HH24:MI:SS'),'YYYY-MON-DD HH24:MI:SS') thedate,
 round((usage.tablespace_usedsize*block_size.value)/1024/1024/1024,2) gbsize
 from    dba_hist_tbspc_space_usage usage,
 v$tablespace               tablespace,
 dba_hist_snapshot          snapshot,
 v$parameter                block_size
 where   usage.snap_id       = snapshot.snap_id
 and     usage.tablespace_id = tablespace.ts#
 and     tablespace.name     = '&tablespace'
 and     block_size.name     = 'db_block_size'
 )
 group by
 trunc(thedate)
 order by
 trunc(thedate)
 )
 )
 );

//


SELECT   S.sid || ',' || S.serial# sid_serial, S.username,T.blocks * TBS.block_size / 1024 / 1024 mb_used, T.tablespace,
T.sqladdr address, Q.hash_value, Q.sql_text
FROM     v$sort_usage T, v$session S, v$sqlarea Q, dba_tablespaces TBS
WHERE    T.session_addr = S.saddr
AND      T.sqladdr = Q.address
AND      T.tablespace = TBS.tablespace_name
and s.process='23426'
and s.status = 'ACTIVE'
ORDER BY S.sid;

Resizing temp:
============

 select FILE_NAME,bytes/1024/1024 from dba_temp_files where TABLESPACE_NAME='TEMP';     // checking temp file//

alter database tempfile '+DATA/orcl/tempfile/temp.275.844266939' resize 1G;             // Resizing Temp file //