Pasando a otras cosas… ultimamente he estado usando mas SQL Developer y deje de utilizar TOAD por completo. Aunque hay muchisimas cosas que TOAD hace y que SQLD no las tiene o las hace muy mal, puedo decir que gran parte de las tareas que hago las puedo realizar con SQLD. Estuve moviendole un poco y cree unos reportes y “plugins” que me han sido muy utiles asi que quiero compartirlos por si les sirven a alguien.

Pueden bajarlos y modificarlos a su gusto, no es necesario ningun link ni agradecimiento ni nada, son gratis y cada quien los puede usar como quiera; y por tal razon no me hago resposable si algo pasa con sus bases de datos, no que fallen o hagan algo mal al contrario funcionan muy bien.

Todos los scripts estan probados en la version de SQL Developer 1.5.5, los reportes funcionan en la version 2.1 pero los plugins fallan, al parecer hay un bug en las nuevas versiones que no deja que los plugins funcionen bien, lo reporte en el foro de discusion pero no han arreglado eso asi que para que todo funcione utilicen la version 1.5.5.

LOG SWITCHES

Este reporte muestra los log switchs de la base de datos durante el dia por cada dia en la parte superior del reporte, si le dan click a un registro de la parte superior mostrara el detalle en la parte inferior todos los switches de ese dia y mostrara cuanto tiempo transcurrio de un log switch a otro.

DOWNLOAD LOG SWITCH

SESSION BROWSER

Este es un reporte donde se pueden ver las sesiones conectadas a la BD y muchisimos detalles sobre estas. No voy a detallar que es lo que hacen todas las opciones pero se puede ver informacion como: current wait, current sql, long operations,etc…

Es muy util para identificar problemas con una sesion en especifico.

DOWNLOAD SESSION BROWSER

TABLESPACE INFO

Permite ver la utilización de espacio de los tablespaces de la base de datos, en la parte inferior se mostrara el detalle de los datafiles del tablespace seleccionado.

DOWNLOAD TABLESPACE INFO

En el siguiente post voy a poner algunos editores y navegadores de SQL Developer…

Hasta las proxima.

Saludos y gracias por seguir leyendo.

Pero no hay nada mejor que un ejemplo para mostrar como funciona…

Primero creamos una tabla para nuestras pruebas

SQL> create table t as select * from dba_objects;

Table created.

Contamos los registros y verificamos que no hay estadisticas

SQL> select count(*) from t;

COUNT(*)
----------
49779

SQL> select table_name, num_rows, blocks, avg_space, avg_row_len, last_analyzed
2  from user_tables;

TABLE   NUM_ROWS     BLOCKS  AVG_SPACE AVG_ROW_LEN LAST_ANAL
----- ---------- ---------- ---------- ----------- ---------
T

SQL>exec dbms_stats.gather_table_stats(user,'T');

PL/SQL procedure successfully completed.

SQL>select table_name,num_rows,blocks,avg_space,avg_row_len,last_analyzed
2  from user_tables;

TABLE   NUM_ROWS     BLOCKS  AVG_SPACE AVG_ROW_LEN LAST_ANAL
----- ---------- ---------- ---------- ----------- ---------
T          49779        704          0          93 26-AUG-09

SQL>select table_name,stats_update_time
2  from dba_tab_stats_history
3  where owner=user;

TABLE STATS_UPDATE_TIME
----- ---------------------------------------------------------------------------
T     26-AUG-09 06.51.01.496224 AM -04:00

SQL>insert into t select * from dba_objects;
49778 rows created.
SQL> /
49778 rows created.
SQL> /
49778 rows created.
SQL> commit;
Commit complete.

SQL>select count(*) from t;

COUNT(*)
----------
199113

SQL>select table_name,num_rows,blocks,avg_space,avg_row_len,last_analyzed
2  from user_tables;

TABLE   NUM_ROWS     BLOCKS  AVG_SPACE AVG_ROW_LEN LAST_ANAL
----- ---------- ---------- ---------- ----------- ---------
T          49779        704          0          93 26-AUG-09

SQL>exec dbms_stats.gather_table_stats(user,'T');

PL/SQL procedure successfully completed.
SQL> select table_name,num_rows,blocks,avg_space,avg_row_len,last_analyzed
2  from user_tables;

TABLE   NUM_ROWS     BLOCKS  AVG_SPACE AVG_ROW_LEN LAST_ANAL
----- ---------- ---------- ---------- ----------- ---------
T         199113       2784          0          93 26-AUG-09

SQL> select table_name,stats_update_time
2  from dba_tab_stats_history
3  where owner=user;

TABLE STATS_UPDATE_TIME
----- ---------------------------------------------------------------------------
T     26-AUG-09 06.51.01.496224 AM -04:00
T     26-AUG-09 07.01.01.161096 AM -04:00

SQL>insert into t select * from dba_objects;
49778 rows created.
SQL> /
49778 rows created.
SQL> select count(*) from t;

COUNT(*)
----------
298669

SQL>select table_name,num_rows,blocks,avg_space,avg_row_len,last_analyzed
2  from user_tables;

TABLE   NUM_ROWS     BLOCKS  AVG_SPACE AVG_ROW_LEN LAST_ANAL
----- ---------- ---------- ---------- ----------- ---------
T         199113       2784          0          93 26-AUG-09

SQL> exec dbms_stats.gather_table_stats(user,'T');

PL/SQL procedure successfully completed.

SQL> l
1  select table_name,num_rows,blocks,avg_space,avg_row_len,last_analyzed
2* from user_tables
SQL> /

TABLE   NUM_ROWS     BLOCKS  AVG_SPACE AVG_ROW_LEN LAST_ANAL
----- ---------- ---------- ---------- ----------- ---------
T         298002       4170          0          93 26-AUG-09

SQL> select table_name,stats_update_time
2  from dba_tab_stats_history
3  where owner=user;

TABLE  STATS_UPDATE_TIME
-----  ---------------------------------------------------------------------------
T      26-AUG-09 06.51.01.496224 AM -04:00
T      26-AUG-09 07.01.01.161096 AM -04:00
T      26-AUG-09 07.04.17.929191 AM -04:00

SQL> exec dbms_stats.restore_table_stats(user,'T','26-AUG-09 07.01.01.161096 AM -04:00');

PL/SQL procedure successfully completed.
SQL> select table_name,num_rows,blocks,avg_space,avg_row_len,last_analyzed
2  from user_tables;

TABLE   NUM_ROWS     BLOCKS  AVG_SPACE AVG_ROW_LEN LAST_ANAL
----- ---------- ---------- ---------- ----------- ---------
T         199113       2784          0          93 26-AUG-09

SQL> select table_name,stats_update_time
2  from dba_tab_stats_history
3  where owner = user;

TABLE  STATS_UPDATE_TIME
-----  ---------------------------------------------------------------------------
T      26-AUG-09 06.51.01.496224 AM -04:00
T      26-AUG-09 07.01.01.161096 AM -04:00
T      26-AUG-09 07.04.17.929191 AM -04:00

TABLE  STATS_UPDATE_TIME
-----  ---------------------------------------------------------------------------
T      26-AUG-09 07.06.50.924803 AM -04:00

SQL> exec dbms_stats.restore_table_stats(user,'T','26-AUG-09 06.51.01.496224 AM -04:00');

PL/SQL procedure successfully completed.
SQL> select table_name,num_rows,blocks,avg_space,avg_row_len,last_analyzed
2  from user_tables;

TABLE   NUM_ROWS     BLOCKS  AVG_SPACE AVG_ROW_LEN LAST_ANAL
----- ---------- ---------- ---------- ----------- ---------
T          49779        704          0          93 26-AUG-09

SQL> select count(*) from t;

COUNT(*)
----------
298669

SQL> select table_name,stats_update_time
2  from dba_tab_stats_history
3  where owner = user;

TABLE  STATS_UPDATE_TIME
-----  ---------------------------------------------------------------------------
T      26-AUG-09 06.51.01.496224 AM -04:00
T      26-AUG-09 07.01.01.161096 AM -04:00
T      26-AUG-09 07.04.17.929191 AM -04:00
T      26-AUG-09 07.06.50.924803 AM -04:00
T      26-AUG-09 07.10.30.136210 AM -04:00

Al borrar el historico de las estadisticas obviamente limpia la vista que contiene los registros historicos y no se pueden recuperar.

SQL> exec dbms_stats.purge_stats(systimestamp);

PL/SQL procedure successfully completed.

SQL> select table_name,stats_update_time
2  from dba_tab_stats_history
3  where owner=user;

no rows selected<

SQL> drop table t;

Table dropped.

SQL> create table t as select * from dba_objects;

Table created.
SQL> create table d as select * from dba_objects;

Table created.
SQL> exec dbms_stats.gather_Schema_stats(user);

PL/SQL procedure successfully completed.

SQL> select table_name,num_rows,blocks,avg_space,avg_row_len,last_analyzed
2  from user_tables;

TABLE   NUM_ROWS     BLOCKS  AVG_SPACE AVG_ROW_LEN LAST_ANAL
----- ---------- ---------- ---------- ----------- ---------
T          49779        704          0          93 26-AUG-09
D          49779        704          0          93 26-AUG-09

SQL> insert into t select * from dba_objects;
49779 rows created.
SQL> /
49779 rows created.
SQL> insert into d select * from dba_objects;
49779 rows created.
SQL> /
49779 rows created.
SQL> /
49779 rows created.
SQL> exec dbms_stats.gather_Schema_stats(user);
PL/SQL procedure successfully completed.

SQL> select table_name,num_rows,blocks,avg_space,avg_row_len,last_analyzed
2  from user_tables;

TABLE   NUM_ROWS     BLOCKS  AVG_SPACE AVG_ROW_LEN LAST_ANAL
----- ---------- ---------- ---------- ----------- ---------
T         149337       2090          0          93 26-AUG-09
D         199116       2784          0          93 26-AUG-09

SQL> select table_name,stats_update_time
2  from dba_tab_stats_history
3  where owner=user;

TABLE  STATS_UPDATE_TIME
-----  ---------------------------------------------------------------------------
D      26-AUG-09 07.18.00.582750 AM -04:00
T      26-AUG-09 07.18.01.161388 AM -04:00
D      26-AUG-09 07.17.06.242711 AM -04:00
T      26-AUG-09 07.17.06.781828 AM -04:00

SQL> exec dbms_stats.restore_schema_stats(user,'26-AUG-09 07.18.00.582750 AM -04:00');

PL/SQL procedure successfully completed.

SQL> select table_name,num_rows,blocks,avg_space,avg_row_len,last_analyzed
2  from user_tables;

TABLE   NUM_ROWS     BLOCKS  AVG_SPACE AVG_ROW_LEN LAST_ANAL
----- ---------- ---------- ---------- ----------- ---------
T          49779        704          0          93 26-AUG-09
D         199116       2784          0          93 26-AUG-09

SQL> exec dbms_stats.restore_schema_stats(user,'26-AUG-09 07.18.01.161388 AM -04:00');

PL/SQL procedure successfully completed.

SQL> select table_name,num_rows,blocks,avg_space,avg_row_len,last_analyzed
2  from user_tables;

TABLE   NUM_ROWS     BLOCKS  AVG_SPACE AVG_ROW_LEN LAST_ANAL
----- ---------- ---------- ---------- ----------- ---------
T         149337       2090          0          93 26-AUG-09
D         199116       2784          0          93 26-AUG-09

SQL> exec dbms_stats.restore_schema_stats(user,'26-AUG-09 07.18.00.000000 AM -04:00');

PL/SQL procedure successfully completed.

SQL> select table_name,num_rows,blocks,avg_space,avg_row_len,last_analyzed
2  from user_tables;

TABLE   NUM_ROWS     BLOCKS  AVG_SPACE AVG_ROW_LEN LAST_ANAL
----- ---------- ---------- ---------- ----------- ---------
T          49779        704          0          93 26-AUG-09
D          49779        704          0          93 26-AUG-09

Bueno, ahora a lo que interesa, como le hago para mover/migrar una base de datos de un servidor a otro, la respuesta como todo en Oracle es muy sencilla…depende.

Bueno, depende de la información que tengamos. Basado en la información de Paula “Tengo una bd oracle 10g y la quiero “mover” a otro servidor”, pues la siguientes preguntas serian:

1. El nuevo servidor es también 10g y la misma versión que el fuente, esto quiere decir que si es 10.0.2 a 10.0.2 y si ambas son de la misma edición (standard, enterprise, etc) ?
2. La versión del sistema operativo es la misma?
3. De que tamaño es la base de datos?
4. Hay posibilidad de detener la base de datos durante la migración o tienen que ser en tiempo real?
5. que mas…? mas detalles. No se me ocurren mas preguntas por el momento…

Que opciones tengo para la migración?

Afortunadamente Oracle provee muchos métodos para realizar esta tarea, de nuevo, todo depende como la queramos hacer y depende de los requerimientos que tengamos. Pero existen soluciones sencillas y soluciones complejas, vamos a ver algunas de ellas de manera general y sin entrar en los detalles de cada una.

Sencillas

Copia Directa

Suponiendo que el nuevo servidor es exactamente igual que el anterior respecto a versiones de software (sistema operativo, base de datos, parches, etc) en teoría si copiamos todos los archivos de datos, control files, redo logs, etc la base de datos debería de funcionar correctamente. Personalmente yo no utilizaría esta opción por que siempre falta algo, un parche, un parámetro,  etc.

Export/Import (DataPump en 10g)

Este podría ser también complejo pero normalmente se hace un export del usuario(s) de la aplicación y se importa en la otra base de datos, creo que es de las mas sencillas que puede existir ademas que podemos hacer el export de una versión anterior a la nueva base de datos por ejemplo de 9i a 10g. El único problema de esta opción es que debemos tener mas o menos el mismo espacio en disco que la base de datos actual para poder hacer el export; por ejemplo en una base de datos de 10Gb tal vez si es conveniente hacerlo pero en una de 600Gb o de Tb ya no es tan practico hacerlo, y si ademas se tiene que transferir el archivo(s) del export pues seria muchísimo mas tardado.

Complejas

RMAN Duplicate.

RMAN es una utilitaria de Oracle para realizar backups/restore. Una opcion que es muy interesante es el “duplicate” y como su nombre lo dice duplica una base de datos a otro servidor. Básicamente como funciona es de la siguiente manera: se hace un backup de la base de datos “fuente/original”, una vez con el backup guardado en el tape/disco/etc el resto del trabajo se hace en el servidor “destino/nuevo”, en el destino se debe tener el software de Oracle instalado, hay que configurar el tnsnames.ora para tener acceso a la base “fuente”, se copia el init.ora del fuente al destino (para tener la misma configuración) y se hacen los cambios necesarios al archivo (cambiar el destino de los control files, memoria, etc), se agregan al init.ora 2 parámetros para el duplicate (db_file_name_convert y log_file_name_convert), se crea el spfile y se crea un script de RMAN para duplicar la base de datos.
El script se ejecuta en la base de datos destino y básicamente el script o RMAN buscan el backup que hicimos de la fuente y hace un restore al destino de todos los archivos, hace un recover de la base hasta la hora/scn/etc que le digamos y deja la nueva base de datos lista para trabajar con ella.
Personalmente este es un método preferido para hacer “refresh” de ambientes por ejemplo de produccion a QA o desarrollo, es rápido (bueno depende de ciertos factores red/servidor/discos/etc) y sencillo ya que una vez teniendo los scripts es solo cuestión de ejecutarlos y RMAN se encarga de todo.

NOTA.- Muchísimos pasos no son mencionados y cierta configuracion se tiene que hacer para que esto funcione correctamente.

Backup/Restore

Es muy similar al Duplicate pero casi todos los pasos los tenemos que hacer manualmente, hacer un backup del fuente, hacer el restore en el destino, recrear control files, hacer recover,etc.

Copy a nivel SAN.

Esta opción es ideal cuando se tienen bases de datos grandes (GB a TB+), en esencia la copia de la información se hace a nivel de hardware/discos. Si la base de datos fuente y destino están en una SAN entonces solo hay que copiar los discos que contienen la base de datos fuente a los discos que van a contener la base de datos destino. Todo esto se hace por medio del sistema operativo y regularmente lo hacen los encargados de los servidores. La participación del DBA en esta opción es mínima, solo hay que poner los tablespaces en la base de datos fuente en modo backup, se hace la copia a nivel hardware, una vez terminada la copia se quita el modo backup de la fuente, se envian los archivos del archive de la fuente al destino (de preferencia se hace un log switch) y en el destino se recrean los control files si es necesario y se hace un recover (aquí va a preguntar por los archives que acabamos de copiar) y listo, la BD queda funcional.

Y estas son las opciones que conozco para migrar/mover/copiar una base de datos de un lado a otro. No entre en detalles técnicos ya que cada sitio puede tener una configuración diferente y hardware diferente, por ejemplo donde trabajo actualmente tenemos un servidor de backups y eso facilita mucho hacer el duplicate de una base de datos en USA a Canadá por medio de la red (algo tardado). También faltan muchos detalles sobre que comandos usar para RMAN y para hacer la copia a nivel SAN, pero todos esos los pueden encontrar en la red en Google.

Si alguien conoce algún método diferente puede agregarlo a los comentarios…

Saludos.

Para que exportar estadísticas?

El “problema” al calcular estadísticas es que los planes de ejecución pueden cambiar en algún punto en la vida de la base de datos; un grupo de tablas al inicio puede tener cientos de registros pero después de 2 años tienen millones, esto hace que al calcular las estadísticas en esas tablas los planes de ejecución cambien. Pero no se supone que ese es el punto de calcular estadísticas, darle a Oracle la información mas actualizada sobre las tablas para que pueda tomar mejores decisiones en cuanto al plan de ejecución? totalmente cierto, eso es lo que queremos, pero hay ciertas situaciones en las que necesitamos saber que es lo que ha cambiado y nadie nos puede dar la respuesta (ni los developers, ni los managers, menos los usuarios). Por lo tanto lo ideal seria poder ver el plan de ejecución anterior (el bueno) con el plan de ejecución actual (el malo, lento); pero esto es complicado ya que tendríamos que estar guardando planes de ejecución por cada Query,etc. Pero que tal si tenemos las estadísticas de la semana pasada o el mes pasado, podríamos importarlas en el ambiente de pruebas y ver que es lo que ha cambiado, probar, probar y probar.
Bueno, pues Oracle ya pensó al respecto y provee un conjunto de procedimientos para facilitar la tarea. A continuación voy a mostrar con un ejemplo como guardar y comparar estadísticas para una tabla.

Vamos a crear una tabla y calcularle estadísticas.
SQL> create table emp2 as select * from emp;
Table created.

SQL> set null <<null>>
 SQL> select to_char(last_analyzed,'dd/mm/yyyy hh24:mi:ss') last_analyzed,
 2         num_rows,
 3         blocks,
 4         avg_space
 5   from user_tables where table_name='EMP2'
 6  ;

LAST_ANALYZED         NUM_ROWS     BLOCKS  AVG_SPACE
 ------------------- ---------- ---------- ----------
 <<null>>            <<null>>   <<null>>   <<null>>

SQL> exec dbms_stats.gather_Table_stats(user,'EMP2');

PL/SQL procedure successfully completed.

SQL> select to_char(last_analyzed,'dd/mm/yyyy hh24:mi:ss') last_analyzed,
 2         num_rows,
 3         blocks,
 4         avg_space
 5   from user_tables where table_name='EMP2';

LAST_ANALYZED         NUM_ROWS     BLOCKS  AVG_SPACE
 ------------------- ---------- ---------- ----------
 16/07/2008 15:57:41         14          4          0

Bueno ahora hay que hacer que las estadísticas cambien y para hacerlo hay que cambiar la tabla EMP2. Vamos insertar 1 millón de registros.

SQL> insert into emp2 select * from emp connect by rownum <= 1000000;

1000013 rows created.

Ahora si calculamos estadísticas obviamente todo va a cambiar, pero lo que queremos hacer es guardar las anteriores y hacer una comparación.

Entonces para hacer un respaldo de las estadísticas anteriores primero debemos crear una tabla donde guardemos las estadísticas pasadas. Esto se realiza fácilmente con el procedimiento CREATE_STAT_TABLE.

DBMS_STATS.CREATE_STAT_TABLE (
ownname VARCHAR2,
stattab VARCHAR2,
tblspace VARCHAR2 DEFAULT NULL);

 








Parámetro


Descripción




Owname


Nombre
  del schema/usuario que va a tener la tabla de estadisticas.




Stattab


Nombre de
  la nueva tabla a crear.




Tblspace


Nombre
  del tablespace donde queremos guardarla, si no se especifica se crea en el
  tablespace default de owname.




En nuestro caso owname es el mismo usuario de la tabla “problema”.

SQL> exec dbms_stats.create_stat_table(USER,’HISTORIAL’);

PL/SQL procedure successfully completed.

Según la documentación de Oracle la información de estadísticas se debe acceder solamente con los procedimientos de DBMS_STATS, pero la tabla no es cosa del otro mundo y si alguien esta interesado puede jugar con ella.

SQL> desc historial;
Name                                      Null?    Type
----------------------------------------- -------- ----------------------------
STATID                                             VARCHAR2(30)
TYPE                                               CHAR(1)
VERSION                                            NUMBER
FLAGS                                              NUMBER
C1                                                 VARCHAR2(30)
C2                                                 VARCHAR2(30)
C3                                                 VARCHAR2(30)
C4                                                 VARCHAR2(30)
C5                                                 VARCHAR2(30)
N1                                                 NUMBER
N2                                                 NUMBER
N3                                                 NUMBER
N4                                                 NUMBER
N5                                                 NUMBER
N6                                                 NUMBER
N7                                                 NUMBER
N8                                                 NUMBER
N9                                                 NUMBER
N10                                                NUMBER
N11                                                NUMBER
N12                                                NUMBER
D1                                                 DATE
R1                                                 RAW(32)
R2                                                 RAW(32)
CH1                                                VARCHAR2(1000)

