Templarios de San Oracle » Scripts

Ordenación de resultados en castellano

Sir Ragnar — Tue, 16 Jun 2009 15:04:13 +0000

Acabo de leer en Oracle Notepad un artículo muy interesante sobre la ordenación de resultados en castellano. Nunca pensé que la ordenación sería así. Supongo que porque en todas las bases de datos Oracle con las que he trabajado tenían el parámetro NLS_SORT fijado en español.

Para comprobar con qué ordenación por defecto está configurada nuestra base de datos basta con hacer una select de la tabla NLS_PARAMETER:

SQL> SELECT * FROM NLS_DATABASE_PARAMETERS;
 
PARAMETER                      VALUE
------------------------------ ----------------------------------------
NLS_CSMIG_SCHEMA_VERSION       5
NLS_LANGUAGE                   SPANISH
NLS_TERRITORY                  SPAIN
NLS_CURRENCY                   ?
NLS_ISO_CURRENCY               SPAIN
NLS_NUMERIC_CHARACTERS         ,.
NLS_CHARACTERSET               WE8ISO8859P15
NLS_CALENDAR                   GREGORIAN
NLS_DATE_FORMAT                DD/MM/RR
NLS_DATE_LANGUAGE              SPANISH
NLS_SORT                       SPANISH
NLS_TIME_FORMAT                HH24:MI:SSXFF
NLS_TIMESTAMP_FORMAT           DD/MM/RR HH24:MI:SSXFF
NLS_TIME_TZ_FORMAT             HH24:MI:SSXFF TZR
NLS_TIMESTAMP_TZ_FORMAT        DD/MM/RR HH24:MI:SSXFF TZR
NLS_DUAL_CURRENCY              ?
NLS_COMP                       BINARY
NLS_LENGTH_SEMANTICS           BYTE
NLS_NCHAR_CHARACTERSET         AL16UTF16
NLS_NCHAR_CONV_EXCP            FALSE
NLS_RDBMS_VERSION              10.2.0.4.0

Campos null con precisión en vistas

Sir Ragnar — Fri, 25 Jan 2008 13:38:30 +0000

Muchas veces he necesitado crear una vista para sustituir una antigua tabla. En ocasiones he tenido que mantener en la vista una columna que ya no existe pero que debo dejar por algún motivo. Lo que hago es definir la columna como “Función(NULL) AS NOMBRE_COLUMNA”. Si es VARCHAR2 pongo directamente NULL. Si quiero que sea un number TO_NUMBER(NULL) y si es una fecha TO_DATE(NULL). Por ejemplo:

CREATE OR REPLACE VIEW CAMPOS_NULOS AS(
  SELECT NULL              AS CADENA_VACIA,
         TO_NUMBER( NULL ) AS NUMERO_VACIO,
         TO_DATE( NULL )   AS FECHA_VACIA
  FROM DUAL )
/

Si hacemos un desc:

SQL> DESC CAMPOS_NULOS
 Nombre        ¿Nulo?   Tipo
 ------------- -------- ----------------------------
 CADENA_VACIA           VARCHAR2
 NUMERO_VACIO           NUMBER
 FECHA_VACIA            DATE

El único problema, como puede verse en el ejemplo, es que perdía la precisión. A raíz de una respuesta del semidiox Tom he conocido el milagroso CAST. Se le puede poner precisión y tipo a la columa haciendo un “CAST( NULL AS TIPO(PRECISION) )”:

CREATE OR REPLACE VIEW CAMPOS_NULOS AS(
  SELECT CAST( NULL AS VARCHAR2(20) ) AS CADENA_VACIA,
         CAST( NULL AS NUMBER(4) )    AS NUMERO_VACIO,
         CAST( NULL AS DATE )         AS FECHA_VACIA
  FROM DUAL )
/

Y haciendo un desc tenemos que:

SQL> DESC CAMPOS_NULOS
 Nombre        ¿Nulo?   Tipo
 ------------- -------- ----------------------------
 CADENA_VACIA           VARCHAR2(20)
 NUMERO_VACIO           NUMBER(4)
 FECHA_VACIA            DATE

