Archivo del Autor: PabloE

Generar SH1 de una cadena

El paquete DBMS_CRYPTO nos permite, entre otras cosas, generar SHA1 de cualquier cadena de texto. Admite los siguientes parámetros:

  • src – [RAW|BLOB|CLOB]: datos a los que aplicar el hash
  • typ – PLS_INTEGER: algoritmo hash a aplicar

Los algoritmos disponibles son los siguientes:

  • HASH_MD4 := 1
  • HASH_MD5 := 2
  • HASH_SH1 := 3

Nota: Es necesario conceder permisos de ejecución sobre este paquete a los usuarios que vayan a utilizarlo.

select DBMS_CRYPTO.hash(utl_raw.cast_to_raw ('Hello'),
                        3) "hash_Hello",
       DBMS_CRYPTO.hash(utl_raw.cast_to_raw ('HELLO'),
                        3) "hash_HELLO"
from dual;
hash_Hello
----------------------------------------
F7FF9E8B7BB2E09B70935A5D785E0CC5D9D0ABF0

hash_HELLO
----------------------------------------
C65F99F8C5376ADADDDC46D5CBCF5762F9E55EB7

Ver también Generar el HASH de una cadena

Generar el HASH de una cadena

El paquete DBMS_UTILITY nos permite, entre otras cosas, generar resúmenes HASH de cualquier cadena de texto. Admite los siguientes parámetros:

  • name – VARCHAR2: cadena a la que se aplica la función hash
  • base – NUMBER: valor mínimo que devolverá la función hash
  • hash_size – NUMBER: valor máximo que devolverá la función hash
select DBMS_UTILITY.get_hash_value('Hello',
                                   1,
                                   power(2,16)-1
                                  ) "hash_Hello",
       DBMS_UTILITY.get_hash_value('HELLO',
                                   1,
                                   power(2,16)-1
                                  ) "hash_HELLO"
from dual;
hash_Hello hash_HELLO
---------- ----------
     11511      16086

Ver también Generar SH1 de una cadena

PL/SQL HTTP call function

La función que se muestra a continuación es una implementación ligera de acceso a recursos HTTP que sirve tanto para peticiones GET como POST. Esta función no da soporte a conexiones seguras HTTPS ni al envío de parámetros que requieran un tratamiento especial, como puede ser el envío de ficheros. Estas limitaciones nos permiten contar con una función relativamente pequeña que se puede incluir fácilmente en cualquier proyecto o script de prueba.

La función cuenta con 4 constantes, declaradas en las primeras líneas de código, para definir los siguientes aspectos:

  • cons_max_retries: Número de reintentos que vamos a realizar en caso de error de conexión.
  • cons_result_ok: Mensaje resultado en caso de éxito.
  • cons_result_error: Mensaje resultado en caso de error.
  • cons_result_sharp: Carácter separador para montar los mensajes de respuesta compuestos.

El código completo de la función http_param se muestra a continuación:

create function http_param(
                           p_url         in  varchar2,
                           p_method      in  varchar2,
                           p_param       in  varchar2,
                           p_html_result out varchar2
                          ) return varchar2
is

   cons_max_retries             CONSTANT number := 3; -- Maximum retries number.
   cons_result_ok               CONSTANT varchar2(10) := 'OK';
   cons_result_error            CONSTANT varchar2(10) := 'ERROR';
   cons_result_sharp            CONSTANT varchar2(1)  := '#';

   req                          UTL_HTTP.REQ;
   resp                         UTL_HTTP.RESP;
   v_value                      varchar2(1024);
   v_url                        varchar2(200);
   v_param                      varchar2(500);
   v_param_length               number;
   v_html_result                varchar2(32767);

   retry                        boolean;
   num_retries                  number;

   v_result                     varchar2(1024);