Ok, ahora que ya tenemos nuestra tabla como copiamos nuestras estadísticas a ella. Para eso utilizamos el procedimiento dbms_stats.EXPORT_TABLE_STATS, aunque para este ejemplo solo estamos utilizando la parte de una sola tabla hay otros procedimientos que permiten hacerlo a nivel schema, base de datos, etc:
EXPORT_COLUMN_STATS Procedure
EXPORT_DATABASE_STATS Procedure
EXPORT_DICTIONARY_STATS Procedure
EXPORT_FIXED_OBJECTS_STATS Procedure
EXPORT_INDEX_STATS Procedure
EXPORT_SCHEMA_STATS Procedure
EXPORT_SYSTEM_STATS Procedure
EXPORT_TABLE_STATS Procedure

En lo personal yo recomendaría hacerlo hasta nivel schema para así no perder las estadísticas de una tabla.

EXPORT_TABLE_STATS
Permite sacar las estadisticas de una tabla y guardarlas en otra.

DBMS_STATS.EXPORT_TABLE_STATS (
 ownname  VARCHAR2,
 tabname  VARCHAR2,
 partname VARCHAR2 DEFAULT NULL,
 stattab  VARCHAR2,
 statid   VARCHAR2 DEFAULT NULL,
 cascade  BOOLEAN  DEFAULT TRUE,
 statown  VARCHAR2 DEFAULT NULL);

Parametro


Descripción




Owname


Nombre
  del schema/usuario dueño de la tabla de la cual queremos respaldar.




Tabname


Nombre de
  la tabla que queremos respaldar.




Partname


Nombre de
  la partición.




Stattab


Nombre de
  la tabla donde vamos a guardar las estadísticas.




Statid


Identificador
  para las estadísticas. Es opcional pero es recomendable identificarlas.




Cascade


TRUE
  default, si deseamos exportar estadísticas de índices y columnas.




Statown


Quien es
  el dueño de la tabla de estadísticas, diferente a owname.

SQL> exec dbms_stats.export_table_stats(USER,’EMP2′,null, ‘HISTORIAL’,'Primera’,TRUE,’SCOTT’);

PL/SQL procedure successfully completed.

SQL> SELECT COUNT(*) FROM HISTORIAL;

COUNT(*)
———-
9

Ahora ya tenemos un respaldo de estadísticas (si alguien esta interesado puede hacer un select a la tabla y ver que contiene), en este momento podemos calcular las nuevas y comenzar a comparar.

SQL> exec dbms_stats.gather_Table_stats(user,'EMP2');

PL/SQL procedure successfully completed.

SQL> select to_char(last_analyzed,'dd/mm/yyyy hh24:mi:ss') last_analyzed,
 2         num_rows,
 3         blocks,
 4         avg_row_len
 5   from user_tables where table_name='EMP2';

LAST_ANALYZED         NUM_ROWS     BLOCKS AVG_ROW_LEN
 ------------------- ---------- ---------- -----------
 16/07/2008 16:29:16    1007517       5539          34

Perfecto, ahora tenemos estadísticas nuevas. Obviamente en nuestro ejemplo ya sabemos que fue lo que cambio, pero en un ambiente real regularmente no lo sabemos.

Bueno ahora como le hacemos para comparar las estadísticas actuales con las estadísticas anteriores. Para esto nos vamos a servir de un poco de PL/SQL, la verdad no se si Oracle provee alguna herramienta mas amigable para comparar por que hacer un programa para comparar si es un poco fastidioso, sobre todo cuando se desea comparar varias tablas a la vez.
El procedimiento que nos da información (muy poca a mi parecer y un poco limitado) de las estadísticas es dbms_stats.GET_TABLE_STATS.

DBMS_STATS.GET_TABLE_STATS (
 ownname         VARCHAR2,
 tabname         VARCHAR2,
 partname        VARCHAR2 DEFAULT NULL,
 stattab         VARCHAR2 DEFAULT NULL,
 statid          VARCHAR2 DEFAULT NULL,
 numrows     OUT NUMBER,
 numblks     OUT NUMBER,
 avgrlen     OUT NUMBER,
 statown         VARCHAR2 DEFAULT NULL,
 cachedblk   OUT NUMBER,
 cachehit    OUT NUMBER);
 SQL> set serveroutput on
 SQL>
 SQL> DECLARE
 2   numr NUMBER;
 3   numb NUMBER;
 4   avgr NUMBER;
 5   vtabname varchar2(100);
 6   vstattab varchar2(100);
 7   vstatid  varchar2(100);
 8  BEGIN
 9
 10    vtabname := 'EMP2';
 11    vstatid  := 'PRIMERA';
 12    vstattab := 'HISTORIAL';
 13
 14    dbms_stats.get_table_stats(
 15    ownname=> USER,
 16    tabname=> vtabname,
 17    partname=>null,
 18    stattab=>vstattab,
 19    statid=> vstatid,
 20    numrows=>numr,
 21    numblks=>numb,
 22    avgrlen=>avgr,
 23    statown=>USER);
 24
 25    dbms_output.put_line ('Table: '||vtabname);
 26    dbms_output.put_line('# of rows: ' || TO_CHAR(numr));
 27    dbms_output.put_line('# of blocks: ' || TO_CHAR(numb));
 28    dbms_output.put_line('Avg row len: ' || TO_CHAR(avgr) || ' bytes');
 29
 30  end;
 31  /
 Table: EMP2
 # of rows: 14
 # of blocks: 4
 Avg row len: 37 bytes

PL/SQL procedure successfully completed.

Con esto podemos comparar el antes y despues

Antes


Despues




Rows


14


1007517




Blocks


4


5539




Avg Row
  Len


37


34

Así que esta es una manera “rápida” y sucia de respaldar las estadísticas de una tabla (aunque es posible hacerlo para el schema, BD,etc) y después comparar para saber que fue lo que paso.
En el siguiente post voy a mostrar que más se puede hacer con las estadísticas que tenemos guardadas.

</pre>

• Dar click en el reporte dentro la sección de User Defined Reports.

• Seleccionar la conexión sobre la cual deseamos obtener la información.

• Seleccionar a que porcentaje deseamos dejar los tablespaces. Por ejemplo si actualmente sabemos que unos estan a 98% y queremos dejarlos al 50% entonces ponemos 50. El reporte obtendrá cuanto espacio (MB) se necesita agregar a los tablespaces para bajarlos a 50%

• El reporte se muestra en la pantalla con toda la información que necesitamos.

El query que da la información anterior es el siguiente:

 SELECT nvl(name,'=== TOTAL for DB ===') "Tablespace"                          ,
  TO_CHAR(SUM(mbytes),'999,999,999.99') "Total MB" ,
  TO_CHAR(SUM(used),'999,999,999.99') "Used MB"    ,
  TO_CHAR(SUM(free),'999,999,999.99') "Free MB"    ,
  ROUND(AVG(pct_used),2) "%Used"                   ,
  ROUND(AVG(pct_free),2) "%Free"                   ,
  'SQLDEV:GAUGE:0:100:0:0:'
  || AVG(pct_used) AS "Tablespace Utilization"          ,
  TO_CHAR(SUM(new_sz),'999,999,999.99') "Expected Size" ,
  TO_CHAR(SUM(add_sz),'999,999,999.99') "Add MB for desired %"
   FROM
  (SELECT name                ,
    ROUND(mbytes,2) mbytes    ,
    ROUND(used,2) used        ,
    ROUND(free,2) free        ,
    ROUND(pct_used,2) pct_used,
    ROUND(pct_free,2) pct_free,
    ROUND(
    CASE
      WHEN ( ((100 *used)/ trim(:desired_pct))-mbytes < 0)
      THEN mbytes
      ELSE ((100*used)/ trim(:desired_pct))
    END,2) new_sz,
    ROUND(
    CASE
      WHEN ( (((100 *used)/ trim(:desired_pct))-mbytes) < 0 )
      THEN 0
      ELSE (((100 *used)/ trim(:desired_pct))-mbytes)
    END,2) add_sz
     FROM
    (SELECT NVL(b.tablespace_name, NVL(a.tablespace_name,'UNKOWN')) name,
      mbytes_alloc Mbytes                                               ,
      mbytes_alloc-NVL(mbytes_free,0) used                              ,
      NVL(mbytes_free,0) free                                           ,
      ((mbytes_alloc-NVL(mbytes_free,0))/ mbytes_alloc)*100 pct_used    ,
      100           -(((mbytes_alloc-NVL(mbytes_free,0))/ mbytes_alloc)*100) pct_free
       FROM
      (SELECT SUM(bytes)/1024/1024 Mbytes_free,
        MAX(bytes)      /1024/1024 largest    ,
        tablespace_name
         FROM dba_free_space
     GROUP BY tablespace_name
      ) a                                      ,
      (SELECT SUM(bytes)/1024/1024 Mbytes_alloc,
        SUM(maxbytes)   /1024/1024 Mbytes_max  ,
        tablespace_name
         FROM sys.dba_data_files
     GROUP BY tablespace_name

    UNION ALL

       SELECT SUM(bytes)/1024/1024 Mbytes_alloc,
        SUM(maxbytes)   /1024/1024 Mbytes_max  ,
        tablespace_name
         FROM dba_temp_files
     GROUP BY tablespace_name
      ) b
      WHERE a.tablespace_name (+) = b.tablespace_name
    )
  )
GROUP BY rollup (name)
ORDER BY
  CASE
    WHEN name IS NULL
    THEN 200
    ELSE ROUND(AVG(pct_free),2)
  END ASC

Para crear el reporte solo hay que dar click derecho sobre User Defined Reports y seleccionar Add Report

Luego llenar los detalles del reporte:

Después Apply…y listo, a disfrutar del reporte.

Aquí esta el codigo XML para importar el reporte

.
Reporte en XML

Después de obtener el explain plan me di cuenta que a partir de la versión 10g esta vista incluye también el recycle_bin. A continuación voy a explicar el problema y como resolverlo (después de calcular estadísticas de sistema, modificar parámetros del init,etc).

Recycle Bin

Básicamente el recycle bin es similar al de windows, es un lugar dentro de la base de datos que sirve para guardar todos los objectos borrados. El recycle bin esta habilitado por default; así que si nosotros hacemos algo como:

drop table emp;

la tabla es “borrada” y nosotros podemos volver a crear otra tabla emp (igualita) y trabajar con ella,etc. Pero en realidad la tabla no fue borrada, lo que sucedió fue que oracle nada mas renombro la tabla con el prefijo BIN$$ y una secuencia de caracteres, la tabla (la estructura, indices, constraints, registros) siguen dentro del mismo tablespace ocupando espacio y no son borrados hasta que se utiliza el comando PURGE.

La razón de esta funcionalidad es variada pero principalmente es para poder recuperar información borrada de manera accidental.

Mas información sobre el recycle bin: What is the recycle bin?

Y que tiene que ver el recycle bin con dba_free_space?

Pues a partir de la versión 10g la vista accesa tambien la tabla sys.recyclebin$ para saber cuanto espacio queda libre en un tablespace, como habia mecionado anteriormente los objetos borrados no son eliminados completamente y en esta tabla se guarda la información(nombre, tamaño,etc) respecto a estos objetos.
Tiene sentido que la vista ahora incluya el recycle_bin (RBin) ya que hay que tomar en cuenta ahora cuanto espacio ocupan los objetos “borrados”.

Bueno, ahora mejor muestro un ejemplo sobre lo que puede suceder y como resolverlo.

Primero hay que ejecutar un query que contenga la vista:

SQL> select * from v$version;

BANNER
--------------------------------------------------------------------------------
Oracle Database 10g Enterprise Edition Release 10.2.0.2.0 - 64bi
PL/SQL Release 10.2.0.2.0 - Production
CORE    10.2.0.2.0      Production
TNS for HPUX: Version 10.2.0.2.0 - Production
NLSRTL Version 10.2.0.2.0 - Production

SQL> set lines 130
SQL> set pages 10000
SQL> alter system flush shared_pool;

System altered.

Elapsed: 00:00:00.05
SQL> alter system flush buffer_cache;

System altered.

Elapsed: 00:00:00.29
SQL> l
  1  select tablespace_name TS2,
  2         sum(bytes) SUM_B2,
  3         max(bytes) MAX_B2,
  4         count(bytes) CNT_B2
  5    from dba_free_space
  6*  group by tablespace_name

SQL> /

TS2                                SUM_B2     MAX_B2     CNT_B2
------------------------------ ---------- ---------- ----------
PSAPPW1                        3.7242E+10 2990538752      21213
PSAPPW1640                     1.6777E+10 4160749568          8
PSAPPW1700                     3194159104 1581252608          7
PSAPPW1DB                       671744000  670957568          2
PSAPPW1DIM                     6167658496 3471835136        305
PSAPPW1FACT                    2222653440  900661248         64
PSAPPW1ODS                     6.9220E+11 3220176896      17456
PSAPPW1USR                     1730150400  455475200       3486
PSAPUNDO                       5.5332E+10 1736441856       1242
PSAPZFCT0                      2.6376E+10 1534066688      10457
PSAPZFCT1                      9236316160  443547648        523
PSAPZODS0                      7.2968E+10 2434793472        452
PSAPZODS1                      2.5842E+10 3226468352       1011
SYSAUX                          892534784  834600960         96
SYSTEM                         2040774656 2040479744          7

15 rows selected.

Elapsed: 00:02:50.81

Execution Plan
----------------------------------------------------------
Plan hash value: 2686115433

-----------------------------------------------------------------------------------------
| Id  | Operation                    | Name             | Rows  | Bytes |TempSpc| Cost  |
-----------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT             |                  |   649 | 19470 |       |   126K|
|   1 |  SORT GROUP BY               |                  |   649 | 19470 |       |   126K|
|   2 |   VIEW                       | DBA_FREE_SPACE   |   649 | 19470 |       |   126K|
|   3 |    UNION-ALL                 |                  |       |       |       |       |
|   4 |     NESTED LOOPS             |                  |     7 |   259 |       |     5 |
|   5 |      NESTED LOOPS            |                  |     7 |   210 |       |     5 |
|*  6 |       TABLE ACCESS FULL      | TS$              |     2 |    40 |       |     3 |
|*  7 |       TABLE ACCESS CLUSTER   | FET$             |     4 |    40 |       |     1 |
|*  8 |      INDEX UNIQUE SCAN       | I_FILE2          |     1 |     7 |       |       |
|   9 |     NESTED LOOPS             |                  |    74 |  5328 |       |    90 |
|  10 |      NESTED LOOPS            |                  |    74 |  4810 |       |    90 |
|* 11 |       TABLE ACCESS FULL      | TS$              |    14 |   364 |       |     3 |
|* 12 |       FIXED TABLE FIXED INDEX| X$KTFBFE (ind:1) |     5 |   195 |       |     7 |
|* 13 |      INDEX UNIQUE SCAN       | I_FILE2          |     1 |     7 |       |       |
|  14 |     NESTED LOOPS             |                  |     1 |    97 |       |   125K|
|  15 |      NESTED LOOPS            |                  |     1 |    90 |       |   125K|
|* 16 |       HASH JOIN              |                  | 20579 |   763K|   488K|    42 |
|  17 |        TABLE ACCESS FULL     | RECYCLEBIN$      | 20791 |   243K|       |    18 |
|* 18 |        TABLE ACCESS FULL     | TS$              |    14 |   364 |       |     3 |
|* 19 |       FIXED TABLE FIXED INDEX| X$KTFBUE (ind:1) |     1 |    52 |       |     7 |
|* 20 |      INDEX UNIQUE SCAN       | I_FILE2          |     1 |     7 |       |       |
|  21 |     NESTED LOOPS             |                  |   567 | 29484 |       |   462 |
|* 22 |      HASH JOIN               |                  |   567 | 25515 |       |   462 |
|* 23 |       HASH JOIN              |                  |  7475 |   240K|       |   430 |
|* 24 |        TABLE ACCESS FULL     | TS$              |     2 |    40 |       |     3 |
|  25 |        TABLE ACCESS FULL     | UET$             |  7475 | 97175 |       |   426 |
|  26 |       TABLE ACCESS FULL      | RECYCLEBIN$      | 20791 |   243K|       |    18 |
|* 27 |      INDEX UNIQUE SCAN       | I_FILE2          |     1 |     7 |       |       |
-----------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

   6 - filter("TS"."BITMAPPED"=0)
   7 - filter("TS"."TS#"="F"."TS#")
   8 - access("F"."TS#"="FI"."TS#" AND "F"."FILE#"="FI"."RELFILE#")
  11 - filter("TS"."BITMAPPED"0 AND ("TS"."ONLINE$"=1 OR "TS"."ONLINE$"=4) AND
              "TS"."CONTENTS$"=0)
  12 - filter("TS"."TS#"="F"."KTFBFETSN")
  13 - access("F"."KTFBFETSN"="FI"."TS#" AND "F"."KTFBFEFNO"="FI"."RELFILE#")
  16 - access("TS"."TS#"="RB"."TS#")
  18 - filter("TS"."BITMAPPED"0 AND ("TS"."ONLINE$"=1 OR "TS"."ONLINE$"=4) AND
              "TS"."CONTENTS$"=0)
  19 - filter("U"."KTFBUESEGTSN"="RB"."TS#" AND "U"."KTFBUESEGFNO"="RB"."FILE#"
              AND "U"."KTFBUESEGBNO"="RB"."BLOCK#")
  20 - access("RB"."TS#"="FI"."TS#" AND "RB"."FILE#"="FI"."RELFILE#")
  22 - access("U"."TS#"="RB"."TS#" AND "U"."SEGFILE#"="RB"."FILE#" AND
              "U"."SEGBLOCK#"="RB"."BLOCK#")
  23 - access("TS"."TS#"="U"."TS#")
  24 - filter("TS"."BITMAPPED"=0)
  27 - access("U"."TS#"="FI"."TS#" AND "U"."SEGFILE#"="FI"."RELFILE#")

Note
-----
   - cpu costing is off (consider enabling it)

Statistics
----------------------------------------------------------
     520872  recursive calls
       1992  db block gets
     123081  consistent gets
      31977  physical reads
          0  redo size
       1235  bytes sent via SQL*Net to client
        465  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
         21  sorts (memory)
          0  sorts (disk)
         15  rows processed

Del query podemos observar lo siguiente:
Tiempo de ejecución:

Elapsed: 00:02:50.81

Del explain plan podemos ver que accesa el recycle bin:

TABLE ACCESS FULL      | RECYCLEBIN$      | 20791 |   243K|

Y también podemos ver que las estadísticas son algo altas para esta simple vista.

Ok, ahora hacemos un Purge y volvemos a ejecutar el query y revisamos el resultado.

SQL> PURGE DBA_RECYCLEBIN;

DBA Recyclebin purged.

Elapsed: 00:28:58.65

SQL> alter system flush shared_pool;

System altered.

Elapsed: 00:00:00.10
SQL> alter system flush buffer_cache;

System altered.

Elapsed: 00:00:01.51
SQL> set timing on;
SQL> set autotrace on;
SQL> select tablespace_name TS2,
  2  sum(bytes) SUM_B2,
  3  max(bytes) MAX_B2,
  4  count(bytes) CNT_B2
  5  from dba_free_space
  6  group by tablespace_name;

TS2                                SUM_B2     MAX_B2     CNT_B2
------------------------------ ---------- ---------- ----------
PSAPPW1                        3.7242E+10 2990538752       3370
PSAPPW1640                     1.6777E+10 4160749568          8
PSAPPW1700                     3194159104 1581252608          7
PSAPPW1DB                       671744000  670957568          2
PSAPPW1DIM                     6167658496 3471835136        288
PSAPPW1FACT                    2222653440  900661248         64
PSAPPW1ODS                     6.9220E+11 3220176896      17456
PSAPPW1USR                     1730150400 1233649664         12
PSAPUNDO                       5.4988E+10 1736441856       1234
PSAPZFCT0                      2.6376E+10 1534066688       3412
PSAPZFCT1                      9236316160  443547648        523
PSAPZODS0                      7.2968E+10 2434793472        452
PSAPZODS1                      2.5842E+10 3226468352       1011
SYSAUX                          892534784  834600960         96
SYSTEM                         2040774656 2040479744          7

15 rows selected.

Elapsed: 00:00:06.21

Execution Plan
----------------------------------------------------------
Plan hash value: 2686115433

-----------------------------------------------------------------------------------------
| Id  | Operation                    | Name             | Rows  | Bytes |TempSpc| Cost  |
-----------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT             |                  |   649 | 19470 |       |   126K|
|   1 |  SORT GROUP BY               |                  |   649 | 19470 |       |   126K|
|   2 |   VIEW                       | DBA_FREE_SPACE   |   649 | 19470 |       |   126K|
|   3 |    UNION-ALL                 |                  |       |       |       |       |
|   4 |     NESTED LOOPS             |                  |     7 |   259 |       |     5 |
|   5 |      NESTED LOOPS            |                  |     7 |   210 |       |     5 |
|*  6 |       TABLE ACCESS FULL      | TS$              |     2 |    40 |       |     3 |
|*  7 |       TABLE ACCESS CLUSTER   | FET$             |     4 |    40 |       |     1 |
|*  8 |      INDEX UNIQUE SCAN       | I_FILE2          |     1 |     7 |       |       |
|   9 |     NESTED LOOPS             |                  |    74 |  5328 |       |    90 |
|  10 |      NESTED LOOPS            |                  |    74 |  4810 |       |    90 |
|* 11 |       TABLE ACCESS FULL      | TS$              |    14 |   364 |       |     3 |
|* 12 |       FIXED TABLE FIXED INDEX| X$KTFBFE (ind:1) |     5 |   195 |       |     7 |
|* 13 |      INDEX UNIQUE SCAN       | I_FILE2          |     1 |     7 |       |       |
|  14 |     NESTED LOOPS             |                  |     1 |    97 |       |   125K|
|  15 |      NESTED LOOPS            |                  |     1 |    90 |       |   125K|
|* 16 |       HASH JOIN              |                  | 20579 |   763K|   488K|    42 |
|  17 |        TABLE ACCESS FULL     | RECYCLEBIN$      | 20791 |   243K|       |    18 |
|* 18 |        TABLE ACCESS FULL     | TS$              |    14 |   364 |       |     3 |
|* 19 |       FIXED TABLE FIXED INDEX| X$KTFBUE (ind:1) |     1 |    52 |       |     7 |
|* 20 |      INDEX UNIQUE SCAN       | I_FILE2          |     1 |     7 |       |       |
|  21 |     NESTED LOOPS             |                  |   567 | 29484 |       |   462 |
|* 22 |      HASH JOIN               |                  |   567 | 25515 |       |   462 |
|* 23 |       HASH JOIN              |                  |  7475 |   240K|       |   430 |
|* 24 |        TABLE ACCESS FULL     | TS$              |     2 |    40 |       |     3 |
|  25 |        TABLE ACCESS FULL     | UET$             |  7475 | 97175 |       |   426 |
|  26 |       TABLE ACCESS FULL      | RECYCLEBIN$      | 20791 |   243K|       |    18 |
|* 27 |      INDEX UNIQUE SCAN       | I_FILE2          |     1 |     7 |       |       |
-----------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

   6 - filter("TS"."BITMAPPED"=0)
   7 - filter("TS"."TS#"="F"."TS#")
   8 - access("F"."TS#"="FI"."TS#" AND "F"."FILE#"="FI"."RELFILE#")
  11 - filter("TS"."BITMAPPED"0 AND ("TS"."ONLINE$"=1 OR "TS"."ONLINE$"=4) AND
              "TS"."CONTENTS$"=0)
  12 - filter("TS"."TS#"="F"."KTFBFETSN")
  13 - access("F"."KTFBFETSN"="FI"."TS#" AND "F"."KTFBFEFNO"="FI"."RELFILE#")
  16 - access("TS"."TS#"="RB"."TS#")
  18 - filter("TS"."BITMAPPED"0 AND ("TS"."ONLINE$"=1 OR "TS"."ONLINE$"=4) AND
              "TS"."CONTENTS$"=0)
  19 - filter("U"."KTFBUESEGTSN"="RB"."TS#" AND "U"."KTFBUESEGFNO"="RB"."FILE#"
              AND "U"."KTFBUESEGBNO"="RB"."BLOCK#")
  20 - access("RB"."TS#"="FI"."TS#" AND "RB"."FILE#"="FI"."RELFILE#")
  22 - access("U"."TS#"="RB"."TS#" AND "U"."SEGFILE#"="RB"."FILE#" AND
              "U"."SEGBLOCK#"="RB"."BLOCK#")
  23 - access("TS"."TS#"="U"."TS#")
  24 - filter("TS"."BITMAPPED"=0)
  27 - access("U"."TS#"="FI"."TS#" AND "U"."SEGFILE#"="FI"."RELFILE#")

Note
-----
   - cpu costing is off (consider enabling it)

Statistics
----------------------------------------------------------
       1411  recursive calls
       1992  db block gets
       8777  consistent gets
       8820  physical reads
          0  redo size
       1233  bytes sent via SQL*Net to client
        465  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
         20  sorts (memory)
          0  sorts (disk)
         15  rows processed

Inmediatamente podemos ver varias cosas:

1. El tiempo se redujo considerablemente: de 00:02:50.81 a 00:00:06.21.
2. La estadísticas cambiaron muchísimo.

Con este ejemplo quería mostrar que el recycle bin puede afectar el performance de algunos queries.
Después de buscar un poco en metalink encontre las siguientes notas en las cuales mencionan el problema, en algunas dice que es un bug y en otras dice que es un comportamiento “normal” y que podemos recrear la vista agregandole un hint para mejorar el performance.

Cuando se haga el purge se debe realizar a dba_recyclebin con un usuario que tenga el rol sysdba ya que si solo hacemos purge recyclebin solo se eliminaran los objetos del usuario actual y no de toda la base de datos.

Si se cree que no es necesario estar utilizando el recycle bin entonces podemos deshabilitarlo usando: alter system set recyclebin = off scope=both; cuidado ya que aunque deshabilitemos el recycle bin los objetos que se encontraban antes de esta acción continuaran ocupando espacio (por lo cual debemos hacer primero un purge).

Metalink: Note:302333.1, Note:271169.1,Note:3492682.8

Oracle Technology Network

Yo nunca había hecho una migración de standard a enterprise, así que inmediatamente me fui a Googlear la documentación de Oracle y me encontré el siguiente documento :

http://download.oracle.com/docs/cd/B19306_01/server.102/b14238/intro.htm#BABFBJCC

Que básicamente dice :

Moving From the Standard Edition to the Enterprise Edition

If you are using the Standard Edition of the Oracle Database and want to move to the Enterprise Edition, then complete the following steps:

1. Ensure that the release number of your Standard Edition server software is the same release as the Enterprise Edition server software.

For example, if your Standard Edition server software is release 10.2.0, then you should upgrade to release 10.2.0 of the Enterprise Edition.

2. Shut down your database.

3. If your operating system is Windows, then stop all Oracle services, including the OracleServiceSID Oracle service, where SID is the instance name.

4. Deinstall the Standard Edition server software.

5. Install the Enterprise Edition server software using the Oracle Universal Installer.

Select the same Oracle home that was used for the de-installed Standard Edition. During the installation, be sure to select the Enterprise Edition. When prompted, choose Software Only from the Database Configuration screen.

6. Start up your database.

Your database is now upgraded to the Enterprise Edition.

Simple verdad? Pues no, no era tan simple hay algunos detalles que no
se muestran en este documento. A continuación voy a poner los pasos que realicé en mi actualización.

1. Primero hay que obtener un respaldo de la base y de los archivos init.ora, listener.ora, sqlnet.ora.
2. « Bajar » la base de datos (shutdown immediate).
3. Si se tiene instalado DBConsole (Enterprise Manager) hay que apagar los servicios : emctl stop dbconsole.
4. Detener los listeners : lsnrctl stop listener.
5. Verificar que el directorio oraInventory para nuestra base exista en el folder correcto. Ej : /oracle/oraInventory
6. Pasos 7 y 8 son para Unix. Si es windows entonces nada mas ejecutar el installer desde Programs.
7. Abrir una sesion de XTerm (Unix) para hacer la desinstalación. No olvidar la variable DISPLAY (en Unix), todo este proceso es similar a la instalación.
8. Desde la sesión XTerm entrar al directorio ($ORACLE_HOME/oui/bin) y ejecutar el instalador (./runInstaller)
9. Click en Deinstall Products
10. Como deseamos desinstalar el SOFTWARE solamente hay que seleccionar el Oracle home que deseamos desinstalar. Antes de desinstalar asegúrese de tener backup de init (spfile), listener, tnsnames ya que este proceso « borra » el Oracle Base (donde esta instalado el software de oracle).
11. Después de seleccionar el Oracle Home entonces dar click en REMOVE y luego YES.
12. La pantalla de REMOVE va aparecer con el progreso de la operación.
13. Cuando termine la desinstalación cerrar el Oracle Universal Installer.
14. En mi caso tuve que borrar el restante del Oracle Base

cd $ORACLE_BASE
rm –Rf product

15. El siguiente paso es instalar el software únicamente pero en la versión Enterprise Edition.
16. Una vez instalada la nueva versión entonces instalar los PatchSets y los Patches.
17. Regresar los respaldos de init.ora, listener.ora, tnsnames.ora a su lugar original.
18. Recrear el password file en caso que se haya tenido activada esta opción.
19. Abrir la base de datos de nuevo. Como es la misma versión (10g) no hay que hacer migración y los mismos archivos (datafiles, controlfiles, redo logs,etc) deben funcionar correctamente.
20. En algunos documentos que lei solo recomiendan re-ejecutar el catalog.sql y catproc.sql, pero en mi caso yo ejecute casi todos los scripts de nuevo.
21. Connect as sys and execute

@$ORACLE_HOME/rdbms/admin/catalog.sql;
@$ORACLE_HOME/rdbms/admin/catblock.sql;
@$ORACLE_HOME/rdbms/admin/catproc.sql;
@$ORACLE_HOME/rdbms/admin/catoctk.sql;
@$ORACLE_HOME/rdbms/admin/owminst.plb;
Conectarse como system y ejecutar:
@$ORACLE_HOME/sqlplus/admin/pupbld.sql;
@$ORACLE_HOME/sqlplus/admin/help/hlpbld.sql helpus.sql;

1. Verificar que sus backups funcionen.
2. Probar el listener y tnsnames.
3. Si se tenia DBConsole instalada hay que reinstalar de nuevo.
4. En mi caso, y creo que fue por que re-ejecute todos los scripts tuve que hacer grants a algunos usuarios como el usuario de backups. Asi que esten atentos por que puede ser que deban reasignar los privilegios a ciertos usuarios. Básicamente por que los scripts recrean de nuevo el diccionario de datos

Y pues simplemente este es el pequeño proceso para hacer una migración de Standard Edition a Enterprise Edition. En general todo debe ser muy sencillo a exepción de la ejecución de los scripts que hicieron que varios usuarios perdieran privilegios.

Así que ahora que voy a continuar trabajando voy a tener mas ejemplos y casos raros que podré analizar aquí.

Se me acabaron las vacaciones, que bueno ya me estaba aburriendo mucho en la casa, hay que distraerse en el trabajo un rato.

También ya tenia planeadas unas vacaciones a México para navidad y año nuevo así que todo se acomodo “mágicamente”, mi ultimo día de trabajo fue el 21 de Diciembre y yo volé a México el 20 (pedí un día), pasé las vacaciones con mi familia y acabamos de regresar el 5 de Enero, directito a clases de francés. Lo bueno de todo es que todavía no tengo una semana de regresar y ya me salieron 3 ofertas de empleo, una ya la rechace por que no me sentía agusto con el contrato y por que estaba muy lejos de donde vivo y las otras 2 hay van en las negociaciones, una de ellas es de DBA y es la que mas me interesa ya que quiero regresar a ese camino y la otra es de developer ETL.

Y pues esas han sido las razones por que no he escrito nada, no he tenido mucho tiempo y también me he vuelto muy flojo; espero este nuevo año sea mas constante.

Y pues fue gracias a Sir Ragnar que me “taggeo” que vuelvo a las andadas con el blog.

Así que agárrense que hay les voy de nuevo con éste blog y con el de plsqlenespanol a ver que sale.

1. Cuando era niño por poco incendio la casa de mi casa por andar jugando con cerillos (fósforos) cerca de unos botes con gasolina, afortunadamente no paso a mayores ya que mi mamá y unas señoras que estaban con ella apagaron el fuego rápidamente. Pero nunca se me va a olvidar esa travesura.
2. Soy mexicano, del norte si señor del meritito Chihuahua, viví alrededor de 21 años en ciudad Juárez y actualmente vivo en Montreal Canadá con mi esposa.
3. La primer vez que aprendi Oracle fue cuando trabajaba para la universidad y nos dieron cursos para migrar las aplicaciones, cosa que desde entonces(1999) no se ha hecho.
4. Me gusta mucho viajar y he estado en varias partes de USA, varios lugares de México (obviamente) y algunos lugares de Europa. Me gustaría mucho conocer Sudamérica, ahora que conozco más gente de por allá se me hace mas interesante.
5. Siempre he querido aprender a tocar un instrumento, en especial la guitarra, pero por una u otra razón no se ha dado…bueno más bien por flojonazo!.
6. No me gusta ver los deportes en la TV, aunque mi esposa me esta instruyendo en el soccer y el fútbol americano. Y no practico ningún deporte, soy un flojonazo!.
7. Me gusta mucho la fotografía y pues trato de mejorar cada vez más, hay voy, hay voy..
8. Casi toda la comida me gusta, pero la comida muy condimentada me cae mal al estomago (en especial la árabe).

Y pues eso es todo amigos!!! no pienso continuar la cadena por que no me gustan las cadenas y por que no tengo a quien pasársela :), si encuentro alguna victima entonces se la haré llegar.

