jueves, 17 de agosto de 2017

BULK COLLECT

http://www.oracle.com/technetwork/issue-archive/2008/08-mar/o28plsql-095155.html

DEVELOPER: PL/SQL Practices


On BULK COLLECT

By Steven Feuerstein Oracle ACE Director 

Best practices for knowing your LIMIT and kicking %NOTFOUND
I have started using BULK COLLECT whenever I need to fetch large volumes of data. This has caused me some trouble with my DBA, however. He is complaining that although my programs might be running much faster, they are also consuming way too much memory. He refuses to approve them for a production rollout. What's a programmer to do?
The most important thing to remember when you learn about and start to take advantage of features such as BULK COLLECT is that there is no free lunch. There is almost always a trade-off to be made somewhere. The tradeoff with BULK COLLECT, like so many other performance-enhancing features, is "run faster but consume more memory."
Specifically, memory for collections is stored in the program global area (PGA), not the system global area (SGA). SGA memory is shared by all sessions connected to Oracle Database, but PGA memory is allocated for each session. Thus, if a program requires 5MB of memory to populate a collection and there are 100 simultaneous connections, that program causes the consumption of 500MB of PGA memory, in addition to the memory allocated to the SGA.
Fortunately, PL/SQL makes it easy for developers to control the amount of memory used in a BULK COLLECT operation by using the LIMIT clause.
Suppose I need to retrieve all the rows from the employees table and then perform some compensation analysis on each row. I can use BULK COLLECT as follows:

PROCEDURE process_all_rows
IS
   TYPE employees_aat 
   IS TABLE OF employees%ROWTYPE
      INDEX BY PLS_INTEGER;
   l_employees employees_aat;
BEGIN
   SELECT *
   BULK COLLECT INTO l_employees
      FROM employees;
     
   FOR indx IN 1 .. l_employees.COUNT 
   LOOP
       analyze_compensation 
      (l_employees(indx));
   END LOOP;
END process_all_rows;


Very concise, elegant, and efficient code. If, however, my employees table contains tens of thousands of rows, each of which contains hundreds of columns, this program can cause excessive PGA memory consumption.
Consequently, you should avoid this sort of "unlimited" use of BULK COLLECT. Instead, move the SELECT statement into an explicit cursor declaration and then use a simple loop to fetch many, but not all, rows from the table with each execution of the loop body, as shown in Listing 1.
Code Listing 1: Using BULK COLLECT with LIMIT clause

PROCEDURE process_all_rows (limit_in IN PLS_INTEGER DEFAULT 100)
IS
    CURSOR employees_cur 
    IS 
        SELECT * FROM employees;

    TYPE employees_aat IS TABLE OF employees_cur%ROWTYPE
        INDEX BY PLS_INTEGER;

    l_employees employees_aat;
BEGIN   
    OPEN employees_cur;
    LOOP
        FETCH employees_cur 
            BULK COLLECT INTO l_employees LIMIT limit_in;

        FOR indx IN 1 .. l_employees.COUNT 
        LOOP
            analyze_compensation (l_employees(indx));
        END LOOP;

        EXIT WHEN l_employees.COUNT < limit_in;

   END LOOP;

   CLOSE employees_cur;
END process_all_rows;


The process_all_rows procedure in Listing 1 requests that up to the value of limit_in rows be fetched at a time. PL/SQL will reuse the same limit_in elements in the collection each time the data is fetched and thus also reuse the same memory. Even if my table grows in size, the PGA consumption will remain stable.
How do you decide what number to use in the LIMIT clause? Theoretically, you will want to figure out how much memory you can afford to consume in the PGA and then adjust the limit to be as close to that amount as possible.
From tests I (and others) have performed, however, it appears that you will see roughly the same performance no matter what value you choose for the limit, as long as it is at least 25. The test_diff_limits.sql script, included with the sample code for this column, demonstrates this behavior, using the ALL_SOURCE data dictionary view on an Oracle Database 11g instance. Here are the results I saw (in hundredths of seconds) when fetching all the rows (a total of 470,000):

Elapsed CPU time for limit of 1 = 1839
Elapsed CPU time for limit of 5 = 716
Elapsed CPU time for limit of 25 = 539
Elapsed CPU time for limit of 50 = 545
Elapsed CPU time for limit of 75 = 489
Elapsed CPU time for limit of 100 = 490
Elapsed CPU time for limit of 1000 = 501
Elapsed CPU time for limit of 10000 = 478
Elapsed CPU time for limit of 100000 = 527 


Kicking the %NOTFOUND Habit

I was very happy to learn that Oracle Database 10g will automatically optimize my cursor FOR loops to perform at speeds comparable to BULK COLLECT. Unfortunately, my company is still running on Oracle9i Database, so I have started converting my cursor FOR loops to BULK COLLECTs. I have run into a problem: I am using a LIMIT of 100, and my query retrieves a total of 227 rows, but my program processes only 200 of them. [The query is shown in Listing 2.] What am I doing wrong?
Code Listing 2: BULK COLLECT, %NOTFOUND, and missing rows

PROCEDURE process_all_rows
IS
   CURSOR table_with_227_rows_cur 
   IS 
      SELECT * FROM table_with_227_rows;

   TYPE table_with_227_rows_aat IS 
      TABLE OF table_with_227_rows_cur%ROWTYPE
      INDEX BY PLS_INTEGER;

   l_table_with_227_rows table_with_227_rows_aat;
BEGIN   
   OPEN table_with_227_rows_cur;
   LOOP
      FETCH table_with_227_rows_cur 
         BULK COLLECT INTO l_table_with_227_rows LIMIT 100;

         EXIT WHEN table_with_227_rows_cur%NOTFOUND;     /* cause of missing rows */

      FOR indx IN 1 .. l_table_with_227_rows.COUNT 
      LOOP
         analyze_compensation (l_table_with_227_rows(indx));
      END LOOP;
   END LOOP;

   CLOSE table_with_227_rows_cur;
END process_all_rows;


You came so close to a completely correct conversion from your cursor FOR loop to BULK COLLECT! Your only mistake was that you didn't give up the habit of using the %NOTFOUND cursor attribute in your EXIT WHEN clause.
The statement

EXIT WHEN 
table_with_227_rows_cur%NOTFOUND;


makes perfect sense when you are fetching your data one row at a time. With BULK COLLECT, however, that line of code can result in incomplete data processing, precisely as you described.
Let's examine what is happening when you run your program and why those last 27 rows are left out. After opening the cursor and entering the loop, here is what occurs:
1. The fetch statement retrieves rows 1 through 100. 
2. table_with_227_rows_cur%NOTFOUND evaluates to FALSE, and the rows are processed. 
3. The fetch statement retrieves rows 101 through 200. 
4. table_with_227_rows_cur%NOTFOUND evaluates to FALSE, and the rows are processed. 
5. The fetch statement retrieves rows 201 through 227. 
6. table_with_227_rows_cur%NOTFOUND evaluates to TRUE , and the loop is terminated—with 27 rows left to process!

Next Steps



When you are using BULK COLLECT and collections to fetch data from your cursor, you should never rely on the cursor attributes to decide whether to terminate your loop and data processing. 

So, to make sure that your query processes all 227 rows, replace this statement:

EXIT WHEN 
table_with_227_rows_cur%NOTFOUND; 

with

EXIT WHEN 
l_table_with_227_rows.COUNT = 0; 


Generally, you should keep all of the following in mind when working with BULK COLLECT:

  • The collection is always filled sequentially, starting from index value 1.
  • It is always safe (that is, you will never raise a NO_DATA_FOUND exception) to iterate through a collection from 1 to collection .COUNT when it has been filled with BULK COLLECT.
  • The collection is empty when no rows are fetched.
  • Always check the contents of the collection (with the COUNT method) to see if there are more rows to process.
  • Ignore the values returned by the cursor attributes, especially %NOTFOUND.

martes, 13 de junio de 2017

INITRANS

SQL> CREATE TABLE test (id NUMBER);

Table created.