En la Documentación oficial se explica la manera de uso y más ejemplos.

Uso de expresiones regulares con Oracle

Sir Ragnar — Fri, 24 Aug 2007 15:27:10 +0000

Muchas veces necesito saber qué registros de una tabla tienen valores no numéricos en un campo varchar. Normalmente me hago una función en un paquete y la utilizo en la select que toque:

FUNCTION esCadenaNumerica( vCadena VARCHAR2 ) RETURN VARCHAR2 IS 
  ------------
  -- Variables
  ------------
  nTonta NUMBER;
BEGIN 
  nTonta := TO_NUMBER( vCadena );
 
  -- Si llego hasta aquí es que el número es válido.
  RETURN 'TRUE';
EXCEPTION
  WHEN VALUE_ERROR THEN
    -- El número no es válido.
    RETURN 'FALSE';
END;

La función devuelve un varchar para poder ser usada en una select. Esta select me daría los valores no numéricos de una columna:

1
2
3

SELECT VVALOR
FROM   TABLA
WHERE  NombrePaquete.esCadenaNumerica( VVALOR ) = 'FALSE'

Por supuesto, la función podría ser más rica agregándole parámetros para una máscara de conversión o para pedir también la precisión.
El caso es que me ha hecho falta buscar valores no numéricos en una tabla en un esquema en el que no tengo permiso para crear ni funciones ni procedimientos. Podría haber optado por hacer un bloque de pl/sql anónimo, pero he preferido buscar algo más directo y lo he encontrado. Las expresiones regulares están disponibles en la 10g y permiten hacer búsquedas de una manera parecida al like pero más potente. Es algo bastante más común en el mundo java pero también está disponible para los plsqleros a través de la función REGEXP_LIKE. Está bien explicado en este artículo que he encontrado: Oracle and Regular Expressions.
Por ejemplo, esta select me saca los valores de una columna que no son números enteros:

SELECT VVALOR
FROM   TABLA
WHERE  REGEXP_LIKE( VVALOR, '[^0-9]')
/

Además de permitir búsquedas, también se pueden hacer potentes replaces y substrs. Flipante. Este es un enlace en plan tip donde el autor se ha currado unas inserciones y un montón de sentencias de prueba: Oracle Regular Expressions, versión 10.2. En la wikipedia, como de costumbre, también está bien explicado: Definición de expresión regular.

DDL de FKs que apuntan a una tabla

Sir Ragnar — Thu, 26 Jul 2007 17:08:32 +0000

Uniendo el script que obtiene las tablas que apuntan a una con la utilidad del todopoderoso paquete DMBS_METADATA me he hecho otro script que me obtiene el ddl de las claves foráneas que apuntan a una tabla determinada. No sé si me volverá a hacer falta algún día pero por si acaso o por si a alguien más le interesa, aquí está el script:

-- Script para obtener el ddl de la lista de claves foráneas que
-- referencian a una tabla
-- http://www.tsoracle.com
---------------
-- Sets varios
--------------
SET VERIFY OFF
SET LONG 5000
------------
-- Parámetros
------------
ACCEPT propi PROMPT "Propietario (enter para usuario conectado): "
ACCEPT tabla PROMPT "Nombre de la tabla: "
BREAK ON TABLE_NAME
COLUMN DEFI FORMAT A120
------------
-- Select
------------
PROMPT Tablas que referencian a &&tabla
SELECT DBMS_METADATA.get_DDL( 'REF_CONSTRAINT', 
                              r.CONSTRAINT_NAME, 
                              r.OWNER ) 
       DEFI
FROM   ALL_CONSTRAINTS T, ALL_CONSTRAINTS R
WHERE  T.OWNER      = NVL( UPPER( '&&propi' ), USER )
  AND  T.TABLE_NAME = UPPER( '&&tabla' )
  AND  T.CONSTRAINT_TYPE IN ( 'P', 'U' ) -- Que sean pk o uk
  AND  R.R_OWNER           = T.OWNER
  AND  R.R_CONSTRAINT_NAME = T.CONSTRAINT_NAME
  AND  R.CONSTRAINT_TYPE   = 'R'         -- Que sea una fk
