jueves, 8 de diciembre de 2016

SQL%FOUND


Atributo booleano que se evalúa como TRUE si la última sentencia SQL afectó al menos una fila.

Puede probar el SQL%ROWCOUNT , SQL%FOUND , y atributos de SQL%NOTFOUND en la sección ejecutable de un bloque para recoger información después se ejecuta el comando apropiados DML. PL / SQL no devuelve un error si una sentencia DML no afecta a las filas de la tabla subyacente. Sin embargo, si una sentencia SELECT no recupera ninguna fila, PL / SQL devuelve una excepción.

Observe que los atributos tienen el prefijo SQL. Estos atributos del cursor se utilizan con los cursores implícitos que son creados automáticamente por PL / SQL y para los que no saben los nombres. Por lo tanto, se utiliza SQL en lugar del nombre del cursor.

El atributo SQL%NOTFOUND es lo contrario de SQL%NOTFOUND . Este atributo puede ser utilizado como la condición de salida en un bucle. Es útil en UPDATE y DELETE cuando se cambian ninguna fila porque excepciones no se devuelven en estos casos.
Usted aprenderá acerca de cursor explícito atributos en la lección titulada "Uso de los cursores explícitos".

Ejemplo:

DECLARE

CURSOR C_EMP IS
SELECT LAST_NAME
FROM HR.EMPLOYEES
WHERE EMPLOYEE_ID = 100;

V_EMP VARCHAR2(30);

BEGIN

OPEN C_EMP ;
FECTH C_EMP
INTO V_EMP;

IF C_EMP%FOUND THEN

--ALGO

END IF;

CLOSE C_EMP;


END;
Share:

SQL%NOTFOUND


Atributo booleano que se evalúa como TRUE si La última sentencia SQL no afectó incluso una fila.

Puede probar el SQL%ROWCOUNT , SQL%FOUND , y atributos de SQL%NOTFOUND en la sección ejecutable de un bloque para recoger información después se ejecuta el comando apropiados DML. PL / SQL no devuelve un error si una sentencia DML no afecta a las filas de la tabla subyacente. Sin embargo, si una sentencia SELECT no recupera ninguna fila, PL / SQL devuelve una excepción.

Observe que los atributos tienen el prefijo SQL. Estos atributos del cursor se utilizan con los cursores implícitos que son creados automáticamente por PL / SQL y para los que no saben los nombres. Por lo tanto, se utiliza SQL en lugar del nombre del cursor.

El atributo SQL%NOTFOUND es lo contrario de SQL%NOTFOUND . Este atributo puede ser utilizado como la condición de salida en un bucle. Es útil en UPDATE y DELETE cuando se cambian ninguna fila porque excepciones no se devuelven en estos casos.
Usted aprenderá acerca de cursor explícito atributos en la lección titulada "Uso de los cursores explícitos".

Ejemplo:

DECLARE

CURSOR C_EMP IS
SELECT LAST_NAME
FROM HR.EMPLOYEES
WHERE EMPLOYEE_ID = 100;

V_EMP VARCHAR2(30);

BEGIN

OPEN C_EMP ;
FECTH C_EMP
INTO V_EMP;

IF C_EMP%NOTFOUND THEN

--ALGO

END IF;

CLOSE C_EMP;


END;
Share:

SQL%ROWCOUNT


Un valor entero que representa el número de filas afectadas por la última sentencia SQL.

Puede probar el SQL%ROWCOUNT , SQL%FOUND , y atributos de SQL%NOTFOUND en la sección ejecutable de un bloque para recoger información después se ejecuta el comando apropiados DML. PL / SQL no devuelve un error si una sentencia DML no afecta a las filas de la tabla subyacente. Sin embargo, si una sentencia SELECT no recupera ninguna fila, PL / SQL devuelve una excepción.

Observe que los atributos tienen el prefijo SQL. Estos atributos del cursor se utilizan con los cursores implícitos que son creados automáticamente por PL / SQL y para los que no saben los nombres. Por lo tanto, se utiliza SQL en lugar del nombre del cursor.

El atributo SQL%NOTFOUND es lo contrario de SQL%NOTFOUND . Este atributo puede ser utilizado como la condición de salida en un bucle. Es útil en UPDATE y DELETE cuando se cambian ninguna fila porque excepciones no se devuelven en estos casos.
Usted aprenderá acerca de cursor explícito atributos en la lección titulada "Uso de los cursores explícitos".

DECLARE
  v_rows_deleted VARCHAR2(30)
  v_empno employees.employee_id%TYPE := 176;
BEGIN

  DELETE FROM  employees
  WHERE employee_id = v_empno;
  v_rows_deleted := (SQL%ROWCOUNT ||
                       ' row deleted.');
  DBMS_OUTPUT.PUT_LINE (v_rows_deleted);

END;