begin

     -- Init variables
     v_url := p_url;
     v_param := p_param;
     v_param_length := length(v_param);

     if p_method = 'GET' then
        v_url := v_url||'?'||v_param;
     end if;
    
     retry := true;
     num_retries := 1;

     -- Retry loop
     while retry and num_retries <= cons_max_retries loop

         v_result := cons_result_ok;

         begin
             req := UTL_HTTP.BEGIN_REQUEST (url=> v_url, method => p_method);
             UTL_HTTP.SET_HEADER (r      =>  req,
                                  name   =>  'Content-Type',
                                  value  =>  'application/x-www-form-urlencoded');
             
             if p_method = 'POST' then
               UTL_HTTP.SET_HEADER (r      =>   req,
                                    name   =>   'Content-Length',
                                    value  =>   v_param_length);
               UTL_HTTP.WRITE_TEXT (r      =>   req,
                                    data   =>   v_param);
             end if;
             
             resp := UTL_HTTP.GET_RESPONSE(req);
             
             -- Communication errors
             if resp.status_code != 200 then

                 dbms_output.put_line('Connection error:');
                 dbms_output.put_line('  Resp.status_code: '||resp.status_code);
                 dbms_output.put_line('  Resp.reason_phrase: '||resp.reason_phrase);
                 dbms_output.put_line('  Resp.http_version: '||resp.http_version);
                 dbms_output.put_line('  Resp.private_hndl: '||resp.private_hndl);
                 v_result := cons_result_error||cons_result_sharp||'Resp.status_code: '||resp.status_code||' - Resp.reason_phrase: '||resp.reason_phrase;

             -- Valid response
             else

                 -- Read response
                 begin
                    loop
                         UTL_HTTP.READ_LINE(resp, v_value, TRUE);
                         v_html_result := v_html_result || v_value;
                    end loop;
                 exception
                    when UTL_HTTP.END_OF_BODY then
                         UTL_HTTP.END_RESPONSE(resp);
                    when others then
                         v_result := cons_result_error||cons_result_sharp||'ERROR -> http_param: error READ_LINE - '||sqlerrm;
                         dbms_output.put_line( v_result );
                 end;

             end if;

             retry := false;
         exception
            when UTL_HTTP.TRANSFER_TIMEOUT then
               v_result := cons_result_error||cons_result_sharp||'WARNING -> http_param: error UTL_HTTP.TRANSFER_TIMEOUT (retry '||num_retries||'/'||cons_max_retries||') - '||sqlerrm;
               dbms_output.put_line( v_result );
               retry       := true;
               num_retries := num_retries + 1;
            when UTL_HTTP.HTTP_CLIENT_ERROR then
               v_result := cons_result_error||cons_result_sharp||'WARNING -> http_param: error UTL_HTTP.HTTP_CLIENT_ERROR (retry '||num_retries||'/'||cons_max_retries||') - '||sqlerrm;
               dbms_output.put_line( v_result );
               retry       := true;
               num_retries := num_retries + 1;
            when UTL_HTTP.HTTP_SERVER_ERROR then
               v_result := cons_result_error||cons_result_sharp||'WARNING -> http_param: error UTL_HTTP.HTTP_SERVER_ERROR (retry '||num_retries||'/'||cons_max_retries||') - '||sqlerrm;
               dbms_output.put_line( v_result );
               retry       := true;
               num_retries := num_retries + 1;
            when UTL_HTTP.REQUEST_FAILED then
               v_result := cons_result_error||cons_result_sharp||'WARNING -> http_param: error UTL_HTTP.REQUEST_FAILED (retry '||num_retries||'/'||cons_max_retries||') - '||sqlerrm;
               dbms_output.put_line( v_result );
               retry       := true;
               num_retries := num_retries + 1;
            when OTHERS then
               v_result := cons_result_error||cons_result_sharp||'ERROR -> http_param - '||sqlerrm;
               dbms_output.put_line( v_result );
               retry       := false;
               num_retries := num_retries + 1;
         end;

     end loop;

    -- Result
    p_html_result := v_html_result;
    return v_result;

exception
   when others then
      v_result := cons_result_error||cons_result_sharp||'ERROR -> http_param - '||sqlerrm;
      dbms_output.put_line('Error others: '||v_result);
      return v_result;
end http_param;

Para probar su funcionamiento podemos realizar una consulta al servicio de información meteorológica de Yahoo! En este caso para la ciudad de Madrid:

declare
  v_html_result varchar2(32767);
  v_result      varchar2(2048);
begin
  v_result := http_param(
                         p_url => 'http://weather.yahooapis.com/forecastrss',
                         p_method => 'GET',
                         p_param => 'w=12578024&u=c',
                         p_html_result => v_html_result
                        );
  dbms_output.put_line('Result: '||v_result);
  dbms_output.put_line('HTML result: ');
  if length(v_html_result) > 255 then
      for i in 0..ceil(length(v_html_result)/255) loop
          dbms_output.put_line(substr(v_html_result, ((255*i) + 1), 255));
      end loop;
  else
      dbms_output.put_line(v_html_result);
  end if;
end;

El resultado esperado, en caso de que logremos conectar con el servicio de Yahoo! desde nuestra sesión de base de datos, sería algo similar a esto:

Result: OK
HTML result: ...<xml_with_weather_data>...

Oracle 11g

Hay que tener en cuenta que a partir de la versión 11g de Oracle existe un control de acceso para el uso de cualquier protocolo que permita abrir conexiones externas a la base de datos. Este control de acceso se encuentra regulado por listas de acceso o ACL. Si no hemos habilitado el acceso a las URLs necesarias dando de alta las reglas oportunas en las ACL obtendremos un error como el siguiente:

ERROR#WARNING -> http_param: error UTL_HTTP.REQUEST_FAILED (retry 1/3) -
ORA-29273: HTTP request failed
ORA-06512: at "SYS.UTL_HTTP", line 1130
ORA-24247: network access denied by access control list (ACL)
ERROR#WARNING -> http_param: error UTL_HTTP.REQUEST_FAILED (retry 2/3) -
ORA-29273: HTTP request failed
ORA-06512: at "SYS.UTL_HTTP", line 1130
ORA-24247: network access denied by access control list (ACL)
ERROR#WARNING -> http_param: error UTL_HTTP.REQUEST_FAILED (retry 3/3) -
ORA-29273: HTTP request failed
ORA-06512: at "SYS.UTL_HTTP", line 1130
ORA-24247: network access denied by access control list (ACL)
Result: ERROR#WARNING -> http_param: error UTL_HTTP.REQUEST_FAILED (retry 3/3) -
ORA-29273: HTTP request failed
ORA-06512: at "SYS.UTL_HTTP", line 1130
ORA-24247: network access denied by access control list (ACL)
HTML result:

En la entrada «Control de acceso a recursos de red – ACL management» se explica cómo crear la ACL necesaria para completar la prueba de conexión con Yahoo!.

Generar valores RANDOM

El paquete DBMS_RANDOM nos permite, entre otras cosas, generar números aleatorios indicando un rango. Admite los siguientes parámetros, que pueden ser omitidos:

  • low – NUMBER: valor mínimo que devolverá la función random
  • high – NUMBER: valor máximo que devolverá la función random
select DBMS_RANDOM.value nums_decim,
       DBMS_RANDOM.value(1000,
                         9999) nums_range_decim,
       trunc(DBMS_RANDOM.value(1000,
                               9999)) nums_range_int
from dual;
NUMS_DECIM NUMS_RANGE_DECIM NUMS_RANGE_INT
---------- ---------------- --------------
0,76259616 8188,26474538092           3750

Control de acceso a recursos de red – ACL management

Con la salida de Oracle 11g se ha incluido en la base de datos un sistema para controlar el acceso a recursos de red que, por defecto, bloquea cualquier intento de conexión al exterior. Esto nos obliga a crear una serie de listas, o ACLs, para controlar y permitir el acceso a los recursos de red que sean necesarios en nuestros desarrollos.

El paquete DBMS_NETWORK_ACL_ADMIN nos proporciona todos los procesos necesarios para crear y gestionar estas listas. En el siguiente ejemplo se muestran los pasos que debemos seguir para habilitar a dos usuarios el acceso a una URL concreta:

  • Nombre de la lista ACL: network_access_test.xml
  • Usuarios con permisos de conexión: TEST_USER y TEST_USER_2
  • URL de acceso: *.yahooapis.com