ORDER BY R.TABLE_NAME, R.CONSTRAINT_NAME
/
---------------------
-- Restauro el verify
---------------------
SET VERIFY ON

Sé que se nota que estoy flipao con el dbms_metadata pero es que no puedo creer que haya podido vivir tanto tiempo sin él. La de ríos de código que me podría haber ahorrado.

Consulta de tablas que apuntan a una

Sir Ragnar — Wed, 25 Jul 2007 14:10:06 +0000

Este es un script para obtener un listado con las claves foráneas que apuntan a la tabla que le pasan como parámetro. Es útil si tenemos la buena costumbre de nombrar las claves con algún sufijo o prefijo que nos indiquen el tipo. Si no, sería necesario agregar más columnas a la select. También podría interesar agregar una columna con el nombre del propietario de la clave foránea.

-- Script para obtener la lista de claves foráneas que 
-- referencian a una tabla
-- http://www.tsoracle.com
---------------
-- Sets varios
--------------
SET VERIFY OFF
------------
-- Parámetros
------------
ACCEPT propi PROMPT "Propietario (enter para usuario conectado): "
ACCEPT tabla PROMPT "Nombre de la tabla: "
BREAK ON TABLE_NAME
------------
-- Select
------------
PROMPT Tablas que referencian a &&tabla
SELECT R.TABLE_NAME, R.CONSTRAINT_NAME,
       T.CONSTRAINT_NAME AS CLAVE_REFERENCIADA
FROM   ALL_CONSTRAINTS T, ALL_CONSTRAINTS R
WHERE  T.OWNER      = NVL( UPPER( '&&propi' ), USER ) -- El valor por defecto es el usuario conectado
  AND  T.TABLE_NAME = UPPER( '&&tabla' )
  AND  T.CONSTRAINT_TYPE IN ( 'P', 'U' ) -- Que sean pk o uk
  AND  R.R_OWNER           = T.OWNER
  AND  R.R_CONSTRAINT_NAME = T.CONSTRAINT_NAME
  AND  R.CONSTRAINT_TYPE   = 'R'         -- Que sea una fk
ORDER BY R.TABLE_NAME, R.CONSTRAINT_NAME
/
---------------------
-- Restauro el verify
---------------------
SET VERIFY ON

Obtener ddl de permisos

Sir Ragnar — Tue, 24 Jul 2007 14:04:53 +0000

Otra función interesante del paquete DBMS_METADATA es get_Granted_DDL. Tal como su nombre sugiere, te devuelve el código ddl de los permisos que tenga el usuario que le pasas como parámetro. En este caso le pasaríamos dos parámetros, el primero de los cuales es el tipo(a elegir entre AUDIT, DEFAULT_ROLE, OBJECT_GRANT, PROXY, ROLE_GRANT, SYSTEM_GRANT y TABLESPACE_QUOTA), el segundo es el usuario. Los otros parámetros pueden tomar los valores por defecto. Por ejemplo, la siguiente select nos daría el ddl de creación de permisos de sistema para el viejo Scott

SET LONG 5000
SELECT DBMS_METADATA.GET_GRANTED_DDL( 'SYSTEM_GRANT', 'SCOTT' )
FROM   DUAL
/

Esta nos daría la de los objetos a los que tiene privilegios directamente, sin pasar por un rol:

SET LONG 5000
SELECT DBMS_METADATA.GET_GRANTED_DDL( 'OBJECT_GRANT', USER ) AS CPRIVILEGIO
FROM   DUAL
/

Para los otros posibles valores para el tipo, no he conseguido hacerlo funcionar. No sé si es que me faltan privilegios o que estoy haciendo algo mal (o las dos cosas a la vez).

Script de descripción de tablas mejorado

Sir Ragnar — Fri, 20 Jul 2007 23:41:35 +0000