El ejemplo elimina una fila con employee_id 176 de la tabla de empleados. Usando el atributo% ROWCOUNT SQL, puede imprimir el número de registros borrados.

Share:

CURSORES

Un cursor es un puntero a la zona de memoria privada asignada por el servidor Oracle. Se utiliza para manejar el conjunto de resultados de una sentencia SELECT.

Hay dos tipos de cursores: implícitos y explícitos.

  1. Implícito: Creado y gestionado internamente por el servidor Oracle para procesar sentencias SQL
  2. Explícita: Declarado explícitamente por el programador


Usted ya ha aprendido que puede incluir sentencias SQL que devuelven una sola fila en un bloque PL/SQL. Los datos recuperados por la sentencia SQL deberían celebrarse en las variables mediante la cláusula INTO.

De dónde viene el proceso de declaraciones de SQL Server Oracle?
El servidor de Oracle asigna un área de memoria privada llamada el área de contexto para el procesamiento de sentencias SQL. La sentencia SQL se analiza y procesa en esta área. La información necesaria para el procesamiento y la información recuperada después de su transformación se almacenan en esta área. Usted no tiene control sobre esta zona, ya que se maneja internamente por el servidor Oracle.
Un cursor es un puntero a la zona de contexto. Sin embargo, este cursor es un cursor implícito y es gestionado automáticamente por el servidor Oracle. Cuando el bloque ejecutable emite una sentencia SQL, PL / SQL crea un cursor implícito.

Tipos de cursores
Hay dos tipos de cursores:

Implícita: se crea y gestionado por el servidor de Oracle Un cursor implícito. Usted no tiene acceso a ella. El servidor de Oracle crea un cursor como cuando tiene que ejecutar una sentencia SQL.

Explícita: Como programador, es posible que desee recuperar varias filas de una tabla de base de datos, tiene un puntero a cada fila que se recupera, y el trabajo en las filas de una en una. En tales casos, se puede declarar cursores explícitamente en función de sus necesidades de negocio. Un cursor declarado por los programadores se llama cursor explícito. Usted declara un cursor tal en la parte declarativa de un bloque PL / SQL.

1. En la parte declarativa de un bloque PL/SQL, declare el cursor por nombrarlo y la definición de la estructura de la consulta que se asocia con él.
2. Abra el cursor.  La sentencia OPEN ejecuta la consulta y se une cualquier variable que se hace referencia. Filas identificados por la consulta se llaman el conjunto activo y ahora están disponibles para ir a buscar.
3. Obtener los datos desde el cursor.  En el diagrama de flujo mostrado en la diapositiva, después de cada zona de alcance, se prueba el cursor para cualquier fila existente. Si no hay más filas para procesar, debe cerrar el cursor.
4. Cierre el cursor.  La sentencia CLOSE libera el conjunto activo de filas. Ahora es posible reabrir el cursor para establecer un conjunto activo fresco.


Un programa PL/SQL abre un cursor, procesa filas devueltas por una consulta, y luego cierra el cursor. El cursor marca la posición actual en el conjunto activo.
1. La sentencia OPEN ejecuta la consulta asociada con el cursor, identifica el conjunto activo, y posiciona el cursor en la primera fila.
2. La sentencia FETCH recupera la fila actual y avanza el cursor a la siguiente Remar hasta que no haya más filas o se cumple una condición especificada.
3. La sentencia CLOSE libera el cursor.



La sentencia OPEN ejecuta la consulta asociada con el cursor, identifica el conjunto activo, y posiciona el puntero del cursor en la primera fila. La instrucción OPEN está incluido en la sección ejecutable del bloque PL / SQL.
OPEN es una sentencia ejecutable que realiza las siguientes operaciones:
1. asigna dinámicamente la memoria para un área de contexto
2. analiza la instrucción SELECT
3. Se liga las variables de entrada (establece los valores de las variables de entrada mediante la obtención de sus direcciones de memoria)
4. Identifica el conjunto activo (el conjunto de filas que satisfacen los criterios de búsqueda). Las filas en el conjunto activo no se recuperan en variables cuando se ejecute la sentencia OPEN. Más bien, la sentencia FETCH recupera las filas desde el cursor a las variables.
5. Coloca el puntero a la primera fila en el conjunto activo
Nota: Si una consulta no devuelve ninguna fila cuando se abre el cursor, PL / SQL no plantea una excepción. Usted puede encontrar el número de filas devueltas con un cursor explícitos mediante el uso de la <cursor_name>% ROWCOUNT atributo.

La sentencia FETCH recupera las filas de la cursor uno a la vez. Después de cada zona de alcance, el cursor avanza a la siguiente fila en el conjunto activo. Usted puede utilizar el atributo% NOTFOUND para determinar si todo el conjunto activo se ha recuperado.