Continuando con gather_table_stats, ahora quiero ver la opción METHOD_OPT. Vamos a recordar que opciones podemos tener para este parámetro:

FOR ALL [INDEXED | HIDDEN] COLUMNS
[size_clause]

FOR COLUMNS [size clause] column|attribute [size_clause] [,column|attribute [size_clause]...]

size_clause is defined as size_clause := SIZE {integer | REPEAT | AUTO | SKEWONLY}

-Integer : numéro de buckets de histogramas dentro del rango de 1 .. 254.

-Repeat: Calcula histogramas solamente en las columnas que ya tienen histogramas.

-Auto: Oracle determina a cuales columnas les debe de calcular histogramas basándose en la carga y distribución de datos.

-Skewonly: Oracle determina a cuales columnas debe calcular histogramas basándose en la distribución de datos.

El valor de DEFAULT es FOR ALL COLUMNS SIZE AUTO

Histogramas

Antes de pasar a escribir instrucciones vamos a ver que son los histogramas para comprender por que es útil la opción mencionada.

Cuando se calculan estadísticas en una tabla, DBMS_STATS obtiene información sobre la distribución de los datos en las columnas de la tabla. La información básica sobre la distribución puede ser el valor máximo y mínimo de una columna, pero esta información o este nivel de estadísticas pueden ser insuficientes si los datos dentro de la columna no están distribuidos uniformemente (skewed, no se como traducir esa palabra). Para distribuciones “no uniformes” se utilizan los histogramas y le dicen a Oracle como están distribuidos los datos en la columna.

Básicamente los histogramas son útiles cuando tenemos datos distribuidos de manera no uniforme, por ejemplo si tenemos una tabla con 1,000,000 de registros donde 950,000 tienen el valor ‘X’ y otros 50,000 tienen otros valores diferentes(Y, Z, A, B, C, etc). Cuando queremos obtener los datos que tienen X (where columna=’X') obviamente no queremos que utilice un índice ya que va a tener un costo muy alto debido a que tiene que accesar casi TODA (FULL) la tabla + todo el índice, pero cuando queremos un valor especifico (una minoría) como Y (where columna=’Y') entonces ahí si queremos que use un índice ya que no va a accesar toda la tabla si no una porción.

Oracle utiliza dos tipos de histogramas: Heigh-balanced y frecuencia.

Heigh-Balanced

En este tipo los valores de las columnas son divididos en bandas o grupos y cada grupo contiene aproximadamente el mismo número de registros. Tomemos por ejemplo una columna que tiene valores del 1 al 100 y un histograma con 10 grupos (buckets), entonces el histograma seria como sigue:

En este ejemplo el número de registros por grupo es 1/10 de todos los registros de la tabla, esto quiere decir 10 registros por cada grupo.

Si los datos no estuvieran uniformemente podría ser algo así:

Aquí la mayoría de los registros tienen un valor de 5 y por ejemplo los registros con un valor entre 60 y 100 son 1/10 de todos los registros de la tabla, esto quiere decir que pueden ser como máximo 10 registros en comparación con el ejemplo anterior que son 4/10 y que podrían llegar a ser 40 registros.

Frecuencia

En este tipo cada valor de la columna corresponde a un grupo (bucket) del histograma. Cada grupo contiene el número de ocurrencias/repeticiones de un valor.

Y pues de esta manera tenemos 10 grupos donde el grupo de “a” tiene 5 registros, el grupo de “e” tiene 10 repeticiones, etc.

Manos a la obra…

Para terminar con la teoría vamos a ver un ejemplo como funciona este rollo…

SQL> CREATE TABLE DEMO AS SELECT * FROM ALL_OBJECTS;
Table created.
SQL> CREATE INDEX STAT_IDX ON DEMO(STATUS);
Index created.
SQL> SET AUTOTRACE TRACEONLY EXPLAIN;
SQL> SELECT COUNT(*)
  2  FROM DEMO
  3  WHERE STATUS='INVALID';
Execution Plan
----------------------------------------------------------
Plan hash value: 3974250510
------------------------------------------------------------------------------
| Id  | Operation         | Name     | Rows  | Bytes | Cost (%CPU)| Time     |
------------------------------------------------------------------------------
|   0 | SELECT STATEMENT  |          |     1 |     5 |     1   (0)| 00:00:01 |
|   1 |  SORT AGGREGATE   |          |     1 |     5 |            |          |
|*  2 |   INDEX RANGE SCAN| STAT_IDX |    94 |   470 |     1   (0)| 00:00:01 |
------------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   2 - access("STATUS"='INVALID')
Note
-----
   - dynamic sampling used for this statement
SQL> SELECT COUNT(*)
  2  FROM DEMO
  3  WHERE STATUS='VALID';
Execution Plan
----------------------------------------------------------
Plan hash value: 2265447936
----------------------------------------------------------------------------------
| Id  | Operation             | Name     | Rows  | Bytes | Cost (%CPU)| Time     |
----------------------------------------------------------------------------------
|   0 | SELECT STATEMENT      |          |     1 |     5 |    32   (0)| 00:00:01 |
|   1 |  SORT AGGREGATE       |          |     1 |     5 |            |          |
|*  2 |   INDEX FAST FULL SCAN| STAT_IDX | 50562 |   246K|    32   (0)| 00:00:01 |
----------------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   2 - filter("STATUS"='VALID')
Note
-----
   - dynamic sampling used for this statement

Ahora vamos a calcular estadisticas con histogramas.

SQL> exec dbms_stats.gather_table_stats('SCOTT','DEMO',METHOD_OPT=>'FOR COLUMNS SIZE AUTO STATUS');
PL/SQL procedure successfully completed.
SQL> SELECT COUNT(*)
  2  FROM DEMO
  3  WHERE STATUS='INVALID';
Execution Plan
----------------------------------------------------------
Plan hash value: 3974250510
------------------------------------------------------------------------------
| Id  | Operation         | Name     | Rows  | Bytes | Cost (%CPU)| Time     |
------------------------------------------------------------------------------
|   0 | SELECT STATEMENT  |          |     1 |     7 |     1   (0)| 00:00:01 |
|   1 |  SORT AGGREGATE   |          |     1 |     7 |            |          |
|*  2 |   INDEX RANGE SCAN| STAT_IDX |   146 |  1022 |     1   (0)| 00:00:01 |
------------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   2 - access("STATUS"='INVALID')
SQL> SELECT COUNT(*)
  2  FROM DEMO
  3  WHERE STATUS='VALID';
Execution Plan
----------------------------------------------------------
Plan hash value: 2265447936
----------------------------------------------------------------------------------
| Id  | Operation             | Name     | Rows  | Bytes | Cost (%CPU)| Time     |
----------------------------------------------------------------------------------
|   0 | SELECT STATEMENT      |          |     1 |     7 |    31   (7)| 00:00:01 |
|   1 |  SORT AGGREGATE       |          |     1 |     7 |            |          |
|*  2 |   INDEX FAST FULL SCAN| STAT_IDX | 52655 |   359K|    31   (7)| 00:00:01 |
----------------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   2 - filter("STATUS"='VALID')
SQL> SET AUTOT OFF;
SQL> SELECT COUNT(*)
  2  FROM DEMO
  3  WHERE STATUS='INVALID';
  COUNT(*)
----------
        94
SQL> SELECT COUNT(*)
  2  FROM DEMO
  3  WHERE STATUS='VALID';
  COUNT(*)
----------
     52711

Aquí podemos que el explain plan no cambio mucho, “al parecer” salió peor que sin histogramas, por ejemplo con el valor INVALID tenemos rows 94 vs 146 al final, con la otra opción tenemos 50562 vs 52655 lo cual esta un poco alejado al numero de registros que existen. Esto se debe a que le dijimos a Oracle que hiciera el cálculo de manera AUTOmatica.

Vamos ahora a decirle un número de buckets.

SQL> EXEC DBMS_STATS.GATHER_TABLE_STATS('SCOTT','DEMO',METHOD_OPT=>'FOR COLUMNS SIZE 100 STATUS');
PL/SQL procedure successfully completed.
SQL> CONNECT SCOTT/ORACLE;
Connected.
SQL> SET AUTOT TRACEONLY EXPLAIN
SQL> SELECT COUNT(*)
  2  FROM DEMO
  3  WHERE STATUS='INVALID';
Execution Plan
----------------------------------------------------------
Plan hash value: 3974250510
------------------------------------------------------------------------------
| Id  | Operation         | Name     | Rows  | Bytes | Cost (%CPU)| Time     |
------------------------------------------------------------------------------
|   0 | SELECT STATEMENT  |          |     1 |     7 |     1   (0)| 00:00:01 |
|   1 |  SORT AGGREGATE   |          |     1 |     7 |            |          |
|*  2 |   INDEX RANGE SCAN| STAT_IDX |    99 |   693 |     1   (0)| 00:00:01 |
------------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   2 - access("STATUS"='INVALID')
SQL> SELECT COUNT(*)
  2  FROM DEMO
  3  WHERE STATUS='VALID';
