SCRIPTS DE BANCO DE DADOS ORACLE

Objetos em Library Cache

SELECT SUBSTR(owner,1,10) Owner,
SUBSTR(type,1,12) Type,
SUBSTR(name,1,20) Name,
executions,
sharable_mem Mem_used,
SUBSTR(kept||' ',1,4) "Kept?"
FROM v$db_object_cache WHERE TYPE IN ('TRIGGER','PROCEDURE','PACKAGE BODY','PACKAGE')
ORDER BY EXECUTIONS DESC
Script de quanto cada sessão está consumindo de memória na PGA.
SELECT NVL(a.username,'(oracle)') AS username,
a.module,
a.program,
Trunc(b.value/1024) AS memory_kb
FROM v$session a,
v$sesstat b,
v$statname c
WHERE a.sid = b.sid AND b.statistic# = c.statistic# AND c.name = 'session pga memory' AND a.program
IS NOT NULL
ORDER BY b.value DESC
Monitorar quantidade em MB de uso por usuários
accept usr prompt "Digite o nome do Usuário.......:"

clear col
clear buffer
clear breaks
clear computes

SET LINESIZE 1000

set pages 100

COL username FOR A20 heading 'User|Name'

col inst_id for 999 heading 'Inst|Id'
COL module FOR A30 heading 'Module'
col program for a30 heading 'Program'
col memory_Mb for 999999 heading 'Memory|Mb'

break on username on inst_id on report skip 2

compute sum of memory_Mb on username skip 1

compute sum of memory_Mb on report

select a.inst_id,
a.sid,
nvl(a.username,'(oracle)') as username,
a.module,
a.program,
trunc(b.value/1024/1024) as memory_mb
from gv$session a,
gv$sesstat b,
gv$statname c
where a.sid = b.sid
and a.inst_id = b.inst_id
and b.statistic# = c.statistic#
and b.inst_id = c.inst_id
and c.name = 'session pga memory'
and a.program is not null
and a.username like upper(nvl('%&usr%',a.USERNAME))
order by a.inst_id,
a.module,
a.program desc;
Monitorar Tablespace Temporária
SELECT

d.tablespace_name tablespace_name

, d.status tablespace_status

, NVL(a.bytes, 0) tablespace_size

, NVL(t.bytes, 0) used
, TRUNC(NVL(t.bytes / a.bytes * 100, 0)) used_pct

, NVL(s.current_users, 0) current_users

FROM sys.dba_tablespaces d

, ( select tablespace_name, sum(bytes) bytes

from dba_temp_files group by tablespace_name

)a

, ( select tablespace_name, sum(bytes_cached) bytes

from v$temp_extent_pool group by tablespace_name

)t

, v$sort_segment s

WHERE d.tablespace_name = a.tablespace_name(+) AND d.tablespace_name = t.tablespace_name(+)

AND d.tablespace_name = s.tablespace_name
Objetos que sofreram "Pin" em cache para melhorias de performance
select NAME,
TYPE,
KEPT
from v$db_object_cache where KEPT = 'YES'
Monitoramento das sessões do RMAN no banco de dados
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 <>
Espaço livre em Tablespaces
SELECT TABLESPACE_NAME ,
SUM(BYTES) / 1024 ESPACO_LIVRE_EM_KBYTES
FROM DBA_FREE_SPACE
GROUP BY CUBE(TABLESPACE_NAME);

Espaço Ocupado em Tablespaces

SELECT TABLESPACE_NAME ,
SUM(BYTES) / 1024 ESPACO_OCUPADO_EM_KBYTES
FROM DBA_SEGMENTS
GROUP BY CUBE (TABLESPACE_NAME);

ESPAÇO OCUPADO PELAS TABELAS NAS TABLESPACES (POR TABELA)