Considere el ejemplo mostrado en la diapositiva. Dos variables, empno y lname, se declaran para contener los valores han obtenido desde el cursor. Examine la sentencia FETCH.

Haber recogido con éxito los valores desde el cursor a las variables. Sin embargo, hay seis empleados del departamento 30, pero sólo una fila era descabellada. Para recuperar todas las filas, debe utilizar bucles. En la siguiente diapositiva, se ve cómo se utiliza un bucle para buscar a todas las filas.

La sentencia FETCH realiza las siguientes operaciones:
1. Lee los datos de la fila actual en la salida de las variables PL / SQL
2. Avanza el puntero a la siguiente fila en el conjunto activo

Puede incluir el mismo número de variables en la cláusula INTO de la sentencia FETCH ya que hay columnas en la sentencia SELECT; asegúrese de que los tipos de datos son compatibles. Relacionar cada variable para corresponder a las columnas posicionalmente. Alternativamente, también puede definir un récord para el cursor y hacer referencia al registro en el FETCH cláusula INTO. Por último, la prueba para ver si el cursor contiene filas. Si una zona de alcance adquiere ningún valor, no hay filas de izquierda a procesar en el conjunto activo y se registra ningún error.

Share:

DML EN PL-SQL


Usted manipular datos en la base de datos mediante el uso de comandos DML. Puede emitir comandos DML tales como INSERT, UPDATE, DELETE y MERGE sin restricciones en PL / SQL. Los bloqueos de fila (y bloqueos de tabla) se liberan mediante la inclusión de las declaraciones de confirmar o deshacer en el código PL / SQL.
  • La sentencia INSERT añade nuevas filas a la tabla.
  • La sentencia UPDATE modifica filas existentes en la tabla.
  • La instrucción DELETE elimina filas de la tabla.
  • La instrucción MERGE selecciona filas de una tabla a actualizar o insertar en otra mesa. La decisión de actualizar o insertar en la tabla de destino se basa en una condición en la cláusula ON.

Nota: MERGE es una afirmación determinista. Es decir, no se puede actualizar la misma fila de la tabla de destino varias veces en la misma sentencia MERGE. Debe tener INSERT y objetos UPDATE privilegios en la tabla de destino y SELECT privilegio en la tabla fuente.

Ejemplos:

DECLARE

V_CODIGO NUMBER := 1;
V_NOMBRE VARCHAR2(30) := 'JOSE';

BEGIN

INSERT INTO TABLA(C_CODIGO,C_NOMBRE)
VALUES (V_CODIGO,V_NOMBRE);

V_NOMBRE := 'JUAN';

UPDATE TABLA NOMBRE
SET C_NOMBRE = V_NOMBRE

WHERE C_CODIGO = V_CODIGO;

DELETE TABLA
WHERE C_CODIGO = V_CODIGO;

COMMIT;

END;

La instrucción MERGE inserciones o actualizaciones filas de una tabla utilizando los datos de otra tabla. Cada fila se inserta o actualiza en la tabla de destino en función de una condición de unión igualitaria.
El ejemplo que se muestra coincide con la columna empno en la tabla copy_emp a la columna de employee_id en la tabla empleados. Si se encuentra una coincidencia, la fila se actualiza para que coincida con la línea de la tabla empleados. Si no se encuentra la fila, se inserta en la tabla copy_emp.
El ejemplo completo de usar MERGE en un bloque PL / SQL se muestra en la página siguiente.

BEGIN
MERGE INTO copy_emp c
     USING employees e
     ON (e.employee_id = c.empno)
   WHEN MATCHED THEN
     UPDATE SET
       c.first_name     = e.first_name,
       c.last_name      = e.last_name,
       c.email          = e.email,
       c.phone_number   = e.phone_number,
       c.hire_date      = e.hire_date,
       c.job_id         = e.job_id,
       c.salary         = e.salary,
       c.commission_pct = e.commission_pct,
       c.manager_id     = e.manager_id,
       c.department_id  = e.department_id
   WHEN NOT MATCHED THEN
     INSERT VALUES(e.employee_id,  e.first_name, e.last_name,
          e.email, e.phone_number, e.hire_date, e.job_id,
          e.salary, e.commission_pct, e.manager_id, 
          e.department_id);
END;
/
Share:

SERVEROTUPUT

El SERVEROTUPUT es el paquete que nos permite utilizar funciones propias de ORACLE, como puede ser la salida de mensajes como mostrare a continuacion.

set SERVEROUTPUT ON

DECLARE

 V_NOMBRE VARCHAR2(30) := 'JOSE JIMENEZ';

BEGIN

--DBMS_OUTPUT = PAQUETE
--PUT_LINE = FUNCION

DBMS_OUTPUT.PUT_LINE(V_NOMBRE );

END;

Resultado: JOSE JIMENEZ
Share:

INTO