SQL> SELECT ini_trans, max_trans from dba_tables WHERE table_name = 'TEST';

 INI_TRANS  MAX_TRANS
---------- ----------
         1        255

SQL> ALTER TABLE TEST INITRANS 5 MAXTRANS 255 ;

Table altered.

SQL> SELECT ini_trans, max_trans from dba_tables WHERE table_name = 'TEST' ;

 INI_TRANS  MAX_TRANS
---------- ----------
         5        255

jueves, 8 de junio de 2017

CREATE TRIGGER uptime_log

SQL>
SQL> CREATE TABLE uptime_log (
  2      database_name       VARCHAR2(30),
  3      event_name          VARCHAR2(20),
  4      event_time          DATE,
  5      triggered_by_user   VARCHAR2(30)
  6  );

Table created.

SQL>
SQL>
SQL> CREATE OR REPLACE TRIGGER log_shutdown
  2  BEFORE SHUTDOWN ON DATABASE
  3  BEGIN
  4      INSERT INTO uptime_log
  5          (database_name,
  6           event_name,
  7           event_time,
  8           triggered_by_user)
  9          VALUES (sys.database_name,
 10                  sys.sysevent,
 11                  sysdate,
 12                  sys.login_user);
 13      COMMIT;
 14  END;
 15  /

Trigger created.

SQL>
SQL> drop table uptime_log;

Table dropped.

sábado, 13 de mayo de 2017

BACKUP SPFILE

run { 
 allocate channel ch1 type Disk maxpiecesize = 1900M FORMAT '/path/hbk_%t_set%s_piece%p_dbid%I.rman'; 
 backup incremental level 0 
 tag cold_db_f 
 filesperset 1 
 (database); 
 backup archivelog all delete all input FORMAT '/path/hbk_%t_set%s_piece%p_dbid%I.rman'; 
 backup spfile format '/oradata/orcl/rmanb/spfile_%d_%s_%T_dbid%I.rman'; 
 backup current controlfile format '/path/ctl_%t_dbid%I.rman'; 
}

jueves, 30 de marzo de 2017

Guía para Maestría Avanzada de Comandos Linux Parte 2



Guía para Maestría Avanzada de Comandos Linux Parte 2

En la Parte 1 de la serie, usted aprendió algunos comandos útiles no tan conocidos y algunos de los comandos comúnmente utilizados pero con parámetros no tan conocidos para hacer su trabajo de manera más eficiente. Para continuar con la serie, ahora aprenderá algunos comandos Linux más avanzados útiles para los usuarios Oracle, ya sean desarrolladores o DBAs.
Alias y unalias
Supongamos que quiere verificar el grupo de variables del entorno ORACLE_SID de su shell. Deberá tipear:
echo $ORACLE_HOME

Como DBA o desarrollador, utiliza frecuentemente este comando y pronto se cansa de tipear los 16 caracteres. ¿Hay una manera más simple?
Sí: el comando alias. Con este enfoque, puede crear un breve alias, como "os", para representar todo el comando:
alias os='echo $ORACLE_HOME'

Ahora cuando quiera verificar ORACLE_SID, simplemente escriba "os" (sin comillas) y Linux ejecuta el comando con el alias.
No obstante, si se desconecta y se vuelve a conectar, el alias es eliminado y debe ingresar el comando alias nuevamente. Para eliminar este paso, todo lo que debe hacer es colocar el comando en su archivo de perfil shell. Para bash, el archivo es .bash_profile (note el punto antes del nombre de archivo, es parte del nombre de archivo) en su directorio de inicio. Para los shells bourne y korn, es .profile, y para c-shell, .chsrc.
Usted puede crear un alias para cualquier nombre. Por ejemplo, yo siempre creo un alias para el comando rm como rm -i, que hace que el comando rm sea interactivo.
alias rm=’rm -i’

Cuando emito un comando rm, Linux solicita mi confirmación, y a menos que agregue "y", no elimina el archivo—así quedo protegido ante la posibilidad de eliminar accidentalmente un archivo importante. Utilizo lo mismo para mv (para cambiar el archivo a otro nombre), lo cual evita la sobrescritura accidental de archivos existentes, y cp (para copiar el archivo).
A continuación, presentamos una lista de algunos alias muy útiles que quiero definir:
alias bdump='cd $ORACLE_BASE/admin/$ORACLE_SID/bdump'
alias l='ls -d .* --color=tty'
alias ll='ls -l --color=tty'
alias mv='mv -i'
alias oh='cd $ORACLE_HOME'
alias os='echo $ORACLE_SID'
alias rm='rm -i'
alias tns='cd $ORACLE_HOME/network/admin'

Para ver qué alias han sido definidos en su shell, use alias sin ningún parámetro.
Sin embargo, hay un pequeño problema. He definido un alias, rm, que ejecuta rm -i. Este comando solicitará mi confirmación cada vez que intente eliminar un archivo. ¿Pero qué sucede si quiero eliminar muchos archivos y estoy seguro de que pueden eliminarse sin mi confirmación?
La solución es simple: Para suprimir el alias y utilizar solo el comando, necesitaré ingresar dos comillas simples:
$ ''rm *