-- Create ACL
BEGIN
 DBMS_NETWORK_ACL_ADMIN.CREATE_ACL (
  acl          => 'network_access_test.xml', 
  description  => 'Network access test', 
  principal    => 'TEST_USER', -- Must be in upper case
  is_grant     => TRUE,
  privilege    => 'connect',
  start_date   => NULL,
  end_date     => NULL);
END;
/

 -- Creates the second role privilege
BEGIN
 DBMS_NETWORK_ACL_ADMIN.ADD_PRIVILEGE (
  acl          => 'network_access_test.xml',
  principal    => 'TEST_USER_2',
  is_grant     => TRUE, 
  privilege    => 'connect',
  position     => NULL,
  start_date   => NULL,
  end_date     => NULL);
END;
/

 -- Creates the first target host
BEGIN
 DBMS_NETWORK_ACL_ADMIN.ASSIGN_ACL (
  acl          => 'network_access_test.xml',
  host         => '*.yahooapis.com',
  lower_port   => NULL,
  upper_port   => NULL); 
END;
/

Para asegurarnos de que hemos activado el acceso correcto podemos consultar las siguientes vistas:

-- List ACLs
select *
from RESOURCE_VIEW
where any_path like '/sys/acls/%';

-- List ACL privileges
select *
from DBA_NETWORK_ACL_PRIVILEGES;

-- List URLs
select *
from DBA_NETWORK_ACLS;

Por último vamos a mostrar cómo eliminar usuarios, conexiones y la ACL completa que hemos creado:

-- Delete users / roles from ACL
BEGIN
 DBMS_NETWORK_ACL_ADMIN.DELETE_PRIVILEGE (
  acl          => 'network_access_test.xml',
  principal    => 'TEST_USER',
  is_grant     => TRUE, 
  privilege    => 'connect');
END;
/

-- Delete URLs
BEGIN
 DBMS_NETWORK_ACL_ADMIN.UNASSIGN_ACL (
  acl          => 'network_access_test.xml',
  host         => '*.yahooapis.com',
  lower_port   => NULL,
  upper_port   => NULL); 
END;
/

-- Drop ACL
BEGIN
 DBMS_NETWORK_ACL_ADMIN.DROP_ACL (
  acl          => 'network_access_test.xml'); 
END;
/

En este ejemplo se ha creado una ACL básica que permite acceso completo a una URL. Pero las ACL permiten controlar aspectos como los puertos a los que se tiene acceso, definición de subredes o establecer la ventana temporal en la que estará activo el acceso para cada usuario.

Para profundizar en estos aspectos se puede consultar el siguiente enlace:
http://download.oracle.com/docs/cd/B28359_01/network.111/b28531/authorization.htm#DBSEG40012

UTL_FILE test

PL/SQL cuenta con un modo de acceso al sistema de ficheros que abstrae al programador del medio físico. A través de la declaración de directorios virtuales (select * from ALL_DIRECTORIES) hace que sea más sencillo trabajar con recursos del sistema de ficheros. Pero al mismo tiempo dificulta el análisis de cualquier problema con el acceso a estos recursos.

Un pequeño script como el siguiente, que verifique cada una de las operaciones disponibles en PL/SQL para el acceso a un medio físico y nos informe de los errores que se produzcan en cada una de ellas, puede sernos de gran ayuda:

set serveroutput on;
DECLARE

 -- Configure procedure
 v_dir varchar2(255) := 'LOG_FILE_DIR';

 -- Variables
 f_file utl_file.file_type;
 v_file varchar2(255);
 v_file_dest varchar2(255);
 v_file_copy varchar2(255);

 v_msg_line varchar2(32767);
 v_buffer varchar2(32767);

 v_write_error varchar2(2048);
 v_read_error varchar2(2048);
 v_copy_error varchar2(2048);
 v_remove_error varchar2(2048);
 v_rename_error varchar2(2048);