La cláusula INTO es obligatoria y se produce entre el SELECT y FROM cláusulas. Se utiliza para especificar los nombres de las variables que contienen los valores que SQL rendimientos de la cláusula SELECT. Debe especificar una variable para cada elemento seleccionado, y el orden de las variables deben corresponder con los elementos seleccionados.

Utilice la cláusula INTO para poblar bien las variables PL/SQL o variables del lenguaje principal.

Consultas debe devolver una sola fila
Sentencias SELECT dentro de un bloque caída PL/SQL en la clasificación ANSI de SQL incorporado, para el que se aplica la regla siguiente: Las consultas deben devolver una sola fila. Una consulta que devuelve más de una fila o ninguna fila genera un error.
PL/SQL gestiona estos errores al elevar excepciones estándar, que se puede manejar en la sección excepción del bloque con el NO_DATA_FOUND y TOO_MANY_ROWS excepciones. Incluya una condición WHERE en la instrucción SQL para que la declaración devuelve una sola fila. Usted aprenderá acerca de la gestión de excepciones en la lección titulada "Manejo de excepciones".

Nota: En todos los casos en que se utiliza DBMS_OUTPUT.PUT_LINE en los ejemplos de código, la SET SERVEROUTPUT ON declaración precede al bloque.


Cómo recuperar varias filas de una tabla y operar sobre los Datos
Una instrucción SELECT con la cláusula INTO puede recuperar sólo una fila a la vez. Si su requerimiento es para recuperar varias filas y operar sobre los datos, puede hacer uso de cursores explícitos. Te presentan a los cursores adelante en esta lección y aprender acerca de los cursores explícitos en la lección titulada "Uso de los cursores explícitos".


Share:

NESTED BLOCKS O BLOQUES ANIDADOS


Los bloques PL/SQL se pueden anidar.


  • Una sección ejecutable (BEGIN ... END) pueden contener bloques anidados.
  • Una sección de excepción puede contener? Bloques anidados.
Siendo procesal concede PL / SQL la capacidad de los estados de nidos. Puede bloques nido donde se permite que una sentencia ejecutable, con lo que el bloque anidado un comunicado. Si su sección ejecutable tiene código para muchas funcionalidades relacionados lógicamente para soportar múltiples requerimientos del negocio, se puede dividir la sección ejecutable en bloques más pequeños. La sección de excepción también puede contener bloques anidados.


El ejemplo mostrado tiene un (padre) bloque exterior y un bloque (niño) anidado. La variable v_outer_variable se declara en el bloque exterior y la variable v_inner_variable se declara en el bloque interno.

v_outer_variable es local en el bloque exterior sino global al bloque interior. Al acceder a esta variable en el bloque interior, PL / SQL primero busca una variable local en el interior de manzana con ese nombre. No hay ninguna variable con el mismo nombre en el bloque interior, por lo PL / SQL busca la variable en el bloque exterior. Por lo tanto, v_outer_variable se considera que es la variable global para todos los bloques de cerramiento. Puede acceder a esta variable en el bloque interior como se muestra en la diapositiva. Las variables declaradas en un bloque PL / SQL se consideran como locales en ese bloque y global a todos sus sub-bloques.

v_inner_variable es local en el bloque interno y no es global, porque el bloque interno no tiene ningún bloques anidados. Esta variable se puede acceder sólo dentro del bloque interior. Si PL / SQL no encuentra la variable declarada a nivel local, que mira hacia arriba en la parte declarativa de los bloques de los padres. PL / SQL no se parece a la baja en los bloques del niño.


La salida del bloque de muestra en el portaobjetos es el siguiente:
  • anonymous block completed
  • Father's Name: Patrick
  • Date of Birth: 12-DEC-02
  • Child's Name: Mike
  • Date of Birth: 20-APR-72

Examine la fecha de nacimiento que se imprime para el padre y el niño. La salida no proporciona la información correcta, porque el alcance y la visibilidad de las variables no se aplican correctamente.
  • El ámbito de una variable es la parte del programa en el que se declara la variable y es accesible.
  • La visibilidad de una variable es la parte del programa donde se puede acceder a la variable sin utilizar un calificador.
Scope
  • La variable v_father_name y la primera aparición de la variable v_date_of_birth se declaran en el bloque exterior. Estas variables tienen el alcance de la frase en la que se declaran. Por lo tanto, el alcance de estas variables se limita a la bloque exterior.
  • Las variables v_child_name y v_date_of_birth se declaran en el interior de manzana o el bloque anidado. Estas variables son accesibles sólo dentro del bloque anidado y no son accesibles en el bloque exterior. Cuando una variable está fuera de alcance, PL / SQL libera la memoria utilizada para almacenar la variable; por lo tanto, no pueden ser referenciados estas variables.\

Visibilidad