SELECT OWNER ,
TABLE_NAME ,
TABLESPACE_NAME ,
NUM_ROWS NUMERO_DE_LINHAS ,
AVG_ROW_LEN TAMANHO_MEDIO_DA_LINHA ,
NUM_ROWS * AVG_ROW_LEN ESPACO_OCUPADO_POR_DADOS ,
BLOCKS BLOCOS_OCUPADOS ,
EMPTY_BLOCKS BLOCOS_VAZIOS ,
BLOCKS + EMPTY_BLOCKS BLOCOS_TOTAL ,
BLOCKS * 8 BLOCOS_OCUPADOS_KB , -- DB_BLOCK_SIZE = 8K
EMPTY_BLOCKS * 8 BLOCOS_VAZIOS_KB ,
(BLOCKS + EMPTY_BLOCKS) * 8 BLOCOS_TOTAL_KB
FROM DBA_TABLES;
ESPAÇO OCUPADO PELAS TABELAS NAS TABLESPACES (POR TABLESPACE)
SELECT OWNER ,
TABLESPACE_NAME ,
SUM(NUM_ROWS) NUMERO_DE_LINHAS ,
SUM(AVG_ROW_LEN) TAMANHO_MEDIO_DA_LINHA ,
SUM(NUM_ROWS * AVG_ROW_LEN) ESPACO_OCUPADO_POR_DADOS ,
SUM(BLOCKS) BLOCOS_OCUPADOS ,
SUM(EMPTY_BLOCKS) BLOCOS_VAZIOS ,
SUM(BLOCKS + EMPTY_BLOCKS) BLOCOS_TOTAL ,
SUM(BLOCKS) * 8 BLOCOS_OCUPADOS_KB , -- DB_BLOCK_SIZE
= 8K
SUM(EMPTY_BLOCKS) * 8 BLOCOS_VAZIOS_KB ,
 SUM(BLOCKS + EMPTY_BLOCKS) * 8 BLOCOS_TOTAL_KB
FROM DBA_TABLES
GROUP BY CUBE (OWNER,TABLESPACE_NAME);

DISTRIBUIÇÃO DE OBJETOS DO USUÁRIO OWNER PELAS TABLESPACES

SELECT TABLESPACE_NAME ,
SEGMENT_TYPE TIPO ,
COUNT(*) QUANT
FROM DBA_SEGMENTS
WHERE OWNER = 'OWNER'
GROUP BY CUBE (TABLESPACE_NAME ,
SEGMENT_TYPE) ;
TABELAS QUE PRECISARÃO DE MAIS ESPAÇO EM CASO DE CRESCIMENTO DE 30%
SELECT OWNER ,
TABLE_NAME ,
TABLESPACE_NAME ,
TO_CHAR((((NUM_ROWS * AVG_ROW_LEN)*1.3) -
((BLOCKS + EMPTY_BLOCKS) * 8192))/1024,'999999999.9') DEFICIT_KB ,
NUM_ROWS NUMERO_DE_LINHAS ,
AVG_ROW_LEN TAMANHO_MEDIO_DA_LINHA ,
NUM_ROWS * AVG_ROW_LEN ESPACO_OCUPADO_POR_DADOS ,
BLOCKS BLOCOS_OCUPADOS ,
EMPTY_BLOCKS BLOCOS_VAZIOS ,
BLOCKS + EMPTY_BLOCKS BLOCOS_TOTAL ,
BLOCKS * 8 BLOCOS_OCUPADOS_KB , -- DB_BLOCK_SIZE = 8K
EMPTY_BLOCKS * 8 BLOCOS_VAZIOS_KB ,
(BLOCKS + EMPTY_BLOCKS) * 8 BLOCOS_TOTAL_KB
FROM DBA_TABLES
WHERE ((NUM_ROWS * AVG_ROW_LEN)*1.3) >
((BLOCKS + EMPTY_BLOCKS) * 8192)
AND OWNER = 'OWNER'
ORDER BY ((NUM_ROWS * AVG_ROW_LEN)*1.3) -
((BLOCKS + EMPTY_BLOCKS) * 8192) DESC;
TOTAL DEFICIT EM CASO DE CRESCIMENTO DE 30%
SELECT SUM((((NUM_ROWS * AVG_ROW_LEN)*1.3) -
((BLOCKS + EMPTY_BLOCKS) * 8192))/1024) DEF
FROM DBA_TABLES
WHERE ((NUM_ROWS * AVG_ROW_LEN)*1.3) >
((BLOCKS + EMPTY_BLOCKS) * 8192)
AND OWNER = 'OWNER'
OBJETOS INVÁLIDOS
select
owner,
decode(object_type,null,'===========================>',object_type) as "OBJECT_TYPE",
count(object_type) as "TOTAL",
decode(grouping(owner),0,null,1,'Total de objectos invalidos.') as " "
from dba_objects where status <> 'VALID'
group by rollup (owner, object_type)
order by owner, object_type desc