Fíjese que se trata de dos comillas simples (') antes del comando rm, no dos comillas dobles. Esto suprimirá el alias rm. Otro enfoque es utilizar una barra inversa (\):
$ \rm *

Para eliminar un alias previamente definido, simplemente utilice el comando unalias:
$ unalias rm


ls


El comando ls es frecuentemente utilizado pero pocas veces es utilizado en su totalidad. Sin ninguna opción, ls despliega meramente todos los archivos y directorios en formato tabular.
$ ls
admin            has                  mesg         precomp
apex             hs                   mgw          racg
assistants       install              network      rdbms
                         
... output snipped ...
                      
Para mostrarlos en una lista, use la opción -1 (el número 1, no la letra "l").
$ ls -1
admin
apex
assistants
                         
... output snipped ...
                      
Esta opción es útil en shell scripts donde los nombres de archivo necesitan incorporarse en otro programa o comando para la manipulación.
Seguramente, usted utilizó -l (la letra "l", no el número "1") que despliega todos los atributos de los archivos y directorios. Veámoslo una vez más:
$ ls -l 
total 272
drwxr-xr-x    3 oracle   oinstall     4096 Sep  3 03:27 admin
drwxr-x---    7 oracle   oinstall     4096 Sep  3 02:32 apex
drwxr-x---    7 oracle   oinstall     4096 Sep  3 02:29 assistants

La primera columna muestra el tipo de archivo y los permisos sobre él: "d" significa directorio, "-" significa archivo regular, "c" significa un dispositivo de caracteres, "b" significa un dispositivo de bloques, "p" significa named pipe, y "l" (letra minúscula L, no I) significa enlace simbólico.
Una opción muy útil es --color, que muestra los archivos en muchos colores diferentes de acuerdo con el tipo de archivo. Aquí hay un ejemplo:

Fíjese que los archivos 1 y 2 son archivos comunes. link1 es un enlace simbólico, que se muestra en rojo; dir1 es un directorio y se muestra en amarillo; y pipe1 es un named pipe, y se muestra en diferentes colores para una identificación más fácil.
En algunos distros, el comando ls viene preinstalado con un alias (descripto en la sección anterior) como ls --color; de manera que usted pueda ver los archivos en color cuando tipea "ls". Este enfoque puede no ser aconsejable, especialmente si tiene un output como ese arriba. Puede cambiar los colores, pero una forma más rápida puede ser simplemente suspender el alias:
$ alias ls="''ls"  

Otra opción útil es la opción -F, que añade un símbolo después de cada archivo para mostrar el tipo de archivo - una "/" después de los directorios, "@" después de enlaces simbólicos, y "|" después de named pipes.
$ ls -F
dir1/  file1  file2  link1@  pipe1|

Si tiene un subdirectorio en un directorio y quiere hacer solo una lista de ese directorio, ls -l le mostrará los contenidos del subdirectorio también. Por ejemplo, supongamos que la estructura de directorio es la siguiente:
/dir1
+-->/subdir1
+--> subfile1
+--> subfile2

El directorio dir1 tiene un subdirectorio subdir1 y dos archivos: subfile1 y subfile2. Si solo desea ver los atributos del directorio dir1, emite:
$ ls -l dir1
total 4
drwxr-xr-x    2 oracle   oinstall     4096 Oct 14 16:52 subdir1
-rw-r--r--    1 oracle   oinstall        0 Oct 14 16:48 subfile1
-rw-r--r--    1 oracle   oinstall        0 Oct 14 16:48 subfile2

Fíjese que el directorio dir1 no está en la lista del output. En cambio, se muestran los contenidos del directorio. Este es un comportamiento esperado cuando se procesan directorios. Para mostrar únicamente el directorio dir1, deberá utilizar el comando -d.
$ ls -dl dir1
drwxr-xr-x    3 oracle   oinstall     4096 Oct 14 16:52 dir1

Vea el output del siguiente output ls -l:
-rwxr-x--x    1 oracle   oinstall 10457761 Apr  6  2006 rmanO
-rwxr-x--x    1 oracle   oinstall 10457761 Sep 23 23:48 rman
-rwsr-s--x    1 oracle   oinstall 93300507 Apr  6  2006 oracleO
-rwx------    1 oracle   oinstall 93300507 Sep 23 23:49 oracle

Notará que los tamaños de los archivos se muestran en bytes. Esto puede ser fácil en archivos pequeños, pero cuando el tamaño de los archivos es grande, puede no ser tan fácil leer un número largo. La opción "-h" es práctica aquí, para mostrar el tamaño de manera legible para personas.
$ ls -lh

-rwxr-x--x    1 oracle   oinstall      10M Apr  6  2006 rmanO
-rwxr-x--x    1 oracle   oinstall      10M Sep 23 23:48 rman
-rwsr-s--x    1 oracle   oinstall      89M Apr  6  2006 oracleO
-rwx------    1 oracle   oinstall      89M Sep 23 23:49 oracle

Fíjese cómo se muestra el tamaño en M (para megabytes), K (para kilobytes), etc.
$ ls -lr

El parámetro -r muestra el output en orden inverso. En este comando, los archivos se mostrarán en orden alfabético inverso.
$ ls -lR

El operador -R hace que el comando ls se ejecute repetitivamente—es decir, explorar los subdirectorios y mostrar esos archivos también.
¿Qué sucede si quiere mostrar los archivos del más grande al más chico? Esto puede realizarse con el parámetro -S.
$ ls -lS

total 308
-rw-r-----    1 oracle   oinstall    52903 Oct 11 18:31 sqlnet.log
-rwxr-xr-x    1 oracle   oinstall     9530 Apr  6  2006 root.sh
drwxr-xr-x    2 oracle   oinstall     8192 Oct 11 18:14 bin
drwxr-x---    3 oracle   oinstall     8192 Sep 23 23:49 lib


xargs


La mayoría de los comandos Linux tienen el fin de obtener un output: una lista de archivos, una lista de sucesiones, etc. ¿Pero qué sucede si quiere utilizar algún otro comando con el output del anterior como parámetro? Por ejemplo, el comando file muestra el tipo de archivo (ejecutable, texto ascii, etc.); puede manipular el output para que muestre solo los nombres de archivo y ahora quiere pasar estos nombres al comando ls -l para ver la fecha de registro. El comando xargs hace exactamente eso. Permite ejecutar algunos otros comandos en el output. Recuerde esta sintaxis de la Parte 1:
file -Lz * | grep ASCII | cut -d":" -f1 | xargs ls -ltr

Ahora, queremos utilizar el comando ls -l y pasar la lista de arriba como parámetros, uno a la vez. El comando xargs le permitió hacer eso. La última parte, xargs ls -ltr, toma el output y ejecuta el comando ls -ltr sobre ellos, como si ejecutase:
alert_DBA102.log:        ASCII English text
alert_DBA102.log.Z:      ASCII text (compress'd data 16 bits)
dba102_asmb_12307.trc.Z: ASCII English text (compress'd data 16 bits)
dba102_asmb_20653.trc.Z: ASCII English text (compress'd data 16 bits)

xargs no es útil por sí mismo, pero es bastante bueno cuando se combina con otros comandos. Aquí se muestra otro ejemplo, donde queremos contaar la cantidad de líneas en esos archivos:
alert_DBA102.log
alert_DBA102.log.Z
dba102_asmb_12307.trc.Z
dba102_asmb_20653.trc.Z

Ahora, queremos utilizar el comando ls -l y pasar la lista de arriba como parámetros, uno a la vez. El comando xargs le permitió hacer eso. La última parte, xargs ls -ltr, toma el output y ejecuta el comando ls -ltr sobre ellos, como si ejecutase:
ls -ltr alert_DBA102.log
ls -ltr alert_DBA102.log.Z
ls -ltr dba102_asmb_12307.trc.Z
ls -ltr dba102_asmb_20653.trc.Z

xargs no es útil por sí mismo, pero es bastante bueno cuando se combina con otros comandos.
Aquí se muestra otro ejemplo, donde queremos contaar la cantidad de líneas en esos archivos:
$ file * | grep ASCII | cut -d":" -f1  | xargs wc -l
  47853 alert_DBA102.log
     19 dba102_cjq0_14493.trc
  29053 dba102_mmnl_14497.trc
    154 dba102_reco_14491.trc
     43 dba102_rvwr_14518.trc
  77122 total

(Nota: la tarea de arriba también puede lograrse con el siguiente comando:)
$ wc -l ‘file * | grep ASCII | cut -d":" -f1 | grep ASCII | cut -d":" -f1‘

La versión xargs está dada para ilustrar el concepto. Linux tiene varias maneras de lograr la misma tarea; use la que mejor se adapte a su situación.
Al utilizar este enfoque, usted puede rápidamente renombrar los archivos de un directorio.
$ ls | xargs -t -i mv {} {}.bak

La opción -i le comunica a xargs que reemplace {} con el nombre de cada elemento. La opción -t ordena a xargs que imprima el comando antes de ejecutarlo.
Otra operación es muy útil cuando quiere abrir los archivos para edición utilizando vi:
$ file * | grep ASCII | cut -d":" -f1 | xargs vi

Este comando abre los archivos uno por uno utilizando vi. Cuando quiere buscar muchos archivos y abrirlos para edición, esto resulta muy útil.
También tiene varias opciones. Tal vez la más útil es la opción -p, que hace que la operación sea interactiva:
$ file * | grep ASCII | cut -d":" -f1 | xargs -p vi
vi alert_DBA102.log dba102_cjq0_14493.trc dba102_mmnl_14497.trc
dba102_reco_14491.trc dba102_rvwr_14518.trc ?...
                      
Aquí xarg le pide confirmación antes de ejecutar cada comando. Si presiona "y", ejecuta el comando. Le resultará extremadamente útil cuando realice algunas operaciones potencialmente perjudiciales e irreversibles en el archivo—como eliminar o sobrescribirlo.
La opción -t utiliza un modo verboso; despliega el comando que está por ejecutar, la cual es una opción muy útil durante la depuración.
¿Qué sucede si el output pasara a xargs en blanco? Considere:
$ file * | grep SSSSSS | cut -d":" -f1 | xargs -t wc -l
wc -l 
            0
$

Aquí buscar "SSSSSS" no produce ninguna concordancia; entonces el input de xargs son todos espacios en blanco, como se muestra en la segunda línea (producida al utilizar la opción -t o verbosa). A pesar de que esto puede ser útil, en algunos casos usted puede querer detener xargs si no hay nada que procesar; si lo hay, puede utilizar la opción -r:
$ file * | grep SSSSSS | cut -d":" -f1 | xargs -t -r wc -l
$

El comando existe si no hay nada que ejecutar.
Supongamos que quiere eliminar los archivos utilizando el comando rm, que debería ser el argumento para el comando xargs. No obstante, rm puede aceptar una cantidad limitada de argumentos. ¿Qué sucede si su lista de argumentos excede ese límite? La opción -n para xargs limita la cantidad de argumentos en una sola línea de comando.
Aquí mostramos cómo puede limitar solo dos argumentos por línea de comando: Incluso si cinco líneas pasan a xargs ls -ltr, solo dos archivos pasan a ls -ltr por vez.
$ file * | grep ASCII | cut -d":" -f1 | xargs -t -n2 ls -ltr  
ls -ltr alert_DBA102.log dba102_cjq0_14493.trc 
-rw-r-----    1 oracle   dba           738 Aug 10 19:18 dba102_cjq0_14493.trc
-rw-r--r--    1 oracle   dba       2410225 Aug 13 05:31 alert_DBA102.log
ls -ltr dba102_mmnl_14497.trc dba102_reco_14491.trc 
-rw-r-----    1 oracle   dba       5386163 Aug 10 17:55 dba102_mmnl_14497.trc
-rw-r-----    1 oracle   dba          6808 Aug 13 05:21 dba102_reco_14491.trc
ls -ltr dba102_rvwr_14518.trc 
-rw-r-----    1 oracle   dba          2087 Aug 10 04:30 dba102_rvwr_14518.trc

Utilizando este enfoque, usted puede rápidamente renombrar los archivos de un directorio.
$ ls | xargs -t -i mv {} {}.bak

La opción -i le comunica a xargs que reemplace {} con el nombre de cada elemento.

rename


Como sabe, el comando mv renombra los archivos. Por ejemplo,
$ mv oldname newname
oldnamenewnamerename
rename .log .log.‘date +%F-%H:%M:%S‘ *

reemplaza todos los archivos con la extensión .log por .log.. Entonces sqlnet.log se convierte en sqlnet.log.2006-09-12-23:26:28.

find


Ente los usuarios Oracle, el más conocido es el comando find. Hasta ahora, sabe cómo utilizar find para buscar archivos en un directorio determinado. Aquí mostramos un ejemplo que comienza con la palabra "file" en el directorio actual:
$ find . -name "file*"
./file2
./file1
./file3
./file4

No obstante, ¿qué sucede si quiere buscar nombres como FILE1, FILE2, etc.? -name "file*" no tendrá concordancia. Para una búsqueda con distinción de mayúsculas y minúsculas, use la opción -iname:
$ find . -iname "file*"
./file2
./file1
./file3
./file4
./FILE1
./FILE2

Puede restringir su búsqueda a un tipo específico de archivos. Por ejemplo, el comando de arriba obtendrá archivos de todo tipo: archivos comunes, directorios, enlaces simbólicos, etc. Para buscar solo archivos comunes, puede utilizar el parámetro -type f.
$ find . -name "orapw*" -type f 
./orapw+ASM
./orapwDBA102
./orapwRMANTEST
./orapwRMANDUP
./orapwTESTAUX

-type puede tomar los modificadores f (para archivos comunes), l (para enlaces simbólicos), d (directorios), b (dispositivos de bloque), p (named pipes), c (dispositivos de caracteres), s (sockets).
Un pequeño cambio en el comando de arriba es combinarlo con el comando file que conoció en la Parte 1. El comando file le dice qué tipo de archivo es. Puede transmitirlo como post procesador para el output desde el comando find. El parámetro -exec ejecuta el comando que sigue el parámetro. En este caso, el comando a ejecutar después de find es file:
$ find . -name "*oraenv*" -type f -exec file {} \;
./coraenv: Bourne shell script text executable
./oraenv: Bourne shell script text executable

Esto es útil cuando quiere descubrir si el archivo de texto ASCII podría ser algún tipo de shell script.
Si sustituye -exec con -ok, el comando es ejecutado pero solicita confirmación primero. Aquí hay un ejemplo:
$ find . -name "sqlplus*" -ok {} \;      
< {} ... ./sqlplus > ? y
 
SQL*Plus: Release 9.2.0.5.0 - Production on Sun Aug 6 11:28:15 2006
 
Copyright (c) 1982, 2002, Oracle Corporation.  All rights reserved.
 
Enter user-name: / as sysdba
 
Connected to:
Oracle9i Enterprise Edition Release 9.2.0.5.0 - 64bit Production
With the Partitioning,Real Application Clusters,OLAP 
and Oracle Data Mining options
JServer Release 9.2.0.5.0 - Production
 
SQL> exit
Disconnected from Oracle9i Enterprise Edition Release 9.2.0.5.0-64bit Production
With the Partitioning,Real Application Clusters,OLAP 
and Oracle Data Mining options
JServer Release 9.2.0.5.0 - Production
< È* ... ./sqlplusO > ? n
$

Aquí, hemos pedido al shell que busque todos los programas que comienzan con "sqlplus", y que los ejecute. Fíjese que no hay nada entre -ok y {}, por lo tanto solo ejecutará los archivos que encuentre. Encuentra dos archivos—sqlplus y sqlplusO—y en ambos casos pregunta si usted desea ejecutarlos. Respondemos "y" para el prompt de "sqlplus" y lo ejecuta. Después de salir, solicita el segundo archivo que encontró (sqlplusO) y solicita confirmación una y otra vez, a lo cual respondimos "n"—entonces, no se ejecutó.

Consejo para Usuarios Oracle


Oracle produce varios archivos extraños: archivos de localización, archivos testigo, archivos dump, etc. A menos que se limpien periódicamente, pueden llenar el sistema de archivos e interrumpir la base de datos.
Para garantizar que eso no suceda, simplemente busque los archivos con extensión "trc" y elimínelos si tienen más de tres días de antigüedad. Un comando simple es la solución:
find . -name "*.trc" -ctime +3 -exec rm {} \;

Para eliminarlos antes del límite de tres días, use la opción -f.
           
find . -name "*.trc" -ctime +3 -exec rm -f {} \;

Si simplemente desea enumerar los archivos:
find . -name "*.trc" -ctime +3 -exec ls -l {} \;


m4


Este comando toma un archivo input y sustituye las cadenas dentro de él con los parámetros transmitidos, lo cual es similar a sustituirlas por variables. Por ejemplo, vea un archivo input:
$ cat temp
The COLOR fox jumped over the TYPE fence.

Si quiere sustituir las cadenas "COLOR" por "brown" y "TYPE" por "broken", puede utilizar:
$ m4 -DCOLOR=brown -DTYPE=broken temp
The brown fox jumped over the broken fence.
Else, if you want to substitute "white" and "high" for the same:

$ m4 -DCOLOR=white -DTYPE=high temp  
The white fox jumped over the high fence.


whence y which


Estos comandos son utilizados para saber dónde se almacenan los ejecutables mencionados en el PROCESO del usuario. Cuando el ejecutable es encontrado en el proceso, se comportan de manera bastante similar y muestran el proceso:
                         
$ which sqlplus  
/u02/app/oracle/products/10.2.0.1/db1/bin/sqlplus
$ whence sqlplus 
/u02/app/oracle/products/10.2.0.1/db1/bin/sqlplus

                      
El output es idéntico. Sin embargo, si el ejecutable no es encontrado en el proceso, el comportamiento es diferente. El comando which produce un mensaje explícito:
$ which sqlplus1
/usr/bin/which: no sqlplus1 in (/u02/app/oracle/products/10.2.0.1/db1/bin:/usr
/kerberos/bin:/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin)
                      
whereas El comando whence no produce mensaje:
$ whence sqlplus1]

y vuelve a shell prompt. Esto es útil en casos donde el ejecutable no es encontrado en el proceso (en lugar de mostrar el mensaje):
  
$ whence invalid_command
$ which invalid_command
which: no invalid_command in (/usr/kerberos/sbin:/usr/kerberos/bin:/bin:/sbin: 
/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:
/usr/bin/X11:/usr/X11R6/bin:/root/bin)     
                      
Cuando whence no encuentra un ejecutable en el proceso, vuelve sin ningún mensaje pero el código de retorno no es cero. Esto puede utilizarse en shell scripts; por ejemplo:
RC=‘whence myexec‘
If [ $RC -ne "0" ]; then
   echo "myexec is not in the $PATH"
fi

Una opción muy útil es la opción -i, que muestra el alias y el ejecutable, si está presente. Por ejemplo, usted pudo ver el uso del alias al comienzo de este artículo. El comando rm es en realidad un alias en mi shell, y también en cualquier lugar donde haya un comando rm en el sistema.
$ which ls /bin/ls  $ which -i ls alias ls='ls --color=tty'         /bin/ls 
El comportamiento por defecto es mostrar la primera ocurrencia del ejecutable en el proceso. Si el ejecutable existe en diferentes directorios del proceso, las ocurrencias subsiguientes son ignoradas. Puede ver todas las ocurrencias del ejecutable mediante la opción -a.
$ which java   
/usr/bin/java

$ which -a java
/usr/bin/java
/home/oracle/oracle/product/11.1/db_1/jdk/jre/bin/java


top


El comando top es probablemente el más útil para un Oracle DBA que administra una base de datos sobre Linux. Digamos que el sistema es lento y quiere saber quién está saturando la CPU y/o memoria. Para mostrar los procesos clave, utiliza el comando top.
Fíjese que a diferencia de otros comandos, top no produce un output y permanece inactivo. Actualiza la pantalla para mostrar nueva información. Por lo tanto, si simplemente activa top y deja la pantalla activa, siempre contará con la información más actual. Para cancelar e ir hacia shell, puede presionar Control-C.
$ top

18:46:13  up 11 days, 21:50,  5 users,  load average: 0.11, 0.19, 0.18 
151 processes: 147 sleeping, 4 running, 0 zombie, 0 stopped 
CPU states:  cpu    user    nice  system    irq  softirq  iowait    idle 
           total   12.5%    0.0%    6.7%   0.0%     0.0%    5.3%   75.2% 
Mem:  1026912k av,  999548k used,   27364k free,       0k shrd,  116104k buff 
                    758312k actv,  145904k in_d,   16192k in_c 
Swap: 2041192k av,  122224k used, 1918968k free                  590140k cached 
 
  PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND 
  451 oracle    15   0  6044 4928  4216 S     0.1  0.4   0:20   0 tnslsnr 
 8991 oracle    15   0  1248 1248   896 R     0.1  0.1   0:00   0 top 
    1 root      19   0   440  400   372 S     0.0  0.0   0:04   0 init 
    2 root      15   0     0    0     0 SW    0.0  0.0   0:00   0 keventd 
    3 root      15   0     0    0     0 SW    0.0  0.0   0:00   0 kapmd 
    4 root      34  19     0    0     0 SWN   0.0  0.0   0:00   0 ksoftirqd/0 
    7 root      15   0     0    0     0 SW    0.0  0.0   0:01   0 bdflush 
    5 root      15   0     0    0     0 SW    0.0  0.0   0:33   0 kswapd 
    6 root      15   0     0    0     0 SW    0.0  0.0   0:14   0 kscand 
    8 root      15   0     0    0     0 SW    0.0  0.0   0:00   0 kupdated 
    9 root      25   0     0    0     0 SW    0.0  0.0   0:00   0 mdrecoveryd
                         
... output snipped ...
                      
Examinemos los diferentes tipos de información producidos. La primera línea:
18:46:13  up 11 days, 21:50,  5 users,  load average: 0.11, 0.19, 0.18

muestra la hora actual (18:46:13), que el sistema ha estado activo durante 11 días; que el sistema ha trabajado durante 21 horas 50 segundos. Se muestra el promedio de carga del sistema (0.11, 0.19, 0.18) para los últimos 1, 5 y 15 minutos respectivamente. (A propósito, usted también puede obtener esta información ejecutando el uptime command.)
Si el promedio de carga no es necesario, presione la letra "l" (L minúscula); lo desactivará. Para volver a activarlo presione l nuevamente. La segunda línea:
151 processes: 147 sleeping, 4 running, 0 zombie, 0 stopped

muestra la cantidad de procesos, en ejecución, inactivos, etc. La tercera y cuarta línea:
CPU states:  cpu    user    nice  system    irq  softirq  iowait    idle 
           total   12.5%    0.0%    6.7%   0.0%     0.0%    5.3%   75.2%

muestran los detalles del uso de CPU. La línea de arriba muestra que los procesos de los usuarios consumen un 12,5% y el sistema consume un 6,7%. Los procesos del usuario incluyen los procesos Oracle. Presione "t" para activar y desactivar estas tres líneas. Si hay más de una CPU, usted verá una línea por CPU.
Las próximas dos líneas:
Mem:  1026912k av, 1000688k used,  26224k free,    0k shrd,  113624k buff 
                    758668k actv,  146872k in_d,  14460k in_c
Swap: 2041192k av, 122476k used,   1918716k free             591776k cached

muestran la memoria disponible y utilizada. La memoria total es "1026912k av", aproximadamente 1GB, de la cual solo 26224k o 26MB está libre. El espacio de intercambio es de 2GB; pero casi no es utilizado. Para activarlo y desactivarlo, presione "m".
El resto muestra los procesos en un formato tabular. A continuación, se explican las columnas:
ColumnaDescripción
PIDEl ID del proceso
USEREl usuario que ejecuta el proceso
PRILa prioridad del proceso
NIEl valor nice: Cuanto más alto es el valor, más baja es la prioridad de la tarea
SIZEMemoria utilizada por este proceso (código+datos+stack)
RSSMemoria física utilizada por este proceso
SHAREMemoria compartida utilizada por este proceso
STATEl estado de este proceso, mostrado en códigos. Algunos códigos importantes de estado son:
R – Running (enejecución)
S –Sleeping
(inactivo)
Z – Zombie
(vacilante)
T – Stopped
(detenido)
Usted también puede ver el segundo y tercer carácter, que indican:
W – Swapped out process (proceso intercambiado)
N – positive nice value (valor nice positivo)
%CPUPorcentaje de CPU utilizado por este proceso
%MEMPorcentaje de memoria utilizado por este proceso
TIMETiempo total de CPU utilizado por este proceso
CPUSi este es un proceso de procesadores múltiples, esta columna indica el ID de la CPU sobre la cual se está ejecutando este proceso.
COMMANDComando utilizado por este proceso

Mientras se muestra top, puede presionar algunas teclas para formatear la representación visual como usted quiera. Presionar la tecla mayúscula M clasifica el output por uso de memoria. (Fíjese que utilizar la letra minúscula m activará o desactivará las líneas de resumen de memoria en la parte superior de la representación visual). Esto es muy útil cuando quiere descubrir quién consume la memoria. Vea un ejemplo de output:
PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND 
31903 oracle    15   0 75760  72M 72508 S     0.0  7.2   0:01   0 ora_smon_PRODB2 
31909 oracle    15   0 68944  66M 64572 S     0.0  6.6   0:03   0 ora_mmon_PRODB2 
31897 oracle    15   0 53788  49M 48652 S     0.0  4.9   0:00   0 ora_dbw0_PRODB2

Ahora que ya sabe cómo interpretar el output, veamos cómo utilizar los parámetros de línea de comando.
El más útil es -d, que indica la demora entre las actualizaciones de pantalla. Para actualizar cada segundo, use top -d 1.
La otra opción útil es -p. Si solo desea monitorear algunos procesos, no todos, puede especificar solo aquellos después de la opción -p. Para monitorear los procesos 13609, 13608 y 13554:
top -p 13609 -p 13608 -p 13554

Esto mostrará los resultados en el mismo formato que el comando top, pero solo esos procesos específicos.

Consejo para Usuarios Oracle


Es casi innecesario decir que top resulta muy útil para analizar el desempeño de los servidores de base de datos. Aquí mostramos un output top parcial.
20:51:14  up 11 days, 23:55,  4 users,  load average: 0.88, 0.39, 0.27 
113 processes: 110 sleeping, 2 running, 1 zombie, 0 stopped 
CPU states:  cpu    user    nice  system    irq  softirq  iowait    idle 
           total    1.0%    0.0%    5.6%   2.2%     0.0%   91.2%    0.0% 
Mem:  1026912k av, 1008832k used,   18080k free,       0k shrd,   30064k buff 
                    771512k actv,  141348k in_d,   13308k in_c 
Swap: 2041192k av,   66776k used, 1974416k free                  812652k cached 
 
  PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND 
16143 oracle    15   0 39280  32M 26608 D     4.0  3.2   0:02   0 oraclePRODB2...
    5 root      15   0     0    0     0 SW    1.6  0.0   0:33   0 kswapd
                           
... output snipped ...
                        
Analicemos el output cuidadosamente. Lo primero que debería notar es que la columna "inactiva" de la CPU indica; 0,0%—es decir, la CPU está completamente ocupada haciendo algo. La pregunta es, ¿haciendo qué? Preste atención a la columna "sistema", ligeramente a la izquierda; muestra 5,6%. Entonces el sistema no está haciendo mucho. Vaya más a la izquierda hasta la columna "usuario", que muestra 1,0%. Como los procesos de usuarios incluyen Oracle también, Oracle no consume los ciclos de CPU. Por lo tanto, ¿qué consume toda la CPU?
La respuesta está en la misma línea, justo a la derecha en la columna "iowait", que indica un 91,2%. Esto lo explica todo: la CPU está esperando IO el 91,2% del tiempo.
¿Entonces, por qué tanta espera por IO? La respuesta está en la pantalla. Fíjese en el PID del proceso con mayor consumo: 16143. Puede utilizar la siguiente consulta para determinar qué está haciendo el proceso:
select s.sid, s.username, s.program
from v$session s, v$process p
where spid = 16143
and p.addr = s.paddr
/

       SID USERNAME PROGRAM
------------------- -----------------------------
       159 SYS      rman@prolin2 (TNS V1-V3)    

El proceso rman está reduciendo los ciclos de CPU relacionados con la espera de IO. Esta información ayuda a determinar el próximo plan de acción.

skill y snice


En el debate anterior, aprendió cómo identificar un recurso de consumo de CPU. ¿Qué sucede si descubre que un proceso consume mucha CPU y memoria, pero no quiere cancelarlo? Considere este output top:
$ top -c -p 16514

23:00:44  up 12 days,  2:04,  4 users,  load average: 0.47, 0.35, 0.31 
1 processes: 1 sleeping, 0 running, 0 zombie, 0 stopped 
CPU states:  cpu    user    nice  system    irq  softirq  iowait    idle 
           total    0.0%    0.6%    8.7%   2.2%     0.0%   88.3%    0.0% 
Mem:  1026912k av, 1010476k used,   16436k free,       0k shrd,   52128k buff 
                    766724k actv,  143128k in_d,   14264k in_c 
Swap: 2041192k av,   83160k used, 1958032k free                  799432k cached 
 
  PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND 
16514 oracle    19   4 28796  26M 20252 D N   7.0  2.5   0:03   0 oraclePRODB2...

Ahora que confirmó que el proceso 16514 consume mucha memoria, puede "congelarlo"—pero no cancelarlo—usando el comando skill.
$ skill -STOP 1

Luego, vea el output top:
23:01:11  up 12 days,  2:05,  4 users,  load average: 1.20, 0.54, 0.38 
1 processes: 0 sleeping, 0 running, 0 zombie, 1 stopped 
CPU states:  cpu    user    nice  system    irq  softirq  iowait    idle 
           total    2.3%    0.0%    0.3%   0.0%     0.0%    2.3%   94.8% 
Mem:  1026912k av, 1008756k used,   18156k free,       0k shrd,    3976k buff 
                    770024k actv,  143496k in_d,   12876k in_c 
Swap: 2041192k av,   83152k used, 1958040k free                  851200k cached 
 
  PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND 
16514 oracle    19   4 28796  26M 20252 T N   0.0  2.5   0:04   0 oraclePRODB2...

La CPU ahora está un 94% inactiva, de 0%. El proceso queda efectivamente congelado. Después de algún tiempo, puede querer reanudar el proceso del coma:
$ skill -CONT 16514

Este enfoque es muy útil para congelar temporalmente los procesos a fin de hacer lugar para finalizar los procesos más importantes.
El comando es muy versátil. Si desea detener todos los procesos de usuario "oracle", hay únicamente un solo comando que lo hace todo:
$ skill -STOP oracle

Puede utilizar un usuario, PID, un comando o terminal id como argumento. Lo que se muestra a continuación detiene todos los comandos rman.
$ skill -STOP rman

Como puede ver, skill decide ese argumento que ingresó—un ID para el proceso, un id de usuario o un comando—y actúa en consecuencia. Esto puede causar problemas en algunos casos, donde puede tener un usuario y un comando con el mismo nombre. El mejor ejemplo es el proceso "oracle", que en general es ejecutado por el usuario "oracle". Por lo tanto, cuando quiere detener el proceso denominado "oracle" y realiza:
$ skill -STOP oracle

todos los procesos del usuario "oracle" se detienen, incluso la sesión que puede estar ejecutando en ese momento. Para ser completamente ambiguo, puede opcionalmente ofrecer un nuevo parámetro para especificar el tipo de parámetro. Para detener un comando llamado oracle, puede:
$ skill -STOP -c oracle

El comando snice es similar. En lugar de detener un proceso, hace que su prioridad sea más baja. Primero, vea el output:
  PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND 
    3 root      15   0     0    0     0 RW    0.0  0.0   0:00   0 kapmd 
13680 oracle    15   0 11336  10M  8820 T     0.0  1.0   0:00   0 oracle 
13683 oracle    15   0  9972 9608  7788 T     0.0  0.9   0:00   0 oracle 
13686 oracle    15   0  9860 9496  7676 T     0.0  0.9   0:00   0 oracle 
13689 oracle    15   0 10004 9640  7820 T     0.0  0.9   0:00   0 oracle 
13695 oracle    15   0  9984 9620  7800 T     0.0  0.9   0:00   0 oracle 
13698 oracle    15   0 10064 9700  7884 T     0.0  0.9   0:00   0 oracle 
13701 oracle    15   0 22204  21M 16940 T     0.0  2.1   0:00   0 oracle

Ahora, reduzca cuatro puntos la prioridad de los procesos de "oracle". Fíjese que cuanto mayor es el número, más baja es la prioridad.
$ snice +4 -u oracle

  PID USER     PRI  NI  SIZE  RSS SHARE STAT %CPU %MEM   TIME CPU COMMAND 
16894 oracle    20   4 38904  32M 26248 D N   5.5  3.2   0:01   0 oracle

Note cómo la columna NI (para valores nice) ahora es 4 y la prioridad está ahora fijada en 20, en lugar de 15. Esto es bastante útil para reducir prioridades.

Cómo puedo borrar lo que hay en caché

sudo su
sync && echo 3 > /proc/sys/vm/drop_caches
exit

Lectura Adicional

viernes, 24 de marzo de 2017

TAREAS AUTOMATICAS ORACLE

SQL> SELECT JOB_NAME, SCHEDULE_NAME, SCHEDULE_TYPE, ENABLED
  2  FROM DBA_SCHEDULER_JOBS
  3  WHERE PROGRAM_NAME = 'GATHER_STATS_PROG';

JOB_NAME         SCHEDULE_NAME            SCHEDULE_TYPE  ENABLED
---------------- ------------------------ -------------- -------
GATHER_STATS_JOB MAINTENANCE_WINDOW_GROUP WINDOW_GROUP   TRUE


DBA_AUTOTASK_TASK

PACKAGE DBMS_AUTO_TASK_ADMIN

martes, 31 de enero de 2017

ORACLE 12C LIBERAR MEMORIA

SQL>alter system flush shared pool;
SQL>alter system flush buffer cache;

Estadisticas Extendidas

SET SERVEROUTPUT ON

exec dbms_stats.drop_extended_stats('sh','customers','(CUST_CITY,CUST_STATE_PROVINCE,COUNTRY_ID)');

DECLARE

cg_name VARCHAR2(30);

BEGIN

cg_name := dbms_stats.create_extended_stats('SH','CUSTOMERS',

'(CUST_CITY,CUST_STATE_PROVINCE,COUNTRY_ID)');

dbms_output.put_line('column group name is:'||cg_name);

dbms_stats.gather_table_stats('SH','CUSTOMERS',

method_opt=>'for all columns size 1, for columns (CUST_CITY,CUST_STATE_PROVINCE,COUNTRY_ID) size 3');

END;

/

jueves, 5 de enero de 2017

Troubleshooting Guide ORA-3136: WARNING Inbound Connection Timed Out (Doc ID 465043.1)

To BottomTo Bottom

In this Document
Purpose
Troubleshooting Steps
References

Applies to:

Oracle Net Services - Version 10.2.0.5 to 12.1.0.2 [Release 10.2 to 12.1]
Information in this document applies to any platform.
***Checked for relevance on 23-SEPT-2015***

Purpose

Troubleshooting guide for "ORA-3136  WARNING inbound connection timed out" seen in the alert log.

Troubleshooting Steps

The "WARNING: inbound connection timed out (ORA-3136)" in the alert log indicates that the client was not able to complete  the  authentication process within the period of time specified by the parameter SQLNET.INBOUND_CONNECT_TIMEOUT.

You might also see the errors ORA-12170 or TNS-12535 in the sqlnet.log that is generated on the server.
Check $ORACLE_HOME/network/log for this file.  This entry should contain client address from which the timeout originated and may be helpful in determining how to troubleshoot the issue.  Some applications or JDBC thin driver applications may not have these details.  The sqlnet.log file is not generated  by default in 11g and newer. 

From 10.2.0.1 onwards the default setting for the parameter SQLNET.INBOUND_CONNECT_TIMEOUT is 60 seconds.  If the client is not able to authenticate within 60 seconds, the warning would appear in the alert log and the client connection will be terminated.
Note: This timeout restriction was introduced to combat Denial of Service (DoS) attack whereby malicious clients attempt to flood database servers with connect requests that consumes resources.

The following are the most likely reasons for this error -
  1. Server gets a connection request from a malicious client which is not supposed to connect to the database.  In this case the error thrown would be the expected and desirable behavior. You can get the client address for which the error was thrown in the sqlnet.log file that is local to the database.
  2. The server receives a valid client connection request but the client takes a long time to authenticate more than the default 60 seconds.
  3. The DB server is heavily loaded due to which it cannot finish the client logon within the timeout specified.
To understand what is causing this issue, following checks can be done
The default value of 60 seconds is good enough in most conditions for the database server to authenticate a client connection. If it is taking longer, then it's worth checking the following items before implementing the workaround:

1. Check whether local connection on the database server is successful & quick.
2. If local connections are quick ,then check for underlying network delay with the help of your network administrator.
3. Check whether your Database performance has degraded in anyway.
4. Check alert log for any critical errors for eg, ORA-600 or ORA-7445 and get them  resolved first.
These critical errors might have triggered the slowness of the database server.

It is often necessary to increase the values for INBOUND CONNECT TIMEOUT at  both the listener and the database in order to resolve this issue.    It is usually advisable to set the database (sqlnet.ora) value slightly higher than the listener (listener.ora).    The authentication process is more demanding for the database than the listener.


To set these parameters to use values higher than the default of 60 seconds, follow these instructions and restart the listener.  There is no need to restart Oracle:

Edit the server side sqlnet.ora file and add this parameter:

SQLNET.INBOUND_CONNECT_TIMEOUT=  Where is the value in seconds.

E.g.:

SQLNET.INBOUND_CONNECT_TIMEOUT = 120

Edit the listener.ora file and add this parameter:
INBOUND_CONNECT_TIMEOUT_ =   Again, where is the timeout value in seconds. 

For example if the listener name is LISTENER then use:

INBOUND_CONNECT_TIMEOUT_LISTENER = 110

From Oracle version 10.2.0.1 onwards the default value of INBOUND_CONNECT_TIMEOUT_ is 60 seconds. For previous releases it is zero or OFF by default.

How to check whether inbound timeout is active for the listener:

For example,  INBOUND_CONNECT_TIMEOUT_ =110

You can check whether the parameter is active or not by simply doing telnet to the listener port.
$ telnet
for eg.

$ telnet 123.23.23.23 1521

The telnet session should disconnect after 110 seconds which indicates that the inbound connection timeout for the listener is active.

Alternatively, check at the LSNRCTL prompt using:

LSNRCTL>set current_listener
LSNRCTL>show inbound_connect_timeout

To check whether database server SQLNET.INBOUND_CONNECT_TIMEOUT is active:
Eg.

SQLNET.INBOUND_CONNECT_TIMEOUT=120

miércoles, 4 de enero de 2017

Comandos Solaris

COMANDO SCP

scp letodb-02-11-11.dmp.gz oracle@172.20.101.16:/u01

CAMBIAR FECHA

 date 1021.00

route
route -p add default 10.1.2.1
route -p delete 10.1.3.0 10.1.2.1
Comunidad snmp
svcadm restart net-snmp
snmpwalk -v 2c -m all -c mcsmgmtRO 10.57.130.22 | more
redes
netstat -nr
cat /etc/vfstab
mount 192.168.1.3:/export/NFS/NFS_USBFS0001 /u03
umount /u03

jueves, 1 de diciembre de 2016

RMAN Table Point In Time Recovery (PITR) in Oracle Database 12c Release 1 (12.1)

RMAN Table Point In Time Recovery (PITR) in Oracle Database 12c Release 1 (12.1)

In previous releases point in time recovery of a table or table partition was only possible by manually creating a point in time clone of the database, retrieving the table using data pump, then removing the clone. Oracle 12c includes a new RMAN feature which performs all these steps, initiated from a single command.
Related articles.

Setup

To demonstrate this, we need to create a table to do a PITR on. This example assumes you are running in archivelog mode and have adequate backups in place to allow a recovery via a point in time clone. For such a recent modification, using a flashback query would be more appropriate, but this serves the purpose for this test.
CONN / AS SYSDBA

CREATE USER test IDENTIFIED BY test
  QUOTA UNLIMITED ON users;

GRANT CREATE SESSION, CREATE TABLE TO test;

CONN test/test

CREATE TABLE t1 (id NUMBER);
INSERT INTO t1 VALUES (1);
COMMIT;
Check the current SCN.
CONN / AS SYSDBA

SELECT DBMS_FLASHBACK.get_system_change_number FROM dual;

GET_SYSTEM_CHANGE_NUMBER
------------------------
                 1853267

SQL>
Add some more data since the SCN was checked.
CONN test/test

INSERT INTO t1 VALUES (2);
COMMIT;

SELECT * FROM t1;

        ID
----------
         1
         2

SQL> 
Exit from SQL*Plus and log in to RMAN as a root user with SYSDBA or SYSBACKUP privilege.

Table Point In Time Recovery (PITR)

Log in to RMAN as a user with SYSDBA or SYSBACKUP privilege.
$ rman target=/
Issue the RECOVER TABLE command, giving a suitable AUXILIARY DESTINATION location for the auxiliary database. In the following example the REMAP TABLE clause is used to give the recovered table a new name.
RECOVER TABLE 'TEST'.'T1'
  UNTIL SCN 1853267
  AUXILIARY DESTINATION '/u01/aux'  
  REMAP TABLE 'TEST'.'T1':'T1_PREV';


RMAN> RECOVER TABLE username.tablename UNTIL TIME 'TIMESTAMP…'
  AUXILIARY DESTINATION '/u01/tablerecovery'
  DATAPUMP DESTINATION '/u01/dpump'
  DUMP FILE 'tablename.dmp'
  NOTABLEIMPORT   
REMAP TABLE 'username.tablename': 'username.new_table_name'; 


The output from this command is shown here. It's rather long, but it clearly shows the creation of the clone and the data pump export and import operations. Once the operation is complete, we can see the T1_PREV table has been created and contains the data as it was when the SCN was captured.
sqlplus test/test

SELECT * FROM t1_prev;

 ID
----------
  1

SQL> 

Table Point In Time Recovery (PITR) to Dump File

Rather than completing the whole recovery, you can just stop at the point where the recovered table is in a data pump dump file, which you can import manually at a later time. The following example uses the DATAPUMP DESTINATION, DUMP FILE and NOTABLEIMPORT clauses to achieve this.
RECOVER TABLE 'TEST'.'T1'
  UNTIL SCN 1853267
  AUXILIARY DESTINATION '/u01/aux'
  DATAPUMP DESTINATION '/u01/export'
  DUMP FILE 'test_t1_prev.dmp'
  NOTABLEIMPORT;
The output from this command is shown here. Once the operation is complete, we can see the resulting dump file in the specified directory.
$ ls -al /u01/export
total 120
drwxr-xr-x. 2 oracle oinstall   4096 Dec 26 17:33 .
drwxrwxr-x. 5 oracle oinstall   4096 Dec 26 12:30 ..
-rw-r-----. 1 oracle oinstall 114688 Dec 26 17:34 test_t1_prev.dmp
$

lunes, 31 de octubre de 2016

+ASM CHECK ALL REPAIR


 

SQL> alter diskgroup DG_DATA check all repair;

Diskgroup altered.

SQL> alter diskgroup DG_DATA rebalance power 11 nowait;

 

miércoles, 14 de septiembre de 2016

REPORT_SQL_MONITOR

Oracle 11g automatically monitors SQL statements if they are run in parallel, or consume 5 or more seconds of CPU or I/O in a single execution. This allows resource intensive SQL to be monitored as it is executing, as well as giving access to detailed information about queries once they are complete.
SQL monitoring requires the STATISTICS_LEVEL parameter to be set to 'TYPICAL' or 'ALL', and the CONTROL_MANAGEMENT_PACK_ACCESS parameter set to 'DIAGNOSTIC+TUNING'.
SQL> CONN / AS SYSDBA
Connected.
SQL> SHOW PARAMETER statistics_level

NAME         TYPE  VALUE
------------------------------------ ----------- ------------------------------
statistics_level       string  TYPICAL

SQL> SHOW PARAMETER control_management_pack_access

NAME         TYPE  VALUE
------------------------------------ ----------- ------------------------------
control_management_pack_access      string  DIAGNOSTIC+TUNING

SQL>

MONITOR Hint

The MONITOR hint switches on SQL monitoring for statements that would not otherwise initiate it.
SELECT /*+ MONITOR */ d.dname, WM_CONCAT(e.ename) AS employees
FROM   emp e
       JOIN dept d ON e.deptno = d.deptno
GROUP BY d.dname
ORDER BY d.dname;
If you have long running statements you don't want to monitor, use the NO_MONITOR hint to prevent them being monitored.

REPORT_SQL_MONITOR

The REPORT_SQL_MONITOR function is used to return a SQL monitoring report for a specific SQL statement. The SQL statement can be identified using a variety of parameters, but it will typically be identified using the SQL_ID parameter.
The function can accept many optional parameters, shown here, but most of the time you will probably only use the following.
  • SQL_ID - The SQL_ID of the query of interest. When NULL (the default) the last monitored statement is targeted.
  • SQL_EXEC_ID - When the SQL_ID is specified, the SQL_EXEC_ID indicates the individual execution of interest. When NULL (the default) the most recent execution of the statement targeted by the SQL_ID is assumed.
  • REPORT_LEVEL - The amount of information displayed in the report. The basic allowed values are 'NONE', 'BASIC', 'TYPICAL' or 'ALL', but the information displayed can be modified further by adding (+) or subtracting (-) named report sections (eg. 'BASIC +PLAN +BINDS' or 'ALL -PLAN'). This is similar to the way DBMS_XPLAN output can be tailored in the later releases. I almost always use 'ALL'.
  • TYPE - The format used to display the report ('TEXT', 'HTML', 'XML' or 'ACTIVE'). The 'ACTIVE' setting is new to Oracle 11g Release 2 and displays the output using HTML and Flash, similar to the way it is shown in Enterprise Manager.
  • SESSION_ID - Targets a subset of queries based on the specified SID. Use SYS_CONTEXT('USERENV','SID') for the current session.
The report accesses several dynamic performance views, so you will most likely access it from a privileged user, or a user granted the SELECT_CATALOG_ROLE role.
To see it in action, first we make sure we have a monitored statement to work with.
CONN scott/tiger

SELECT /*+ MONITOR */ d.dname, WM_CONCAT(e.ename) AS employees
FROM   emp e
       JOIN dept d ON e.deptno = d.deptno
GROUP BY d.dname
ORDER BY d.dname;
Monitored statements can be identified using the V$SQL_MONITOR view. This view was present in Oracle 11g Release 1, but has additional columns in Oracle 11g Release 2, making it much more useful. It contains an entry for each execution monitored, so it can contain multiple entries for individual SQL statements.
CONN / AS SYSDBA

-- 11gR1
SELECT sql_id, status
FROM   v$sql_monitor;

SQL_ID       STATUS
------------- -------------------
526mvccm5nfy4 DONE (ALL ROWS)

SQL>

-- 11gR2
SET LINESIZE 200
COLUMN sql_text FORMAT A80

SELECT sql_id, status, sql_text
FROM   v$sql_monitor
WHERE  username = 'SCOTT';

SQL_ID        STATUS              SQL_TEXT
------------- ------------------- --------------------------------------------------------------------------------
526mvccm5nfy4 DONE (ALL ROWS)     SELECT /*+ MONITOR */ d.dname, WM_CONCAT(e.ename) AS employees
                                  FROM   emp e
                                         JOIN dept d ON e.deptno = d.deptno
                                  GROUP BY d.dname
                                  ORDER BY d.dname

SQL>
Once the SQL_ID is identified, we can generate a report using the REPORT_SQL_MONITOR function.
SET LONG 1000000
SET LONGCHUNKSIZE 1000000
SET LINESIZE 1000
SET PAGESIZE 0
SET TRIM ON
SET TRIMSPOOL ON
SET ECHO OFF
SET FEEDBACK OFF

SPOOL /host/report_sql_monitor.htm
SELECT DBMS_SQLTUNE.report_sql_monitor(
  sql_id       => '526mvccm5nfy4',
  type         => 'HTML',
  report_level => 'ALL') AS report
FROM dual;
SPOOL OFF
Examples of the output for each available TYPE are displayed below.
  • TEXT
  • HTML
  • XML
  • ACTIVE - Active HTML available in 11gR2 requires a download of Javascript libraries and a Flash movie from an Oracle website, so must be used on a PC connected to the internet, unless you download the relevant libraries and use the BASE_PATH parameter in the function call to identify their location.
In Oracle 12c, the REPORT_SQL_MONITOR function is now found in the DBMS_SQL_MONITOR package.

REPORT_SQL_MONITOR_LIST

The REPORT_SQL_MONITOR_LIST function was added in Oracle 11g Release 2 to generate a summary screen, similar to that on the "Monitored SQL Executions" page of Enterprise Manager. There are a number of parameters to filer the content of the report (shown here), but most of the time you will probably only use the TYPE and REPORT_LEVEL parameters, similar to those in the REPORT_SQL_MONITOR function. The query below shows how the function can be used.
SET LONG 1000000
SET LONGCHUNKSIZE 1000000
SET LINESIZE 1000
SET PAGESIZE 0
SET TRIM ON
SET TRIMSPOOL ON
SET ECHO OFF
SET FEEDBACK OFF

SPOOL /host/report_sql_monitor_list.htm
SELECT DBMS_SQLTUNE.report_sql_monitor_list(
  type         => 'HTML',
  report_level => 'ALL') AS report
FROM dual;
SPOOL OFF
Examples of the output for each available TYPE are displayed below.
  • TEXT
  • HTML
  • XML
  • ACTIVE - Active HTML is not currently supported, but the parameter list, specifically the BASE_PATH, suggest it will be supported in future.
In Oracle 12c, the REPORT_SQL_MONITOR_LIST function is now found in the DBMS_SQL_MONITOR package.