Execution Plan
----------------------------------------------------------
Plan hash value: 2265447936
----------------------------------------------------------------------------------
| Id  | Operation             | Name     | Rows  | Bytes | Cost (%CPU)| Time     |
----------------------------------------------------------------------------------
|   0 | SELECT STATEMENT      |          |     1 |     7 |    31   (7)| 00:00:01 |
|   1 |  SORT AGGREGATE       |          |     1 |     7 |            |          |
|*  2 |   INDEX FAST FULL SCAN| STAT_IDX | 52702 |   360K|    31   (7)| 00:00:01 |
----------------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   2 - filter("STATUS"='VALID')

Orale, ahora vemos que la información que tiene Oracle es mas exacta respecto al numero de registros, por ejemplo INVALID 94 vs 99 y VALID 50562 vs 52702, cuando los valores reales son 94 y 52711. Así que el numero de bandas (buckets) que le especifiquemos a Oracle que tiene que crear influyen bastante en como Oracle va a identificar los diferentes rangos.

Cuando debo calcular histogramas.

Bueno igual que en todo los casos de performance tunning no existe una regla que aplique a todos los casos, según lo que he leído por ejemplo muchas personas recomiendan calcular histogramas en sistemas de datawarehouse y no “siempre” en OLTP (aunque hay excepciones), si se conoce muy bien la aplicación y se sabe que alguna(s) columna(s) tiene una distribución de datos no uniforme por ejemplo de 1 millón de registros solo 1000 tienen valores diferentes y el resto tiene el valor X, tal vez esa columna sea una candidata para histogramas. Una vez observe que un query tenia un explain plan “perfecto” accesaba índices, el costo era bajo, etc. Sin embargo para algunos casos se tardaba “mas” tiempo que en otros casos y querían saber cual era la razón, estuvimos probando con varias opciones y nos dimos cuenta que una de las columnas usadas en el query caia en el esquema mencionado anteriormente, calculamos histogramas (200 buckets) en esa columna y el query mejoro bastante su ejecución.

Aunque esto se aplica a las columnas yo no recomendaría calcular histogramas a TODAS las columnas debido a que no siempre será benéfico o no tendrá un gran impacto en la ejecución y pues además el calculo implica mas tiempo al obtener estadísticas con gather_table_stats.

Conclusión

Quería mencionar esta opción de gather_table_stats debido a que puede ayudar muchísimo a la ejecución de un query, le da mas información a Oracle sobre la distribución de la información y eso ayuda a obtener un mejor explain plan. Aunque recomiendo hacer pruebas antes de implementarlo en un ambiente de producción.

Hasta la próxima…a lo mejor continuo con gather_schema_Stats

Bueno continuamos con la onda de DBMS_STATS, ahora con el procedimiento GATHER_TABLE_STATS. Este procedimiento permite calcular las estadísticas de una tabla, columnas e índices (como ya lo había mencionado anteriormente).

Sintaxis

DBMS_STATS.GATHER_TABLE_STATS (
   ownname          VARCHAR2,
   tabname          VARCHAR2,
   partname         VARCHAR2 DEFAULT NULL,
   estimate_percent NUMBER   DEFAULT to_estimate_percent_type
                                    (get_param('ESTIMATE_PERCENT')),
   block_sample     BOOLEAN  DEFAULT FALSE,
   method_opt       VARCHAR2 DEFAULT get_param('METHOD_OPT'),
   degree           NUMBER   DEFAULT to_degree_type(get_param('DEGREE')),
   granularity      VARCHAR2 DEFAULT GET_PARAM('GRANULARITY'),
   cascade          BOOLEAN  DEFAULT to_cascade_type(get_param('CASCADE')),
   stattab          VARCHAR2 DEFAULT NULL,
   statid           VARCHAR2 DEFAULT NULL,
   statown          VARCHAR2 DEFAULT NULL,
   no_invalidate    BOOLEAN  DEFAULT  to_no_invalidate_type (
                                     get_param('NO_INVALIDATE')),
   force            BOOLEAN DEFAULT FALSE);

A la practica…

Vamos a crear una tabla con la cual podamos jugar y ver si nos da los resultados que deseamos.

SQL> set timing on;
SQL> create table emps as
  2  select level empid,
  3         sysdate - (((18 * 365)/level) + dbms_random.value()*(47*365)) hired,
  4         trunc((50000 + dbms_random.value()*90000)) salary,
  5         dbms_random.string('A',10) name
  6  from dual
  7  connect by level <=1000000
  8  ;
Table created.
Elapsed: 00:00:53.67

Hay que crear el PK y un índice para la fecha de contratación basado en el año solamente.

SQL> alter table emps add constraint pk_emps primary key (empid);
Table altered.
SQL> create index emps_hired on emps (extract(year from hired));
Index created.
Elapsed: 00:00:02.86
SQL> set lines 130
SQL> alter session set nls_date_format='dd.mon.yyyy hh24:mi:ss';
Session altered.
Elapsed: 00:00:00.00
SQL> set null {null}

Ahora vamos a revisar que la tabla no tiene estadísticas y el índice si.

SQL> select table_name,
  2      num_rows,
  3      blocks,
  4      empty_blocks,
  5      avg_space,
  6      chain_cnt,
  7      avg_row_len,
  8      sample_size,
  9      last_analyzed
 10    from dba_tables
 11   where owner = 'SCOTT' and table_name = 'EMPS';
TABLE_NAME        NUM_ROWS     BLOCKS EMPTY_BLOCKS  AVG_SPACE  CHAIN_CNT AVG_ROW_LEN SAMPLE_SIZE LAST_ANA
--------------- ---------- ---------- ------------ ---------- ---------- ----------- ----------- ---
EMPS            {null}     {null}     {null}       {null}     {null}     {null}      {null}      {null}
Elapsed: 00:00:00.00
SQL> select index_name, last_analyzed, num_rows, distinct_keys, leaf_blocks
  2    from dba_indexes
  3   where owner = 'SCOTT' and index_name = 'PK_EMPS';
INDEX_NAME                     LAST_ANALYZED        NUM_ROWS DISTINCT_KEYS LEAF_BLOCKS
------------------------------ ------------------ ---------- ------------- -----------
PK_EMPS                        05.oct.07 10:13:11    1000000       1000000        2087
Elapsed: 00:00:00.03

Borramos las estadísticas del índice para ver como se comporta.

SQL> exec dbms_stats.delete_INDEX_sTATS('SCOTT','PK_EMPS');
PL/SQL procedure successfully completed.
Elapsed: 00:00:00.18
SQL> exec dbms_stats.delete_index_stats('SCOTT','EMPS_HIRED');
PL/SQL procedure successfully completed.
Elapsed: 00:00:00.01
SQL> select index_name, last_analyzed, num_rows, distinct_keys, leaf_blocks
  2    from dba_indexes
  3   where owner = 'SCOTT' and index_name like '%EMPS%';
INDEX_NAME                     LAST_ANALYZED        NUM_ROWS DISTINCT_KEYS LEAF_BLOCKS
------------------------------ ------------------ ---------- ------------- -----------
PK_EMPS                        {null}             {null}     {null}        {null}
EMPS_HIRED                     {null}             {null}     {null}        {null}
Elapsed: 00:00:00.01

Vamos a ver como se comporta Oracle con índices y tablas sin estadísticas.

SQL> select *
  2  from emps
  3  where extract(year from hired) = '1959';
Elapsed: 00:00:01.11
Execution Plan
----------------------------------------------------------
Plan hash value: 2150600608
------------------------------------------------------------------------------------------
| Id  | Operation                   | Name       | Rows  | Bytes | Cost (%CPU)| Time     |
------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT            |            |    53 |   105K|     5   (0)| 00:00:01 |
|   1 |  TABLE ACCESS BY INDEX ROWID| EMPS       |    53 |   105K|     5   (0)| 00:00:01 |
|*  2 |   INDEX RANGE SCAN          | EMPS_HIRED |  4524 |       |     1   (0)| 00:00:01 |
------------------------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   2 - access(EXTRACT(YEAR FROM INTERNAL_FUNCTION("HIRED"))=1959)
Note
-----
   - dynamic sampling used for this statement
Statistics
----------------------------------------------------------
        738  recursive calls
          0  db block gets
        197  consistent gets
        583  physical reads
          0  redo size
        597  bytes sent via SQL*Net to client
        381  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          9  sorts (memory)
          0  sorts (disk)
          1  rows processed
SQL> select *
  2  from emps
  3  where extract(year from hired) = '2000';
21438 rows selected.
Elapsed: 00:00:02.37
Execution Plan
----------------------------------------------------------
Plan hash value: 2150600608
------------------------------------------------------------------------------------------
| Id  | Operation                   | Name       | Rows  | Bytes | Cost (%CPU)| Time     |
------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT            |            | 23305 |    45M|     5   (0)| 00:00:01 |
|   1 |  TABLE ACCESS BY INDEX ROWID| EMPS       | 23305 |    45M|     5   (0)| 00:00:01 |
|*  2 |   INDEX RANGE SCAN          | EMPS_HIRED |  4524 |       |     1   (0)| 00:00:01 |
------------------------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   2 - access(EXTRACT(YEAR FROM INTERNAL_FUNCTION("HIRED"))=2000)
Note
-----
   - dynamic sampling used for this statement
Statistics
----------------------------------------------------------
          4  recursive calls
          0  db block gets
       7324  consistent gets
       4171  physical reads
          0  redo size
     828924  bytes sent via SQL*Net to client
      16100  bytes received via SQL*Net from client
       1431  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
      21438  rows processed
SQL> select *
  2  from emps
  3  where to_char(hired,'YYYY') = '2000';
21438 rows selected.
Elapsed: 00:00:01.45
Execution Plan
----------------------------------------------------------
Plan hash value: 2715242515
--------------------------------------------------------------------------
| Id  | Operation         | Name | Rows  | Bytes | Cost (%CPU)| Time     |
--------------------------------------------------------------------------
|   0 | SELECT STATEMENT  |      | 23305 |    45M|  1197  (13)| 00:00:15 |
|*  1 |  TABLE ACCESS FULL| EMPS | 23305 |    45M|  1197  (13)| 00:00:15 |
--------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   1 - filter(TO_CHAR(INTERNAL_FUNCTION("HIRED"),'YYYY')='2000')
Note
-----
   - dynamic sampling used for this statement
Statistics
----------------------------------------------------------
          5  recursive calls
          0  db block gets
       6224  consistent gets
         46  physical reads
          0  redo size
     828924  bytes sent via SQL*Net to client
      16100  bytes received via SQL*Net from client
       1431  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
      21438  rows processed

Podemos ver que no esta mal, utiliza el índice que creamos y agregue un full scan para ver el comportamiento.

Ahora vamos a calcular las estadísticas con gather_table_stats para ver que es lo que cambia.

SQL> select table_name,
  2         num_rows,
  3      blocks,
  4      empty_blocks,
  5      avg_space,
  6      chain_cnt,
  7      avg_row_len,
  8      sample_size,
  9      last_analyzed
 10    from dba_tables
 11   where owner = 'SCOTT' and table_name = 'EMPS';
TABLE_NAME        NUM_ROWS     BLOCKS EMPTY_BLOCKS  AVG_SPACE  CHAIN_CNT AVG_ROW_LEN SAMPLE_SIZE LAST_ANA
--------------- ---------- ---------- ------------ ---------- ---------- ----------- ----------- ---
EMPS                995047       4798            0          0          0          32       49610 05.oct.07 10:45:13
Elapsed: 00:00:00.09
SQL> select index_name, last_analyzed, num_rows, distinct_keys, leaf_blocks
  2    from dba_indexes
  3   where owner = 'SCOTT' and index_name like '%EMPS%';
INDEX_NAME                     LAST_ANALYZED        NUM_ROWS DISTINCT_KEYS LEAF_BLOCKS
------------------------------ ------------------ ---------- ------------- -----------
PK_EMPS                        05.oct.07 10:45:22    1000000       1000000        2087
EMPS_HIRED                     05.oct.07 10:45:27    1000000            49        2089
Elapsed: 00:00:00.42

Empezamos viendo el full scan para comparar. Podemos ver que después de calcular estadísticas el COST BASED OPTIMIZER mejoro el plan de ejecución, por ejemplo el número de bytes anterior era de 45M y después es de 281K una gran mejora.

SQL> select *
  2  from emps
  3  where to_char(hired,'YYYY') = '2000';
21438 rows selected.
Elapsed: 00:00:02.06
Execution Plan
----------------------------------------------------------
Plan hash value: 2715242515
--------------------------------------------------------------------------
| Id  | Operation         | Name | Rows  | Bytes | Cost (%CPU)| Time     |
--------------------------------------------------------------------------
|   0 | SELECT STATEMENT  |      |  9950 |   281K|  1180  (11)| 00:00:15 |
|*  1 |  TABLE ACCESS FULL| EMPS |  9950 |   281K|  1180  (11)| 00:00:15 |
--------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   1 - filter(TO_CHAR(INTERNAL_FUNCTION("HIRED"),'YYYY')='2000')
Statistics
----------------------------------------------------------
        664  recursive calls
          0  db block gets
       6255  consistent gets
       4731  physical reads
          0  redo size
     828924  bytes sent via SQL*Net to client
      16100  bytes received via SQL*Net from client
       1431  SQL*Net roundtrips to/from client
          9  sorts (memory)
          0  sorts (disk)
      21438  rows processed

Ahhh, ahora podemos ver como después de calcular estadísticas Oracle toma otro camino diferente. Antes de calcular estadísticas Oracle decidió de usar el índice.

------------------------------------------------------------------------------------------
| Id  | Operation                   | Name       | Rows  | Bytes | Cost (%CPU)| Time     |
------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT            |            | 23305 |    45M|     5   (0)| 00:00:01 |
|   1 |  TABLE ACCESS BY INDEX ROWID| EMPS       | 23305 |    45M|     5   (0)| 00:00:01 |
|*  2 |   INDEX RANGE SCAN          | EMPS_HIRED |  4524 |       |     1   (0)| 00:00:01 |
------------------------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   2 - access(EXTRACT(YEAR FROM INTERNAL_FUNCTION("HIRED"))=2000)

Pero ahora vemos que Oracle esta decidiendo hacer un full scan…mmmm.

SQL> select *
  2  from emps
  3  where extract(year from hired) = '2000';
21438 rows selected.
Elapsed: 00:00:02.67
Execution Plan
----------------------------------------------------------
Plan hash value: 2715242515
--------------------------------------------------------------------------
| Id  | Operation         | Name | Rows  | Bytes | Cost (%CPU)| Time     |
--------------------------------------------------------------------------
|   0 | SELECT STATEMENT  |      | 24125 |   683K|  1181  (12)| 00:00:15 |
|*  1 |  TABLE ACCESS FULL| EMPS | 24125 |   683K|  1181  (12)| 00:00:15 |
--------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   1 - filter(EXTRACT(YEAR FROM INTERNAL_FUNCTION("HIRED"))=2000)
Statistics
----------------------------------------------------------
        689  recursive calls
          0  db block gets
       6265  consistent gets
       4740  physical reads
          0  redo size
     828924  bytes sent via SQL*Net to client
      16100  bytes received via SQL*Net from client
       1431  SQL*Net roundtrips to/from client
         12  sorts (memory)
          0  sorts (disk)
      21438  rows processed

Podemos ver como el calculo de estadísticas afecto el explain plan para un mismo query, básicamente Oracle nos esta diciendo que es mas “barato” hacer un full scan que usar un índice. Vamos a analizar los explain plans; el costo (CPU) es mas alto 5 vs 1181 pero los bytes son mejores en el full scan (683K vs 45M) así que Oracle ha decidido que es mejor hacer un full scan (no quiero entrar en detalles de la razón ya que me llevaría mucho tiempo explicarlo, por el momento vamos a dejarlo así pero existe una razón por que es mas costoso usar el índice vs un full scan EN ESTE CASO).

Lo que quería mostrar es que el plan de ejecución puede (va a cambiar) con el calculo de estadísticas y esto es debido a que Oracle tiene mas información para decidir cual es el “mejor” camino.

Pero podemos ver que para el siguiente caso continua utilizando el índice y de hecho mejora mucho el plan de ejecución.

Antes de calcular estadísticas el plan era el siguiente:

------------------------------------------------------------------------------------------
| Id  | Operation                   | Name       | Rows  | Bytes | Cost (%CPU)| Time     |
------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT            |            |    53 |   105K|     5   (0)| 00:00:01 |
|   1 |  TABLE ACCESS BY INDEX ROWID| EMPS       |    53 |   105K|     5   (0)| 00:00:01 |
|*  2 |   INDEX RANGE SCAN          | EMPS_HIRED |  4524 |       |     1   (0)| 00:00:01 |
------------------------------------------------------------------------------------------

Después de calcular estadísticas:

SQL> select *
  2  from emps
  3  where extract(year from hired) = '1959';
Elapsed: 00:00:00.26
Execution Plan
----------------------------------------------------------
Plan hash value: 2150600608
------------------------------------------------------------------------------------------
| Id  | Operation                   | Name       | Rows  | Bytes | Cost (%CPU)| Time     |
------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT            |            |     1 |    29 |     4   (0)| 00:00:01 |
|   1 |  TABLE ACCESS BY INDEX ROWID| EMPS       |     1 |    29 |     4   (0)| 00:00:01 |
|*  2 |   INDEX RANGE SCAN          | EMPS_HIRED |     1 |       |     3   (0)| 00:00:01 |
------------------------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
   2 - access(EXTRACT(YEAR FROM INTERNAL_FUNCTION("HIRED"))=1959)
Statistics
----------------------------------------------------------
        689  recursive calls
          0  db block gets
        125  consistent gets
         21  physical reads
          0  redo size
        597  bytes sent via SQL*Net to client
        381  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
         12  sorts (memory)
          0  sorts (disk)
          1  rows processed

Podemos observar varias cosas aquí, el numero de bytes accesadsos son menos (29 vs 105K) lo mismo para el numero de rows (1 vs 53), inclusive si vemos las estadísticas, el numero de lecturas físicas es menor (21 vs 583) hay grandes diferencias.

Vamos a analizar poquito por que ahora con estadísticas Oracle los planes cambiaron.

SQL> select extract(year from hired), count(*),(count(*)/1000000)*100 PCT
  2  from scott.emps
  3  group by extract(year from hired)
  4  having extract(year from hired) in ('2000','1959');
EXTRACT(YEARFROMHIRED)   COUNT(*)        PCT
---------------------- ---------- ----------
                  2000      21438     2.1438
                  1959          1      .0001
Elapsed: 00:00:01.79

En los ejemplos que estamos utilizando buscamos por dos años,2000 y 1959, podemos ver que del total de millón de registros el año 2000 contiene 21,438(2%) y el año 1959 1(casi nada %), y es por eso que Oracle en el primero considera mejor hacer un full scan ya que va accesar una cantidad considerable de registros y en el otro caso es preferible usar un índice ya que es solo 1 registro el que se va accesar; obviamente Oracle no tenia esa información antes de calcular estadísticas, no sabia cuantos valores diferentes tenia ni que porcentaje del total de la tabla había respecto a un dato.

Conclusión

Podemos ver que al plan de ejecución mejoro muchísimo después de calcular estadísticas y eso que solo utilizamos los valores por default. También observamos que el explain plan va a cambiar una vez que calculemos estadísticas, el cambio puede ser benéfico o puede afectar así que es mejor probar antes de aplicarlo a una base de producción, tal vez en el caso del full scan nosotros deseamos que utilicé el índice, en este caso tendríamos que hacer algunos cambios pero por ahora así lo vamos a dejar para no ahondar en otras cosas y perdernos mas. Otra cosa que se vio fue que al momento de calcular estadísticas a la tabla también se le calcularon estadísticas a los índices de manera automática y realmente no necesitamos calcular individualmente cada índice.

En el próximo capitulo de esta telenovela voy a continuar con GATHER_TABLE_STATS y voy a utilizar otros parámetros para calcular las estadísticas y observar que hay de diferente.

Hasta la próxima…

Otra manera de calcular estadisticas además del comando ANALYZE es el paquete DBMS_STATS. Este paquete se utiliza para modificar, ver, exportar, importar y borrar estadisticas de la base de datos.

Como ya habia mencionado Oracle recomienda la utilización de este paquete a partir de la versión 9i para el calculo de estadisticas en lugar de usar ANALYZE debido a que es mas exacto y mas eficiente. Aunque ANALYZE ya no sea la opción adecuada para calcular estadisticas eso no quiere decir que ya no sirva para nada, todavia se puede utilizar para validar la estructura de una tabla o buscar por CHAINED ROWS y algunas otras cosas.

Cuando se generan nuevas estadisticas para una tabla, columna o indice las estadisticas existentes son actualizadas por Oracle, cuando se actualizan las estadisticas Oracle invalida cualquier SQL que se encuentra en memoria (parsed) que accesa el objeto al cual se les estan calculando estadisticas. Esto quiere decir que si alguien ejecuto un query sobre la tabla empleados y se empiezan a calcular estadisticas sobre esa table Oracle invalida el query SQL que esta compartido en la memoria en lugar de re-utilizarlo (espero no haber confundido aqui esto tiene que ver con la manera en que Oracle reutiliza SQL previamente ejecutados, cualquier duda pregunten). Oracle utiliza las nuevas estadisticas cuando el query SQL es ejecutado de nuevo y por lo cual puede utilizar un plan de ejecucion diferente.

Procedimientos para el calculo de estadisticas dentro del paquete DBMS_STATS

Bueno vamos a empezar con el primero antes de que se haga mas aburrido y luego vamos explicando el por que de algunas cosas.

GATHER_INDEX_STATS