He introducido una mejora en el script que utilizo para describir tablas en el plus. En principio, tal como dije, me describe tablas del esquema en el que estoy. Esto lo hice así porque paso de estar todo el rato metiendo el nombre del usuario cuando, el 99,99% de los desc que hago son siempre de tablas o vistas del usuario con el que estoy conectado. Bueno, lo que he hecho es que el script se de cuenta de si lo que he escrito es un sinónimo. Y entonces da el cambiazo y describe en realidad la tabla a la que apunta el sinónimo, aunque sea de otro esquema.

-- Script mejorado para obtener la descripción de una tabla o de 
-- un sinónimo que apunte a una tabla.
-- http://www.tsoracle.com
--------------
-- Sección Set
--------------
SET LINES  120
SET HEADING ON
SET VERIFY OFF
-------------------------
-- Definición de columnas
-------------------------
COLUMN CLAVE_PRIMARIA FORMAT A1 
COLUMN COLUMN_NAME    FORMAT A20 
COLUMN TIPO           FORMAT A15 
COLUMN DEFECTO        FORMAT A15 
COLUMN COMENTARIO     FORMAT A43 
COLUMN COMMENTS       FORMAT A69 
COLUMN TABLA_FORANEA  FORMAT A40 
-------------
-- Parámetros
-------------
ACCEPT tabla PROMPT "Escribe el nombre de la tabla: "
PROMPT .
----------------------------------
-- Ver si es un sinónimo de tabla
---------------------------------
var owner VARCHAR2(30)
var tabla VARCHAR2(30)
DECLARE
 
BEGIN
  -- Veo si es un sinónimo lo que me están pidiendo
  SELECT TABLE_OWNER, TABLE_NAME
  INTO   :owner,      :tabla
  FROM   USER_SYNONYMS
  WHERE  SYNONYM_NAME = UPPER( '&&tabla' );
EXCEPTION 
  WHEN NO_DATA_FOUND THEN 
    -- No es un sinónimo
    :owner := USER;
    :tabla := UPPER( '&&tabla' );
END;
/
----------
-- Selects
----------
SELECT DECODE( OWNER, USER, NULL, OWNER || '.' ) ||
       TABLE_NAME AS TABLE_NAME, COMMENTS
FROM   ALL_TAB_COMMENTS
WHERE  OWNER      = :owner
  AND  TABLE_NAME = :tabla
/
SELECT P.PK CLAVE_PRIMARIA,
       M.COLUMN_NAME, 
       M.DATA_TYPE || DECODE( M.DATA_TYPE, 
                              /*************************************/
                              'DATE', NULL, -- Poner aquí los tipos
                              'LONG', NULL, -- de varible para los 
                              'BLOB', NULL, -- que no queramos ver
                              'CLOB', NULL, -- la precisión
                              /*************************************/
                              '(' || TO_CHAR( NVL( M.DATA_PRECISION, 
                                                   M.DATA_LENGTH))||
                              DECODE( M.DATA_SCALE, NULL, NULL, 
                                      ',' ||
                                      TO_CHAR( M.DATA_SCALE ) ) ||
                              ')' ) TIPO,
       M.NULLABLE,
       M.DATA_DEFAULT DEFECTO,
       C.COMMENTS COMENTARIO
FROM   ( SELECT N.TABLE_NAME, L.COLUMN_NAME, '*' PK
         FROM   ALL_CONS_COLUMNS L, ALL_CONSTRAINTS N
         WHERE  L.CONSTRAINT_NAME = N.CONSTRAINT_NAME
           AND  L.OWNER      = :owner
           AND  N.OWNER      = :owner
           AND  N.TABLE_NAME = :tabla
           AND  N.CONSTRAINT_TYPE = 'P' ) P, -- Clave primaria
       ALL_TAB_COLUMNS M, ALL_COL_COMMENTS C
WHERE  M.TABLE_NAME  = C.TABLE_NAME
  AND  M.COLUMN_NAME = C.COLUMN_NAME
  AND  M.OWNER       = C.OWNER
  AND  M.TABLE_NAME  = P.TABLE_NAME  (+)
  AND  M.COLUMN_NAME = P.COLUMN_NAME (+)
  AND  M.TABLE_NAME  = :tabla
  AND  M.OWNER       = :owner
