Esta es una compilación de tareas que un
administrador de base de datos ha de ejecutar
de forma diaria, semanal, mensual y otras sin un periodo definido.
Actividad diaria
En esta entrada nos centraremos en las tareas diarias.
Comprueba si la instancia Oracle está funcionando o no.
1. Sistema operativo Windows:
mirar el programa services.msc
2. Sistema operativo Unix: ps -ef | grep pmon
3. SQL: SQL> select status from v$instance;
Comprueba si los listeners
Oracle están funcionando o no
Para que desde fuera del
servidor donde está instalada la base de datos Oracle se pueda acceder a la
misma el servicio denominado listener ha de estar activado, o
como se suele decir, el listener de
Oracle ha de estar escuchando.
Puede pasar que la base
de datos esté correctamente levantada y no se pueda conectar desde otros
servidores, que también están correctamente configurados (TNSNAMES correcto,
etc.). En estos casos puede ser que el listener
tenga algún problema, o simplemente que no haya sido iniciado. En ese caso tan
sólo habría que arrancar el listener.
Consultar el estado del
mismo, arrancarlo o pararlo es muy sencillo. Sólo hay que abrir una sesión de
línea de comandos (consola, terminal, etc. ) con el usuario con el que se ha
instalado la base de datos, y ejecutar el comando lsnrctl con
los siguientes parámetros para cada caso:
·
Comprobar su estado: > lsnrctl status
·
Parar el listener: >
lsnrctl stop
·
Levantar el listener: > lsnrctl start
Comprueba si hay sesiones que bloquean otras sesiones
En Oracle hay una vista v$lock que nos indica los objetos que
se encuentran en bloqueo, el identificador de usuario y sesión y el tipo de
bloqueo.
Una “join” con la tabla
dba_objects nos proporciona además el nombre y tipo de los objetos bloqueados:
Existen principalmente
dos tipos de bloqueo:
·
Bloqueos de tablas (TM)
·
Bloqueos a nivel de fila (TX)
Los bloqueos a nivel de tabla son creados
cuando se ejecuta una sentencia DML del tipo: update, insert, delete, select
..for update sobre la tabla entera.
Los bloqueos a nivel de
fila se crean cuando se ejecutan sentencias DML contra un conjunto de registros
específicos.
Una consulta sobre esta vista nos permite rápidamente
saber que procesos están bloqueados y si además hacemos un join con v$open_cursor podemos
ver que consulta es la que se encuentra parada a la espera de que se produzca
el desbloqueo para poder ejecutarse. En la consulta siguiente podemos ver las
sentencias paradas y el id de proceso que las está bloqueando.
Esta consulta permite
ver los objetos que están esperando a que termine un bloqueo y la sentencia que
quieren ejecutar. el id de proceso nos da la pista de quien esta bloqueando:
select /*+ ordered
no_merge(L_WAITER)
no_merge(L_LOCKER) use_hash(L_LOCKER)
no_merge(S_WAITER) use_hash(S_WAITER)
no_merge(S_LOCKER) use_hash(S_LOCKER)
use_nl(O)
use_nl(U)
*/
/* first the table-level locks (TM) and mixed TM/TX TX/TM */
S_LOCKER.OSUSER OS_LOCKER,
S_LOCKER.USERNAME LOCKER_SCHEMA,
S_LOCKER.PROCESS LOCKER_PID,
S_WAITER.OSUSER OS_WAITER,
S_WAITER.USERNAME WAITER_SCHEMA,
S_WAITER.PROCESS WAITER_PID,
'Table lock (TM): '||U.NAME||'.'||O.NAME||
' - Mode held: '||
decode(L_LOCKER.LMODE,
0, 'None', /* same as Monitor */
1, 'Null', /* N */
2, 'Row-S (SS)', /* L */
3, 'Row-X (SX)', /* R */
4, 'Share', /* S */
5, 'S/Row-X (SSX)', /* C */
6, 'Exclusive', /* X */
'???: '||to_char(L_LOCKER.LMODE))||
' / Mode requested: '||
decode(L_WAITER.REQUEST,
0, 'None', /* same as Monitor */
1, 'Null', /* N */
2, 'Row-S (SS)', /* L */
3, 'Row-X (SX)', /* R */
4, 'Share', /* S */
5, 'S/Row-X (SSX)', /* C */
6, 'Exclusive', /* X */
'???: '||to_char(L_WAITER.REQUEST))
SQL_TEXT_WAITER
from
V$LOCK L_WAITER,
V$LOCK L_LOCKER,
V$SESSION S_WAITER,
V$SESSION S_LOCKER,
sys.OBJ$ O,
sys.USER$ U
where S_WAITER.SID = L_WAITER.SID
and L_WAITER.TYPE IN ('TM')
and S_LOCKER.sid = L_LOCKER.sid
and L_LOCKER.ID1 = L_WAITER.ID1
and L_WAITER.REQUEST > 0
and L_LOCKER.LMODE > 0
and L_WAITER.ADDR != L_LOCKER.ADDR
and L_WAITER.ID1 = O.OBJ#
and U.USER# = O.OWNER#
union
select /*+ ordered
no_merge(L_WAITER)
no_merge(L_LOCKER) use_hash(L_LOCKER)
no_merge(S_WAITER) use_hash(S_WAITER)
no_merge(S_LOCKER) use_hash(S_LOCKER)
no_merge(L1_WAITER) use_hash(L1_WAITER)
no_merge(O) use_hash(O)
*/
/* now the (usual) row-locks TX */
S_LOCKER.OSUSER OS_LOCKER,
S_LOCKER.USERNAME LOCKER_SCHEMA,
S_LOCKER.PROCESS LOCK_PID,
S_WAITER.OSUSER OS_WAITER,
S_WAITER.USERNAME WAITER_SCHEMA,
S_WAITER.PROCESS WAITER_PID,
'TX: '||O.SQL_TEXT SQL_TEXT_WAITER
from
V$LOCK L_WAITER,
V$LOCK L_LOCKER,
V$SESSION S_WAITER,
V$SESSION S_LOCKER,
V$_LOCK L1_WAITER,
V$OPEN_CURSOR O
where S_WAITER.SID = L_WAITER.SID
and L_WAITER.TYPE IN ('TX')
and S_LOCKER.sid = L_LOCKER.sid
and L_LOCKER.ID1 = L_WAITER.ID1
and L_WAITER.REQUEST > 0
and L_LOCKER.LMODE > 0
and L_WAITER.ADDR != L_LOCKER.ADDR
and L1_WAITER.LADDR = L_WAITER.ADDR
and L1_WAITER.KADDR = L_WAITER.KADDR
and L1_WAITER.SADDR = O.SADDR
and O.HASH_VALUE = S_WAITER.SQL_HASH_VALUE
Comprueba el “alert log” si hay errores
El registro de alertas
es un registro cronológico de mensajes y errores, e incluye los siguientes
elementos:
- Todos los errores
internos (ORA-600),
- Errores de corrupción de
bloques (ORA-1578)
- Errores de bloqueo
(ORA-60)
- Operaciones
administrativas, como sentencias CREATE, ALTER y DROP y instrucciones STARTUP,
SHUTDOWN y ARCHIVELOG.
- Mensajes y errores
relacionados con las funciones de los procesos de servidor compartido y
despachador.
- Errores que ocurren
durante la actualización automática de una vista materializada.
- Los valores de todos los
parámetros de inicialización que tenían valores no predeterminados al iniciarse
la base de datos y la instancia.
Los archivos de seguimiento se escriben en nombre de los procesos del servidor siempre que se produzcan errores críticos. Además, al establecer el parámetro de inicialización SQL_TRACE = TRUE, el recurso de rastreo SQL genera estadísticas de rendimiento para el procesamiento de todas las sentencias SQL de una instancia y las escribe en el repositorio de diagnóstico automático.
Opcionalmente, puede solicitar que se generen archivos de seguimiento para los procesos del servidor. Independientemente del valor actual del parámetro de inicialización SQL_TRACE, cada sesión puede habilitar o deshabilitar el registro de trazas en nombre del proceso del servidor asociado mediante la instrucción SQL ALTER SESSION SET SQL_TRACE.
Este ejemplo habilita el recurso de rastreo de SQL para una sesión específica:
ALTER SESSION SET SQL_TRACE TRUE;
Puede ver y cambiar las configuraciones de umbral para las métricas de alertas del servidor mediante los procedimientos SET_THRESHOLD y GET_THRESHOLD del paquete de PL / SQL, DBMS_SERVER_ALERTS.
SELECT
metrics_name,
warning_value,
critical_value,
consecutive_occurrences
FROM
dba_thresholds
WHERE
metrics_name LIKE '%CPU Time%';
Vista
|
Descripción
|
DBA_THRESHOLDS
|
Enumera los valores de umbral definidos para la instancia
|
DBA_OUTSTANDING_ALERTS
|
Describe las alertas pendientes de la base de datos
|
DBA_ALERT_HISTORY
|
Enumera un historial de alertas que se han borrado
|
V$ALERT_TYPES
|
Proporciona información como grupo y tipo para cada alerta
|
V$METRICNAME
|
Contiene los nombres, identificadores y otra información sobre las
métricas del sistema
|
V$METRIC
|
Contiene valores de métrica a nivel de sistema
|
V$METRIC_HISTORY
|
Contiene un historial de valores de métrica a nivel de sistema
|
Utilice los paquetes DBMS_SESSION o DBMS_MONITOR si desea controlar el seguimiento de SQL para una sesión.
El paquete DBMS_MONITOR
le permite utilizar PL / SQL para controlar el rastreo adicional y la
recopilación de estadísticas.
Proceso PLSQL
|
Descripción
|
CLIENT_ID_STAT_DISABLE
|
Inhabilita la recopilación estadística habilitada previamente para un
identificador de cliente determinado
|
CLIENT_ID_STAT_ENABLE
|
Permite la recopilación estadística de un determinado identificador de
cliente
|
CLIENT_ID_TRACE_DISABLE
|
Deshabilita la traza activada previamente para un identificador de cliente
determinado globalmente para la base de datos
|
CLIENT_ID_TRACE_ENABLE
|
Habilita la traza de un identificador de cliente determinado globalmente
para la base de datos
|
DATABASE_TRACE_DISABLE
|
Deshabilita la traza de SQL para toda la base de datos o una instancia
específica
|
DATABASE_TRACE_ENABLE
|
Habilita la traza de SQL para toda la base de datos o una instancia
específica
|
SERV_MOD_ACT_STAT_DISABLE
|
Inhabilita la recopilación estadística activada para una combinación dada
de Nombre del servicio, MÓDULO y ACCIÓN
|
SERV_MOD_ACT_STAT_ENABLE
|
Permite la recopilación de estadísticas para una combinación dada de
Nombre del servicio, MÓDULO y ACCIÓN
|
SERV_MOD_ACT_TRACE_DISABLE
|
Deshabilita la traza para TODAS las instancias habilitadas para una
combinación o una combinación dada de Nombre de servicio, MÓDULO y ACCIÓN
nombre globalmente
|
SERV_MOD_ACT_TRACE_ENABLE
|
Habilita el rastreo de SQL para una combinación dada de Nombre de
servicio, MÓDULO y ACCIÓN globalmente a menos que se especifique un
nombre_instancia
|
SESSION_TRACE_DISABLE
|
Deshabilita la traza previamente habilitada para un identificador de
sesión de base de datos (SID) en la instancia local
|
SESSION_TRACE_ENABLE
|
Habilita la traza de un identificador de sesión de base de datos (SID) en
la instancia local
|
Comprueba si hay dbms jobs ejecutándose y comprueba los estados del mismo.
ORACLE ofrece una cola
para planificar operaciones rutinarias en una base de datos. La funcionalidad
de los Jobs de Oracle es parecida al cron de UNIX en el cual se puede
planificar una tarea, a una determinada hora y con una periodicidad concreta
pero en base de datos.
El paquete encargado de
hacer esta planificación es DBMS_JOB.
Para que cualquier Job
de Oracle se pueda ejecutar tenemos que tener en cuenta el parámetro
job_queue_processes no esté a cero, ya que es el que nos indica el número de
colas que gestionarán nuestros jobs. Este parámetro debe de ser mayor del
número de jobs que se desee ejecutar de forma simultánea (el máximo es 1000
para Oracle).
Las vistas que podemos
usar para manejar los jobs son:
- DBA_JOBS: Muestra la
información de todos los jobs de la base de datos.
- ALL_JOBS: Muestra la misma información que dba_jobs pero sólo los jobs a los
cuales puede acceder el usuario actual con el que se está realizando la
consulta.
Para consultar todos los jobs:
select * from all_scheduler_jobs;
Consultar log de ejecución de jobs:
select * from all_scheduler_job_log order by log_date desc;
Consultar los jobs que están en ejecución:
select * from all_scheduler_running_jobs;
Detener un job:
exec dbms_scheduler.stop_jop('USER.JOB');
Se puede forzar la parada de un job ejecutando la siguiente query como usuario system:
exec dbms_scheduler.stop_job('USER.JOB', true);
Deshabilitar un Job:
exec dbms_scheduler.disable('USER.JOB');
Se puede forzar la deshabilitación de un job ejecutando la siguiente query como system:
exec dbms_scheduler.disable('USER.JOB', true);
Habilitar un Job:
exec dbms_scheduler.enable('USER.JOB');
Arrancar un Job:
exec dbms_scheduler.run_job('USER.JOB');