Bueno ya habiamos mencionado que este procedimiento calcula estadisticas a los indices.

Sintaxis

DBMS_STATS.GATHER_INDEX_STATS (
ownname          VARCHAR2,
indname          VARCHAR2,
partname         VARCHAR2 DEFAULT NULL,
estimate_percent NUMBER   DEFAULT to_estimate_percent_type
(GET_PARAM('ESTIMATE_PERCENT')),
stattab          VARCHAR2 DEFAULT NULL,
statid           VARCHAR2 DEFAULT NULL,
statown          VARCHAR2 DEFAULT NULL,
degree           NUMBER   DEFAULT to_degree_type(get_param('DEGREE')),
granularity      VARCHAR2 DEFAULT GET_PARAM('GRANULARITY'),
no_invalidate    BOOLEAN  DEFAULT to_no_invalidate_type
(GET_PARAM('NO_INVALIDATE')),
force            BOOLEAN DEFAULT FALSE);

Parametro Descripcion

ownname Schema/usuario/dueño del indice al cual se le van a calcular

indname Nombre del indice

partname Nombre de la particion

estimate_percent Porcentaje de registros a estimar (NULL significa compute[todos]). Rango valido [0.000001,100]. Se recomienda usar la constante DBMS_STATS.AUTO_SAMPLE_SIZE para dejar que Oracle obtenga el valor adecuado para calcular las estadisticas.

stattab Tabla de estadisticas donde se guardan las actuales (mas adelante mencionamos eso)

statid Identificador para asociar las estadisticas actuales

statown Schema que contiene la tabla de estadisticas (si es diferente al usuario)

degree Grado de paralelismo, el default es NULL, lo cual significa que usa el que tenga la tabla cuando se creo.

granularity Detalle del calculo, solo se utiliza cuando la tabla esta particionada.

ALL,AUTO,DEFAULT,GLOBAL,GLOBAL AND PARTITION, PARTITION, SUBPARTITION.

no_invalidate No invalida los cursores (SQL query) que dependen del objeto si se pone TRUE. Por default los invalida inmediatamente.

force Calcula estadisticas inclusive si el objeto esta bloqueado.