BEGIN

 -- Filename.
 v_file := 'utl_test.tmp';
 v_file_dest := 'utl_test_moved.tmp';
 v_file_copy := 'utl_test_copied.tmp';

 -- Write test.
 begin
 v_msg_line := 'Write test line.';
 f_file := utl_file.FOPEN( v_dir, v_file, 'A', 32767 );
 utl_file.PUT_LINE( f_file, v_msg_line, true );
 utl_file.FCLOSE( f_file );
 exception
 when others then
 v_write_error := sqlerrm;
 end;

 -- Read test.
 begin
 f_file := utl_file.FOPEN( v_dir, v_file, 'R', 32767 );
 utl_file.GET_LINE( f_file, v_buffer, 32767 );
 utl_file.FCLOSE( f_file );
 exception
 when others then
 v_read_error := sqlerrm;
 end;

 -- Copy test.
 begin
 utl_file.FCOPY( v_dir, v_file, v_dir, v_file_copy );
 exception
 when others then
 v_copy_error := sqlerrm;
 end;

 -- Remove test.
 begin
 utl_file.FREMOVE( v_dir, v_file );
 exception
 when others then
 v_remove_error := sqlerrm;
 end;

 -- Rename test.
 begin
 utl_file.FRENAME( v_dir, v_file_copy, v_dir, v_file_dest );
 exception
 when others then
 v_rename_error := sqlerrm;
 end;

 -- Test Result
 dbms_output.put_line('UTL_FILE Test results at '||to_char(sysdate, 'dd mon yyyy hh24:mi:ss'));
 dbms_output.put_line('');
 dbms_output.put_line('DB_NAME.......'||sys_context('userenv','db_name'));
 dbms_output.put_line('SERVER_HOST...'||sys_context('userenv','server_host'));
 dbms_output.put_line('');
 dbms_output.put_line('Write test....'||nvl(v_write_error, 'OK'));
 dbms_output.put_line('Read test.....'||nvl(v_read_error, 'OK'));
 dbms_output.put_line('Copy test.....'||nvl(v_copy_error, 'OK'));
 dbms_output.put_line('Remove test...'||nvl(v_remove_error, 'OK'));
 dbms_output.put_line('Rename test...'||nvl(v_rename_error, 'OK'));

 -- Clean test file.
 utl_file.FREMOVE( v_dir, v_file_dest );

EXCEPTION
 WHEN OTHERS THEN
 utl_file.FCLOSE( f_file );
 dbms_output.put_line('Error utl_file_test: '||sqlerrm);
END;

Si todo es correcto, deberíamos obtener un resultado como el siguiente:

UTL_FILE Test results at 25 jun 2014 22:37:23

DB_NAME.......ora_test
SERVER_HOST...vmtest

Write test....OK
Read test.....OK
Copy test.....OK
Remove test...OK
Rename test...OK

Búsquedas en columnas de tipo LONG

Cuando intentamos hacer una búsqueda sobre una columna de tipo LONG del mismo modo que operamos con columnas VARCHAR nos encontramos con el problema de que no se comportan del mismo modo. Y el problema es más común de lo que a priori se puede esperar dado que varias vistas del diccionario de datos utilizan este tipo de datos para almacenar información bastante interesante.

En el caso que nos ocupa, estábamos intentando localizar el uso de una columna concreta en cualquier vista accesible por el usuario. Cuando intentamos consultar la vista ALL_VIEWS para localizar en ALL_VIEWS.TEXT las menciones a la columna que buscábamos nos encontramos con el siguiente error:

select *
from all_views
where upper(text) like '%TABLE_NAME%';
ORA-00932: inconsistent datatypes: expected NUMBER got LONG

La función UPPER() es una más de las muchas que no se pueden aplicar sobre tipos de datos LONG.

Después de darle varias vueltas al problema, e intentar distintas alternativas, logramos escribir un pequeño bloque anónimo que nos permitía realizar la búsqueda:

-- Search in LONG datatype columns
set serveroutput on;
begin
    for i in (select * from all_views) loop
        if instr(upper(i.text), 'TABLE_NAME') > 0 then
            dbms_output.put_line('View: '||i.view_name);
        end if;
    end loop;
end;

Y por fin obtuvimos el resultado esperado:

View: ALL_ALL_TABLES
View: ALL_TAB_COLUMNS
View: ALL_TAB_COL_STATISTICS
...
...
...