Páginas

02 septiembre 2017

Batería de scripts útiles.


Algunas consultas SQL muy útiles para el administrador de Oracle (estado de la base de datos Oracle, parámetros generales, ficheros de control, conexiones actuales a Oracle, nombre del ejecutable que se utiliza, nombre del usuario, diccionario de datos, …)
Vista que muestra el estado de la base de datos:

Select * from v$instance;
Consulta que muestra si la base de datos está abierta
select status from v$instance;
Vista que muestra los parámetros generales de Oracle
select * from v$system_parameter;
Versión de Oracle
select value from v$system_parameter where name = 'compatible';
Ubicación y nombre del fichero spfile
select value from v$system_parameter where name = 'spfile';
Ubicación y número de ficheros de control
select value from v$system_parameter where name = 'control_files';
Nombre de la base de datos
select value from v$system_parameter where name = 'db_name';
Vista que muestra las conexiones actuales a Oracle Para visualizarla es necesario entrar con privilegios de administrador
select osuser, username, machine, program  order by osuser;
Vista que muestra el número de conexiones actuales a Oracle agrupado por aplicación que realiza la conexión
select program Aplication, count(program) Numero_Sesiones from v$session group by program order by Numero_Sesiones 
Vista que muestra los usuarios de Oracle conectados y el número de sesiones por usuario
select username Usuario_Oracle, count(username) Numero_Sesiones from v$session group by username order by Numero_Sesiones desc;
Propietarios de objetos y número de objetos por propietario
select owner, count(owner) Numero from dba_objects group by owner order by Numero desc 
Diccionario de datos (incluye todas las vistas y tablas de la Base de Datos)
select * from dictionary
select table_name from dictionary
Muestra los datos de una tabla especificada (en este caso todas las tablas que lleven la cadena "EMPLO"
select * from ALL_ALL_TABLES where upper(table_name) like '%EMPLO%' 
Tablas propiedad del usuario actual
select * from user_tables 
Todos los objetos propiedad del usuario conectado a Oracle
select * from user_catalog  
Consulta SQL para el DBA de Oracle que muestra los tablespaces, el espacio utilizado, el espacio libre y los ficheros de datos de los mismos:
select t.tablespace_name  "Tablespace",  t.status "Estado",                                                                                                                                                                                                                      
    ROUND(MAX(d.bytes)/1024/1024,2) "MB Tamaño",                                                                                                                                                                                                                                 
    ROUND((MAX(d.bytes)/1024/1024) -                                                                                                                                                                                                                                             
    (SUM(decode(f.bytes, NULL,0, f.bytes))/1024/1024),2) "MB Usados",                                                                                                                                                                                                            
    ROUND(SUM(decode(f.bytes, NULL,0, f.bytes))/1024/1024,2) "MB Libres",                                                                                                                                                                                                        
    t.pct_increase "% incremento",                                                                                                                                                                                                                                               
    SUBSTR(d.file_name,1,80) "Fichero de datos"                                                                                                                                                                                                                                  
FROM DBA_FREE_SPACE f, DBA_DATA_FILES d,  DBA_TABLESPACES t                                                                                                                                                                                                                      
WHERE t.tablespace_name = d.tablespace_name  AND                                                                                                                                                                                                                                 
    f.tablespace_name(+) = d.tablespace_name                                                                                                                                                                                                                                     
    AND f.file_id(+) = d.file_id GROUP BY t.tablespace_name,                                                                                                                                                                                                                     
    d.file_name,   t.pct_increase, t.status ORDER BY 1,3 DESC;  
Productos Oracle instalados y la versión:
select * from product_component_version 
Roles y privilegios por roles:
select * from role_sys_privs  
Reglas de integridad y columna a la que afectan:
select constraint_name, column_name from sys.all_cons_columns  
Tablas de las que es propietario un usuario, en este caso "HR":
select table_owner, table_name from sys.all_synonyms where table_owner like 'HR'
Otra forma más efectiva (tablas de las que es propietario un usuario):
select DISTINCT TABLE_NAME                                                                                                                                                                                                                                                       
FROM ALL_ALL_TABLES                                                                                                                                                                                                                                                              
WHERE OWNER LIKE 'HR' 
Parámetros de Oracle, valor actual y su descripción:
select v.name, v.value value, decode(ISSYS_MODIFIABLE, 'DEFERRED',                                                                                                                                                                                                               
     'TRUE', 'FALSE') ISSYS_MODIFIABLE,  decode(v.isDefault, 'TRUE', 'YES',                                                                                                                                                                                                      
     'FALSE', 'NO') "DEFAULT",  DECODE(ISSES_MODIFIABLE,  'IMMEDIATE',                                                                                                                                                                                                           
     'YES','FALSE',  'NO',  'DEFERRED', 'NO', 'YES') SES_MODIFIABLE,                                                                                                                                                                                                             
     DECODE(ISSYS_MODIFIABLE, 'IMMEDIATE', 'YES',  'FALSE', 'NO',                                                                                                                                                                                                                
     'DEFERRED', 'YES','YES') SYS_MODIFIABLE ,  v.description                                                                                                                                                                                                                    
FROM V$PARAMETER v                                                                                                                                                                                                                                                               
WHERE name not like 'nls%'   ORDER BY 1
Usuarios de Oracle y todos sus datos (fecha de creación, estado, id, nombre, tablespace temporal,...):
select  * FROM dba_users
Tablespaces y propietarios de los mismos:
select owner, decode(partition_name, null, segment_name,                                                                                                                                                                                                                         
   segment_name || ':' || partition_name) name,                                                                                                                                                                                                                                  
   segment_type, tablespace_name,bytes,initial_extent,                                                                                                                                                                                                                           
   next_extent, PCT_INCREASE, extents, max_extents                                                                                                                                                                                                                               
from dba_segments                                                                                                                                                                                                                                                                
Where 1=1 And extents > 1 order by 9 desc, 3 
Últimas consultas SQL ejecutadas en Oracle y usuario que las ejecutó:
select distinct vs.sql_text, vs.sharable_mem,                                                                                                                                                                                                                                    
  vs.persistent_mem, vs.runtime_mem,  vs.sorts,                                                                                                                                                                                                                                  
  vs.executions, vs.parse_calls, vs.module,                                                                                                                                                                                                                                      
  vs.buffer_gets, vs.disk_reads, vs.version_count,                                                                                                                                                                                                                               
  vs.users_opening, vs.loads,                                                                                                                                                                                                                                                    
  to_char(to_date(vs.first_load_time,                                                                                                                                                                                                                                            
  'YYYY-MM-DD/HH24:MI:SS'),'MM/DD  HH24:MI:SS') first_load_time,                                                                                                                                                                                                                 
  rawtohex(vs.address) address, vs.hash_value hash_value ,                                                                                                                                                                                                                       
  rows_processed  , vs.command_type, vs.parsing_user_id  ,                                                                                                                                                                                                                       
  OPTIMIZER_MODE  , au.USERNAME parseuser                                                                                                                                                                                                                                        
from v$sqlarea vs , all_users au                                                                                                                                                                                                                                                 
where (parsing_user_id != 0)  AND                                                                                                                                                                                                                                                
(au.user_id(+)=vs.parsing_user_id)                                                                                                                                                                                                                                               
and (executions >= 1) order by   buffer_gets/executions desc  
Todos los ficheros de datos y su ubicación:
select * from V$DATAFILE   
Ficheros temporales:
select * from V$TEMPFILE  
Tablespaces:
select * from V$TABLESPACE  
Otras vistas muy interesantes:
select * from V$BACKUP; 
select * from V$ARCHIVE; 
select * from V$LOG;   
select * from V$LOGFILE;
select * from V$LOGHIST; 
select * from V$ARCHIVED_LOG; 
select * from V$DATABASE; 
Memoria Share_Pool libre y usada
select name,to_number(value) bytes                                                                                                                                                                                                                                               
from v$parameter where name ='shared_pool_size'                                                                                                                                                                                                                                  
union all                                                                                                                                                                                                                                                                        
select name,bytes                                                                                                                                                                                                                                                                
from v$sgastat where pool = 'shared pool' and name = 'free memory'   
Cursores abiertos por usuario
select b.sid, a.username, b.value Cursores_Abiertos                                                                                                                                                                                                                              
      from v$session a,                                                                                                                                                                                                                                                          
           v$sesstat b,                                                                                                                                                                                                                                                          
           v$statname c                                                                                                                                                                                                                                                          
      where c.name in ('opened cursors current')                                                                                                                                                                                                                                 
      and   b.statistic# = c.statistic#                                                                                                                                                                                                                                          
      and   a.sid = b.sid                                                                                                                                                                                                                                                        
      and   a.username is not null                                                                                                                                                                                                                                               
      and   b.value >0                                                                                                                                                                                                                                                           
      order by 3 
Aciertos de la caché (no debe superar el 1 por ciento)
select sum(pins) Ejecuciones, sum(reloads) Fallos_cache,                                                                                                                                                                                                                         
trunc(sum(reloads)/sum(pins)*100,2) Porcentaje_aciertos                                                                                                                                                                                                                          
from v$librarycache                                                                                                                                                                                                                                                              
where namespace in ('TABLE/PROCEDURE','SQL AREA','BODY','TRIGGER');  
Sentencias SQL completas ejecutadas con un texto determinado en el SQL
select c.sid, d.piece, c.serial#, c.username, d.sql_text                                                                                                                                                                                                                         
FROM v$session c, v$sqltext d                                                                                                                                                                                                                                                    
WHERE  c.sql_hash_value = d.hash_value                                                                                                                                                                                                                                           
and upper(d.sql_text) like '%WHERE CAMPO LIKE%'                                                                                                                                                                                                                                  
ORDER BY c.sid, d.piece   
Una sentencia SQL concreta (filtrado por sid)
select c.sid, d.piece, c.serial#, c.username, d.sql_text                                                                                                                                                                                                                         
FROM v$session c, v$sqltext d                                                                                                                                                                                                                                                    
WHERE  c.sql_hash_value = d.hash_value                                                                                                                                                                                                                                           
and sid = 105                                                                                                                                                                                                                                                                    
ORDER BY c.sid, d.piece                                                                                                                                                                                                                                                          
Tamaño ocupado por la base de datos  
select sum(BYTES)/1024/1024 MB from DBA_EXTENTS
Tamaño de los ficheros de datos de la base de datos
select sum(bytes)/1024/1024 MB from dba_data_files
Tamaño ocupado por una tabla concreta sin incluir los índices de la misma
select sum(bytes)/1024/1024 MB from user_segments                                                                                                                                                                                                                               
 where segment_type='TABLE' and segment_name='NOMBRETABLA' 
Tamaño ocupado por una tabla concreta incluyendo los índices de la misma
select sum(bytes)/1024/1024 Table_Allocation_MB from user_segments                                                                                                                                                                                                               
 where segment_type in ('TABLE','INDEX') and                                                                                                                                                                                                                                     
(segment_name='NOMBRETABLA' or segment_name in                                                                                                                                                                                                                                   
select index_name from user_indexes where table_name='NOMBRETABLA')) 
Tamaño ocupado por una columna de una tabla
select sum(vsize('NOMBRECOLUMNA'))/1024/1024 MB from NOMBRETABLA 
Espacio ocupado por usuario
select owner, SUM(BYTES)/1024/1024 FROM DBA_EXTENTS MB group by owner; 
Espacio ocupado por los diferentes segmentos (tablas, índices, undo, rollback, cluster, ...)
select SEGMENT_TYPE, SUM(BYTES)/1024/1024 FROM DBA_EXTENTS MB                                                                                                                                                                                                                    
group by SEGMENT_TYPE 
Espacio ocupado por todos los objetos de la base de datos, muestra los objetos que más ocupan primero
select SEGMENT_NAME, SUM(BYTES)/1024/1024 FROM DBA_EXTENTS MB                                                                                                                                                                                                                    
group by SEGMENT_NAME                                                                                                                                                                                                                                                            
order by 2 desc  
Obtener todas las funciones de Oracle: NVL, ABS, LTRIM, ...
select distinct object_name                                                                                                                                                                                                                                                      
FROM all_arguments                                                                                                                                                                                                                                                               
WHERE package_name = 'STANDARD'  
order by object_name





No hay comentarios:

Publicar un comentario

Por favor deja tu comentario, es valioso.