Verficar el manual para obtener mas detalles de los parametros.(http://download.oracle.com/docs/cd/B19306_01/appdev.102/b14258/d_stats.htm#sthref8108)\

Bueno, primero vamos a usar un procedimiento que ayuda a borrar las estadisticas actuales.

SQL> EXEC DBMS_STATS.DELETE_INDEX_STATS('SCOTT','PK_EMP');

PL/SQL procedure successfully completed.

Ahora vamos a ver que es lo que esta almacenado como estadisticas:

SQL> select OWNER,INDEX_NAME,NUM_ROWS,
2         SAMPLE_SIZE,LAST_ANALYZED,
3         BLEVEL,LEAF_BLOCKS,DISTINCT_KEYS
4  from dba_indexes
5  where owner = 'SCOTT'
6  and index_name ='PK_EMP';
OWNER      INDEX_NAME   NUM_ROWS SAMPLE_SIZE LAST_ANAL     BLEVEL LEAF_BLOCKS DISTINCT_KEYS
---------- ---------- ---------- ----------- --------- ---------- ----------- -------------
SCOTT      PK_EMP

Aqui podemos ver que el indice no ha sido analizado y por lo tanto no tiene estadisticas aunque la tabla puede tenerlas como se muestra en el siguiente ejemplo:

SQL> select OWNER,table_NAME,LAST_ANALYZED
2  from dba_tables
3  where owner = 'SCOTT'
4  and table_name = 'EMP';
OWNER      TABLE_NAME                     LAST_ANAL
---------- ------------------------------ ---------
SCOTT      EMP                            22-AUG-07

Asi que podemos tener tablas con estadisticas e indices sin estadisticas y viceversa. Aunque no es remendable tener este tipo de estadisticas es posible.

Ahora vamos a calcular las estadisticas del indice:

SQL> EXEC DBMS_STATS.GATHER_INDEX_STATS('SCOTT','PK_EMP');
PL/SQL procedure successfully completed.
SQL> select OWNER,INDEX_NAME,NUM_ROWS,
2         SAMPLE_SIZE,LAST_ANALYZED,
3         BLEVEL,LEAF_BLOCKS,DISTINCT_KEYS
4  from dba_indexes
5  where owner = 'SCOTT'
6  and index_name ='PK_EMP';
OWNER      INDEX_NAME   NUM_ROWS SAMPLE_SIZE LAST_ANAL     BLEVEL LEAF_BLOCKS DISTINCT_KEYS
---------- ---------- ---------- ----------- --------- ---------- ----------- -------------
SCOTT      PK_EMP             14          14 02-OCT-07          0           1            14

Y asi de sencillo se pueden calcular estadisticas para un indice. En este caso utilizamos unicamente las opciones por default.

Vamos a analizar que se hizo, le dijimos que indice queremos calcular, pero podemos ver que el sample_size utilizado fue el mismo numero de registros de la tabla esto quiere decir que Oracle uso NULL que significa COMPUTE que significa 100% o todos los registros. Para este caso en que la tabla es muy pequeña es muy rapido pero hay casos donde las tablas son de millones de registros estoy puede tardar varios minutos asi que se recomienda dejar que oracle lo determine utilizando DBMS_STATS.AUTO_SAMPLE_SIZE.

Vamos a cambiar este parametro para compara resultados con una tabla con algunos registros demas:

SQL> INSERT INTO SCOTT.EMP2(EMPNO,ENAME)
2  SELECT LEVEL,'TEST'
3  FROM DUAL
4  CONNECT BY LEVEL <=1000000;
1000000 rows created.
SQL> EXEC DBMS_STATS.DELETE_INDEX_STATS('SCOTT','PK_EMP2');
PL/SQL procedure successfully completed.
SQL> select OWNER,INDEX_NAME,NUM_ROWS,
2         SAMPLE_SIZE,LAST_ANALYZED,
3         BLEVEL,LEAF_BLOCKS,DISTINCT_KEYS
4  from dba_indexes
5  where owner = 'SCOTT'and index_name ='PK_EMP2';
OWNER      INDEX_NAME   NUM_ROWS SAMPLE_SIZE LAST_ANAL     BLEVEL LEAF_BLOCKS DISTINCT_KEYS
---------- ---------- ---------- ----------- --------- ---------- ----------- -------------
SCOTT      PK_EMP2
SQL> EXEC DBMS_STATS.GATHER_INDEX_STATS('SCOTT','PK_EMP2');
PL/SQL procedure successfully completed.
SQL> select OWNER,INDEX_NAME,NUM_ROWS,
2         SAMPLE_SIZE,LAST_ANALYZED,
3         BLEVEL,LEAF_BLOCKS,DISTINCT_KEYS
4  from dba_indexes
5  where owner = 'SCOTT'and index_name ='PK_EMP2';
OWNER      INDEX_NAME   NUM_ROWS SAMPLE_SIZE LAST_ANAL     BLEVEL LEAF_BLOCKS DISTINCT_KEYS
---------- ---------- ---------- ----------- --------- ---------- ----------- -------------
SCOTT      PK_EMP2       1000000     1000000 02-OCT-07          2        1875       1000000
SQL> EXEC DBMS_STATS.GATHER_INDEX_STATS('SCOTT','PK_EMP2',null,10);
PL/SQL procedure successfully completed.
SQL> select OWNER,INDEX_NAME,NUM_ROWS,
2         SAMPLE_SIZE,LAST_ANALYZED,
3         BLEVEL,LEAF_BLOCKS,DISTINCT_KEYS
4  from dba_indexes
5  where owner = 'SCOTT'and index_name ='PK_EMP2';
OWNER      INDEX_NAME   NUM_ROWS SAMPLE_SIZE LAST_ANAL     BLEVEL LEAF_BLOCKS DISTINCT_KEYS
---------- ---------- ---------- ----------- --------- ---------- ----------- -------------
SCOTT      PK_EMP2        971743      593140 02-OCT-07          2        1822        971743
SQL> EXEC DBMS_STATS.GATHER_INDEX_STATS('SCOTT','PK_EMP2',null,50);
PL/SQL procedure successfully completed.
SQL> select OWNER,INDEX_NAME,NUM_ROWS,
2         SAMPLE_SIZE,LAST_ANALYZED,
3         BLEVEL,LEAF_BLOCKS,DISTINCT_KEYS
4  from dba_indexes
5  where owner = 'SCOTT'and index_name ='PK_EMP2';
OWNER      INDEX_NAME   NUM_ROWS SAMPLE_SIZE LAST_ANALYZED            BLEVEL LEAF_BLOCKS DISTINCT_KEYS
---------- ---------- ---------- ----------- -------------------- ---------- ----------- -----------
SCOTT      PK_EMP2       1008372      615498 02/OCT/2007 11:53:18          2        1891       1008372
SQL> EXEC DBMS_STATS.GATHER_INDEX_STATS('SCOTT','PK_EMP2',null,DBMS_STATS.AUTO_SAMPLE_SIZE);
PL/SQL procedure successfully completed.
SQL> select OWNER,INDEX_NAME,NUM_ROWS,
2         SAMPLE_SIZE,LAST_ANALYZED,
3         BLEVEL,LEAF_BLOCKS,DISTINCT_KEYS
4  from dba_indexes
5  where owner = 'SCOTT'and index_name ='PK_EMP2';
OWNER      INDEX_NAME   NUM_ROWS SAMPLE_SIZE LAST_ANALYZED            BLEVEL LEAF_BLOCKS DISTINCT_KEYS
---------- ---------- ---------- ----------- -------------------- ---------- ----------- -----------
SCOTT      PK_EMP2       1000000     1000000 02/OCT/2007 11:55:34          2        1875       1000000

Aqui podemos ver que al igual que el comando ANALYZE si le damos un valor mas alto a estimate_percent entones obtendremos estadisticas mas exactas, pero de igual manera va a tardar mas tiempo en calcularlas. Puede observarse que en el ultimo ejemplo se calcularon usando AUTO_SAMPLE_SIZE y Oracle decidio que lo ideal era calcular para todos los registros.

Y asi se calculan estadisticas para indices, en lo personal yo casi nunca he utilizado este metodo debido a que siempre las calculo automaticamente con el procedimiento GATHER_TABLES_STATS o GATHER_SCHEMA_STATS, esto lo voy a mostrar en los proximos dias.

Los procedimientos tienen mas parametros sobre los cuales no mostre como funcionaban, la verdad no lo hice por que los parametros explican claramente que hacen cada uno y debido a que se utilizan para casos mas “avanzados” como particiones, paralelismo, etc. Y la verdad me dio flojera hacer una caso de prueba para ese tipo, creo que los mas importantes y que se aplican mas seguido son los mostrados, a menos que yo personalmente considere mencionar otro lo voy a hacer y si alguien desea saber como funciona entonces haganmelo saber.

Cuando calcular estadisticas?

De nuevo, no existe una regla sobre cada cuando se deben de calcular; pero algunos consejos son por ejemplo si se insertan/borran/actualizan un gran numero de registros a una tabla, tal vez millones, entonces inmediatamente despues hay que calcular debido a que si puede afectar los planes de ejecucion ya que se hizo un gran cambio. Si se desea hacer de manera automatica entonces depende de la carga de la base de datos, de la aplicacion, puede haber casos que semanalmente esta bien o hay veces que 1 vez al mes.

Bueno hasta la siguiente…con GATHER_TABLE_STATS.

http://www.lifehack.org/articles/technology/beginners-guide-run-linux-like-any-other-program-in-windows.html

powered by performancing firefox

sys@DBA> select rownum from dual connect by rownum <=10;

ROWNUM
----------
1
2
3
4
5
6
7
8
9
10

10 rows selected.

sys@DBA> select dbms_random.value from dual connect by rownum <=10;

VALUE
----------
.876879822
.04653477
.592060427
.273758898
.488285804
.523971849
.717315039
.092101034
.598717486
.99935022

10 rows selected.

10 rows selected.

• Que son y para que sirven?

Primero lo primero, que son las famosas estadísticas. Bueno básicamente datos/información que describe en detalle los objetos dentro de la base de datos, regularmente las tablas y los indices. Estas estadísticas son utilizadas por el query optimizer que se encarga de seleccionar el plan de ejecución más optimo para un query.
Ejemplos de estadísticas son:

• Tablas (numero de registros, numero de bloques de datos, tamaño promedio del registro).
• Columnas (Numero de valores distintos, numero de valores NULOS, como esta distribuida la información en las columnas.
• Indices (Numero de hojas, niveles, clustering factor.
• Sistema (Utilización y desempeño de I/O y del CPU )

Toda esta información se guarda dentro del diccionario de datos de Oracle. Debido a la naturaleza cambiante(delete,update,insert) de los objetos (tablas, indices) se deben calcular las estadísticas de manera regular dependiendo de la carga de cambios que se tenga en la base de datos.

• Como calculo las estadísticas?

Existen dos formas(instrucciones) para calcular estadísticas: ANALYZE TABLE y DBMS_STATS.
Hoy nada mas voy a ver ANALYZE TABLE, después entraré en detalle con DBMS_STATS ya que requiere más tiempo.

• ANALYZE TABLE

Esta instrucción permite calcular estadísticas, validar la estructura de un indice o tabla, identificar en una tabla registros migrados o encadenados (migrated, chained).

Nota: Aunque esta instrucción todavía existe en la versión 10g no se recomienda usarla para calcular estadísticas desde la versión 9i. Así que solo es ilustrativa para saber que existe.

Requisitos
Se debe tener el privilegio ANALYZE ANY para poder analizar la tabla de otro usuario, pero si se desea analizar las tablas de su propio usuario entonces solo debe existir el objeto dentro de mi schema.

Sintaxis rápida

ANALYZETABLE   xxx COMPUTE STATISTICSINDEX       ESTIMATE STATISTICS  {SAMPLE nn [ROWS|PERCENT]}

CLUSTER     DELETE STATISTICS

Donde xxx es el nombre de la tabla o el indice.

Opciones
COMPUTE STATISTICS. Calcula las estadísticas de manera exacta, básicamente lee todos y cada unos de los registros con sus columnas para generar estadísticas, esto quiere decir que si tengo una tabla con 100 millones de registros esta opción leerá todos los registros, esta opción pude ser la más tardada debido a eso pero es la más exacta.

ESTIMATE STATISTICS. Como su nombre lo indica esta opción estima las estadísticas, regularmente esta opción es la más utilizada debido a que es acertada(no en todos los casos) y además toma mucho menos tiempo que la otra. Se puede especificar SAMPLE nn donde nn puede ser el numero de registros(ROWS) o el porcentaje de la tabla (PERCENT).

Ejemplos,ejemplos y más ejemplos…

Primero vamos a crear una tabla e insertarle datos.

scott@DBA> create table test as
select * from all_objects;
scott@DBA>
insert into test select * from all_objects;

48073 rows created.

scott@DBA> insert into test select * from all_objects;

48073 rows created.

scott@DBA> insert into test select * from all_objects;

48073 rows created.

scott@DBA> insert into test select * from all_objects;

48073 rows created.

scott@DBA> commit;

Commit complete.

scott@DBA> select count(*) from test;

COUNT(*)

----------

240365

Después revisamos si la tabla tiene estadísticas.

scott@DBA> select table_name,
num_rows,
blocks,
avg_space,
chain_cnt,
avg_row_len,
sample_Size
from user_tables
where table_name ='TEST';
TABLE_NAME                       NUM_ROWS     BLOCKS  AVG_SPACE  CHAIN_CNT AVG_ROW_LEN SAMPLE_SIZE
------------------------------ ---------- ---------- ---------- ---------- ----------- -----------

TEST

Aqui podemos confirmar que la tabla no tiene información estadística. Ahora vamos a calcular estadísticas y luego verificamos que es lo que sucede.

scott@DBA> analyze table test compute statistics;
Table analyzed.Elapsed: 00:00:08.34

Aqui podemos ver que tarda 8 segundos y medio en terminar de calcular todas las estadísticas, ahora vamos a revisar que información guardo.

scott@DBA> select table_name,
num_rows,
blocks,
avg_space,
chain_cnt,
avg_row_len,
sample_Size
from user_tables
where table_name ='TEST';TABLE_NAME
NUM_ROWS     BLOCKS  AVG_SPACE  CHAIN_CNT AVG_ROW_LEN SAMPLE_SIZE
------------------------------ ---------- ---------- ---------- ---------- ----------- -----------
TEST                               240365       3350        904          0          97      240365

Elapsed: 00:00:00.01

Aquí se muestra que ahora Oracle tiene información respecto a la tabla.
Ahora vamos a calcular las estadísticas con sample.

Primero hay que borrar las estadísticas de la tabla, esto se realiza con la opción DELETE STATISTICS.

scott@DBA> analyze table test delete statistics;
Table analyzed.Elapsed: 00:00:00.18

scott@DBA> select table_name,num_rows,blocks,avg_space,chain_cnt,avg_row_len,sample_Size from user_tables where table_name ='TEST';

TABLE_NAME                       NUM_ROWS     BLOCKS  AVG_SPACE  CHAIN_CNT AVG_ROW_LEN SAMPLE_SIZE
------------------------------ ---------- ---------- ---------- ---------- ----------- -----------
TEST

Elapsed: 00:00:00.01

scott@DBA> analyze table test estimate statistics;

Table analyzed.

Elapsed: 00:00:00.06

scott@DBA> select table_name,num_rows,blocks,avg_space,chain_cnt,avg_row_len,sample_Size from user_tables where table_name ='TEST';

TABLE_NAME                       NUM_ROWS     BLOCKS  AVG_SPACE  CHAIN_CNT AVG_ROW_LEN SAMPLE_SIZE
------------------------------ ---------- ---------- ---------- ---------- ----------- -----------
TEST                               242821       3350        873          0          97         993

Elapsed: 00:00:00.01

Como podemos observar el calculo tardo muchísimo menos tiempo que el calculo completo (6 centésimas de seg VS 8.5 segs), ademas que la información estimada es diferente al calculo completo.

Vamos a probar con 10%, 20% y 80% de SAMPLE.

scott@DBA> analyze table test delete statistics;
Table analyzed.Elapsed: 00:00:00.20

scott@DBA> analyze table test estimate statistics sample 10 percent;

Table analyzed.

Elapsed: 00:00:00.71

scott@DBA> select table_name,num_rows,blocks,avg_space,chain_cnt,avg_row_len,sample_Size from user_tables where table_name ='TEST';

TABLE_NAME                       NUM_ROWS     BLOCKS  AVG_SPACE  CHAIN_CNT AVG_ROW_LEN SAMPLE_SIZE
------------------------------ ---------- ---------- ---------- ---------- ----------- -----------
TEST                               241809       3350        904          0          97       22770

Elapsed: 00:00:00.06

scott@DBA> analyze table test estimate statistics sample 20 percent;

Table analyzed.

Elapsed: 00:00:01.04

scott@DBA> select table_name,num_rows,blocks,avg_space,chain_cnt,avg_row_len,sample_Size from user_tables where table_name ='TEST';

TABLE_NAME                       NUM_ROWS     BLOCKS  AVG_SPACE  CHAIN_CNT AVG_ROW_LEN SAMPLE_SIZE
------------------------------ ---------- ---------- ---------- ---------- ----------- -----------
TEST                               241809       3350        904          0          97       43310

Elapsed: 00:00:00.03

scott@DBA.REGRESS.RDBMS.DEV.US.ORACLE.COM> analyze table test estimate statistics sample 80 percent;

Table analyzed.

Elapsed: 00:00:04.34

scott@DBA> select table_name,num_rows,blocks,avg_space,chain_cnt,avg_row_len,sample_Size from user_tables where table_name ='TEST';

TABLE_NAME                       NUM_ROWS     BLOCKS  AVG_SPACE  CHAIN_CNT AVG_ROW_LEN SAMPLE_SIZE
------------------------------ ---------- ---------- ---------- ---------- ----------- -----------
TEST                               240365       3350        904          0          97      240365

Elapsed: 00:00:00.01

scott@DBA.REGRESS.RDBMS.DEV.US.ORACLE.COM> analyze table test compute statistics;

Table analyzed.

Elapsed: 00:00:04.36

scott@DBA.REGRESS.RDBMS.DEV.US.ORACLE.COM> select table_name,num_rows,blocks,avg_space,chain_cnt,avg_row_len,sample_Size
from user_tables where table_name ='TEST';

TABLE_NAME                       NUM_ROWS     BLOCKS  AVG_SPACE  CHAIN_CNT AVG_ROW_LEN SAMPLE_SIZE
------------------------------ ---------- ---------- ---------- ---------- ----------- -----------
TEST                               240365       3350        904          0          97      240365

Elapsed: 00:00:00.01

Como podemos observar entre más elevado es el porcentaje más cercanas son las estadísticas de la tabla a la opción COMPUTE y obviamente tarda mucho más tiempo en calcular las estadísticas.

• Y los indices???

Bueno los indices son analizados al mismo tiempo que se analiza la tabla, veamos un ejemplo.
Primero creamos el indice en la tabla, verificamos que no hay estadísticas creadas para el indice y comenzamos a calcular para distintos porcentajes.

scott@DBA> create index testidx on test(object_name);
Index created.
scott@DBA> SELECT num_rows, sample_size, leaf_blocks, distinct_keys, avg_leaf_blocks_per_key, avg_data_blocks_per_key
2    FROM user_indexes
3   WHERE index_name = 'TESTIDX';

NUM_ROWS SAMPLE_SIZE LEAF_BLOCKS DISTINCT_KEYS AVG_LEAF_BLOCKS_PER_KEY AVG_DATA_BLOCKS_PER_KEY
---------- ----------- ----------- ------------- ----------------------- -----------------------

Elapsed: 00:00:00.04

scott@DBA> analyze table test estimate statistics sample 10 percent;

Table analyzed.

Elapsed: 00:00:00.48

scott@DBA> SELECT num_rows, sample_size, leaf_blocks, distinct_keys, avg_leaf_blocks_per_key, avg_data_blocks_per_key
2    FROM user_indexes
3   WHERE index_name = 'TESTIDX';

NUM_ROWS SAMPLE_SIZE LEAF_BLOCKS DISTINCT_KEYS AVG_LEAF_BLOCKS_PER_KEY AVG_DATA_BLOCKS_PER_KEY
---------- ----------- ----------- ------------- ----------------------- -----------------------
243057       25522        1219         29417                       1                       5

Elapsed: 00:00:00.01

scott@DBA> analyze table test estimate statistics sample 20 percent;

Table analyzed.

Elapsed: 00:00:00.87

scott@DBA> SELECT num_rows, sample_size, leaf_blocks, distinct_keys, avg_leaf_blocks_per_key, avg_data_blocks_per_key
2    FROM user_indexes
3   WHERE index_name = 'TESTIDX';

NUM_ROWS SAMPLE_SIZE LEAF_BLOCKS DISTINCT_KEYS AVG_LEAF_BLOCKS_PER_KEY AVG_DATA_BLOCKS_PER_KEY
---------- ----------- ----------- ------------- ----------------------- -----------------------
242871       49411        1219         29310                       1                       5

Elapsed: 00:00:00.00

scott@DBA> analyze table test estimate statistics sample 80 percent;

Table analyzed.

Elapsed: 00:00:04.40

scott@DBA> SELECT num_rows, sample_size, leaf_blocks, distinct_keys, avg_leaf_blocks_per_key, avg_data_blocks_per_key
2    FROM user_indexes
3   WHERE index_name = 'TESTIDX';

NUM_ROWS SAMPLE_SIZE LEAF_BLOCKS DISTINCT_KEYS AVG_LEAF_BLOCKS_PER_KEY AVG_DATA_BLOCKS_PER_KEY
---------- ----------- ----------- ------------- ----------------------- -----------------------
240365      240365        1189         28595                       1                       5

Elapsed: 00:00:00.01

scott@DBA> analyze table test compute statistics;

Table analyzed.

Elapsed: 00:00:04.39

Como podemos observar en el caso de los indices sucede lo mismo que con las tablas, entre el porcentaje es menor también lo es la exactitud de las estadísticas.

• Desempeño(Performance)

Bueno y como afectan las estadísticas al performance. Vamos viendo un ejemplo donde veamos el explain plan sin estadísticas y con estadísticas.

scott@DBA> analyze table test delete statistics;Table analyzed.scott@DBA> select * from test where object_name='TEST';

Execution Plan
----------------------------------------------------------

Plan hash value: 464205115
---------------------------------------------------------------------------------------
| Id  | Operation                   | Name    | Rows  | Bytes | Cost (%CPU)| Time     |
---------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT            |         |     5 |   640 |     2   (0)| 00:00:01 |
|   1 |  TABLE ACCESS BY INDEX ROWID| TEST    |     5 |   640 |     2   (0)| 00:00:01 |
|*  2 |   INDEX RANGE SCAN          | TESTIDX |     5 |       |     1   (0)| 00:00:01 |
---------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------
2 - access("OBJECT_NAME"='TEST')

Note
----

- dynamic sampling used for this statement

Statistics
----------------------------------------------------------
1743  recursive calls
0  db block gets
420  consistent gets
0  physical reads
0  redo size
1564  bytes sent via SQL*Net to client
381  bytes received via SQL*Net from client
2  SQL*Net roundtrips to/from client
50  sorts (memory)
0  sorts (disk)
5  rows processed

scott@DBA> analyze table test compute statistics;

Table analyzed.

scott@DBA> select * from test where object_name='TEST';

Execution Plan
----------------------------------------------------------
Plan hash value: 464205115
---------------------------------------------------------------------------------------
| Id  | Operation                   | Name    | Rows  | Bytes | Cost (%CPU)| Time     |
---------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT            |         |     8 |   696 |     9   (0)| 00:00:01 |
|   1 |  TABLE ACCESS BY INDEX ROWID| TEST    |     8 |   696 |     9   (0)| 00:00:01 |
|*  2 |   INDEX RANGE SCAN          | TESTIDX |     8 |       |     3   (0)| 00:00:01 |
---------------------------------------------------------------------------------------
Predicate Information (identified by operation id):
---------------------------------------------------
2 - access("OBJECT_NAME"='TEST')
Statistics
----------------------------------------------------------
1685  recursive calls
0  db block gets
352  consistent gets
0  physical reads
0  redo size
1564  bytes sent via SQL*Net to client
381  bytes received via SQL*Net from client
2  SQL*Net roundtrips to/from client
50  sorts (memory)
0  sorts (disk)
5  rows processed

Como se puede observar en la sección de statistics vemos que los recursive calls y consisten gets son menores cuando se calculan las estadísticas.

• Cada cuando se deben calcular estadísticas

Esta es una pregunta difícil de contestar ya que esto depende de la actividad(delete,insert,update) que tiene la base de datos en un determinado tiempo, por ejemplo si se borran/actualizan/insertan muchos datos probablemente es bueno calcular las estadísticas cada semana, de nuevo esto depende de la carga que se tenga en un tiempo determinado y la mejora manera es hacer pruebas y verificar los resultados.

• Conclusiones

Esta fue una “embarrada rapida” sobre lo que son las estadísticas y como se calculan con analyze table. Como se pudo observar en los ejemplos si se calculan estadísticas ayuda al desempeño de los queries. En mi experiencia he visto que el no calcular estadísticas puede causar grandes problemas en el desempeño de la base de datos así que como regla general se deben de calcular. A partir de la versión 10g de Oracle se incluye un JOB que calcula las estadísticas de manera automática y a partir de la versión 9i se recomienda utilizar el paquete DBMS_STATS en lugar de ANALYZE TABLE (aunque aquí lo vimos como ejemplo ilustrativo).

En el siguiente capitulo voy a ver como se calculan con el paquete DBMS_STATS.

Primero hay que saber a que usuario le vamos a calcular estadísticas.
vowner VARCHAR2 (100) := ‘APPLOWNER‘;

Para poder calcularle a las tablas que tienen las estadísticas des actualizadas primero las tablas se deben monitorear para que Oracle pueda identificar cuales tablas han tenido cambios significativos y por lo tanto sea necesario re calcular estadísticas. Para monitorear las tablas se utiliza el comando ALTER TABLE tblname MONITORING.
Se utiliza un cursor el cual genera los comandos para alterar las tablas que no son monitoreadas, regularmente las tablas nuevas.
Note que aqui se utiliza la variable anteriormente declarada.

CURSOR nomonitoringtables
IS
SELECT 'ALTER TABLE ' || vowner || '.' || table_name || ' MONITORING ' AS command
FROM dba_tables
WHERE MONITORING = 'NO' AND TEMPORARY = 'N' AND owner = vowner;

Como también deseamos calcular histogramas a ciertas tablas entonces declaramos una colección la cual contiene la lista de tablas a las cuales se les calcularan histogramas. también se tiene que saber de que tamaño va a ser el histograma, para esto utilizamos una variable.
En caso que no se desee calcular histogramas a ninguna de las tablas entonces dejar la inicialización de la colección vacía. Algo asi:

histtbl_t ();
TYPE histtbl_t IS TABLE OF VARCHAR2 (500);

   --calculate histograms to the next tables
vhisttables      histtbl_t      := histtbl_t ('tbl1','tbl4','tbl3');
vhistogramsize   NUMBER         := 200;

Como primer paso en la ejecución calculamos las estadísticas a las tablas que no tienen y a las que no están actualizadas.

--CALCULATE STALE STATISTICS
DBMS_STATS.gather_schema_stats (ownname => vowner,
options => 'GATHER AUTO',
estimate_percent => DBMS_STATS.auto_sample_size,
method_opt => 'for all columns size auto',
DEGREE => 2,
gather_temp => FALSE,
block_sample => TRUE,
CASCADE => TRUE,
no_invalidate => FALSE
);

Después si hay tablas a las cuales se desea calcular histogramas entonces se calcula a ese grupo de tablas.

--calculate histograms
IF vhisttables.COUNT () <> 0
THEN
FOR indx IN vhisttables.FIRST .. vhisttables.LAST
LOOP
DBMS_STATS.gather_table_stats (ownname => vowner,
tabname => vhisttables (indx),
estimate_percent => DBMS_STATS.auto_sample_size,
block_sample => TRUE,
method_opt => 'FOR ALL INDEXED COLUMNS SIZE '||vhistogramsize   ,
DEGREE => 2,
CASCADE => TRUE,
no_invalidate => FALSE
);
END LOOP;
END IF;

Por ultimo, utilizando el cursor para alterar las tablas, se alteran las tablas nuevas que no han sido monitoreadas para que a la siguiente ejecución se calculen las estadísticas.

--ALTER NEW TABLES TO MONITORING
FOR vtables IN nomonitoringtables
LOOP
EXECUTE IMMEDIATE vtables.command;
END LOOP;


Script completo:
/*
Calculate Weekly Statistics for APPLOWNER
*/

DECLARE
vowner           VARCHAR2 (100) := 'APPLOWNER';

   CURSOR nomonitoringtables
IS
SELECT 'ALTER TABLE ' || vowner || '.' || table_name || ' MONITORING ' AS command
FROM dba_tables
WHERE MONITORING = 'NO' AND TEMPORARY = 'N' AND owner = vowner;

   TYPE histtbl_t IS TABLE OF VARCHAR2 (500);

   --calculate histograms to the next tables
vhisttables      histtbl_t      := histtbl_t ('SALDOS_IMP');
vhistogramsize   NUMBER         := 200;
BEGIN
--CALCULATE STALE STATISTICS
DBMS_STATS.gather_schema_stats (ownname => vowner,
options => 'GATHER AUTO',
estimate_percent => DBMS_STATS.auto_sample_size,
method_opt => 'for all columns size auto',
DEGREE => 2,
gather_temp => FALSE,
block_sample => TRUE,
CASCADE => TRUE,
no_invalidate => FALSE
);

   --calculate histograms
IF vhisttables.COUNT () <> 0
THEN
FOR indx IN vhisttables.FIRST .. vhisttables.LAST
LOOP
DBMS_STATS.gather_table_stats (ownname => vowner,
tabname => vhisttables (indx),
estimate_percent => DBMS_STATS.auto_sample_size,
block_sample => TRUE,
method_opt => 'FOR ALL INDEXED COLUMNS SIZE '||vhistogramsize,
DEGREE => 2,
CASCADE => TRUE,
no_invalidate => FALSE
);
END LOOP;
END IF;

   --ALTER NEW TABLES TO MONITORING
FOR vtables IN nomonitoringtables
LOOP
EXECUTE IMMEDIATE vtables.command;
END LOOP;
END;

Si se desea que este script se ejecute de manera automática entonces hay que calendarizarlo en un job como se muestra a continuación.

DECLARE
X NUMBER;
BEGIN
SYS.DBMS_JOB.SUBMIT
( job       => X
,what      => '/*
Calculate Weekly Statistics for APPLOWNER
*/

DECLARE
vowner           VARCHAR2 (100) := ''APPLOWNER'';

   CURSOR nomonitoringtables
IS
SELECT ''ALTER TABLE '' || vowner || ''.'' || table_name || '' MONITORING '' AS command
FROM dba_tables
WHERE MONITORING = ''NO'' AND TEMPORARY = ''N'' AND owner = vowner;

   TYPE histtbl_t IS TABLE OF VARCHAR2 (500);

   --calculate histograms to the next tables
vhisttables      histtbl_t      := histtbl_t (''tbl1'',''tbl2'',''tbl3'');
vhistogramsize   NUMBER         := 200;
BEGIN
--CALCULATE STALE STATISTICS
DBMS_STATS.gather_schema_stats (ownname => vowner,
options => ''GATHER AUTO'',
estimate_percent => DBMS_STATS.auto_sample_size,
method_opt => ''for all columns size auto'',
DEGREE => 2,
gather_temp => FALSE,
block_sample => TRUE,
CASCADE => TRUE,
no_invalidate => FALSE
);

   --calculate histograms
IF vhisttables.COUNT () <> 0
THEN
FOR indx IN vhisttables.FIRST .. vhisttables.LAST
LOOP
DBMS_STATS.gather_table_stats (ownname => vowner,
tabname => vhisttables (indx),
estimate_percent => DBMS_STATS.auto_sample_size,
block_sample => TRUE,
method_opt => ''FOR ALL INDEXED COLUMNS SIZE ''||vhistogramsize,
DEGREE => 2,
CASCADE => TRUE,
no_invalidate => FALSE
);
END LOOP;
END IF;

   --ALTER NEW TABLES TO MONITORING
FOR vtables IN nomonitoringtables
LOOP
EXECUTE IMMEDIATE vtables.command;
END LOOP;
END;'
,next_date => to_date('17/12/2006 00:00:00','dd/mm/yyyy hh24:mi:ss')
,interval  => 'TRUNC(SYSDATE+7)'
,no_parse  => TRUE
);
SYS.DBMS_OUTPUT.PUT_LINE('Job Number is: ' || to_char(x));
END;
/

commit;

powered by performancing firefox

powered by performancing firefox

powered by performancing firefox

Por ejemplo, si tenemos datos en una colección de la siguiente manera y queremos hacer un SELECT y que aparezcan los datos 1 a 1 por renglón, entonces hacemos lo siguiente:

SELECT * FROM TABLE( sys.dbms_debug_vc2coll (1,2,3,4,5) ) ;

Aquí podemos ver la función TABLE la cual toma los valores de una colección en este caso la colección es del tipo dbms_debug_vc2coll, el resultado es el siguiente:

powered by performancing firefox

powered by performancing firefox

Foros de Oracle
http://forums.oracle.com/

http://asktom.oracle.com/
http://tkyte.blogspot.com

Technet (Necesitas cuenta, pero la puedes sacar gratis), te recomiendo la seccion de articulos y de tutoriales
http://www.oracle.com/technology/index.html

METALINK (sitio de soporte de Oracle, pregunta en tu compañia si tienen la licencia y el support ID y quien te puede dar de alta)
https://metalink.oracle.com/

http://www.oracleplsqlprogramming.com/
http://www.stevenfeuerstein.com/

http://www.toadworld.com/

http://www.petefinnigan.com/

http://oraqa.com/

http://www.oracle-base.com/

http://www.dbazine.com/oracle

http://www.oraclealchemist.com/index.php

Tips, foros,etc de Oracle, PL/SQL, SQL svr…
http://www.revealnet.com/

Tantito humor de inges…hay muchos que hacen referencia a situaciones EDS :)
http://www.dilbert.com/comics/dilbert/archive/

http://www.chami.com/html-kit/

powered by performancing firefox

Lector de RSS
http://www.wizzcomputers.com/WizzRss.php

Oracle Search extensions
http://awads.net/wp/oracle-firefox-extensions/
http://awads.net/wp/oracle-firefox-plugins/
http://awads.net/wp/2006/09/07/oracle-bookmarklets-the-easiest-way-to-search-documentation-and-more/

Oracle Bookmarklets
OraDocs Global
10gR2
10gR1
9iR2
9iR1
8iR3
Oracle Enterprise Search
Metalink
AskTom
OTN Forums
Oracle-I

Customize Google
http://www.customizegoogle.com/

Switch Proxy Tool, Copy Plain Text, Lorem Ipsum Generator
http://mozmonkey.com/

FasterFox
http://fasterfox.mozdev.org/

IE tab
http://ietab.mozdev.org/

Performancing
http://performancing.com/

Tiny Menu

Google Sync
http://www.google.com/tools/firefox/browsersync/

Gmail Space
http://www.rjonna.com/ext/gspace.php

Diccionario RAE
javascript:Qr=document.getSelection();if(!Qr){void(Qr=prompt(‘Diccionario%20de%20la%20Real%20Academia%20Espa%C3%83%C2%B1ola.%20Vig%C3%83%C2%A9sima%20segunda%20edici%C3%83%C2%B3n.%20Teclee%20la%20palabra%20que%20desea%20consultar:’,”))}if(Qr)location.href=’http://buscon.rae.es/draeI/SrvltGUIBusUsual?TIPO_HTML=2&TIPO_BUS=3&LEMA=’+escape(Qr)+’ ‘

Babel Fish
http://babelfish.altavista.com/

Pageaddict.com

Foxmarks Bookmark Synchronizer

powered by performancing firefox

Lector de RSS
http://www.wizzcomputers.com/WizzRss.php

Oracle Search extensions
http://awads.net/wp/oracle-firefox-extensions/
http://awads.net/wp/oracle-firefox-plugins/
http://awads.net/wp/2006/09/07/oracle-bookmarklets-the-easiest-way-to-search-documentation-and-more/

Oracle Bookmarklets
OraDocs Global
10gR2
10gR1
9iR2
9iR1
8iR3
Oracle Enterprise Search
Metalink
AskTom
OTN Forums
Oracle-I

Customize Google
http://www.customizegoogle.com/

Switch Proxy Tool, Copy Plain Text, Lorem Ipsum Generator
http://mozmonkey.com/

FasterFox
http://fasterfox.mozdev.org/

IE tab
http://ietab.mozdev.org/

Performancing
http://performancing.com/

Tiny Menu

Google Sync
http://www.google.com/tools/firefox/browsersync/

Gmail Space
http://www.rjonna.com/ext/gspace.php

Diccionario RAE

Babel Fish

Wikipedia

powered by performancing firefox

http://www.red-database-security.com/whitepaper/oracle_password_benchmark.html
http://www.red-database-security.com/whitepaper/oracle_password_cracker.html

Tambien esta opcion:
http://www.sans.org/info/911/

powered by performancing firefox

Lector de RSS
http://www.wizzcomputers.com/WizzRss.php

Oracle Search extensions
http://awads.net/wp/oracle-firefox-extensions/
http://awads.net/wp/oracle-firefox-plugins/
http://awads.net/wp/2006/09/07/oracle-bookmarklets-the-easiest-way-to-search-documentation-and-more/

Oracle Bookmarklets
OraDocs Global
10gR2
10gR1
9iR2
9iR1
8iR3
Oracle Enterprise Search
Metalink
AskTom
OTN Forums
Oracle-I

Customize Google
http://www.customizegoogle.com/

Switch Proxy Tool, Copy Plain Text, Lorem Ipsum Generator
http://mozmonkey.com/

FasterFox
http://fasterfox.mozdev.org/

IE tab
http://ietab.mozdev.org/

Performancing
http://performancing.com/

Tiny Menu

Google Sync
http://www.google.com/tools/firefox/browsersync/

Gmail Space
http://www.rjonna.com/ext/gspace.php

Diccionario RAE

Babel Fish

Wikipedia

Este esta muy suave,
pero esta caon que lo hagan los developers…al menos aqui.
:)
http://oracleandy.blogspot.com/2006/09/if-only.html

http://www.milenio.com/mediacenter/humor/2006/11/02/cerdo.jpg

http://www.milenio.com/mediacenter/humor/2006/11/02/jabaz.jpg

http://www.milenio.com/mediacenter/humor/2006/11/02/jis.jpg

El primero es el siguiente:
http://delfino.nunez.googlepages.com/dbms_application_info

http://download-west.oracle.com/docs/cd/B19306_01/server.102/b14237/limits003.htm

Lector de RSS
http://www.wizzcomputers.com/WizzRss.php

Oracle Search extensions
http://awads.net/wp/oracle-firefox-extensions/
http://awads.net/wp/oracle-firefox-plugins/
http://awads.net/wp/2006/09/07/oracle-bookmarklets-the-easiest-way-to-search-documentation-and-more/

Oracle Bookmarklets
OraDocs Global
10gR2
10gR1
9iR2
9iR1
8iR3
Oracle Enterprise Search
Metalink
AskTom
OTN Forums
Oracle-I

Customize Google
http://www.customizegoogle.com/

Switch Proxy Tool, Copy Plain Text, Lorem Ipsum Generator
http://mozmonkey.com/

FasterFox
http://fasterfox.mozdev.org/

IE tab
http://ietab.mozdev.org/

Performancing
http://performancing.com/

Tiny Menu

Google Sync
http://www.google.com/tools/firefox/browsersync/

Gmail Space
http://www.rjonna.com/ext/gspace.php

Diccionario RAE

Babel Fish

Wikipedia

Este esta muy suave,
pero esta caon que lo hagan los developers…al menos aqui.
:)
http://oracleandy.blogspot.com/2006/09/if-only.html

00 22 * * * find /9a/oradata/DBDIR/arch/ -name '*.arc' -mtime +1 -exec rm {} \;

Que es lo que hace esta linea de comando:

1. 00 22 * * *.- Esto le dice al crontab de ejecutar el comando a los 0 minutos y 22 horas todos los dias ( * * *).
2. find /9a/oradata/DBDIR/arch/ -name '*.arc' -mtime +1.- Buscar los archivos que tienen extension “arc” (o como se tiene definido en la base) y que tienen un dia de antigüedad, esto quiere decir que va a buscar los archivos del archiving que tienen mas de un dia. Si quisieramos borrar los archivos que tienen mas de 7 dias entonces cambiariamos +1 por +7.
3. -exec rm {} \; .-Ejecutar rm(borrar) todos los archivos encontrados.

Algunas veces es necesario borrar archivos a cierta hora. Una solucion es generar un archivo antes de la hora o en la hora a partir de la cual queremos borrar.
Ejemplo:

00 15 * * * touch /arch/oradata/DBDIR/arch/filestamp
00 18 * * * find /arch/oradata/DBDIR/arch -name '*.arc*' ! -newer /arch/oradata/DBDIR/arch/filestamp -exec rm {} \;

La primer linea lo que hace es crear un archivo “dummy”(filestamp) que indica hasta que hora puede borrar los archivos. En este caso va a borrar los archivos hasta las 15 hrs.
La segunda linea busca los archivos que no son mas nuevos que el archivo “filestamp” (! -newer ).

a la proxima….

Sintaxis:
chkdbup -d [oraclesid]

Ejemplo:
chkdbup -d DEVDB

#!/bin/ksh
#######################################################################
#
# SCRIPT       : chkdbup
#
# DESCRIPTION  : This job will check if the database if up and running.
#                If there is an error it will send an email.
#
# INPUT FILES  : $DBA_BASE/init - configuration file
#              : $ORATAB - oracle oratab file
#              : $DBA_BASE/.forward - email notification file
#
# OUTPUT FILES : NONE
#
# CALLED OBJECT: $SCRIPTS/switchdb.ksh - switches environment
#                and variables to a specific SID.
# ASSUMPTIONS  : none
#
# SETUP INSTRUCTIONS : Need to switchdb first to a default.
#
# COMMAND LINE EXECUTION: chkdbup
#
# EXAMPLE: chkdbup DEVDB
#
# RESTART INSTRUCTIONS: rerun script
# SPECIAL CONSIDERATIONS: NONE
#######################################################################
# Modification Log:
# Version Date        Name              Description
#######################################################################
# 1.0     28-Jul-2006 Delfino Nunez     Initial Creation
#######################################################################

########################################################################
# FUNCTION   : showHelp
# DESCRIPTION: Print the help for using the script
########################################################################
function showHelp {
			echo " Argument      Description"
      echo " ------------  ----------------------------------------------"
      echo " -d [sid]      Oracle sid to check."
      echo " -h            This help."
}
########################################################################
# Main Program start here
########################################################################

#variable declaration
. $DBA_BASE/init
export SID=$1
BOXNAME=`uname -n`
MAILIDS=`cat $DBA_BASE/.forward`
export dbpass=`cat $PWDFILE`
export EMAILMSG=$TMP/chkdbup.txt

DATETIME=`date '+%Y-%m-%d-%T'`

#check parameters
if [ "$1" != "" ]
then
while [ "$#" != "0" ]
do
  case $1 in
    -d)
      shift
      if [ "$1" != "" ]; then
        export ORACLE_SID=$1
        shift
      fi
    ;;
    -h)
      showHelp
      exit 0;
    ;;
    *)
      echo "Bad argument: $1"
      showHelp

      exit 1;
    ;;
  esac
done
else
	showHelp
	exit 1
fi

if [ -a $EMAILMSG ]
then
	rm $EMAILMSG
fi

. $SCRIPTS/switchdb.ksh $ORACLE_SID
sqlplus -s /nolog > /dev/null 2>&1 <
    whenever sqlerror exit failure
    connect $dbpass
    select count(*) from dual;
    exit success
EOF

if [[ $? -ne 0 ]]
then
   echo "The following database is not open, please check this problem:\n" >> $EMAILMSG
	 echo "Instance: $ORACLE_SID" >> $EMAILMSG
	 mailx -s "WARNING The database is not open - $BOXNAME:$ORACLE_SID $DATETIME" $MAILIDS < $EMAILMSG
   exit 1
fi

El email seria similar al siguiente:
—–Original Message—–
From: Oracle DBA [mailto:oracle@server.com]
Sent: Friday, July 28, 2006 12:31 PM
To: Nunez, Delfino
Subject: WARNING The database is not open – DEVSERVER:DEVDB 2006-07-28-12:31:01

Instance: DEVDB

Se puede combinar con el siguiente script para que verifique todas las bases que estan en el servidor (oratab).

#!/bin/ksh
#######################################################################
#
# SCRIPT       : all.chkdbup
#
# DESCRIPTION  : This script will call chkdbup script for all databases
#
# INPUT FILES  : $DBA_BASE/init - configuration file
#
# OUTPUT FILES : NONE
#
# CALLED OBJECT: all.chkdbup
# ASSUMPTIONS  : NONE
#
# SETUP INSTRUCTIONS : Need to switchdb first to a default.
#
# COMMAND LINE EXECUTION:
#
# EXAMPLE:
#
# RESTART INSTRUCTIONS: rerun script
# SPECIAL CONSIDERATIONS: NONE
#######################################################################
# Modification Log:
# Version Date        Name              Description
#######################################################################
# 1.0     27-Jun-2006 Delfino Nunez     Initial Creation
#######################################################################

############################################################################
# MAIN PROGRAM STARTS HERE
############################################################################

. $HOME/dba/init
priority=1

if [ -f /var/opt/oracle/oratab ]
then
   export ORATAB='/var/opt/oracle/oratab'
elif [ -f /etc/oratab ]
then
   export ORATAB='/etc/oratab'
else
# following code from Steve Larson
   FOUND_ORATAB=$( find / -name oratab 2>/dev/null | head -1 )
   if [ "$FOUND_ORATAB" ] && [ -f "$FOUND_ORATAB" ]
   then
       ORATAB="$FOUND_ORATAB"
   else
       exit 1
   fi
fi

if [ "$#" != "0" ]
then
    ORACLE_SID=$1
    shift
    export ORACLE_SID
else
    for ORACLE_SID in `awk -F: '$1 !~ /\#/ && $1 !~ /\*/ {print $1}' $ORATAB`
    do
        swdb $ORACLE_SID
        chkdbup $ORACLE_SID
    done
fi

• Los siguientes scripts permiten obtener el espacio utilizado y libre de los tablespaces, uno lo obtiene en base el porcentaje libre de espacio y el otro obtiene el espacio en base a los MB libres. Estos scripts reciben dos parametros: &1 .- es el directorio y archivo donde se va a crear el reporte(spool) y &2 que es el limite ya sea porcentaje (99) o Mb(99999).

tablespace_size_pct.sql

SET line 132
SET pages 50
SET pause OFF
SET feedback OFF
SET echo OFF
SET verify OFF

COLUMN c1 heading "Tablespace|Name"
COLUMN c2 heading "File|Count"
COLUMN c3 heading "Allocated|in MB"
COLUMN c4 heading "Used|in MB"
COLUMN c5 heading "%|free" format 99.99
COLUMN c6 heading "Free|in MB"
COLUMN c7 heading "%|used" format 99.99

spool &1;

SELECT c1,ROUND(c3,2) c3,ROUND(c4,2) c4,ROUND(c6,2) c6,ROUND(c7,2) c7,ROUND(c5,2) c5,c2
FROM(
SELECT   NVL (b.tablespace_name, NVL (a.tablespace_name, 'UNKOWN')) c1,
         mbytes_alloc c3, mbytes_alloc - NVL (mbytes_free, 0) c4,
         NVL (mbytes_free, 0) c6,
         ((mbytes_alloc - NVL (mbytes_free, 0)) / mbytes_alloc) * 100 c7,
           100
         - (((mbytes_alloc - NVL (mbytes_free, 0)) / mbytes_alloc) * 100) c5,
         b.files c2
    FROM (SELECT   SUM (BYTES) / 1024 / 1024 mbytes_free, tablespace_name
              FROM SYS.dba_free_space
          GROUP BY tablespace_name) a,
         (SELECT   SUM (BYTES) / 1024 / 1024 mbytes_alloc, tablespace_name,
                   COUNT (file_name) files
              FROM SYS.dba_data_files
          GROUP BY tablespace_name) b
   WHERE a.tablespace_name(+) = b.tablespace_name
UNION ALL
SELECT   f.tablespace_name,
         SUM (ROUND ((f.bytes_free + f.bytes_used) / 1024 / 1024, 2)
             ) "total MB",
         SUM (ROUND (NVL (p.bytes_used, 0) / 1024 / 1024, 2)) "Used MB",
         SUM (ROUND (  ((f.bytes_free + f.bytes_used) - NVL (p.bytes_used, 0)
                       )
                     / 1024
                     / 1024,
                     2
                    )
             ) "Free MB",
           (SUM (ROUND (NVL (p.bytes_used, 0) / 1024 / 1024, 2)) * 100)
         / (SUM (ROUND ((f.bytes_free + f.bytes_used) / 1024 / 1024, 2))),
           100
         -   (SUM (ROUND (NVL (p.bytes_used, 0) / 1024 / 1024, 2)) * 100)
           / (SUM (ROUND ((f.bytes_free + f.bytes_used) / 1024 / 1024, 2))),
         COUNT (d.file_name)
    FROM SYS.v_$temp_space_header f,
         dba_temp_files d,
         SYS.v_$temp_extent_pool p
   WHERE f.tablespace_name(+) = d.tablespace_name AND f.file_id(+) = d.file_id
         AND p.file_id(+) = d.file_id
GROUP BY f.tablespace_name)
WHERE C1 NOT IN('USERS')
  AND C7 >= &2
ORDER BY c6 ASC;

spool off;
exit;

tablespace_size_spc.sql

SET line 132
SET pages 50
SET pause OFF
SET feedback OFF
SET echo OFF
SET verify OFF

COLUMN c1 heading "Tablespace|Name"
COLUMN c2 heading "File|Count"
COLUMN c3 heading "Allocated|in MB"
COLUMN c4 heading "Used|in MB"
COLUMN c5 heading "%|free" format 99.99
COLUMN c6 heading "Free|in MB"
COLUMN c7 heading "%|used" format 99.99

spool &1;

SELECT c1,ROUND(c3,2) c3,ROUND(c4,2) c4,ROUND(c6,2) c6,ROUND(c7,2) c7,ROUND(c5,2) c5,c2
FROM(
SELECT   NVL (b.tablespace_name, NVL (a.tablespace_name, 'UNKOWN')) c1,
         mbytes_alloc c3, mbytes_alloc - NVL (mbytes_free, 0) c4,
         NVL (mbytes_free, 0) c6,
         ((mbytes_alloc - NVL (mbytes_free, 0)) / mbytes_alloc) * 100 c7,
           100
         - (((mbytes_alloc - NVL (mbytes_free, 0)) / mbytes_alloc) * 100) c5,
         b.files c2
    FROM (SELECT   SUM (BYTES) / 1024 / 1024 mbytes_free, tablespace_name
              FROM SYS.dba_free_space
          GROUP BY tablespace_name) a,
         (SELECT   SUM (BYTES) / 1024 / 1024 mbytes_alloc, tablespace_name,
                   COUNT (file_name) files
              FROM SYS.dba_data_files
          GROUP BY tablespace_name) b
   WHERE a.tablespace_name(+) = b.tablespace_name
UNION ALL
SELECT   f.tablespace_name,
         SUM (ROUND ((f.bytes_free + f.bytes_used) / 1024 / 1024, 2)
             ) "total MB",
         SUM (ROUND (NVL (p.bytes_used, 0) / 1024 / 1024, 2)) "Used MB",
         SUM (ROUND (  ((f.bytes_free + f.bytes_used) - NVL (p.bytes_used, 0)
                       )
                     / 1024
                     / 1024,
                     2
                    )
             ) "Free MB",
           (SUM (ROUND (NVL (p.bytes_used, 0) / 1024 / 1024, 2)) * 100)
         / (SUM (ROUND ((f.bytes_free + f.bytes_used) / 1024 / 1024, 2))),
           100
         -   (SUM (ROUND (NVL (p.bytes_used, 0) / 1024 / 1024, 2)) * 100)
           / (SUM (ROUND ((f.bytes_free + f.bytes_used) / 1024 / 1024, 2))),
         COUNT (d.file_name)
    FROM SYS.v_$temp_space_header f,
         dba_temp_files d,
         SYS.v_$temp_extent_pool p
   WHERE f.tablespace_name(+) = d.tablespace_name AND f.file_id(+) = d.file_id
         AND p.file_id(+) = d.file_id
GROUP BY f.tablespace_name)
WHERE C1 NOT IN('USERS')
  AND C6 <= &2
ORDER BY c6 ASC;

SPOOL OFF;
exit;

• Con el siguiente script podemos ejecutar los SQL scripts anteriores dependiendo los parametros que le enviemos. La forma de ejecutar el script es la siguiente:
  • Para reportar en base al espacio, despues del parametro -d debe seguir el nombre de la instancia (SID), despues del parametro -s sigue la cantidad minima que puede tener libre un tablespace:
    • tbs_monitor.ksh -d DEVELOPMENT -s 500

      Connected.
      Instance: DEVELOPMENT
      Tablespaces with usage < 500 MB.
      
      Tablespace                      Allocated       Used       Free      %      %       File
      Name                                in MB      in MB      in MB   used   free      Count
      ------------------------------ ---------- ---------- ---------- ------ ------ ----------
      SYSTEM                                600     403.13     196.88  67.19  32.81          1
      IDX1                                11741      11363        378  96.78   3.22          3

  • Para reportar en base al porcentaje, en lugar de utilizar el parametro -s se utiliza el parametro -p seguido del porcentaje maximo que puede tener un tablespace:
    • tbs_monitor.ksh -d DEVELOPMENT -p 80

  • Connected.
    Instance: DEVELOPMENT
    Tablespaces with usage >= 80%.
    
    Tablespace                      Allocated       Used       Free      %      %       File
    Name                                in MB      in MB      in MB   used   free      Count
    ------------------------------ ---------- ---------- ---------- ------ ------ ----------
    IDX1                                11741      11363        378  96.78   3.22          3
    IDX2                                 3201       2696        505  84.22  15.78          2
    IDX5                                18385      17394        991  94.61   5.39          3
    DATA02                              13312   11520.13    1791.88  86.54  13.46          2
    DATA03                              33797   31709.13    2087.88  93.82   6.18          4
    DATA01                              56629   46606.38   10022.63  82.30  17.70          7

tbs_monitor.ksh

#!/bin/ksh
#######################################################################
#
# SCRIPT       : tbs_monitor.ksh
#
# DESCRIPTION  : This script will monitor usage in tablespaces of a database.
#                If the usage is >= 90% it will send an email to the DBA group.
#
# INPUT FILES  : [oracle_sid] only one database is processed
#
# OUTPUT FILES : NONE
#
# CALLED OBJECT: $SCRIPTS/switchdb.ksh
# ASSUMPTIONS  : NONE
#
# SETUP INSTRUCTIONS : NONE
#
# COMMAND LINE EXECUTION: tbs_monitor.ksh -d [oracle_sid] [-s sizeinMB] [-p pct]
#
# EXAMPLE: tbs_monitor.ksh -d DEV -s 300
# EXAMPLE: tbs_monitor.ksh -d DEV -p 85
#
# RESTART INSTRUCTIONS: rerun script
# SPECIAL CONSIDERATIONS: NONE
#######################################################################
# Modification Log:
# Version Date        Name              Description
#######################################################################
# 1.0     04-Jul-2006 Delfino Nunez     Initial Creation
#######################################################################

########################################################################
# FUNCTION   : showHelp
# DESCRIPTION: Print the help for using the script
########################################################################
function showHelp {
			echo " Argument      Description"
      echo " ------------  ----------------------------------------------"
      echo "  -d [sid]     Oracle sid to check."
      echo "  -p xx        Report on percentage usage(pct > xx)."
      echo "  -s xxxxxx    Report on MB size usage(sizeMB < xxxxxx)."
      echo "  -h           This help."
      echo " \n\n EXAMPLE: "
      echo "          Report tablespaces that have more than 95% space used"
      echo "          tbs_monitor.ksh -s EDS2TSDE -p 95"
      echo "          Report tablespaces that have less than 300Mb space"
      echo "          tbs_monitor.ksh -s EDS2TSDE -s 300"
}

########################################################################
# Main Program start here
########################################################################
# Verify input paramtter and set environment variables
#parm_list=$@
. $DBA_BASE/init
#set -- $parm_list

#check parameters
if [ "$1" != "" ]
then
while [ "$#" != "0" ]
do
  case $1 in
    -s)
      shift
      if [ "$1" != "" ]; then
        export RPTTYPE="SIZE"
        export PSIZE=$1
        shift
      fi
    ;;
    -d)
      shift
      if [ "$1" != "" ]; then
        export ORACLE_SID=$1
        shift
      fi
    ;;
    -p)
      shift
      if [ "$1" != "" ]; then
        export RPTTYPE="PCT"
        export PSIZE=$1
        shift
      fi
    ;;
    -h)
      showHelp

      exit 0;
    ;;
    *)
      echo "Bad argument: $1"
      showHelp

      exit 1;
    ;;
  esac
done
else
	showHelp
	exit 1
fi

. $SCRIPTS/switchdb.ksh $ORACLE_SID

BOXNAME=`uname -n`
MAILIDS=`cat $DBA_BASE/.forward`

# point to where the rpt file will go
export RPTFILE=$TMP/${ORACLE_SID}_tablespace_rpt.txt
export EMAILMSG=$TMP/tbs_email.txt
export dbpass=`cat $PWDFILE`

# should not need to be changed
export DATE=$(date +%y-%m-%d.%H:%M:%S)

#remove any previous file
if [ -a $RPTFILE ]
then
	rm $RPTFILE
fi
if [ -a $EMAILMSG ]
then
	rm $EMAILMSG
fi

#Run the status report.

case "$RPTTYPE" in
	"PCT")
	   MESSAGE="Tablespaces with usage >= $PSIZE%."
	   sqlplus -s /nolog <
connect $dbpass
prompt Instance: $ORACLE_SID
prompt Tablespaces with usage >= $PSIZE%.
@$SQL/tablespace_size_pct.sql $RPTFILE $PSIZE
EOF

	   ;;
	"SIZE")
     MESSAGE="Tablespaces with usage <= $PSIZE Mb."
	   sqlplus -s /nolog <
connect $dbpass
prompt Instance: $ORACLE_SID
prompt Tablespaces with usage < $PSIZE MB.
@$SQL/tablespace_size_spc.sql $RPTFILE $PSIZE
EOF
	   ;;
esac

#tablespace with problems
if [[ -s $RPTFILE ]]; then
	echo "The following database have problems with the size of their tablespaces:\n" >> $EMAILMSG
	echo "Instance: $ORACLE_SID" >> $EMAILMSG
	echo $MESSAGE >> $EMAILMSG
	cat $RPTFILE >> $EMAILMSG
  mailx -s "ALERT!!! Tablespace Usage Problems - $BOXNAME:$ORACLE_SID $DATE" $MAILIDS < $EMAILMSG
fi

• Y el ultimo script nos permite obtener el reporte para todas las bases que se encuentran en el servidor. Este script lee el archivo ORATAB y saca todas las bases de datos registradas en el servidor. Este script se puede poner en el crontab de la siguiente manera:
• 00 00-01,06-23 * * * /home/oracle/dba/scripts/all.tbs_monitor -p >/dev/null 2>&1
• Aqui le estamos diciendo al crontab que ejecute el script cada hora excepto de 2am-5am, esto por cuestiones de respaldos.
• Si no se quiere procesar todas las bases de datos y solo se quiere verificar algunas entonces es necesario de calendarizar el script tbs_monitor.ksh por cada una de las bases de datos.

all.tbs_monitor

#!/bin/ksh
#######################################################################
#
# SCRIPT       : all.tbs_monitor
#
# DESCRIPTION  : This script will call tbs_monitor script for all databases
#
# INPUT FILES  : $DBA_BASE/init - configuration file
#                -a all databases are processed
#                -p production (*PD) databases are processed
#
# OUTPUT FILES : NONE
#
# CALLED OBJECT: tbs_monitor
# ASSUMPTIONS  : NONE
#
# SETUP INSTRUCTIONS : Need to switchdb first to a default.
#
# COMMAND LINE EXECUTION:
#
# EXAMPLE:
#
# RESTART INSTRUCTIONS: rerun script
# SPECIAL CONSIDERATIONS: NONE
#######################################################################
# Modification Log:
# Version Date        Name              Description
#######################################################################
# 1.0     04-Jul-2006 Delfino Nunez     Initial Creation
#######################################################################

############################################################################
# MAIN PROGRAM STARTS HERE
############################################################################

. $HOME/dba/init
priority=1

########################################################################
# FUNCTION   : showHelp
# DESCRIPTION: Print the help for using the script
########################################################################
function showHelp {
			echo " Argument      Description"
      echo " ------------  ----------------------------------------------"
      echo " -p            Only production databases."
      echo " -a            All databases."
      echo " -h            This help."
      echo " \n\n EXAMPLE: all.tbs_monitor -a"
      echo "          all.tbs_monitor -p"
}

########################################################################
# Main Program start here
########################################################################
if [ -f /var/opt/oracle/oratab ]
then
   export ORATAB='/var/opt/oracle/oratab'
elif [ -f /etc/oratab ]
then
   export ORATAB='/etc/oratab'
else
# following code from Steve Larson
   FOUND_ORATAB=$( find / -name oratab 2>/dev/null | head -1 )
   if [ "$FOUND_ORATAB" ] && [ -f "$FOUND_ORATAB" ]
   then
       ORATAB="$FOUND_ORATAB"
   else
       exit 1
   fi
fi

#check parameter
if [ "$1" != "" ]
then
while [ "$#" != "0" ]
do
  case $1 in
  	-p)
      export INSTANCES=`awk -F: '$1 !~ /\#/ && $1 !~ /\*/ {print $1}' $ORATAB|grep "PD"`
      shift
    ;;
    -a)
      export INSTANCES=`awk -F: '$1 !~ /\#/ && $1 !~ /\*/ {print $1}' $ORATAB`
      shift
    ;;
    -h)
      showHelp
      exit 0;
    ;;
    *)
      echo "Bad argument: $1"
      echo ""
    	showHelp
      exit 1;
    ;;
  esac