ORDER BY M.COLUMN_ID
/
PROMPT CLAVES FORÁNEAS:
BREAK ON TABLA_FORANEA
SELECT DECODE( B.OWNER, :owner, NULL, B.OWNER || '.' ) ||
       B.TABLE_NAME TABLA_FORANEA, 
       C.COLUMN_NAME
FROM   ALL_CONS_COLUMNS C, ALL_CONSTRAINTS A, ALL_CONSTRAINTS B
WHERE  A.R_CONSTRAINT_NAME = B.CONSTRAINT_NAME
  AND  A.CONSTRAINT_NAME   = C.CONSTRAINT_NAME
  AND  A.OWNER             = C.OWNER
  AND  A.TABLE_NAME        = :tabla
  AND  A.OWNER             = :owner
  AND  A.CONSTRAINT_TYPE   = 'R'
ORDER BY B.TABLE_NAME, C.POSITION
/
SET VERIFY ON

Sentencias COMMENT para una tabla o vista

Sir Ragnar — Thu, 19 Jul 2007 23:38:05 +0000

Cuando creo una vista, me gusta ponerle comentarios a ella y también a sus columnas. Normalmente es un rollo porque tengo que copy-pastearme las columnas y luego ir haciendo el comment on column. Lo peor del copy-paste es que es muy fácil cometer errores inadvertidamente (y cambiarle los comentarios a otra tabla o cosas por el estilo). Por esto y por gandulería informática, me he hecho un script para ahorrame trabajo y errores. El script me genera las sentencias comment y ya sólo me queda ir llenando los comentarios.

-- Script para obtener la lista de create comments
-- http://www.tsoracle.com
--------------
-- Sets varios
--------------
SET LINES 120
SET PAGES 1000
SET HEADING OFF
SET VERIFY OFF
 
---------------------
-- Valores de entrada
---------------------
ACCEPT PROPIETARIO PROMPT "Propietario del esquema: "
ACCEPT TABLAOVISTA PROMPT "Nombre de la tabla o vista: "
 
--------------------------------------
-- Selects para la obtención de datos
-------------------------------------
-- Comentario para la tabla o vista
SELECT 'COMMENT ON TABLE &&PROPIETARIO..&&TABLAOVISTA ' ||
       ' IS ''''' || CHR(10) ||
       '/'
FROM DUAL
/
-- Comentario para las columnas de la tabla o vista
SELECT 'COMMENT ON COLUMN ' || 
       OWNER       || '.' ||
       TABLE_NAME  || '.' ||
       COLUMN_NAME || 
       ' IS '''''    || CHR(10) ||
       '/'
FROM   ALL_TAB_COLS
WHERE  OWNER      = UPPER( '&&PROPIETARIO' )
  AND  TABLE_NAME = UPPER( '&&TABLAOVISTA' )
ORDER BY COLUMN_ID
/
----------------------------
-- Restauro heading y verify
----------------------------
SET VERIFY ON 
SET HEADING ON

Diferencias entre columnas

Sir Ragnar — Mon, 09 Jul 2007 10:39:56 +0000

Me he visto obligado a sustituir algunas tablas de un esquema por vistas sobre otro. La idea es hacer una refactorización, por lo que necesito asegurarme de que las nuevas vistas tengan las mismas columnas que las antiguas tablas. Para eso me he hecho un script que se encarga de compararme nombres y tipos de variable. Como utiliza la vista ALL_TAB_COLS sirve para comparar indistintamente vistas y tablas. Por si a alguien le resulta de utilidad, ahí va:

-- Script para comparar columnas de dos vistas o tablas.
-- http://www.tsoracle.com
--------------
-- Sets varios
--------------
SET SERVEROUTPUT ON 
SET VERIFY OFF
---------------------
-- Valores de entrada
---------------------
ACCEPT PROPIETARIO1 PROMPT "Propietario del esquema 1: "
ACCEPT TABLAOVISTA1 PROMPT "Nombre de la tabla o vista 1: "
ACCEPT PROPIETARIO2 PROMPT "Propietario del esquema 2: "
ACCEPT TABLAOVISTA2 PROMPT "Nombre de la tabla o vista 2: "
DECLARE
 
  --------------------
  -- Tipos de Variable
  --------------------
  -- Tipo para diferencias unitarias
  TYPE tDiferencia IS RECORD (
    vColumna ALL_TAB_COLS.COLUMN_NAME%TYPE,
    vValorA  VARCHAR2(200),
    vValorB  VARCHAR2(200) );
 
  -- Tipo para conjuntos de diferencias
  TYPE tDiferencias IS TABLE OF tDiferencia INDEX BY BINARY_INTEGER;
 
  -------------
  -- Constantes
  -------------
  VOWNER1 CONSTANT ALL_TAB_COLS.OWNER%TYPE      := UPPER( 
                                                     SUBSTR( '&&PROPIETARIO1',
                                                             1, 30 ) );
  VTABLA1 CONSTANT ALL_TAB_COLS.TABLE_NAME%TYPE := UPPER( 
                                                     SUBSTR( '&&TABLAOVISTA1',
                                                             1, 30 ) );
 
  VOWNER2 CONSTANT ALL_TAB_COLS.OWNER%TYPE      := UPPER( 
                                                     SUBSTR( '&&PROPIETARIO2',
                                                             1, 30 ) );
  VTABLA2 CONSTANT ALL_TAB_COLS.TABLE_NAME%TYPE := UPPER( 
                                                     SUBSTR( '&&TABLAOVISTA2',
                                                             1, 30 ) );
  VNULL  CONSTANT VARCHAR2(30) := 'SIN VALOR';
  ------------
  -- Variables
  ------------
  -- Variables para llenar las diferencias entre columnas
  plDistintoTipo     tDiferencias;
  plDistintaLongitud tDiferencias;
  plDistintoNulable  tDiferencias;
 
  -- Variable boleana que me indica si existen las dos tablas/vistas
  bExistenAmbas BOOLEAN;
 
  -----------
  -- Cursores
  -----------
  CURSOR cColumnasDistintoTipo IS
    SELECT A.COLUMN_NAME VCOLUMNA, -- Columna de la discordia
 
           -- Datos de la columna de la tabla 1
           NVL( A.DATA_TYPE, VNULL ) DATA_TYPE1, 
           TO_CHAR( A.DATA_LENGTH )  DATA_LENGTH1,
           NVL( A.NULLABLE,  VNULL ) NULLABLE1,
 
           -- Datos de la columna de la tabla 2
           NVL( B.DATA_TYPE, VNULL ) DATA_TYPE2, 
           TO_CHAR( B.DATA_LENGTH )  DATA_LENGTH2,
           NVL( B.NULLABLE,  VNULL ) NULLABLE2
 
    FROM   ALL_TAB_COLS A, ALL_TAB_COLS B
    WHERE  A.COLUMN_NAME = B.COLUMN_NAME
      AND  A.OWNER       = VOWNER1
      AND  A.TABLE_NAME  = VTABLA1
      AND  B.OWNER       = VOWNER2
      AND  B.TABLE_NAME  = VTABLA2
      AND  ( NVL( A.DATA_TYPE, VNULL )  != NVL( B.DATA_TYPE, VNULL ) OR
             A.DATA_LENGTH              != B.DATA_LENGTH             OR
             NVL( A.NULLABLE,  VNULL )  != NVL( B.NULLABLE,  VNULL ) 
            )
    ORDER BY A.COLUMN_ID;
 
  -----------------------------
  -- Funciones y procedimientos
  -----------------------------
  -- Di -------------------------------------------------------------
  PROCEDURE Di( cadena VARCHAR2 ) IS
    -- Procedimiento que hace un dbms_output.put_line cortando
    -- la cadena de entrada a 255 para evitar que de un error
    -- de línea demasiado larga.
  BEGIN
    DBMS_OUTPUT.PUT_LINE( SUBSTR( cadena, 1, 255 ) );
  END Di;
 
  -- diSeparador ----------------------------------------------------
  PROCEDURE diSeparador IS
    -- Procedimiento que escribe unas líneas que hacen las veces
    -- de separador de sección.
  BEGIN
    Di('.');
    Di('====================================================' );
  END;
 
  -- diDiferencia ---------------------------------------------------
  PROCEDURE diDiferencia( rDif tDiferencia ) IS 
    -- Procedimiento que escribe por pantalla una diferencia
  BEGIN
    Di( rDif.vColumna || '. En ' || VTABLA1 || ': ' || rDif.vValorA || ', ' 
                                 || VTABLA2 || ': ' || rDif.vValorB );
  END diDiferencia;
 
  -- diDiferencias -----------------------------------------------------------
  PROCEDURE diDiferencias( vDescri VARCHAR2, plDif tDiferencias ) IS 
    -- Procedimiento que escribe en pantalla la lista de diferencias
  BEGIN
    diSeparador();
    di( vDescri );
 
    IF plDif.LAST IS NOT NULL THEN 
      FOR nInd IN plDif.FIRST..plDif.LAST LOOP 
        diDiferencia( plDif( nInd ) );
      END LOOP;
 
    ELSE 
      Di( 'No ha diferencias' );
    END IF;
  END diDiferencias;
 
  -- agregaDiferencia -----------------------------------------------
  PROCEDURE agregaDiferencia( rDif tDiferencia, plDif IN OUT tDiferencias ) IS 
    -- Procedimiento que agrega una diferencia a una lista de diferencias.
    ------------
    -- Variables
    ------------
    -- Para el siguiente índice de la tabla
    nIndSiguiente BINARY_INTEGER;
  BEGIN
    IF plDif.LAST IS NULL THEN 
      -- La lista está vacía, me están pidiendo que agrege el primer elemento
      nIndSiguiente := 1;
    ELSE 
      nIndSiguiente := plDif.LAST + 1;
    END IF;
 
    plDif( nIndSiguiente ) := rDif;
  END agregaDiferencia;
 
  -- agregaDifSiExiste ----------------------------------------------
  PROCEDURE agregaDifSiExiste( vColumna        ALL_TAB_COLS.COLUMN_NAME%TYPE,
                               vValorA         VARCHAR2,
                               vValorB         VARCHAR2,
                               plDif    IN OUT tDiferencias
                             )
  IS 
    -- Procedimiento que agrega una diferencia si los valores son distintos
    ------------
    -- Variables
    ------------
    -- Variable de diferencia auxiliar
    rDifAux tDiferencia;
  BEGIN
    IF vValorA != vValorB THEN 
      rDifAux.vColumna := vColumna;
      rDifAux.vValorA  := vValorA;
      rDifAux.vValorB  := vValorB;
 
      agregaDiferencia( rDifAux, plDif );
    END IF;    
 
  END agregaDifSiExiste;
 
  -- diColumnasQueNoEstan -------------------------------------------
  PROCEDURE diColumnasQueNoEstan(
              vOwnerA ALL_TAB_COLS.OWNER%TYPE,
              vTablaA ALL_TAB_COLS.TABLE_NAME%TYPE,
              vOwnerB ALL_TAB_COLS.OWNER%TYPE,
              vTablaB ALL_TAB_COLS.TABLE_NAME%TYPE )
  IS
    -- Procedimiento que saca por pantalla la relación de columnas
    -- de la tabla o vista A que no están en la tabla o vista b
 
    -----------
    -- Cursores
    -----------
    -- Cursor que saca las columnas de la tabla o vista A
    -- que no están en la tabla o vista B
    CURSOR cNoColumnas  IS
      SELECT A.COLUMN_NAME
      FROM   ALL_TAB_COLS A
      WHERE  A.OWNER      = vOwnerA
        AND  A.TABLE_NAME = vTablaA
        AND  NOT EXISTS(
              SELECT 'X'
              FROM   ALL_TAB_COLS B
              WHERE  B.OWNER       = vOwnerB
                AND  B.TABLE_NAME  = vTablaB
                AND  B.COLUMN_NAME = A.COLUMN_NAME )
      ORDER BY A.COLUMN_ID;
  BEGIN
    diSeparador();
 
    Di( 'Columnas de '      || vOwnerA || '.' || vTablaA ||
        ' que no están en ' || vOwnerB || '.' || vTablaB ||
        ':');
 
    FOR rCol IN cNoColumnas LOOP
      Di( rCol.COLUMN_NAME );
    END LOOP;
  END diColumnasQueNoEstan;
 
  -- existeTablaOVista ---------------------------------------------------------
  FUNCTION existeTablaOVista( vPropietario VARCHAR2,
                              vTabla       VARCHAR2 ) 
  RETURN BOOLEAN IS 
    -- Función que comprueba se existe una tabla o vista con el propietario
    -- y nombre que le pasan como parámetro.
    ------------
    -- Variables
    ------------
    vAux VARCHAR2(1);
  BEGIN
    SELECT 'X'
    INTO   vAux
    FROM   ALL_OBJECTS 
    WHERE  OWNER       = vPropietario
      AND  OBJECT_NAME = vTabla 
      AND  OBJECT_TYPE IN ( 'TABLE', 'VIEW' );
 
    -- Si llego hasta aquí es que existe.
    RETURN TRUE;
  EXCEPTION 
    WHEN NO_DATA_FOUND THEN 
      RETURN FALSE;
  END existeTablaOVista;
 