La variable v_date_of_birth declarado en el bloque exterior tiene un alcance incluso en el interior de manzana. Sin embargo, esta variable no es visible en el bloque interno porque el bloque interior tiene una variable local con el mismo nombre.

1. Examine el código en la sección ejecutable del bloque PL / SQL. Puede imprimir el nombre del padre, el nombre del niño y la fecha de nacimiento. Sólo la fecha de nacimiento del niño se  puede imprimir aquí porque la fecha de nacimiento del padre no es visible.
2.Fecha del padre de nacimiento es visible en el bloque exterior y, por lo tanto, se pueden imprimir.

Nota: No se puede tener variables con el mismo nombre en un bloque. Sin embargo, como se muestra en este ejemplo, se puede declarar variables con el mismo nombre en dos bloques diferentes (bloques anidados). Los dos elementos representados por identificadores son distintos; cambios en uno no afectan a la otra.

Share:

miércoles, 7 de diciembre de 2016

COMENTARIOS


Podemos comentar en PL/SQL con los siguientes comandos:

                                          /* Comentario 

                                             Comentario*/
                                          -- Comentario


Con tan solo escribir dentro de /**/ tendremos una linea o varias de comentarios, mientras que con -- podemos comentar una sola linea.
Share:

EJECUTANDO CODIGO JAVA DESDE PL/SQL

El código Java a ejecutar se puede incorporar a la base de datos cargando un archivo .jar mediante la instrucción loadjava (comando de sistema operativo que se encuentra en el directorio BIN de la base de datos) o creándolo directamente de forma similar a como se crea una función, procedimiento o paquete. En este ejemplo se usa esta segunda opción.
El siguiente código recibe por parámetro una fecha, desglosada en 6 campos numéricos (año, mes, día, hora, minuto y segundo) y la devuelve en formato texto:
CREATE OR REPLACE AND RESOLVE JAVA SOURCE NAMED "JavaDate" AS
  package pruebas;
  import java.util.Calendar;

  public class JavaDate {  
    public static String getString(int anho, int mes, int dia, int hora, int minuto, int segundo) {
      Calendar calendar;        
      calendar = Calendar.getInstance();
      calendar.set(anho, mes, dia, hora, minuto, segundo);
      return calendar.getTime().toString();
    }
  }

Una vez está el código Java creado en la base de datos, hay que crear una función o procedimiento para llamarlo:

CREATE OR REPLACE FUNCTION f_javadate(p_anho NUMBER,
                                      p_mes NUMBER,
                                      p_dia NUMBER,
                                      p_hora NUMBER,
                                      p_minuto NUMBER,
                                      p_segundo NUMBER) RETURN VARCHAR2 IS LANGUAGE JAVA
 NAME 'pruebas.JavaDate.getString(int, int, int, int, int, int) return String';

Ahora ya sólo falta invocarlo donde sea necesario, por ejemplo:

SELECT f_javadate(  TO_NUMBER(TO_CHAR(SYSDATE, 'YYYY')),
                                    TO_NUMBER(TO_CHAR(SYSDATE, 'MM')),
                                    TO_NUMBER(TO_CHAR(SYSDATE, 'DD')),
                                    TO_NUMBER(TO_CHAR(SYSDATE, 'HH24')),
                                    TO_NUMBER(TO_CHAR(SYSDATE, 'MI')),
                                    TO_NUMBER(TO_CHAR(SYSDATE, 'SS')))
 FROM DUAL;


DESCARGAR SCRIPTS
Share:

viernes, 2 de diciembre de 2016

ESTRUCTURA DE UN BLOQUE DE DATOS


Los bloque de datos forman parte de lo que es la estructura de PL/SQL y se definen de la siguiente manera:

                  DECLARE

                  BEGIN

                  EXCEPTION

                  END;


  • En el DECLARE pondremos los distintos tipos de variables que podemos usar en PL/SQL.
  • Entre BEGIN y END, pondremos nuestro código.
  • En la sección de EXCEPTION atraparemos todas las posibles excepciones levantadas en el bloque.


Share:

jueves, 17 de noviembre de 2016

UNPIVOT

 Ahora vamos a ver el nuevo operador UNPIVOT. Como su nombre indica, una operación UNPIVOT es lo contrario de pivote (aunque sin la posibilidad de desagregar los datos). Una manera más simple de pensar en UNPIVOT es que convierte columnas pivota en filas (una fila de datos para cada columna sea no girados). Veremos ejemplos de esto más adelante, pero Comenzaremos con una descripción general de la sintaxis, de la siguiente manera.

 La sintaxis es similar a la de pivote con algunas ligeras diferencias, incluyendo el significado de las diferentes cláusulas. Estos se describen como sigue:

unpivot_clause: esta cláusula especifica un nombre para una columna para representar los valores de medida no girados. En nuestros ejemplos anteriores de pivote, la columna de la medida fue la suma de los salarios de cada puesto de trabajo y la agrupación departamento;
unpivot_for_clause: la unpivot_for_clause especifica el nombre de la columna que será el resultado de nuestra búsqueda UNPIVOT. Los datos en esta columna describe los valores del indicador en la columna unpivot_clause; y
unpivot_in_clause: este contiene la lista de columnas giradas (no valores) que no girados.
Las cláusulas UNPIVOT son muy difíciles de describir y se sirve mejor a algunos ejemplos.

 UNPIVOT ejemplos simples

Antes de escribir una consulta UNPIVOT, vamos a crear un conjunto de datos pivota para utilizar en nuestros ejemplos. Para simplificar, vamos a crear una vista usando una de nuestras consultas de pivote anteriores, de la siguiente manera.

SQL> CREATE VIEW pivoted_data
  2  AS
  3     SELECT *
  4     FROM   pivot_data
  5     PIVOT (SUM(sal)
  6     FOR    deptno IN (10 AS d10_sal,
  7                       20 AS d20_sal,
  8                       30 AS d30_sal,
  9                       40 AS d40_sal));

Ver creado.
La vista PIVOTED_DATA contiene nuestra norma suma de los sueldos por departamento de trabajo, con los cuatro almacenes totales pivotantes como hemos visto a lo largo de este artículo. Como recordatorio final de la naturaleza de los datos, vamos a consultar este punto de vista.

SQL> SELECT *
  2  FROM   pivoted_data;

JOB           D10_SAL    D20_SAL    D30_SAL    D40_SAL
---------- ---------- ---------- ---------- ----------
CLERK            1430       2090       1045
SALESMAN                               6160
PRESIDENT        5500
MANAGER          2695     3272.5       3135
ANALYST                     6600

5 rows selected.
Ahora vamos a UNPIVOT nuestro conjunto de datos utilizando la nueva sintaxis 11g de la siguiente manera.

SQL> SELECT *
  2  FROM   pivoted_data
  3  UNPIVOT (
  4               deptsal                              --<-- unpivot_clause
  5           FOR saldesc                              --<-- unpivot_for_clause
  6           IN  (d10_sal, d20_sal, d30_sal, d40_sal) --<-- unpivot_in_clause
  7          );

JOB        SALDESC       DEPTSAL
---------- ---------- ----------
CLERK      D10_SAL          1430
CLERK      D20_SAL          2090
CLERK      D30_SAL          1045
SALESMAN   D30_SAL          6160
PRESIDENT  D10_SAL          5500
MANAGER    D10_SAL          2695
MANAGER    D20_SAL        3272.5
MANAGER    D30_SAL          3135
ANALYST    D20_SAL          6600

9 rows selected.
Podemos ver en los resultados que Oracle ha incorporado a cada una de nuestras columnas articuladas en el unpivot_in_clause y los convirtió en filas de datos que describen nuestra medida (es decir, 'D10_SAL', 'D20_SAL' y así sucesivamente). El unpivot_for_clause da esta nueva columna no girados un nombre (es decir, "SALDESC"). El unpivot_clause sí define nuestros datos de la medida, que en este caso es la suma del sueldo del departamento de trabajo.

Es importante tener en cuenta que las consultas UNPIVOT pueden trabajar en cualquier columna (es decir, no sólo los agregados o abatible, columnas). Estamos utilizando el conjunto de datos pivota para mantener la coherencia, pero que podría fácilmente UNPIVOT las columnas de cualquier tabla o vista que tenemos.

Manejo de datos nulos

El número máximo de filas que se pueden devolver por una consulta UNPIVOT es el número de agrupaciones distintas, multiplicado por el número de columnas pivote (en nuestros ejemplos, 5 (puestos de trabajo) * 4 columnas (pivote) = 20). Sin embargo, nuestra primera consulta UNPIVOT sólo ha regresado nueve filas. Si nos fijamos en los datos de pivote fuente misma, podemos ver nueve valores no nulos en las columnas pivote; en otras palabras, once agrupaciones son nulos. El comportamiento predeterminado de UNPIVOT es excluir valores nulos, pero sí tenemos una opción para incluirlos, de la siguiente manera.

 SQL> SELECT *
  2  FROM   pivoted_data
  3  UNPIVOT INCLUDE NULLS
  4        (deptsal
  5  FOR    saldesc IN (d10_sal,
  6                     d20_sal,
  7                     d30_sal,
  8                     d40_sal));