done
else
	showHelp
	exit 1
fi

if [ "$#" != "0" ]
then
    ORACLE_SID=$1
    shift
    export ORACLE_SID
else
    for ORACLE_SID in $INSTANCES
    do
        swdb $ORACLE_SID
        tbs_monitor.ksh -d $ORACLE_SID -s 300
    done
fi

Los scripts utilizan otros scripts o archivos que no estan incluidos aqui y que voy a ir publicando, pero estos scripts pueden usarse como base para crear unos personalizados.

Ejemplo de buscar create table

Ahora esta mas padre buscar información sobre un comando o un concepto de oracle gracias a esta herramienta.

Si tienen Firefox pueden instalar un pluggin para hacer busquedas directamente:
Plugin de Firefox

Si utilizan IE agreguen un boton al Google toolbar:
Plugin IE

Lo ultimo que estabamos esperando para completar los requisitos de migración eran las cartas del FBI(que solo se las piden a los que viven en la frontera con EU). Pues al fin llegaron este fin de semana y pues en chinga me fui a enviarlas por paqueteria a la embajada de canada ya que esta semana se terminaba el plazo para poder enviar toda la documentación.
Ya esta todo listo de nuestro lado y la verdad no fue muy dificil conseguir todo, fue talachero nada mas, y pues ahora nos queda nada mas esperar a que llegue mas información o nos llegue la visa :).

Intuí que se referia al simbolo “#” debido a que el ejemplo mostraba lo siguiente:

111 Kate         $49,000
       122 Lindsey      $52,000
                     ----------- ******
                       ######## sum

Busque en internet que era y este es e link del significado octothorpe… interesante.
http://en.wiktionary.org/wiki/Octothorpe

Anteriormente se menciono que una vez asignado el password al listener ya no se podian ejecutar comandos hasta dar el password de listener. Esto es lo que sucede si se da un comando antes de autentificarse:

LSNRCTL> stat
Connecting to (DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=xxx.xxx.xxx.xxx)(PORT=1521)))
TNS-01169: The listener has not recognized the password

Si agregamos el comando

lsnrctl start/stop

dentro de un shell script, este script nunca funcionaria. Por lo tanto se debe buscar una manera de poder darle el password dentro del script de manera segura, para esto, el lsnrctl nos permite poner el password encriptado.
Como se muestra aqui:

set password C92EDAE88E0FA666

Este password es el mismo que esta almacenado dentro del archivo listener.ora.

Ahora podemos crear un shell script que baje y suba el listener.
Este seria el script para subir el listener.

#!/bin/sh
# ==========================================================================
# Script:         /home/oracle/scripts/backups/startlistener.sh
# Written by:     Delfino Nunez
# First Release:  05-May-2006
# Purpose:        Startup listener
# ==========================================================================
#                       M O D I F I C A T I O N S
#  05/05/06  Delfino Nunez Creation
# ==========================================================================

/ohome/oracle/app/product/9.2.0/bin/lsnrctl >> $LOGFILE << EOF
set password C92EDEE98E0FA357
start
exit
EOF

Para bajar el listener lo unico que se necesita cambiar es la instruccion start.

Una vez que ya se tienen los scripts se pueden candelarizar dentro del “cron”.

El lsnrctl es el programa para subir(start) y bajar(stop) el proceso del listener (tnslnsr) además de permitir realizar algunas configuraciones. Cuando el tnslnsr se ejecuta éste lee la información (configuración) guardada en el archivo listener.ora.

Modos del listener
El listener puede ser configurado en los siguientes modos:
1. Database Provee acceso por medio de la red a una instancia de Oracle.
2. PLSExtProc Es un método para los paquetes de PL/SQL para acceder ejectutables dentro del sistema operativo.
3. Executable Provee acceso a ejecutables por medio de la red.
El modo database es el más utilizado para realizar conecciones a una base de datos. El modo PLSExtProc es utilizado para acceder a ejecutables en el sistema operativo y esta configurado por default. El modo executable permite definir a un ejecutable para ser accesible por medio de una conexión TNS, regularmente esta opción solo se utiliza en Oracle Applications.

Asegurando el listener
Si un password no esta puesto en el listener, alguien que conozca el nombre del host (o dirección IP) y el puerto del listener (default 1521) puede tener control del listener gracias a que el listener se puede controlar de manera remota.
Lo que se puede controlar es lo siguiente:
• Bajar el listener.
• Poner un password para que nadie lo pueda controlar.
• Obtener información detallada del listener, la base de datos y la aplicación al generar logs.
Poner el password
Para asignar un password al listener es muy sencillo y se puede realizar de dos maneras. La primera es asignarlo por medio del archivo de configuración listener.ora con el parametro “PASSWORDS_” pero el inconveniente es que el password quedara de manera clara en el archivo. La forma recomendada es hacerlo por medio del programa lsnrctl como sigue:
Primero corremos el comando stat para saber si hay password asignado:

LSNRCTL> status
Connecting to (DESCRIPTION=(ADDRESS=(PROTOCOL=IPC)(KEY=EXTPROC1)))
STATUS of the LISTENER
------------------------
Alias                     LISTENER
Version                   TNSLSNR for 32-bit Windows: Version 10.2.0.1.0 - Production
Start Date                28-MAY-2006 15:49:28
Uptime                    0 days 0 hr. 35 min. 37 sec
Trace Level               off
Security                  ON: Local OS Authentication
SNMP                      OFF

Como se puede observar en la parte de Security aparece ON: Local OS Authentication debido a que se esta utilizando Oracle 10g, en la version 9i apareceria OFF como lo muestra el siguiente ejemplo:

LSNRCTL> stat
Connecting to (DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=xxxxxxxxxx)(PORT=1521)))
STATUS of the LISTENER
------------------------
Alias                     LISTENER
Version                   TNSLSNR for HPUX: Version 9.2.0.6.0 - Production
Start Date                29-MAY-2006 05:48:47
Uptime                    0 days 11 hr. 54 min. 40 sec
Trace Level               off
Security                  OFF
SNMP                      OFF

Una vez que se verifica que no se tiene asignado un password se lo asignamos:

LSNRCTL> change password
Old password:
New password:
Reenter new password:
LSNRCTL> save_config
Connecting to (DESCRIPTION=(ADDRESS=(PROTOCOL=IPC)(KEY=EXTPROC1)))
No changes to save for LISTENER.
The command completed successfully

En este caso se asigno el password TEST, si verificamos el archivo listener.ora podemos verificar que el password fue asignado al parametro mencionado anteriormente.

LSNRCTL> stat
Connecting to (DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=xxxxxxxx)(PORT=1521)))
STATUS of the LISTENER
------------------------
Alias                     LISTENER
Version                   TNSLSNR for HPUX: Version 9.2.0.6.0 - Production
Start Date                29-MAY-2006 05:48:47
Uptime                    0 days 11 hr. 54 min. 40 sec
Trace Level               off
Security                  ON
SNMP                      OFF

Ahora se puede ver que la opción de security esta en ON, esto indica que tiene asignado un password.

Ahora cada vez que se requiera hacer algo con el lsnrctl se debe proveer el password antes de realizarlo, si no mostrará un error como el siguiente:

LSNRCTL> stat
Connecting to (DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=xxxxxxxxx)(PORT=1521)))
TNS-01169: The listener has not recognized the password

Debemos proveer el password:

LSNRCTL> set password
Password:
The command completed successfully

Una vez puesto el password el archivo listener.ora tiene una nueva linea de configuración donde esta asignado el password.

#----ADDED BY TNSLSNR 29-MAY-2006 10:49:45---
PASSWORDS_LISTENER = AB2E99998E0FZZZZ
#--------------------------------------------

P.D. Voy a comenzar a escribir tambien un poco de Oracle para contribuir a la comunidad. Y para practicar en el frances tambien lo voy a traducir(eso espero!!!!).

Au Revoir.

Voy a comenzar por el primero y más importante. Es la segunda vez que voy al D.F. de vacaciones, la primer vez me pareció impresionante y diferente pero desgraciadamente no conocí tantos lugares como en ésta segunda vez. Estas ultimas vacaciones salieron como pretexto de la cita que teníamos en las oficinas de Québec pero debido a que esta entrevista estaba programada para el día Jueves 23 de Febrero y de cualquier manera debíamos pagar el transporte de Juárez-México y viceversa, optamos (mi esposa y yo) tomarnos una semana de vacaciones de sábado a sábado para conocer la ciudad.

Sábado

Llegamos el sábado al hotel Fiesta Americana reforma, se ubica frente al monumento a Colón y muy cerca del centro histórico, por cerca me refiero a 20 o 30 minutos caminando. El primer día fuimos a dar una vuelta por el centro histórico pasando por el palacio de bellas artes y la torre latinoamericana; estuvimos caminando por las calles aledañas para conocer los alrededores.

Domingo, MUUUUCHAS VACAS!!!!

El domingo es un gran día para ir a los museos de la ciudad ya que la gran mayoría son gratuitos y por lo tanto nosotros optamos ir al museo de antropología e historia y al castillo de Chapultepec. Antes de llegar al museo nos encontramos con una exposición en la calle del Cow Parade y básicamente son vacas de tamaño natural que están pintadas con diferentes temas, algunas vacas estaban pintadas muy padre y otras si eran muy aburridas.

El museo de antropología e historia es impresionante contiene muchas piezas de las culturas que habitaron México como esculturas, vasijas, instrumentos de caza, etc. Además de contener en la planta baja todo lo relacionado con las culturas Mayas, Mexicas, Toltecas y otras más; la segunda planta la tiene dedicada a todos los pueblos indígenas que habitan en la actualidad el país. Me impresionó tanto como nuestro querido México es tan rico en cultura y diversidad y como la gran mayoría de sus habitantes lo conocemos tan poco. Me dio mucho gusto saber que muchas de las piezas aún sigan aquí en México, lastima que no todo el mundo pueda admirarlas sobre todo los niños, este museo seria de gran ayuda para comprender todo lo que se nos enseña en la escuela, ver todo esto en vivo me recuerda los libros de historia de la primaria, ojala tuviéramos un museo de antropología en cada ciudad, seria muy agradable.

Después de terminar la visita al museo de antropología y comer una torta en un puesto a las afueras del museo, continuamos con el recorrido histórico hacia el Castillo de Chapultepec. Para poder llegar al castillo hay que subir un cerro por medio de calle empedrada que rodea el cerro de su base hasta la cima donde se encuentra el castillo de ahí los guardias lo dirigen a las habitaciones del castillo; ahí se pueden observar las habitaciones de lujo que fueron ocupadas por Maximiliano y Carlota, Benito Juárez, Díaz y obviamente los niños héroes. Es impresionante saber como estos personajes vivían en el lujo en aquella época mientras el pueblo estaba en la mísera. Éste es un lugar que todo mexicano debería de conocer, es un lugar muy enriquecedor.

Lunes

Otro día cultural, lo comenzamos yendo a desayunar a un lugar que se encuentra cerca del hotel donde hacen desayunos ricos y unas aguas frescas de frutas naturales muy buenas y todo por la increíble cantidad de $100 pesos. Tomamos el metro con dirección a Indios Verdes y nos bajamos en la estación la raza para dirigirnos a la estación de autobuses del norte donde abordamos un autobús con dirección a Teotihuacan. Después de un viaje de alrededor de 40 minutos llegamos a Teotihuacan, entramos por la puerta 2 por donde no se veía ningún vestigio de pirámide, yo me imaginaba que se podría ver la pirámide del sol desde una distancia lejana pero no fue así. La primer pirámide que nos quedaba cerca era la pirámide de Quetzalcoatl, ésta pirámide no es muy impresionante y no es tan visitaba como las otras dos, lo que tiene de especial es que primero se tiene que subir una pequeña pirámide para poder ver la segunda (a la cual no se tiene acceso), pero lo interesante de la segunda es que tiene figuras de Quetzalcoatl. La segunda pirámide a la que subimos es la pirámide de Sol, ésta es a la que todo mundo quiere subir; es interesante y muy fatigante subir esta pirámide, tiene escalones “normales” y otros demasiado inclinados, algunas personas intentan subirla sin descansar en los “pisos” pero al llegar a la cima llegan fatigados, bueno, todos llegamos fatigados pero algunas personas llegan mareados y casi desmayan. Pero lo importante es llegar a la cima y subir sus 235 escalones y contemplar desde esa altura todo el complejo arqueológico. Por un momento le pasan a uno pensamientos sobre como vivían los aztecas en aquellos tiempos, sobre lo importante que es ese lugar sobre el que esta uno parado, yo creo que todo mundo que las visita piensa algo parecido, se imagina como fue la vida en este lugar… la siguiente pirámide fue la de la Luna, también un poco pesada la subida pero a diferencia de la del Sol ésta tiene un especie de explanada a la mitad de la pirámide además de estar mas destruida en la parte superior, pero es igual de impresionante que cualquiera de las pirámides.

Algo que me llamó la atención fue la gran cantidad de turistas extranjeros aún en temporada baja y en especial los turistas europeos; ya había yo platicado con amigos franceses sobre que lugares prefieren ellos y me comentaban que México era uno de sus principales 5 lugares para conocer y ahora constate esa selección, encontré gran cantidad de turistas franceses, otros que creo que eran griegos y unos cuantos americanos o ingleses. Pero me di cuenta que los franceses están muy interesados en conocer los lugares culturales, eso me dio gusto.

Martes

Continuamos con la onda cultural, este día se lo dedicamos al museo mural de Diego Rivera en el cual hay exposición de algunas pinturas y caricaturas, pero lo realmente importante del museo es el mural de Diego Rivera que se titula Sueño de una tarde dominical en la Alameda Central. De nuevo me recuerda a la primaria, el mural estaba en algún libro de la escuela; lo suave es que hay una explicación de cada personaje que aparece en el mural y cada cosa que fue pintaba en él. Algo que me llamo mucho la atención fue que en la paredes había fotografías y recortes de periódicos que explicaban como por todo lo que paso Diego al hacer el mural, un recorte de periódico que me capto mi atención fue uno que comentaba sobre una frase que existía originalmente en el mural y que decía “Dios no existe”, la frase causó tal revuelo en sus tiempos que incluso fue borrada por un grupo de estudiantes, Diego la volvió a retocar pero fue muy criticado y tuvo que cambiar la frase por una que no recuerdo, pero creo que la original era buena, jejejeeje.

Siguiente parada Munal o museo nacional de arte, este museo contiene un buen numero de pinturas religiosas las cuales me recordaron a las pinturas que había visto en Italia, también tiene muchas pinturas de Diego Rivera, Clemente Orozco y otros pintores mexicanos, de nuevo muchas pinturas me recordaron los libros de texto. En la planta baja había una exposición de Goya, en lo personal no me gusto mucho, no conozco lo suficiente de este pintor como para apreciarlo. Creo que este museo no le pide nada a los museos italianos tiene una muy buena colección de pinturas.

Después del Munal nos dirigimos al Palacio Nacional donde se encuentran gran cantidad de murales de Diego Rivera, se entra por la puerta del frente en la cual los guardias piden una identificación al entrar se ven algunos de los murales los cuales se aprecian claramente al subir las escaleras y en las paredes del lado izquierdo; son impresionantes, están realmente bonitos y además la entrada es gratis!!!, al terminar de ver los murales hay una sala en la que se muestran algunos documentos importantes entre ellos la carta de independencia de México.

Miércoles

Este día lo dedicamos a conocer las afueras del D.F. y nos dirigimos a Xochimilco, para llegar al lugar de las trajinera tuvimos que tomar el metro con dirección a barranca del muerto de ahí tomamos un tren ligero que nos llevaría a Xochimilco. Una vez que llegamos a la Terminal del tren ligero pensábamos que podríamos llegar por nuestra cuenta, pero gracias a una persona que estaba “cazando” turistas pudimos llegar a un embarcadero en el cual esta persona nos quería vender el paseo en trajinera a $350 pesos cuando en el hotel nos habían comentado que cobraban $100 pesos; después de muchas discusiones no llegamos a ningún acuerdo y lo más barato que nos cobraba fueron $200 pesos por una hora, al final lo mandamos a la goma y fuimos a buscar otros embarcaderos y así llegamos al embarcadero principal donde había un chingo de trajineras y donde rentamos una por $140 pesos la hora. Durante una hora ( o 45 minutos) nos paseo por algunos de los canales de Xochimilco los cuales están muy pintorescos, se pueden ver familias completas en la trajinera, trajineras que venden comida, trajineras con mariachis y marimbas, etc. Esta muy suave para ir de paseo con un grupo de amigos o con la familia y así poder pagar mas tiempo la trajinera tomar unas cheves y escuchar un mariachi. Después del paseo nos fuimos a comer a una fondita que habíamos visto y que nos llamo la atención allí comimos por la increíble cantidad de $40 pesotes, muy barato para lo que estamos acostumbrados aquí en Juárez. Continuamos nuestro camino en el metro, mi esposa quería ir a conocer la UNAM, pero como yo no sabia como llegar y la verdad no me interesaba ir a conocerla opte por ir con ella, al parecer ella pensaba que iba a salir de la estación del metro e iba a encontrar todos los edificios que se ven en la televisión, pero gran sorpresa, por algo le dicen ciudad universitaria, preguntamos a las personas que estaban cerca y muchos no sabían y otros nos dieron direcciones que nos llevaron mas lejos del lugar a donde queríamos ir; al final ni llegamos a la UNAM y termine por hacer un coraje por que nada mas caminábamos sin rumbo, nos regresamos al hotel a descansar para prepararnos para la cita de Québec…pero que corajote hice.

Jueves

Nos levantamos un poco tarde para poder descansar de la caminata del día anterior a las 12 del medio día apenas estábamos desayunando/comiendo, terminamos y nos dirigimos a Polanco donde esta ubicada la oficina de migración de Québec. Comenzamos a buscar el numero de la oficina en la calle que según yo me había aprendido de memoria pero gran error llegamos al final de la calle y no encontramos ni madres de oficina entonces optamos por ver los documentos y revisar la dirección, íbamos en sentido contrario, corregimos y llegamos fácilmente, llegamos 30 minutos antes de la hora pactada y estuvimos viendo algunos folletos y mapas que tienen en la sala de espera. Abren la puerta y sale una muchacha con todos sus documentos reborujados y al parecer contenta por que si fue aceptada. Nos recibe una vato y nos pide que pasemos a su oficina. Ya en la oficina se presenta y nos comienza a pedir los documentos y a decirnos que por favor hablemos francés para poder conocer el nivel que tenemos; mientras nos revisa los documentos nos hace preguntas y se las contestamos, al parecer no hay una estructura especial en la entrevista, nos pareció mas bien una entrevista de trabajo ya que nos pregunto muchísimo sobre que hacíamos, como lo hacíamos, por que lo hacíamos, etc. Al final nos comento que toda la documentación estaba bien que habíamos pasado la entrevista y que iba a escribir la carta (la cual tardo un buen rato de terminarla), una vez que nos entrego la carta nos hizo comentarios sobre el cambio que íbamos hacer en nuestra vida, que iba a ser un cambio radical y posiblemente difícil, que el nos recomendaba que continuáramos con el estudio del idioma y que aparte obtuviéramos algunas certificaciones para poder dar confianza a los empleadores de Québec cuando busquemos trabajo, nos hizo mucho hincapié en esto ya que muchas personas no están preparadas a ser rechazadas debido a que los empleadores no conocen los estudios y por lo tanto tienen desconfianza al emplear a alguien extranjero. Bueno todo salio bien, pero… la verdad no salimos gritando de alegría de la entrevista, no es que no estuviéramos concientes de todas las cosas que comento, si no que lo dijo con una crudeza que tal pareciera que te va a ir mal, y no es que me moleste que me lo digan, prefiero que nos digan la verdad y no que nos vendan un sueño que a lo mejor va a ser muy difícil lograr. Por el momento mi esposa y yo nos estamos preparando lo mas que podemos, tenemos ahorros, estamos aprendiendo el idioma (necesitamos practicarlo bastante) y pues tenemos que hacer muchos arreglos antes de irnos, esperamos partir para Febrero del 2007.

Viernes

Este día lo dedicamos a la cuestión religiosa, nos fuimos camino a la Villa de la virgen de Guadalupe, la verdad yo no la conocía, mi esposa ya sabia como era pero yo no. La primer impresión que tuve fue que no es tan grande como me la imaginaba, en la televisión se mira muy grande y la verdad no es así. Hay mucha gente devota que va directo a la basílica de rodillas, nunca pensé que vería eso, pero si, existe, hay mucha gente que es creyente, y muchísima. Otra cosa que me llamo la atención fue el tamaño de todo el complejo, además de la basílica hay otras iglesias y un pequeño parquecito con su cascada y toda la cosa. Una de las principales cosas que quería confirmar era si en la tilma de Juan Diego donde esta impresa la virgen estaba la famosa corona, por que la corona, bueno básicamente por que en la original la virgen tiene corona y en muchas pinturas que vi en los museos y ahí mismo en las iglesias las vírgenes tienen coronas y la virgen de la tilma no tiene corona, es raro, pero no voy a debatir sobre eso en este momento. Terminamos de dar una vuelta por el complejo y luego nos retiramos al hotel…o a otro lado…no recuerdo.

Sábado

Au revoir, adiós D.F. este fue nuestro ultimo día en la ciudad de México y básicamente lo dedicamos para irnos al aeropuerto donde se retraso el vuelo por mas de 2 horas…ni modo.