BEGIN
  -- Amplío el buffer del dbms_output para que no se quede pequeño
  DBMS_OUTPUT.DISABLE;
  DBMS_OUTPUT.ENABLE(10000000);
 
  IF existeTablaOVista( VOWNER1, VTABLA1 ) THEN  
    IF existeTablaOVista( VOWNER2, VTABLA2 ) THEN 
      bExistenAmbas := TRUE;
    ELSE 
      diSeparador();
      di( 'No existe la tabla o vista ' || VOWNER2 || '.' || VTABLA2 );
      bExistenAmbas := FALSE;
    END IF;
  ELSE 
    diSeparador();
    di( 'No existe la tabla o vista ' || VOWNER1 || '.' || VTABLA1 );
    bExistenAmbas := FALSE;
  END IF;
 
  -- Sólo continúo si existen ambas tablas:
  IF bExistenAmbas THEN
 
    -- Columnas de la tabla 1 que no están en la tabla 2
    diColumnasQueNoEstan( VOWNER1, VTABLA1, VOWNER2, VTABLA2 );
 
    -- Columnas de la tabla 2 que no están en la tabla 1
    diColumnasQueNoEstan( VOWNER2, VTABLA2, VOWNER1, VTABLA1 );
 
    -- Ahora recopilo las diferencias en las columnas que sí están en las dos
    -- tablas o vistas.
    FOR rDife IN cColumnasDistintoTipo LOOP 
      agregaDifSiExiste( rDife.VCOLUMNA, rDife.DATA_TYPE1, rDife.DATA_TYPE2, 
                         plDistintoTipo );
 
      agregaDifSiExiste( rDife.VCOLUMNA, rDife.DATA_LENGTH1, rDife.DATA_LENGTH2, 
                         plDistintaLongitud );
 
      agregaDifSiExiste( rDife.VCOLUMNA, rDife.NULLABLE1, rDife.NULLABLE2, 
                         plDistintoNulable );
    END LOOP;
 
    -- Pinto la lista de diferencias por cada tipo
    diDiferencias( 'Diferencias de tipo:',     plDistintoTipo );
    diDiferencias( 'Diferencias de longitud:', plDistintaLongitud );
    diDiferencias( 'Diferencias de nulable:',  plDistintoNulable );
  END IF;
END;
/
SET VERIFY ON

Algunos tips de SQL

Sir Ragnar — Thu, 05 Jul 2007 11:53:34 +0000

Estaba navegando por estos mundos de Oracle buscando algún consejo sobre la forma más eficiente de montar una union y me he topado con este interesante documento sobre tips de sql. Creo que todos los que trabajamos con consultas SQL en Oracle deberíamos conocerlos: SQL Tuning Tips.
Especialmente curioso me ha parecido el primero de ellos que viene a aconsejar seguir algún tipo de patron a la hora de construir las consultas. Es algo que me gusta hacer, pero nunca hubiera pensado que pudiera respaldarlo con argumentos tuneros.