JOB        SALDESC       DEPTSAL
---------- ---------- ----------
CLERK      D10_SAL          1430
CLERK      D20_SAL          2090
CLERK      D30_SAL          1045
CLERK      D40_SAL
SALESMAN   D10_SAL
SALESMAN   D20_SAL
SALESMAN   D30_SAL          6160
SALESMAN   D40_SAL
PRESIDENT  D10_SAL          5500
PRESIDENT  D20_SAL
PRESIDENT  D30_SAL
PRESIDENT  D40_SAL
MANAGER    D10_SAL          2695
MANAGER    D20_SAL        3272.5
MANAGER    D30_SAL          3135
MANAGER    D40_SAL
ANALYST    D10_SAL
ANALYST    D20_SAL          6600
ANALYST    D30_SAL
ANALYST    D40_SAL

20 rows selected.

Con la inclusión de los valores nulos de pivote, volvemos el número máximo de filas posibles de nuestro conjunto de datos. Por supuesto, ahora tenemos once valores nulos, pero esto podría ser algo que se requiere para generar informes o "densificación de datos".



Share:

PIVOT

La cláusula PIVOT Oracle le permite escribir una consulta de partida tabulación cruzada en Oracle 11g. Esto significa que usted puede agregar sus resultados y rotar filas en columnas.

Sintaxis

La sintaxis de la cláusula PIVOT en Oracle / PLSQL es:
SELECT * FROM
(
  SELECT column1, column2
  FROM tables
  WHERE conditions
)
PIVOT 
(
  aggregate_function(column2)
  FOR column2
  IN ( expr1, expr2, ... expr_n) | subquery
)
ORDER BY expression [ ASC | DESC ];

Parámetros o argumentos

aggregate_function
Puede ser una función tal como SUM , COUNT , MIN , MAX o AVG funciones.
EN (expr1, expr2, ... expr_n)
Una lista de valores para columna2 pivote en capítulos de los resultados de la consulta de tabulación cruzada.
subconsulta
Se puede utilizar en lugar de una lista de valores. En este caso, los resultados de la subconsulta se utilizan para determinar los valores para column2 para pivotar en partidas de los resultados de la consulta de tabulación cruzada.

Se aplica a

La cláusula PIVOT se puede utilizar en las siguientes versiones de Oracle / PLSQL:
  • Oracle 12c, 11g de Oracle

Ejemplo

Veamos cómo utilizar la cláusula PIVOT en Oracle.
Vamos a basar nuestro ejemplo sobre una mesa de llamadas órdenes con la siguiente definición:
CREATE TABLE orders
( order_id integer NOT NULL,
  customer_ref varchar2(50) NOT NULL,
  order_date date,
  product_id integer,
  quantity integer,
  CONSTRAINT orders_pk PRIMARY KEY (order_id)
);
Para mostrar los datos de este ejemplo, vamos a seleccionar los registros de la órdenes tabla con la siguiente instrucción SELECT:
SELECT order_id, customer_ref, product_id
FROM orders
ORDER BY order_id;
Estos son los registros en el orden tabla. Vamos a utilizar estos registros para demostrar cómo funciona la cláusula PIVOT:
Solicitar IDcustomer_refID del Producto
50001HERRERO10
50002HERRERO20
50003ANDERSON30
50004ANDERSON40
50005JONES10
50006JONES20
50007HERRERO20
50008HERRERO10
50009HERRERO20
Ahora, vamos a crear nuestra consulta tabulación cruzada utilizando la siguiente cláusula PIVOT:
SELECT * FROM
(
  SELECT customer_ref, product_id
  FROM orders
)
PIVOT
(
  COUNT(product_id)
  FOR product_id IN (10, 20, 30)
)
ORDER BY customer_ref;
En este ejemplo, la cláusula PIVOT devolvería los siguientes resultados:
customer_ref102030
ANDERSON001
JONES110
HERRERO230
Ahora, vamos a romper aparte la cláusula PIVOT y explicar cómo funcionaba.

Especificar campos que desea incluir

En primer lugar, queremos especificar qué campos a incluir en nuestra tabulación cruzada. En este ejemplo, queremos incluir la customer_ref y product_id campos. Esto se hace por la parte siguiente de la declaración:
(
  SELECT customer_ref, product_id
  FROM orders
)
Se pueden listar las columnas que se incluirán en cualquier orden.

Especificar función de agregado

A continuación, tenemos que especificar qué función agregada de usar al crear nuestra consulta tabulación cruzada. Se puede utilizar cualquier agregado tales como SUM , COUNT , MIN , MAX o AVG funciones.
En este ejemplo, vamos a utilizar la función COUNT. Esto contará el número de product_id valores que cumplan con nuestros criterios. Esto se hace por la parte siguiente de la declaración:
PIVOT
(
  COUNT(product_id)

Especificar valores de pivote

Por último, tenemos que especificar qué valores de pivote para incluir en nuestros resultados. Estos serán utilizados como los encabezados de columna en nuestra consulta de tabulación cruzada. Puede utilizar cualquiera de una lista de valores entre paréntesis o una sub consulta para especificar los valores de pivote.
En este ejemplo, vamos a devolver sólo los siguientes valores product_id: 10, 20, 30. Estos valores se convertirán en nuestros títulos de las columnas en nuestra consulta de tabulación cruzada. Además, tenga en cuenta que estos valores son una lista finita de los product_id valores y no necesariamente contener todos los valores posibles.
Esto se hace por la parte siguiente de la declaración:
  FOR product_id IN (10, 20, 30)
)
Ahora bien, cuando lo ponemos todos juntos, obtenemos la siguiente tabla dinámica:
customer_ref102030
ANDERSON001
JONES110
HERRERO230
Excelente contenido, gracias a la gente de:
Share:

COLUMNAS COMPUESTAS

Columnas Compuestas: Ejemplo
Observe el ejemplo:  
  SELECT department_id, job_id,manager_id, SUM(salary)
   FROM   employees    
   GROUP BY ROLLUP( department_id,job_id, manager_id);
Esta consulta hace que Oracle Server calcule los siguientes agrupamientos:
1.  (job_id, manager_id)
2.  (department_id, job_id, manager_id)
3.  (department_id)
4.  Suma total

Si sólo le interesan grupos específicos, no puede limitar el cálculo a esos agrupamientos sin utilizar columnas compuestas. Con las columnas compuestas, esto es posible si se trata las columnas JOB_ID y MANAGER_ID como una unidad durante la acumulación. Las columnas entre paréntesis se tratan como una unidad durante los cálculos ROLLUP y CUBE. Esto se ilustra en el ejemplo de la diapositiva. Al poner las columnas JOB_ID y MANAGER_ID entre paréntesis, le indica a Oracle Server que trate JOB_ID y MANAGER_ID como una unidad, que es una columna compuesta.
Columnas Compuestas: Ejemplo (continuación)
El ejemplo de la diapositiva calcula los siguientes agrupamientos:
(department_id, job_id, manager_id)
(department_id)
( )
El ejemplo de la diapositiva muestra lo siguiente:
Salario total de todos los puestos y supervisor (etiquetado como 1)
Salario total de todos los departamentos, los puestos y los supervisores (etiquetado
como 2)
Salario total de todos los departamentos (etiquetado como 3)
Suma total (etiquetado como 4)
El ejemplo de la diapositiva también se puede escribir como:
 SELECT  department_id, job_id, manager_id, SUM(salary)
FROM    employees    
GROUP    BY department_id,job_id, manager_id
UNION    ALL
SELECT   department_id, TO_CHAR(NULL),TO_NUMBER(NULL), SUM(salary)
FROM     employees    
GROUP BY  department_id
UNION ALL
SELECT  TO_NUMBER(NULL), TO_CHAR(NULL),TO_NUMBER(NULL), SUM(salary)
FROM    employees    
GROUP BY ();
En ausencia de un optimizador que busque en los bloques de consulta para generar el plan de ejecución, la consulta anterior necesitaría tres exploraciones de la tabla base, EMPLOYEES. Esto podría resultar muy ineficiente. Por tanto, se recomienda utilizar columnas compuestas.

Columnas Concatenadas
Los agrupamientos concatenados ofrecen una forma concisa de generar combinaciones de agrupamientos útiles. Para especificar los agrupamientos concatenados, se muestran varios juegos de agrupamientos, cubos y acumulaciones, y se separan con comas. A continuación se ofrece un ejemplo de juegos de agrupamientos concatenados:
GROUP BY GROUPING SETS(a, b), GROUPING SETS(c, d)
Este ejemplo SQL define los siguientes agrupamientos:
(a, c), (a, d), (b, c), (b, d)
La concatenación de juegos de agrupamientos es muy útil por estos motivos:
Facilidad de desarrollo de consultas: No es necesario enumerar manualmente todos los agrupamientos.
Uso por las aplicaciones: El SQL generado por aplicaciones OLAP suele implicar la concatenación de juegos de agrupamientos, en la que cada juego de agrupamientos define los agrupamientos necesarios para una dimensión.

Los agrupamientos concatenados ofrecen una forma concisa de generar combinaciones de agrupamientos útiles. Para especificar los juegos de agrupamientos concatenados, separe varias operaciones ROLLUP, CUBE y juegos de agrupamientos con comas, de modo que Oracle Server las combine en una única cláusula GROUP BY. El resultado es un producto combinado de agrupamientos de cada juego de agrupamientos.

GROUP BY GROUPING SETS(a, b), GROUPING SETS(c, d)




Agrupamientos Concatenados: Ejemplo
El ejemplo de la diapositiva da como resultado los siguientes agrupamientos:
(job_id, manager_id) (1)
(department_id,job_id, manager_id) (2)
(job_id)(3)
(department_id,manager_id)(4)
(department_id) (5)

Se calcula el salario total de cada uno de estos grupos.
Share:

Archivo

Cual es el tema de mayor interes para ti?