TRABALHANDO COM DATAS

SELECT SYSDATE DATA_ATUAL,
ADD_MONTHS(SYSDATE,-1) MENOS_UM_MES,
ADD_MONTHS(SYSDATE,1) MAIS_UM_MES,
LAST_DAY(SYSDATE) ULTIMO_DIA_MES,
TRUNC(SYSDATE,'MONTH') PRIMEIRO_DIA_MES,
MONTHS_BETWEEN(SYSDATE,'01-JAN-2001') QTD_MES,
FLOOR(MONTHS_BETWEEN(SYSDATE,'01-JAN-2001')) ARREDONDA_ABAIXO,
CEIL(MONTHS_BETWEEN(SYSDATE,'01-JAN-2001')) ARREDONDA_ACIMA,
ABS(MONTHS_BETWEEN(SYSDATE,'01-JAN-2001')) VALOR_ABSOLUTO,
ROUND((MONTHS_BETWEEN(SYSDATE,'01-JAN-2001')),2) ARREDONDA,
TRUNC(SYSDATE,'year') PRIMEIRO_DIA_ANO,
to_char(SYSDATE,'dd " DE " FMMONTH " DE " YYYY','nls_date_language=portuguese') DIAMES_EXTENSO,
to_char(SYSDATE,'FMMONTH " DE " YYYY','nls_date_language=portuguese') MES_EXTENSO,
TO_CHAR(SYSDATE,'HH24:MI') HORA_MINUTO,
to_char(sysdate,'FMMonth','nls_date_language=portuguese') mes_corrente,
to_date(lpad(to_char(1234),4,'0'),'hh24mi') dias_data,
Floor(floor(months_between(SYSDATE,SYSDATE)) / 12) IDADE,
decode(TO_NUMBER(TO_CHAR(SYSDATE,'D')),2,'segunda-feira',3,'terça-feira',4,'quarta-feira',
5,'quinta-feira',6,'sexta-feira',7,'sabado',1,'domingo') dia_da_semana
FROM DUAL
Performance de instruções do banco de dados.
select a.username, a.sid, a.serial#, b.spid, c.buffer_gets, c.sorts, c.rows_processed,
to_char(a.logon_time,'DD-MM-RRRR HH24:MI:SS') as "HORARIO", c.address
from v$session a, v$process b, v$sqlarea c
where a.paddr=b.addr and a.sql_address=c.address and a.username is not null
order by c.buffer_gets desc;
Performance de instruções do banco de dados
SELECT a.username, a.sid, a.serial#, b.spid, c.buffer_gets, c.sorts, c.rows_processed,
to_char(a.logon_time,'DD-MM-RRRR HH24:MI:SS') as "HORARIO", c.address
FROM v$session a, v$process b, v$sqlarea c
WHERE a.paddr=b.addr AND a.sql_address=c.address AND a.username IS NOT NULL
ORDER BY c.buffer_gets DESC;
Estatisticas de Tabela
SELECT t.table_name AS "Table Name",
t.num_rows AS "Rows",
t.avg_row_len AS "Avg Row Len",
Trunc((t.blocks * p.value)/1024) AS "Size KB",
t.last_analyzed AS "Last Analyzed"
FROM dba_tables t,
v$parameter p
WHERE t.owner = Decode(Upper('&1'), 'ALL', t.owner, Upper('&1'))
AND p.name = 'db_block_size'
ORDER by t.table_name;
Status de um Indice
SET VERIFY OFF

SELECT table_name,
index_name,
monitoring
FROM v$object_usage
WHERE table_name = UPPER('&1')
AND index_name = DECODE(UPPER('&2'), 'ALL', index_name, UPPER('&2'));
Jobs que estão em execução
SET LINESIZE 500
SET PAGESIZE 1000
SET VERIFY OFF

SELECT a.job "Job",

a.sid,
a.failures "Falhas",
Substr(To_Char(a.last_date,'DD-Mon-YYYY HH24:MI:SS'),1,20) "Ultima Vez",
Substr(To_Char(a.this_date,'DD-Mon-YYYY HH24:MI:SS'),1,20) "Atualmente"
FROM dba_jobs_running a;

SET PAGESIZE 14
SET VERIFY ON
Instruções SQL que estão em andamento
SELECT s.sid,
s.status,
s.process,
s.schemaname,
s.osuser,
a.sql_text,
p.program
FROM v$session s,
v$sqlarea a,
v$process p
WHERE s.SQL_HASH_VALUE = a.HASH_VALUE
AND s.SQL_ADDRESS = a.ADDRESS
AND s.PADDR = p.ADDR
Ver as tabelas de um banco
SELECT table_name, tablespace_name, num_rows, avg_row_len, blocks, empty_blocks FROM dba_tables
WHERE owner = UPPER('&1') ORDER BY table_name;
Mostrar todos paramentros do Oracle
SELECT sp.sid,
sp.name,
sp.value,
sp.display_value
FROM v$spparameter sp
ORDER BY sp.name, sp.sid;
Dependências entre obnjetos
SELECT ad.referenced_name "Object", ad.name "Ref Object", ad.type "Type",
Substr(ad.referenced_owner,1,10) "Ref Owner", Substr(ad.referenced_link_name,1,20) "Ref Link Name"
FROM all_dependencies ad WHERE ad.referenced_name = Upper('&&1') AND ad.owner = Upper('&&2')
ORDER BY 1,2,3;
Ver Tamanho do Banco de Dados
SELECT 'Database Tamanho' "*****" ,ROUND(SUM(ROUND(SUM(NVL(fs.bytes/1024/1024,0)))) /
SUM(ROUND(SUM(NVL(fs.bytes/1024/1024,0))) + ROUND(df.bytes/1024/ 1024 -
SUM(NVL(fs.bytes/1024/1024,0)))) * 100, 0) "%Livre" ,ROUND(SUM(ROUND(df.bytes/1024/1024 -
SUM(NVL(fs.bytes/1024/ 1024,0)))) / SUM(ROUND(SUM(NVL(fs.bytes/1024/1024,0))) +
ROUND(df.bytes/1024/1024 - SUM(NVL(fs.bytes/1024/1024,0)))) * 100, 0) "%Usado"
,SUM(ROUND(SUM(NVL(fs.bytes/1024/1024,0)))) "Mb Livre" ,SUM(ROUND(df.bytes/1024/1024 -
SUM(NVL(fs.bytes/1024/1024,0)))) "Mb Usado" ,SUM(ROUND(SUM(NVL(fs.bytes/1024/1024,0))) +
ROUND(df.bytes/1024/ 1024 - SUM(NVL(fs.bytes/1024/1024,0)))) "Tamanho" FROM dba_free_space fs,
dba_data_files df WHERE fs.file_id(+) = df.file_id GROUP BY df.tablespace_name, df.file_id, df.bytes,
df.autoextensible ORDER BY df.file_id;
Pegando Constraints de uma Tabela
select DECODE(A.POSITION, 1, a.constraint_name ||' ('||C.TABLE_NAME||')' , NULL) CONST,
to_char(a.position) pos,
a.column_name,
b.search_condition
from user_cons_columns a, user_constraints b
, USER_CONSTRAINTS C
where b.table_name=upper('&vtabela')
and a.owner=b.owner
and a.table_name=b.table_name
and a.constraint_name=b.constraint_name
AND B.R_CONSTRAINT_NAME = C.CONSTRAINT_NAME(+)
order by decode(b.constraint_type,'P','A',b.constraint_type),
b.constraint_name,
a.position
Pegando constraints de uma tabela II
SELECT
'PAI' TIPO
, A.OWNER
, ( SELECT TABLE_NAME FROM ALL_CONSTRAINTS WHERE CONSTRAINT_NAME =
A.R_CONSTRAINT_NAME AND OWNER=A.R_OWNER) TABELA
, B.COLUMNS
, A.R_CONSTRAINT_NAME
FROM ALL_CONSTRAINTS A
, ( SELECT
A.OWNER
, A.TABLE_NAME
, A.CONSTRAINT_NAME
, MAX(DECODE(POSITION, 1, CNAME,NULL)) ||
MAX(DECODE(POSITION, 2,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION, 3,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION, 4,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION, 5,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION, 6,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION, 7,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION, 8,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION, 9,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION,10,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION,11,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION,12,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION,13,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION,14,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION,15,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION,16,', '||CNAME,NULL)) COLUMNS
FROM (SELECT OWNER,
SUBSTR(COLUMN_NAME,1,30) CNAME,
SUBSTR(TABLE_NAME,1,30) TABLE_NAME,
SUBSTR(CONSTRAINT_NAME,1,30) CONSTRAINT_NAME,
POSITION
FROM ALL_CONS_COLUMNS) A,
ALL_CONSTRAINTS B
WHERE A.CONSTRAINT_NAME = B.CONSTRAINT_NAME
AND A.OWNER = B.OWNER
AND B.CONSTRAINT_TYPE = 'R'
GROUP BY A.OWNER, A.TABLE_NAME, A.CONSTRAINT_NAME ) B
WHERE A.TABLE_NAME = upper('&TABELA')
AND A.OWNER = B.OWNER
AND A.CONSTRAINT_TYPE ='R'
AND A.CONSTRAINT_NAME = B.CONSTRAINT_NAME
UNION
SELECT
'FILHO' TIPO
, A.OWNER
, A.TABLE_NAME TABELA
, B.COLUMNS
, A.CONSTRAINT_NAME
FROM ALL_CONSTRAINTS A
, ( SELECT
A.OWNER
, A.TABLE_NAME
, A.CONSTRAINT_NAME,
MAX(DECODE(POSITION, 1, CNAME,NULL)) ||
MAX(DECODE(POSITION, 2,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION, 3,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION, 4,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION, 5,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION, 6,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION, 7,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION, 8,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION, 9,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION,10,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION,11,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION,12,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION,13,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION,14,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION,15,', '||CNAME,NULL)) ||
MAX(DECODE(POSITION,16,', '||CNAME,NULL)) COLUMNS
FROM (SELECT OWNER,
SUBSTR(COLUMN_NAME,1,30) CNAME,
SUBSTR(TABLE_NAME,1,30) TABLE_NAME,
SUBSTR(CONSTRAINT_NAME,1,30) CONSTRAINT_NAME,
POSITION
FROM ALL_CONS_COLUMNS) A,
ALL_CONSTRAINTS B
WHERE A.CONSTRAINT_NAME = B.CONSTRAINT_NAME
AND A.OWNER = B.OWNER
AND B.CONSTRAINT_TYPE = 'R'
GROUP BY A.OWNER, A.TABLE_NAME, A.CONSTRAINT_NAME ) B
WHERE A.R_CONSTRAINT_NAME IN (SELECT CONSTRAINT_NAME FROM ALL_CONSTRAINTS WHERE
TABLE_NAME = upper('&&TABELA')
AND CONSTRAINT_TYPE ='P')
AND A.CONSTRAINT_NAME = B.CONSTRAINT_NAME
AND A.OWNER = B.OWNER
ORDER BY TIPO DESC, TABELA, COLUMNS
OBJETOS POR USUÁRIOS
select
u.name,
sum(decode(o.type#, 3, objs)) cl,
sum(decode(o.type#, 2, objs)) OB_TABELAS,
sum(decode(o.type#, 1, objs)) OB_INDICES,
sum(decode(o.type#, 6, objs)) se,
sum(decode(o.type#, 12, objs)) tr,
sum(decode(o.type#, 8, objs)) fn,
sum(decode(o.type#, 7, objs)) pr,
sum(decode(o.type#, 9, objs)) pa,
sum(decode(o.type#, 4, objs)) OB_VIEWS,
sum(decode(o.type#, 5, objs)) sy,
sum(decode(o.type#, 1,0, 2,0, 3,0, 4,0, 5,0, 6,0, 7,0, 8,0, 9,0, 12,0, objs)) ot
from
(select owner#, type#, count(*) objs from sys.obj$ group by owner#, type#) o,
sys.user$ u
where
u.user# = o.owner#
group by u.name
order by
decode(u.name, 'SYS', 1, 'SYSTEM', 2, 'PUBLIC', 3, 4),
u.name

Processo trace de um determinado Usuário

EXECUTE DBMS_SYSTEM.SET_SQL_TRACE_IN_SESSION(SID,SERIAL#,TRUE);
 Arquivo contendo create controlfile no trace file

ALTER DATABASE BACKUP CONTROLFILE TO TRACE;

Atualizar estatísticas do schema

Para atualizar as estatísticas de todo um schema (tables, indexes e clusters) podemos executar o pacote
abaixo.

EXECUTE DBMS_UTILITY.ANALYZE_SCHEMA('','COMPUTE');

Combinar espaços de Tabelas (coalesce)

Para compilar os objetos de todo um schema (procedures, functions e packages) podemos executar o pacote
abaixo.

EXECUTE DBMS_UTILITY.COMPILE_SCHEMA('');

Contenção de Latch (Lock de Memória)

COL C1 FORMAT a25 HEADING 'Tipo de Latch'
COL C2 FORMAT 999.99999 HEADING 'Misses/Gets (%)'
COL C3 FORMAT 999.99999 HEADING 'Immediate Misses/Immediate Gets (%)'

SELECT N.NAME C1, MISSES*100/(gets+1) pct_miss C2, IMMEDIATE_MISSES*100/(immediate_gets+1) C3

FROM V$LATCHNAME N, V$LATCH L WHERE N.LATCH# = L.LATCH# AND N.NAME IN ('redo allocation','redo
copy');

Contenção do Redo Log Buffer

SELECT VALUE FROM V$SYSSTAT WHERE NAME = 'redo log space waittime';

DML's sendo executadas no momento

COL C1 FORMAT A10 HEADING 'Usuario'
COL C2 HEADING 'Texto SQL'
SELECT S.USERNAME C1, T.SQL_TEXT
FROM V$SESSION S, V$SQLTEXT T
WHERE S.SQL_ADDRESS = T.ADDRESS AND
S.SQL_HASH_VALUE = T.HASH_VALUE AND
S.USERNAME IS NOT NULL
ORDER BY S.USERNAME, S.PREV_SQL_ADDR,

S.PREV_HASH_VALUE, T.PIECE;

Efetuar "TRUNCATE TABLE" via procedure

CREATE OR REPLACE PROCEDURE TRUNCTAB
(N_TAB IN VARCHAR2) IS V_CURSOR INTEGER;
IGNORE INTEGER;
BEGIN V_CURSOR := DBMS_SQL.OPEN_CURSOR;
DBMS_SQL.PARSE(V_CURSOR,
'TRUNCATE TABLE 'N_TAB' REUSE STORAGE',DBMS_SQL.V7);
IGNORE := DBMS_SQL.EXECUTE(V_CURSOR);
DBMS_SQL.CLOSE_CURSOR(V_CURSOR);
END;
/

CREATE PUBLIC SYNONYM TRUNCTAB FOR TRUNCTAB;GRANT EXECUTE ON TRUNCTAB TO PUBLIC;

 Eficiência da Library Cache

SELECT ROUND(SUM(PINHITS)/SUM(PINS) * 100,2)FROM V$LIBRARYCACHE;

Eficiência da Sort Area

SELECT
ROUND((SUM(DECODE(NAME, 'sorts (memory)', VALUE, 0))/ (SUM(DECODE(NAME, 'sorts (memory)',
VALUE, 0))+ SUM(DECODE(NAME, 'sorts (disk)', VALUE, 0))))* 100,2) SORT

FROM V$SYSSTAT;

Eficiência do database buffer

SELECT ROUND((1-(PR.VALUE/ (BG.VALUE+CG.VALUE)))*100,2) DB_BUFFER
FROM V$SYSSTAT PR, V$SYSSTAT BG, V$SYSSTAT CG
WHERE PR.NAME = 'physical reads' AND
BG.NAME = 'db block gets' AND

CG.NAME = 'consistent gets';

Eficiência do Dictionary Cache

SELECT ROUND(SUM(GETS)/(SUM(GETS)+SUM(GETMISSES)) * 100,2) DICT FROM V$ROWCACHE;

Encolher o rollback segment

ALTER ROLLBACK SEGMENT RBS_05 SHRINK;
ncolher para 512 Kbytes

ALTER ROLLBACK SEGMENT RBS_05 SHRINK TO 512K;

Fixar Packages na Shared Pool (SQL Area)

Devido ao seu uso constante eu recomendo que ospackages abaixo estejam fixados na Shared Pool.Exemplo de
roteiro para ser disparado no Startup:
EXECUTE DBMS_SHARED_POOL.KEEP('DBMS_SHARED_POOL');
EXECUTE DBMS_SHARED_POOL.KEEP('DBMS_ALERT');EXECUTE DBMS_SHARED_POOL.KEEP('DBMS_DDL');
EXECUTE DBMS_SHARED_POOL.KEEP('DBMS_DESCRIBE');
EXECUTE DBMS_SHARED_POOL.KEEP('DBMS_LOCK');
EXECUTE DBMS_SHARED_POOL.KEEP('DBMS_OUTPUT');
EXECUTE DBMS_SHARED_POOL.KEEP('DBMS_PIPE');
EXECUTE DBMS_SHARED_POOL.KEEP('DBMS_SESSION');
EXECUTE DBMS_SHARED_POOL.KEEP('DBMS_STANDARD');
EXECUTE DBMS_SHARED_POOL.KEEP('DBMS_UTILITY');

EXECUTE DBMS_SHARED_POOL.KEEP('STANDARD');

Fragmentação nos datafiles

SELECT FILE_ID, SEGMENT_NAME, BLOCK_ID,
BLOCK_ID+BLOCKS NEXT, BLOCKS, BYTES
FROM DBA_EXTENTS
UNION
SELECT FILE_ID, 'FREE SPACE', BLOCK_ID,
BLOCK_ID+BLOCKS NEXT, BLOCKS, BYTES
FROM DBA_FREE_SPACE

ORDER BY 1, 3;
 Hora em que a instância do Oracle foi ativada
SELECT TO_CHAR(TO_DATE(D.VALUE,'J'),'MM/DD/YYYY.html')' '
TO_CHAR(TO_DATE(S.VALUE,'SSSSS'),'HH24:MI:SS') STARTUP_TIME
FROM V$INSTANCE D, V$INSTANCE S
WHERE D.KEY = 'STARTUP TIME - JULIAN' AND

S.KEY = 'STARTUP TIME - SECONDS';

Job's que estão em Execução

COL C1 FORMAT 99 HEADING 'Ses'
COL C2 FORMAT 999 HEADING 'Id'
COL C3 FORMAT A10 HEADING 'Submitter' TRUNC
COL C4 FORMAT A10 HEADING 'Security' TRUNC
COL C5 FORMAT A20 HEADING 'Job' WORD_WRAPPED
COL C6 FORMAT A5 HEADING 'LastOkDate'
COL C7 FORMAT A5 HEADING 'LastOkTime'
COL C8 FORMAT A5 HEADING 'ThisRunDate'
COL C9 FORMAT A5 HEADING 'ThisRunTime'
COL C10 FORMAT 99 HEADING 'Err'
SELECT A.SID C1,
A.JOB C2,
B.LOG_USER C3,
B.PRIV_USER C4,
B.WHAT C5,
to_char(A.LAST_DATE,'MM/DD.html') C6,
substr(A.LAST_SEC,1,5) C7,
to_char(A.THIS_DATE,'MM/DD.html') C8,
substr(A.THIS_SEC,1,5) C9,
A.FAILURES C10
FROM DBA_JOBS B, DBA_JOBS_RUNNING A

WHERE A.JOB = B.JOB;

Listagem de todas as Tabelas "V$"

SELECT KQFVINAM FROM X$KQFVI;

Objetos fragmentados canditatos a reconstrucao

COL C1 FORMAT A14
COL C2 FORMAT 999,999,999
BREACK ON OWNER ON TABLESPACE_NAME
SELECT OWNER, TABLESPACE_NAME, SEGMENT_NAME
decode(SEGMENT_TYPE,'TABLE','[T]', 'INDEX', '[I]',
'ROLLBACK','[R]', '[O]') segment_name
, sum(BYTES) C2,
decode(count(*),1,to_char(count(*)),
2,to_char(count(*)),
3,to_char(count(*)),
4,to_char(count(*)),
5,to_char(count(*)),
to_char(count(*))' <>
FROM DBA_EXTENTS
WHERE OWNER NOT IN ('SYS','SYSTEM','OWNER1')
GROUP BY OWNER, TABLESPACE_NAME, SEGMENT_NAME
decode(SEGMENT_TYPE,'TABLE','[T]', 'INDEX', '[I]',
'ROLLBACK','[R]', '[O]')

HAVING count(*) > 5;

Opções instaladas do banco

Para verificar as opções instaladas
no banco, digite:

SELECT * FROM V$OPTION;

 Opções que o Banco de Dados contempla
COL C1 FORMAT A35
COL C2 FORMAT A35
SELECT PARAMETER C1,
VALUE C2

FROM X$OPTION;

Pacotes que estão fixos em Memória

--- **NOTA: execute dbms_shared_pool.keep('nome');
COL C1 HEADING 'Owner'
COL C2 HEADING 'Tipo'
COL C3 HEADING 'Nome'
COL C4 HEADING 'Execucoes' FORMAT 999,999,999
COL C5 HEADING 'Memoria_Usada' FORMAT 999,999,999
SELECT substr(OWNER,1,10) C1,
substr(TYPE,1,12) C2,
substr(NAME,1,20) C3,
EXECUTIONS C4,
SHARABLE_MEM C5,
substr(KEPT' ',1,4) 'Fixo?'
FROM V$DB_OBJECT_CACHE
WHERE TYPE IN ('TRIGGER','PROCEDURE','PACKAGE BODY','PACKAGE')

ORDER BY C4 DESC;

Parâmetros de inicialização do Oracle

SELECT NAME, VALUE FROM V$PARAMETER ORDER BY NAME;

Parâmetros não documentados no INIT.ORA

SELECT KSPPINM
FROM X$KSPPI
WHERE SUBSTR(KSPPINM, 1, 1) = '_'

ORDER BY 1;

Porcentagem de Memória Livre na Shared Pool

SELECT ROUND((SUM(DECODE(NAME, 'free memory', BYTES, 0)) /
SUM(BYTES)) * 100,2) FREE_MEM

FROM V$SGASTAT;

Processo trace no SQL*Plus

Executar antes os arquivos UTLXPLAN.SQL e PLUSTRCE.SQL

SQL> SET AUTOTRACE ON

Processos do Oracle e Processos do SO

SELECT A.USERNAME, A.STATUS, B.USERNAME OS_USER,
B.SPID, A.SID, A.SERIAL#, A.MACHINE
FROM V$SESSION A, V$PROCESS B

WHERE A.PADDR = B.ADDR;

 Quantidade de objetos nas tablespaces
Para verificar a quantidade de objetos dos usuários nas tablespaces, podemos efetuar a DML abaixo:
BREAK ON TABLESPACE ON OWNER
COL C1 FORMAT A25 HEADING OBJETOS DADOS/INDICES
SELECT TABLESPACE_NAME, OWNER
COUNT(*) ' TABELAS' C1
FROM DBA_TABLES
GROUP BY TABLESPACE_NAME, OWNER
UNION
SELECT TABLESPACE_NAME, OWNER COUNT(*) ' INDICES' C1
FROM DBA_INDEXES

GROUP BY TABLESPACE_NAME, OWNER;

Reexecuções solicitadas no Pool compartilhado

COL C1 HEADING 'Objeto(pseudo-codigo)'
COL C2 FORMAT 999.999 HEADING 'Reloads'
COL C3 FORMAT 999.999 HEADING 'Invalidacoes'
SELECT NAMESPACE C1, RELOADS C2,
INVALIDATIONS C3

FROM V$LIBRARYCACHE;

Renovar as tabelas de Snapshot

Para renovar todas as tabelas de snapshot o pacote abaixo pode ser executado a qualquer momento no
siatema de destino.
EXECUTE DBMS_SNAPSHOT.REFRESH_ALL;
Para forcar a renovação de apenas uma tabela:

EXECUTE DBMS_SNAPSHOT.REFRESH('tabela','F'); /*forced refresh*/

Tornar um arquivo autoextend

ALTER DATABASE DATAFILE
'/u03/oradata/dsv01/tbs_dsv01_usr_dados_01.dbf'
AUTOEXTEND ON NEXT 10M MAXSIZE 500M;
ALTER DATABASE DATAFILE
'/u03/oradata/dsv01/tbs_dsv01_usr_dados_01.dbf'
AUTOEXTEND MAXSIZE UNLIMITED;
SELECT FILE#, MAXEXTEND*
, INC*

ROM SYS.FILEXT$;

Utilização do Database Buffer Cache

SELECT DECODE (STATE, 0, 'FREE',
1, 'READ AND MODIFIED',
2, 'READ AND NOT MODIFIED',
3, 'CURRENTLY BEING READ','OTHER') BUFFER,
COUNT(*) FROM X$BH GROUP BY DECODE (STATE, 0, 'FREE',
1, 'READ AND MODIFIED',
2, 'READ AND NOT MODIFIED',

3, 'CURRENTLY BEING READ','OTHER');

Versão do Banco
Para verificar a versão de seu bancode dados, digite:
SELECT * FROM V$VERSION;