![Objetivos ,[object Object],[object Object],[object Object],[object Object]](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)
Recomendados
Recomendados
Más contenido relacionado
La actualidad más candente
La actualidad más candente (20)
Destacado
Destacado (20)
Similar a Sql
Similar a Sql (20)
Más de symple9
Último
Último (20)
Sql
- 1. Introducción
- 4. Almacenamiento de Datos SALGRADE GRADE LOSAL HISAL --------- --------- --------- 1 700 1200 2 1201 1400 3 1401 2000 4 2001 3000 5 3001 9999 DEPT DEPTNO DNAME LOC --------- -------------- ---------- 10 ACCOUNTING NEW YORK 20 RESEARCH DALLAS 30 SALES CHICAGO 40 OPERATIONS BOSTON Hoja de Cálculo Archivo Base de Datos
- 7. Modelos de Datos Modelo del Sistema que el cliente tiene en mente Modelo de Entidades a partir del modelo del cliente Paso a las Tablas, partiendo del modelo de entidades Tablas en Disco Servidor
- 9. Convenciones para el Modelo ER es representante de ventas para CUSTOMER #* id * name o phone EMPLOYEE #* id * last name o first name asignado a Entidad Caja con bordes redondeados, con nombre único, singular, en mayúsculas Sinónimos entre paréntesis Atributo Nombre singular en minúsculas Si es obligatorio se marca con “*” Si es opcional se marca con "o" Identificador Unico (UID) Primario marcado con "(*)" Secundario marcado con "(#)"
- 10. EMPLOYEE #* number * name o job title DEPARTMENT #* number * name o location Convenciones para el Modelo ER Entidad Caja con bordes redondeados, con nombre único, singular, en mayúsculas Sinónimos entre paréntesis Atributo Nombre singular en minúsculas Si es obligatorio se marca con “*” Si es opcional se marca con "o" Identificador Unico (UID) Primario marcado con "(*)" Secundario marcado con "(#)"
- 11. Terminología de una B.D. Relacional EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO ------------- ------------ --------------------- -------- ---------------- ----------- -------------- ----------- 7839 KING PRESIDENT 17-NOV-81 5000 10 7698 BLAKE MANAGER 7839 01-MAY-81 2850 30 7782 CLARK MANAGER 7839 09-JUN-81 2450 10 7566 JONES MANAGER 7839 02-APR-81 2975 20 7654 MARTIN SALESMAN 7698 28-SEP-81 1250 1400 30 7499 ALLEN SALESMAN 7698 20-FEB-81 1600 300 30 7844 TURNER SALESMAN 7698 08-SEP-81 1500 0 30 7900 JAMES CLERK 7698 03-DEC-81 950 30 7521 WARD SALESMAN 7698 22-FEB-81 1250 500 30 7902 FORD ANALYST 7566 03-DEC-81 3000 20 7369 SMITH CLERK 7902 17-DEC-80 800 20 7788 SCOTT ANALYST 7566 09-DEC-82 3000 20 7876 ADAMS CLERK 7788 12-JAN-83 1100 20 7934 MILLER CLERK 7782 23-JAN-82 1300 10 1 2 3 4 5 6
- 14. Comunicación con un RDBMS Usando SQL B.D. SQL> SELECT loc 2 FROM dept; Se introduce la sentencia SQL La Sentencia se envía a la B.D. LOC ------------- NEW YORK DALLAS CHICAGO BOSTON Resultado
- 15. Oracle8: Object Relational Database Management System Tablas de Usuario Diccionario de Datos Servidor
- 20. Solución Completa de ORACLE SQL PL/SQL Oracle7/8 Aplicaciones: HR Financials Manufacturing ... Oracle Designer Oracle Developer Tablas de Datos Diccionario de Datos SQL* Plus O. Discoverer B.D.
- 23. Entorno de PL/SQL Bloque PL/SQL Motor PL/SQL Servidor Oracle8 Ejecutor de Sentencias Procedurales PL/SQL SQL Ejecutor de Sentencias SQL Bloque PL/SQL
- 29. Tablas Utilizadas en el Curso EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO --------- ---------- --------- --------- --------- --------- --------- --------- 7839 KING PRESIDENT 17-NOV-81 5000 10 7698 BLAKE MANAGER 7839 01-MAY-81 2850 30 7782 CLARK MANAGER 7839 09-JUN-81 1500 10 7566 JONES MANAGER 7839 02-APR-81 2975 20 7654 MARTIN SALESMAN 7698 28-SEP-81 1250 1400 30 7499 ALLEN SALESMAN 7698 20-FEB-81 1600 300 30 7844 TURNER SALESMAN 7698 08-SEP-81 1500 0 30 7900 JAMES CLERK 7698 03-DEC-81 950 30 7521 WARD SALESMAN 7698 22-FEB-81 1250 500 30 7902 FORD ANALYST 7566 03-DEC-81 3000 20 7369 SMITH CLERK 7902 17-DEC-80 800 20 7788 SCOTT ANALYST 7566 09-DEC-82 3000 20 7876 ADAMS CLERK 7788 12-JAN-83 1100 20 7934 MILLER CLERK 7782 23-JAN-82 1300 10 EMP DEPT DEPTNO DNAME LOC --------- -------------- ---------- 10 ACCOUNTING NEW YORK 20 RESEARCH DALLAS 30 SALES CHICAGO 40 OPERATIONS BOSTON GRADE LOSAL HISAL --------- --------- --------- 1 700 1200 2 1201 1400 3 1401 2000 4 2001 3000 5 3001 9999 SALGRADE
- 31. Escritura Básica de Sentencias SQL
- 33. La Sentencia SELECT de SQL Selección Projección Tabla 1 Tabla 2 Tabla 1 Tabla 1 Join
- 36. Selección de Todas las Columnas DEPTNO DNAME LOC --------- -------------- ------------- 10 ACCOUNTING NEW YORK 20 RESEARCH DALLAS 30 SALES CHICAGO 40 OPERATIONS BOSTON SQL> SELECT * 2 FROM dept;
- 37. Selección Específica de Columnas DEPTNO LOC --------- ------------- 10 NEW YORK 20 DALLAS 30 CHICAGO 40 BOSTON SQL> SELECT deptno, loc 2 FROM dept;
- 40. Uso de Operadores Aritméticos SQL> SELECT ename, sal, sal+300 2 FROM emp; ENAME SAL SAL+300 ---------- --------- --------- KING 5000 5300 BLAKE 2850 3150 CLARK 2450 2750 JONES 2975 3275 MARTIN 1250 1550 ALLEN 1600 1900 ... 14 rows selected.
- 42. Precedencia de Operadores SQL> SELECT ename, sal, 12*sal+100 2 FROM emp; ENAME SAL 12*SAL+100 ---------- --------- ---------- KING 5000 60100 BLAKE 2850 34300 CLARK 2450 29500 JONES 2975 35800 MARTIN 1250 15100 ALLEN 1600 19300 ... 14 rows selected.
- 43. Uso de Paréntesis SQL> SELECT ename, sal, 12*(sal+100) 2 FROM emp; ENAME SAL 12*(SAL+100) ---------- --------- ----------- KING 5000 61200 BLAKE 2850 35400 CLARK 2450 30600 JONES 2975 36900 MARTIN 1250 16200 ... 14 rows selected.
- 47. Uso de Alias de Columna SQL> SELECT ename AS name, sal salary 2 FROM emp; NAME SALARY ------------- --------- ... SQL> SELECT ename "Name", 2 sal*12 "Annual Salary" 3 FROM emp; Name Annual Salary ------------- ------------- ...
- 49. Uso del Operador de Concatenación SQL> SELECT ename||job AS "Employees" 2 FROM emp; Employees ------------------- KINGPRESIDENT BLAKEMANAGER CLARKMANAGER JONESMANAGER MARTINSALESMAN ALLENSALESMAN ... 14 rows selected.
- 51. Uso de Cadenas de Caracteres Employee Details ------------------------- KING is a PRESIDENT BLAKE is a MANAGER CLARK is a MANAGER JONES is a MANAGER MARTIN is a SALESMAN ... 14 rows selected. SQL> SELECT ename ||' '||'is a'||' '||job 2 AS "Employee Details" 3 FROM emp;
- 53. Eliminación de Filas Duplicadas Las filas duplicadas se eliminan usando DISTINCT en la cláusula SELECT. SQL> SELECT DISTINCT deptno 2 FROM emp; DEPTNO --------- 10 20 30
- 54. Interacción SQL y SQL*Plus SQL*Plus Búfer Scripts SQL Servidor Sentecias SQL Resultado de la Consulta
- 59. Visualización de la Estructura de una Tabla SQL> DESCRIBE dept Name Null? Type ----------------- -------- ---- DEPTNO NOT NULL NUMBER(2) DNAME VARCHAR2(14) LOC VARCHAR2(13)
- 64. Restricción y Clasificación de los Datos
- 66. Limitar Filas por medio de Selecciones “… recupera todos los empleados del departamento 10” EMP EMPNO ENAME JOB ... DEPTNO 7839 KING PRESIDENT 10 7698 BLAKE MANAGER 30 7782 CLARK MANAGER 10 7566 JONES MANAGER 20 ... EMP EMPNO ENAME JOB ... DEPTNO 7839 KING PRESIDENT 10 7782 CLARK MANAGER 10 7934 MILLER CLERK 10
- 68. Uso de la Claúsula WHERE SQL> SELECT ename, job, deptno 2 FROM emp 3 WHERE job='CLERK'; ENAME JOB DEPTNO ---------- --------- --------- JAMES CLERK 30 SMITH CLERK 20 ADAMS CLERK 20 MILLER CLERK 10
- 70. Operadores de Comparación Operador = > >= < <= <> Significado Igual a Mayor que Mayor que o igual a Menor que Menor que o igual a No igual a
- 71. Uso de Operadores de Comparación SQL> SELECT ename, sal, comm 2 FROM emp 3 WHERE sal<=comm; ENAME SAL COMM ---------- --------- --------- MARTIN 1250 1400
- 72. Otros Operadores de Comparación Operador BETWEEN ...AND... IN(list) LIKE IS NULL Significado Entre dos valores (inclusive) Lista de valores Se ajusta a un patrón Es un valor nulo
- 78. Operadores Lógicos Operador AND OR NOT Significado Devuelve TRUE si ambas condiciones son TRUE Devuelve TRUE si alguna de las condiciones es TRUE Devuelve TRUE si la siguiente condición es FALSE
- 79. Uso del Operador AND AND requiere que ambas condiciones sean TRUE SQL> SELECT empno, ename, job, sal 2 FROM emp 3 WHERE sal>=1100 4 AND job='CLERK'; EMPNO ENAME JOB SAL --------- ---------- --------- --------- 7876 ADAMS CLERK 1100 7934 MILLER CLERK 1300
- 81. Uso del Operador NOT SQL> SELECT ename, job 2 FROM emp 3 WHERE job NOT IN ('CLERK','MANAGER','ANALYST'); ENAME JOB ---------- --------- KING PRESIDENT MARTIN SALESMAN ALLEN SALESMAN TURNER SALESMAN WARD SALESMAN
- 83. Reglas de Precedencia ENAME JOB SAL ---------- --------- --------- KING PRESIDENT 5000 MARTIN SALESMAN 1250 ALLEN SALESMAN 1600 TURNER SALESMAN 1500 WARD SALESMAN 1250 SQL> SELECT ename, job, sal 2 FROM emp 3 WHERE job='SALESMAN' 4 OR job='PRESIDENT' 5 AND sal>1500;
- 84. Reglas de Precedencia ENAME JOB SAL ---------- --------- --------- KING PRESIDENT 5000 ALLEN SALESMAN 1600 Uso de paréntesis para forzar prioridad. SQL> SELECT ename, job, sal 2 FROM emp 3 WHERE (job='SALESMAN' 4 OR job='PRESIDENT') 5 AND sal>1500;
- 86. Clasificación en Orden Descendente SQL> SELECT ename, job, deptno, hiredate 2 FROM emp 3 ORDER BY hiredate DESC; ENAME JOB DEPTNO HIREDATE ---------- --------- --------- --------- ADAMS CLERK 20 12-JAN-83 SCOTT ANALYST 20 09-DEC-82 MILLER CLERK 10 23-JAN-82 JAMES CLERK 30 03-DEC-81 FORD ANALYST 20 03-DEC-81 KING PRESIDENT 10 17-NOV-81 MARTIN SALESMAN 30 28-SEP-81 ... 14 rows selected.
- 87. Clasificación por Alías de Columna SQL> SELECT empno, ename, sal*12 annsal 2 FROM emp 3 ORDER BY annsal; EMPNO ENAME ANNSAL --------- ---------- --------- 7369 SMITH 9600 7900 JAMES 11400 7876 ADAMS 13200 7654 MARTIN 15000 7521 WARD 15000 7934 MILLER 15600 7844 TURNER 18000 ... 14 rows selected.
- 89. Resumen SELECT [DISTINCT] {*, column [ alias ], ...} FROM table [WHERE condition(s) ] [ORDER BY { column, expr, alias } [ASC|DESC]];
- 90. Funciones a Nivel de Fila
- 92. Funciones SQL Función Entrada arg 1 arg 2 arg n Las Funciones Realizan Acciones Salida Valor Resultado
- 93. Dos Tipos de Funciones SQL Funciones Funciones a Nivel de Fila Funciones a Nivel de Múltiples Filas
- 95. Funciones a Nivel de Fila Conversion Character Number Date General Single-row functions
- 96. Funciones de Caracteres Funciones de Caracteres LOWER UPPER INITCAP CONCAT SUBSTR LENGTH INSTR LPAD Funciones de Conversión Funciones de Manipulación de Caracteres
- 100. Uso de Funciones de Manipulación de Caracteres SQL> SELECT ename, CONCAT (ename, job), LENGTH(ename), 2 INSTR(ename, 'A') 3 FROM emp 4 WHERE SUBSTR(job,1,5) = 'SALES'; ENAME CONCAT(ENAME,JOB) LENGTH(ENAME) INSTR(ENAME,'A') ---------- ------------------- ------------- ---------------- MARTIN MARTINSALESMAN 6 2 ALLEN ALLENSALESMAN 5 1 TURNER TURNERSALESMAN 6 0 WARD WARDSALESMAN 4 2
- 107. Uso de Operadores Aritméticos en Fechas SQL> SELECT ename, (SYSDATE-hiredate)/7 WEEKS 2 FROM emp 3 WHERE deptno = 10; ENAME WEEKS ---------- --------- KING 830.93709 CLARK 853.93709 MILLER 821.36566
- 108. Funciones de Fecha Número de meses entre dos fechas MONTHS_BETWEEN ADD_MONTHS NEXT_DAY LAST_DAY ROUND TRUNC Agregar meses según calendario, a una fecha Próximo día de la fecha especificada Ultimo día del mes Redondea una fecha Trunca una fecha FUNCION DESCRIPCION
- 111. Funciones de Conversión Conversión Implícita Conversión Explícita Conversión de Tipos de Datos
- 114. Conversión Explícita del Tipo de Dato NUMBER CHARACTER TO_CHAR TO_NUMBER DATE TO_CHAR TO_DATE
- 116. Elementos del Modelo Formato de Fecha YYYY YEAR MM MONTH DY DAY Año completo en número Año en letras Nº del mes con dos dígitos Abreviatura de tres letras del día de la semana Nombre completo del día Nombre completo del mes
- 118. Formato de Fecha RR Año Actual 1995 1995 2001 2001 Fecha Específicada 27-OCT-95 27-OCT-17 27-OCT-17 27-OCT-95 Formato RR 1995 2017 2017 1995 FormatoYY 1995 1917 2017 2095 Si los 2 dígitos especificados del año están Si los 2 dígitos del año corriente están 0-49 0-49 50-99 50-99 La fecha devuelta corresponde al siglo corriente. La fecha devuelta corresponde al siglo posterior al corriente. La fecha devuelta corresponde al siglo anterior al corriente. La fecha devuelta corresponde al siglo corriente.
- 119. Función TO_CHAR con Fechas SQL> SELECT ename, 2 TO CHAR(hiredate, 'fmDD Month YYYY') HIREDATE 3 FROM emp; ENAME HIREDATE ---------- ----------------- KING 17 November 1981 BLAKE 1 May 1981 CLARK 9 June 1981 JONES 2 April 1981 MARTIN 28 September 1981 ALLEN 20 February 1981 ... 14 rows selected.
- 121. SQL> SELECT TO_CHAR(sal,'$99,999') SALARY 2 FROM emp 3 WHERE ename = 'SCOTT'; SALARY -------- $3,000 Uso de la Función TO_CHAR con Números
- 124. Uso de la Función NVL SQL> SELECT ename, sal, comm, (sal*12)+NVL(comm,0) 2 FROM emp; ENAME SAL COMM (SAL*12)+NVL(COMM,0) ---------- --------- --------- -------------------- KING 5000 60000 BLAKE 2850 34200 CLARK 2450 29400 JONES 2975 35700 MARTIN 1250 1400 16400 ALLEN 1600 300 19500 ... 14 rows selected.
- 126. Uso de la Función DECODE SQL> SELECT job, sal, 2 DECODE(job, 'ANALYST' SAL*1.1, 3 'CLERK', SAL*1.15, 4 'MANAGER', SAL*1.20, 5 SAL) 6 REVISED_SALARY 7 FROM emp; JOB SAL REVISED_SALARY --------- --------- -------------- PRESIDENT 5000 5000 MANAGER 2850 3420 MANAGER 2450 2940 ... 14 rows selected.
- 128. Funciones Anidadas SQL> SELECT ename, 2 NVL(TO_CHAR(mgr),'No Manager') 3 FROM emp 4 WHERE mgr IS NULL; ENAME NVL(TO_CHAR(MGR),'NOMANAGER') ---------- ----------------------------- KING No Manager
- 131. Visualización de Datos a partir de Varias Tablas
- 133. Obtención de Datos de Múltiples Tablas EMPNO DEPTNO LOC ----- ------- -------- 7839 10 NEW YORK 7698 30 CHICAGO 7782 10 NEW YORK 7566 20 DALLAS 7654 30 CHICAGO 7499 30 CHICAGO ... 14 rows selected. EMP DEPT EMPNO ENAME ... DEPTNO ------ ----- ... ------ 7839 KING ... 10 7698 BLAKE ... 30 ... 7934 MILLER ... 10 DEPTNO DNAME LOC ------ ---------- -------- 10 ACCOUNTING NEW YORK 20 RESEARCH DALLAS 30 SALES CHICAGO 40 OPERATIONS BOSTON
- 136. Generación de un Producto Cartesiano ENAME DNAME ------ ---------- KING ACCOUNTING BLAKE ACCOUNTING ... KING RESEARCH BLAKE RESEARCH ... 56 rows selected. EMP (14 registros) DEPT (4 registros) EMPNO ENAME ... DEPTNO ------ ----- ... ------ 7839 KING ... 10 7698 BLAKE ... 30 ... 7934 MILLER ... 10 DEPTNO DNAME LOC ------ ---------- -------- 10 ACCOUNTING NEW YORK 20 RESEARCH DALLAS 30 SALES CHICAGO 40 OPERATIONS BOSTON “ Producto Cartesiano: 14*4=56 rows”
- 138. ¿Qué es un Equijoin? EMP DEPT EMPNO ENAME DEPTNO ------ ------- ------- 7839 KING 10 7698 BLAKE 30 7782 CLARK 10 7566 JONES 20 7654 MARTIN 30 7499 ALLEN 30 7844 TURNER 30 7900 JAMES 30 7521 WARD 30 7902 FORD 20 7369 SMITH 20 ... 14 rows selected. DEPTNO DNAME LOC ------- ---------- -------- 10 ACCOUNTING NEW YORK 30 SALES CHICAGO 10 ACCOUNTING NEW YORK 20 RESEARCH DALLAS 30 SALES CHICAGO 30 SALES CHICAGO 30 SALES CHICAGO 30 SALES CHICAGO 30 SALES CHICAGO 20 RESEARCH DALLAS 20 RESEARCH DALLAS ... 14 rows selected. Primary key Foreign key
- 139. Recuperación de Registros con Equijoins SQL> SELECT emp.empno, emp.ename, emp.deptno, 2 dept.deptno, dept.loc 3 FROM emp, dept 4 WHERE emp.deptno=dept.deptno; EMPNO ENAME DEPTNO DEPTNO LOC ----- ------ ------ ------ --------- 7839 KING 10 10 NEW YORK 7698 BLAKE 30 30 CHICAGO 7782 CLARK 10 10 NEW YORK 7566 JONES 20 20 DALLAS ... 14 rows selected.
- 141. Condiciones de Búsqueda Adicionales Usando el Operador AND: Ejemplo EMP DEPT EMPNO ENAME DEPTNO ------ ------- ------- 7839 KING 10 7698 BLAKE 30 7782 CLARK 10 7566 JONES 20 7654 MARTIN 30 7499 ALLEN 30 7844 TURNER 30 7900 JAMES 30 7521 WARD 30 7902 FORD 20 7369 SMITH 20 ... 14 rows selected. DEPTNO DNAME LOC ------ --------- -------- 10 ACCOUNTING NEW YORK 30 SALES CHICAGO 10 ACCOUNTING NEW YORK 20 RESEARCH DALLAS 30 SALES CHICAGO 30 SALES CHICAGO 30 SALES CHICAGO 30 SALES CHICAGO 30 SALES CHICAGO 20 RESEARCH DALLAS 20 RESEARCH DALLAS ... 14 rows selected.
- 143. Combinando Más de Dos Tablas NAME CUSTID ----------- ------ JOCKSPORTS 100 TKB SPORT SHOP 101 VOLLYRITE 102 JUST TENNIS 103 K+T SPORTS 105 SHAPE UP 106 WOMENS SPORTS 107 ... ... 9 rows selected. CUSTOMER CUSTID ORDID ------- ------- 101 610 102 611 104 612 106 601 102 602 106 604 106 605 ... 21 rows selected. ORD ORDID ITEMID ------ ------- 610 3 611 1 612 1 601 1 602 1 ... 64 rows selected. ITEM
- 144. Non-Equijoins EMP SALGRADE EMPNO ENAME SAL ------ ------- ------ 7839 KING 5000 7698 BLAKE 2850 7782 CLARK 2450 7566 JONES 2975 7654 MARTIN 1250 7499 ALLEN 1600 7844 TURNER 1500 7900 JAMES 950 ... 14 rows selected. GRADE LOSAL HISAL ----- ----- ------ 1 700 1200 2 1201 1400 3 1401 2000 4 2001 3000 5 3001 9999 “ el salario en la tabla EMP, está entre el salario más bajo y el salario más alto de la tabla SALGRADE”
- 145. Recuperación de Registros con Non-Equijoins ENAME SAL GRADE ---------- --------- --------- JAMES 950 1 SMITH 800 1 ADAMS 1100 1 ... 14 rows selected. SQL> SELECT e.ename, e.sal, s.grade 2 FROM emp e, salgrade s 3 WHERE e.sal 4 BETWEEN s.losal AND s.hisal;
- 146. Outer Joins EMP DEPT ENAME DEPTNO ----- ------ KING 10 BLAKE 30 CLARK 10 JONES 20 ... DEPTNO DNAME ------ ---------- 10 ACCOUNTING 30 SALES 10 ACCOUNTING 20 RESEARCH ... 40 OPERATIONS No hay empleados en el departamento OPERATIONS
- 148. Uso de Outer Joins SQL> SELECT e.ename, d.deptno, d.dname 2 FROM emp e, dept d 3 WHERE e.deptno(+) = d.deptno 4 ORDER BY e.deptno; ENAME DEPTNO DNAME ---------- --------- ------------- KING 10 ACCOUNTING CLARK 10 ACCOUNTING ... 40 OPERATIONS 15 rows selected.
- 149. Self Joins EMP (WORKER) EMP (MANAGER) EMPNO ENAME MGR ----- ------ ---- 7839 KING 7698 BLAKE 7839 7782 CLARK 7839 7566 JONES 7839 7654 MARTIN 7698 7499 ALLEN 7698 EMPNO ENAME ----- -------- 7839 KING 7839 KING 7839 KING 7698 BLAKE 7698 BLAKE “ MGR en la tabla WORKER es igual a EMPNO en la tabla MANAGER”
- 150. Combinación de una Tabla Consigo Misma WORKER.ENAME||'WORKSFOR'||MANAG ------------------------------- BLAKE works for KING CLARK works for KING JONES works for KING MARTIN works for BLAKE ... 13 rows selected. SQL> SELECT worker.ename||' works for '||manager.ename 2 FROM emp worker, emp manager 3 WHERE worker.mgr = manager.empno;
- 152. Datos Agregados por medio de Funciones de Grupo
- 163. Creando Grupos de Datos EMP “ media de salarios en EMP para cada departamento” DEPTNO SAL --------- --------- 10 2450 10 5000 10 1300 20 800 20 1100 20 3000 20 3000 20 2975 30 1600 30 2850 30 1250 30 950 30 1500 30 1250 DEPTNO AVG(SAL) ------- --------- 10 2916.6667 20 2175 30 1566.6667 2916.6667 2175 1566.6667
- 167. Agrupación por Más de Una Columna EMP “ suma de salarios de EMP para cada oficio (job), agrupado por departamento” DEPTNO JOB SAL --------- --------- --------- 10 MANAGER 2450 10 PRESIDENT 5000 10 CLERK 1300 20 CLERK 800 20 CLERK 1100 20 ANALYST 3000 20 ANALYST 3000 20 MANAGER 2975 30 SALESMAN 1600 30 MANAGER 2850 30 SALESMAN 1250 30 CLERK 950 30 SALESMAN 1500 30 SALESMAN 1250 JOB SUM(SAL) --------- --------- CLERK 1300 MANAGER 2450 PRESIDENT 5000 ANALYST 6000 CLERK 1900 MANAGER 2975 CLERK 950 MANAGER 2850 SALESMAN 5600 DEPTNO -------- 10 10 10 20 20 20 30 30 30
- 168. Uso de la Cláusula GROUP BY sobre Múltiples Columnas SQL> SELECT deptno, job, sum(sal) 2 FROM emp 3 GROUP BY deptno, job; DEPTNO JOB SUM(SAL) --------- --------- --------- 10 CLERK 1300 10 MANAGER 2450 10 PRESIDENT 5000 20 ANALYST 6000 20 CLERK 1900 ... 9 rows selected.
- 171. Exclusión de Resultados de un Grupo “ máximo salario por departamento mayor de 2900$” EMP DEPTNO SAL --------- --------- 10 2450 10 5000 10 1300 20 800 20 1100 20 3000 20 3000 20 2975 30 1600 30 2850 30 1250 30 950 30 1500 30 1250 DEPTNO MAX(SAL) --------- --------- 10 5000 20 3000 5000 3000 2850
- 173. Uso de la Cláusula HAVING SQL> SELECT deptno, max(sal) 2 FROM emp 3 GROUP BY deptno 4 HAVING max(sal)>2900; DEPTNO MAX(SAL) --------- --------- 10 5000 20 3000
- 174. Uso de la Cláusula HAVING SQL> SELECT job, SUM(sal) PAYROLL 2 FROM emp 3 WHERE job NOT LIKE 'SALES%' 3 GROUP BY job 4 HAVING SUM(sal)>5000 5 ORDER BY SUM(sal); JOB PAYROLL --------- --------- ANALYST 6000 MANAGER 8275
- 176. Resumen SELECT column , group_function FROM table [WHERE condition ] [GROUP BY group_by_expression ] [HAVING group_condition ] [ORDER BY column ];
- 177. Subconsultas
- 181. Usando una Subconsulta SQL> SELECT ename 2 FROM emp 3 WHERE sal > 4 (SELECT sal 5 FROM emp 6 WHERE empno=7566); ENAME ---------- KING FORD SCOTT 2975
- 185. Ejecución de Subc. Mono-registro ENAME JOB ---------- --------- MILLER CLERK SQL> SELECT ename, job 2 FROM emp 3 WHERE job = 4 (SELECT job 5 FROM emp 6 WHERE empno = 7369) 7 AND sal > 8 (SELECT sal 9 FROM emp 10 WHERE empno = 7876); CLERK 1100
- 186. Uso de Funciones de Grupo en una Subconsulta ENAME JOB SAL ---------- --------- --------- SMITH CLERK 800 SQL> SELECT ename, job, sal 2 FROM emp 3 WHERE sal = 4 (SELECT MIN(sal) 5 FROM emp); 800
- 188. ¿Qué está mal en esta Sentencia? ERROR: ORA-01427: single-row subquery returns more than one row no rows selected SQL> SELECT empno, ename 2 FROM emp 3 WHERE sal = 4 (SELECT MIN(sal) 5 FROM emp 6 GROUP BY deptno); “ Operador mono-registro en subconsulta multi-registro”
- 189. ¿Funcionaría esta Sentencia? no rows selected La Subconsulta NO devuelve registros SQL> SELECT ename, job 2 FROM emp 3 WHERE job = 4 (SELECT job 5 FROM emp 6 WHERE ename='SMYTHE');
- 191. Uso del Operador ANY en EMPNO ENAME JOB --------- ---------- --------- 7654 MARTIN SALESMAN 7521 WARD SALESMAN SQL> SELECT empno, ename, job 2 FROM emp 3 WHERE sal < ANY 4 (SELECT sal 5 FROM emp 6 WHERE job = 'CLERK') 7 AND job <> 'CLERK'; Subconsultas Multi-registro 950 800 1100 1300
- 192. Uso del Operador ALL en EMPNO ENAME JOB --------- ---------- --------- 7839 KING PRESIDENT 7566 JONES MANAGER 7902 FORD ANALYST 7788 SCOTT ANALYST SQL> SELECT empno, ename, job 2 FROM emp 3 WHERE sal > ALL 4 (SELECT avg(sal) 5 FROM emp 6 GROUP BY deptno) Subconsultas Multi-registro 2916.6667 2175 1566.6667
Notas del editor
- Objetivo En esta lección aprenderemos el sistema de gestión de la base de datos relacional (RDBMS) y el sistema de gestión de la base de datos relacional orientada objeto (ORDBMS). También aprenderemos qué es PL/SQL y dónde se puede utilizar.
- Almacenar la Información Cada organización tiene varias necesidades de información. Una biblioteca, guarda una lista de socios, libros y fechas de devolución. Una compañía necesita guardar información sobre empleados, departamentos y salarios. Estas piezas de información se llaman datos. Las organizaciones pueden almacenar datos en varios medios y en diferentes formatos; por ejemplo, un documento hard-copy en un archivador o un dato almacenado en hojas electrónicas o en bases de datos. Una base de datos es una colección organizada de información. Para manejar bases de datos, necesitamos sistemas de desarrollo de la base de datos (DBMS). Un DBMS es un programa que almacena, recupera y modifica datos en la base de datos requerida. Hay cuatro tipos principales de bases de datos; jerárquica, de red, relacional y más recientemente relacional orientada a objeto. . Nota: Oracle7 es un sistema de gestión de base de datos relacional y Oracle8 es un sistema de base de datos de base de datos relacional orientada a objeto.
- Modelo Relacional Los principios del modelo relacional fueron propuestos por el Dr. E. F. Codd en Junio de 1970 en un documento llamado “Un Modelo de Datos Relacional para Grandes Bancos de Datos Compartidos”. En este documento, el Dr. Codd propuso un modelo relacional para sistemas de base de datos. Los modelos más populares utilizados en aquel momento fueron los jerárquicos y los de red, o incluso unas simples estructuras de datos en ficheros. Los sistemas de gestión de bases de datos relacionales (RDBMS), pronto llegarían a ser muy populares, especialmente por su facilidad de uso y su flexibilidad en la estructura. Además, había un número de vendedores innovadores, como Oracle, que suplieron al RDBMS con un tipo de gestión de la aplicación muy poderoso y con productos para el usuario, proporcionando una solución total. Componentes del Modelo Relacional Colecciones de objetos o relaciones que almacenan los datos. Un conjunto de operadores que pueden actuar en las relaciones para producir otras relaciones. Integridad de datos. Para más información, ver: E. F. Codd , El Modelo Relacional para la Gestión de la Base de Datos, Versión 2. (Reading, Mass.: Addison-Wesley, 1990).
- Base de Datos Relacional Una base de datos relacional utiliza relaciones o tablas bi-dimensionales para almacenar la información. Por ejemplo, podríamos querer almacenar información sobre todos los empleados de nuestra empresa. En una base de datos relacional, creamos varias tablas para almacenar diferentes piezas de información sobre nuestros empleados, tales como una tabla de empleados, una tabla de departamentos y una tabla de salarios.
- Modelos de Datos Los modelos de datos son la piedra angular del diseño. Los ingenieros construyen un modelo de un automóvil antes de ponerlo en producción, para no dejar fuera ningún detalle. Del mismo modo, los diseñadores de sistemas desarrollan modelos para explorar ideas y mejorar la comprensión del diseño de la base de datos. Propósito de los Modelos Los modelos ayudan a comunicar conceptos que la gente tiene en mente. Pueden usarse para los siguientes propósitos: Comunicar Categorizar Describir Especificar Investigar Evolucionar Analizar Imitar El objetivo es producir un modelo en el que encajen varios de estos usos que puede ser comprendidos por un usuario final, pero que a la vez contienen suficiente detalle para que un desarrollador construya un sistema de base de datos.
- Modelo Entidad-Relación En un sistema efectivo, los datos se dividen en categorías discretas o entidades. Un modelo entidad-relación (ER) es una ilustración de varias entidades en un negocio y las relaciones entre ellas. Un modelo ER es derivado de las especificaciones del negocio o narrativas y se construye durante la fase de análisis del ciclo del sistema de desarrollo. Los modelos ER separan la información requerida por el negocio de las actividades realizadas dentro del negocio. Aunque los negocios pueden cambiar de actividad, el tipo de información tiende a permanecer constante. Por lo tanto, las estructuras de los datos también tienden a permanecer constantes. Beneficios del Modelo ER Documenta los requerimientos de información de la empresa, en una forma precisa y clara. Provee una representación gráfica de fácil comprensión para el diseño de la base de datos. Define claramente el alcance de los requerimientos de información. Ofrece un ambiente de trabajo efectivo para la integración de múltiples aplicaciones. Componentes Básicos Entidad: Un elemento relevante acerca del cual se necesita conocer información. Por ejemplo, departamentos, empleados y pedidos. Atributo: Algo que describe o califica una entidad. Por ejemplo, para la entidad de los empleados, los atributos serían el nombre, número, oficio, fecha de contrato, número de departamento, etc. Cada atributo es necesario u opcional. Este estado se llama opcionalidad. Relación: Una asociación nombrada entre entidades que muestra la opcionalidad y el grado. Ejemplos son: empleados-departamentos, y pedidos-artículos.
- Entidades Para representar una entidad en un modelo, seguir las siguientes convenciones: Cajas con bordes redondeados de cualquier tamaño. Nombre en entidad único y singular. El nombre de la entidad debe ir en mayúsculas. Los sinónimos opcionales para el nombre pueden ir con mayúsculas y encerrados entre paréntesis “()”. Atributos Para representar un atributo en un modelo, utilizar las siguientes convenciones: Usar nombres singulares en minúscula. Marcar los atributos obligatorios o valores que deben conocerse, con un asterisco “*”. Marcar los atributos opcionales o valores que pueden conocerse, con una “o”.
- Relaciones Cada dirección de la relación contiene: Un nombre, por ejemplo, enseñado por o asignado a. Una opcionalidad, puede estar o debe estar. Un grado, puede ser uno y solo uno o uno o muchos. Nota: Un sinónimo del término grado es cardinalidad. Relaciones: Sintaxis Cada entidad origen {puede estar|debe estar} nombre de la relación {uno y sólo uno | uno o más}entidad destino. Nota: Por convención, leer en sentido horario. Identificadores Unicos Un identificador único (UID) es cualquier combinación de atributos, relaciones o ambos, que sirven para distinguir cada ocurrencia de una entidad. Cada una de esas ocurrencias debe ser identificable de manera única. Marcar cada atributo que es parte del UID con un signo numérico: # Marcar los identificadores únicos con un signo numérico entre paréntesis:(#) Nota: Para más información sobre el modelo ER, asistir al curso Desarrollo de Modelos de Datos y Diseño de Bases de Datos.
- Terminología utilizada en una Base de Datos Relacional Una base de datos relacional puede contener una o varias tablas. Una tabla es la estructura básica de almacenamiento de un RDBMS. Una tabla contiene todos los datos necesarios sobre algo en el mundo real: por ejemplo, empleados, facturas o clientes. La transparencia de arriba muestra los contenidos de la tabla EMP o relación. Los números indican lo siguiente: 1. Un registro simple o tupla representa todos los datos requeridos para un empleado en particular. Cada registro en una tabla debería identificarse con una clave primaria, lo que evita duplicar registros. El orden de los registros no tiene importancia; especificar el orden del registro cuando se recuperan los datos. 2. Una columna o atributo contiene el número del empleado, que es también la clave primaria. El número de empleado identifica un empleado único en la tabla EMP. Una clave primaria debe contener un valor. 3. Una columna que no es un valor clave. Una columna representa un tipo de dato en una tabla; en el ejemplo, el puesto de trabajo de todos los empleados. El orden de la columna no es importante cuando se almacenan los datos; se especifica cuando se recuperan los datos. 4. Una columna contiene el número de departamento, que también es una clave externa (foreign key). Una clave externa es una columna que define como se relacionan las tablas. Una clave externa se refiere a un clave primaria o a una clave única en otra tabla. En el ejemplo, DEPTNO únicamente identifica un departamento en la tabla DEPT. 5. Un campo se puede encontrar en la intersección de un registro y una columna. Solo puede haber un valor en él. 6. Un campo puede no tener ningún valor. Esto se llama valor nulo . En la tabla EMP, sólo los empleados que no tienen un puesto de vendedor, tienen un valor en el campo COMM (comisión). Nota: Los valores nulos se estudiarán con más profundidad en lecciones siguientes.
- Relaciones entre Tablas Múltiples Cada tabla contiene datos que describen exactamente una entidad. Por ejemplo, la tabla EMP contiene información sobre los empleados. Las categorías de los datos se relacionan en la parte de arriba de cada tabla, y los casos individuales se relacionan abajo. Utilizando un formato de tabla, podemos visualizar, entender y utilizar la información. Debido a que los datos sobre diferentes entidades se almacenan en tablas diferentes, podríamos necesitar combinar dos o más tablas para responder a una cuestión en particular. Por ejemplo, queremos saber la situación del departamento donde trabajan los empleados. En este escenario, necesitamos información de la tabla EMP (que contiene datos sobre los empleados) y de la tabla DEPT (que contiene información sobre los departamentos). Un RDBMS nos permite relacionar los datos de una tabla con los datos de otra utilizando las claves externas. Una clave externa es una columna o un conjunto de columnas que hacen referencia a una clave primaria en la misma tabla o en otra tabla. La habilidad para relacionar datos de una tabla con datos en otra tabla nos permite organizar la información en unidades de gestión separadas. Los datos del empleado se pueden guardar de una forma lógica distinta a los datos del departamento, almacenandolos en una tabla separada. Guías de Ayuda para Claves Externas y Claves Primarias No duplicar los valores que se permiten en una clave primaria. Las claves primarias normalmente no se pueden cambiar. Las claves externas se basan en los valores de los datos y son punteros puramente lógicos, no físicos. Un valor de una clave externa tiene que coincidir con un valor de una clave primaria ya existente o con un valor de una clave única, o de otro modo sería NULL.
- Propiedades de una Base de Datos Relacional En una base de datos relacional, no necesitamos especificar el acceso a las tablas ni saber cómo se ordenan los datos físicamente. Para acceder a la base de datos, ejecutamos una sentencia del lenguaje de consulta estructurado, (SQL), que es el lenguaje estándar del American National Standars Institute (ANSI) para operar sobre bases de datos relacionales. El lenguaje contiene un gran conjunto de operadores para particionar y combinar las relaciones. La base de datos puede modificarse utilizando sentencias SQL.
- Lenguaje de Consulta Estructurado SQL nos permite comunicarnos con el servidor y tiene las siguientes ventajas: Es eficiente. Fácil de aprender y usar. La completa funcionalidad. de SQL nos permite definir, recuperar y manipular los datos en las tablas.
- Acerca de Oracle8 Oracle proporciona un ORDBMS flexible llamado Oracle8. Sus características nos permiten almacenar y gestionar los datos con todas las ventajas de una estructura relacional más PL/SQL, un motor que nos proporciona la habilidad de almacenar y ejecutar unidades de programa. El Servidor ofrece a los usuarios las opciones de recuperar datos basándose en técnicas de optimización. Esto incluye las características de seguridad que controlan cómo se accede a una base de datos y cómo se utiliza. Otra característica es que tiene consistencia y protección de datos a través de mecanismo de bloqueo. Las aplicaciones Oracle pueden ejecutarse en el mismo ordenador que el servidor Oracle8. Alternativamente, podemos ejecutar aplicaciones en un sistema local para el usuario y ejecutar el servidor Oracle8 en otro sistema (arquitectura cliente-servidor). En este entorno cliente-servidor, pueden utilizarse muchos recursos informáticos. Por ejemplo, se puede ejecutar en un ordenador personal una aplicación de reservas aéreas mientras el servidor Oracle8 gestiona, de forma apropiada en un ordenador central, el acceso a los datos de vuelo. Para mas información ver: Manual de Conceptos del Servidor Oracle8, Versión 8.0.3
- Acerca de Oracle8 (continuación) El Servidor Oracle8 es la primera base de datos con posibilidad de almacenar objetos desarrollada por Oracle. Esto extiende las posibilidades del modelo de datos del Servidor Oracle7 para soportar un nuevo modelo de base de datos relacional orientado a objeto. El servidor Oracle 8, proporciona un nuevo motor que incorpora la programación orientada a objetos, tipos de datos complejos, objetos de negocio complejos y compatibilidad con el mundo relacional. El servidor Oracle8 amplia al servidor Oracle7, de varias formas: incluye varias características para la mejora del rendimiento y la funcionalidad de las aplicaciones del proceso de transacciones “online” (OLTP), como puede ser una mejor distribución de la estructura de los datos en tiempo de ejecución, “buffer caches” más grandes, y restricciones diferibles. Las aplicaciones “data warehouse” se beneficiarán de algunas mejoras como la ejecución paralela de operaciones de inserción, actualización y borrado, particionamiento y optimización de consultas paralelas. Al operar dentro de un entorno de trabajo NCA (Network Computing Architecture), el servidor Oracle8 soporta aplicaciones cliente-servidor y aplicaciones basadas en Web distribuidas y de múltiples niveles. El servidor Oracle puede escalar decenas de miles de usuarios actuales, soportando hasta 512 petabytes y puede manejar cualquier tipo de dato, incluyendo texto, datos espaciales, imagen, sonido, vídeo, así como datos estructurados tradicionales. Para más información, ver Manual de Conceptos de Oracle8, Versión 8.0.3
- Objetos A menudo un objeto es considerado como una representación de una cosa del mundo real. Se dice que los objetos hacen saber cómo funcionan las cosas. Un objeto “empleado” puede ser utilizado para calcular las deducciones en su nómina y un objeto “pedido” puede ser utilizado para enviarlo. Algunas definiciones de objetos son: “ Un objeto es un “paquete” de software que contiene una colección de procedimientos relacionados (métodos) y datos (variables).” David Taylor, Tecnología Orientada al Objeto : Una Guía para el Administrador (Reading, Mass.: Addison-Wesley, 1981) “ Un objeto es un concepto, abstracción o cosa con significado y límites precisos para el problema que tenemos cerca”. James Rumbaugh, et. al., Modelo y Diseño Orientados al Objeto (Englewood Cliffs, N.J.: Prentice-Hall, 1991)
- Modelos de Objeto La tecnología del Objeto fue diseñada para modelar problemas de negocio. El modelo se declara en términos de interacciones entre objetos. Cuando se trabaja con objetos, los desarrolladores piensan más en las necesidades de la aplicación y menos en la arquitectura de los sistemas de operación y las necesidades del entorno de desarrollo.
- Características de los Sistemas de Objeto Los sistemas orientados a objetos, se diferencian de los sistemas convencionales en que disponen de las siguientes “habilidades”: Representan información como cosas contenidas en sí mismos ( objetos). Clasifican objetos en tipos de objetos y los organizan en jerarquías de tipo árbol, donde un tipo de objeto puede ser un tipo especial de otro tipo de objeto (especificando objetos de tipo metadato). Los objetos pueden heredar las características de su tipo de objeto ( herencia). Ocultan los datos y los procesos relacionados con cada objeto dentro de ese objeto ( encapsulamiento) . Esto permite cambios en los componentes específicos sin afectar a otros componentes.. Interactuan con otros objetos ( interface o mensajes). Reconocen diferentes tipos de cosas y su comportamiento esperado sin tener que analizarlos. Utilizan la misma petición para llamar a diferentes implementaciones de la misma acción para dos objetos diferentes ( polimorfismo).
- La Solución Completa de Oracle El sistema de gestión de la base de datos relacional de Oracle para objetos, es el núcleo del producto Oracle. Este incluye Oracle8 Server y varias herramientas para ayudar a los usuarios en el mantenimiento, monitorización y uso actual de los datos. El diccionario de datos de Oracle es uno de los componentes más importantes del Servidor. Consiste en un conjunto de tablas y vistas que proporcionan una referencia de sólo lectura a la base de datos.. El ORDBMS gestiona las siguientes tareas: Gestión del almacenamiento y la definición de los datos. Control y restricción del acceso a los datos y de la concurrencia. Proporciona técnicas de backup y recovery). Interpretar sentencias SQL y PL/SQL. Nota: PL/SQL es un lenguaje procedural de Oracle que amplia el SQL añadiendo la lógica de la aplicación. Las sentencias SQL y PL/SQL son utilizadas por todos los programas y usuarios para acceder y manipular los datos almacenados en la base de datos de Oracle. Utilizando programas de aplicación, a menudo podemos acceder a la base de datos sin utilizar directamente PL/SQL o SQL, ya que podemos pulsar un botón o seleccionar una “check box”, por ejemplo; pero las aplicaciones utilizan SQL o PL/SQL implícitamente cuando ejecutan la petición. SQL*Plus es una herramienta de Oracle que reconoce y presenta sus sentencias PL/SQL y SQL al servidor para la ejecución y contiene su propio lenguaje de comandos. Oracle ofrece una amplia variedad de herramientas GUI (graphical user interface) para construir aplicaciones de negocio así como una gran cantidad de aplicaciones de software para muchas áreas de negocio e industrias. Nota: Veremos más acerca del diccionario de datos de Oracle en lecciones siguientes.
- Sentencias SQL Oracle SQL cumple con los estándares aceptados por la industria. Oracle Corporation asegura la conformidad con estándares evolucionados mediante la implicación activa del personal clave en comités de estándares SQL. Los comités aceptados por la industria son: ANSI (American Standards Institute) e ISO (International Standards Organization). Ambos han aceptado al SQL como el lenguaje standard para bases de datos relacionales.
- El Lenguaje Procedural/SQL (PL/SQL) es una extensión a SQL del lenguaje procedural de Oracle Corporation, el lenguaje estándar de acceso a los datos para bases de datos relacionales del objeto. PL/SQL ofrece características modernas de ingeniería de software como la encapsulación de datos, manejo de excepciones, ocultar información y orientación del objeto, así como programación “state-of-the-art” para el servidor Oracle8 y conjunto de herramientas (toolset). PL/SQL incorpora varias de las características avanzadas hechas en lenguajes de programación diseñados durante 1970 y 1980. Esto permite que la manipulación de datos y las sentencias de consulta SQL se incluyan en unidades de código con estructura de bloque y procedurales, haciendo de PL/SQL un poderoso lenguaje de proceso de transacciones. Con PL/SQL, podemos utilizar sentencias SQL para incorporar sentencias de control de flujo de los datos de Oracle8 y PL/SQL para procesar los datos.
- El Motor PL/SQL y el Servidor Oracle8 PL/SQL no es un producto Oracle en sí mismo; es una tecnología empleada por el servidor Oracle8 y por ciertas herramientas Oracle. Los bloques PL/SQL se envían y procesan mediante un motor PL/SQL, el cual puede residir dentro de la herramienta o dentro del servidor Oracle8. El motor utilizado, dependerá de desde dónde se llame a PL/SQL. Cuando trabajamos con bloques PL/SQL desde un programa Pro*, user-exit, SQL*Plus, o Server Manager, el motor PL/SQL en Oracle8 los procesa. Este divide al SQL dentro de bloques en sentencias separadas y los envía al “SQL Statement Excecutor”. Esto significa que se necesita una única transferencia para enviar el bloque de la aplicación al servidor Oracle8, mejorando por tanto el rendimiento, especialmente en una red cliente-servidor. Los subprogramas almacenados puede ser referenciados por cualquier aplicación conectada a la base de datos.
- Integración PL/SQL juega un papel importante para el servidor Oracle8 (a través de procedimientos almacenados, funciones almacenadas, triggers de la base de datos y paquetes) y para las herramientas de desarrollo de Oracle (a través de triggers, parte de Developer/2000). Las aplicaciones Developer/2000 hacen uso de librerías compartidas que contienen código (procedimientos y funciones) y que pueden accederse de forma local o remota. Developer/2000 consta de Oracle Forms, Oracle Reports y Oracle Graphics. Los tipos de datos SQL también pueden utilizarse en PL/SQL. Combinados con el acceso directo que proporciona SQL, estos tipos de dato compartidos integran PL/SQL con el diccionario de datos del servidor Oracle8. PL/SQL cubre el vacío entre el acceso conveniente a la tecnología de la base de dato y la necesidad de la capacidades de programación procedural. PL/SQL en las Herramientas Oracle Muchas herramientas de Oracle, incluyendo Developer/2000, tienen su propio motor PL/SQL, el cual es independiente del motor presente en el servidor Oracle8. El motor filtra las sentencias SQL y las envía de forma individual al “SQL Statement Executor” en el servidor Oracle8. Este procesa las sentencias procedurales restantes en el “Procedural Statemente Executor”, el cual está dentro del motor PL/SQL. El “Procedural Statement Executor” procesa los datos localizados en la aplicación (que ya está dentro del entorno del cliente más que en la base de datos). Esto reduce el trabajo de envío al servidor Oracle8 y el número de cursores de memoria requeridos.
- Mejora del Rendimiento PL/SQL puede mejorar el rendimiento de una aplicación. Los beneficios difieren dependiendo del entorno de ejecución. PL/SQL puede ser utilizado para agrupar sentencias SQL dentro de un bloque único y enviarlo al servidor en una sola llamada, reduciendo por consiguiente el tráfico en la red. Sin PL/SQL, las sentencias SQL se procesarían de una en una. Cada sentencia SQL resulta en otra llamada al servidor Oracle8 y en un mayor alcance del rendimiento. En un entorno de red, el alcance puede ser significativo. Como muestra la diapositiva, si su aplicación es intensiva SQL, podemos utilizar bloques PL/SQL y subprogramas para agrupar sentencias SQL antes de enviarlas al Oracle8 Server para su ejecución. PL/SQL también puede cooperar con las herramientas de desarrollo de aplicaciones del servidor Oracle8 como Forms y Reports (Developer/2000). Añadiendo el poder del proceso procedural a estas herramientas, PL/SQL aumenta el rendimiento. Nota: Los procedimientos y las funciones declaradas como parte de una aplicación Developer/2000 son distintas de aquellas almacenadas en la base de datos, aunque su estructura general es la misma. Los subprogramas almacenados son objetos de la base de datos y se almacenan en el Diccionario de Datos. Pueden ser accedidos por cualquier aplicación, incluyendo las aplicaciones Developer/2000.
- Podemos beneficiarnos de las ventajas que suponen las capacidades procedurales de PL/SQL, que no están disponibles en SQL. Estructura de Bloque PL/SQL Cada unidad de bloque PL/SQL comprende uno o más bloques. Estos bloques pueden estar separados completamente o anidados unos dentro de otros. Las unidades básicas (procedimientos, funciones y bloques anónimos) que construyen un programa PL/SQL, son bloques lógicos que pueden contener cualquier número de subloques anidados. Por lo tanto, un bloque puede representar una pequeña parte de otro bloque, que a veces puede ser parte del la unidad total del código. Construcciones de Programa PL/SQL El ejemplo de la parte superior, muestra las distintas de construcciones en PL/SQL que utilizan el bloque básico PL/SQL. Están disponibles basándose en el entorno donde se ejecutan. Modularizar el Desarrollo del Programa Agrupar de forma lógica las sentencias relacionadas entre los bloques. Anidar subloques dentro de bloques mayores para construir programas potentes. Resolver un problema complejo dentro de un conjunto de módulos lógicos manejables y bien definidos, e implementar los módulos con bloques. Colocar en librerías el código PL/SQL reutilizable para que sea compartido entre las aplicaciones Developer/2000, o almacenarlo en Oracle8 Server para hacerlo accesible para cualquier aplicación que pueda interactuar con una base de datos de Oracle.
- Sacar Ventaja de la Portabilidad Ya que PL/SQL es nativo para el servidor Oracle8; podemos mover programas a otro entorno (sistema operativo o plataforma) que soporte el Oracle8 y PL/SQL. En otras palabras, los programas PL/SQL pueden ejecutarse en cualquier lugar donde pueda ejecutarse Oracle8; no necesitamos adaptarlos a cada entorno nuevo. También podemos mover el código entre Oracle8 y nuestra aplicación. Podemos escribir paquetes portables y crear librerías que puedan ser reutilizadas en diferentes entornos. Declarar Identificadores Declarar variables, cursores, restricciones y excepciones utilizables en SQL y en sentencias procedurales. Declarar variables pertenecientes a tipos de datos objeto: escalar, referencias, compuestos y largos. Declarar variables de forma dinámica basándose en la estructura de datos de las tablas y columnas de la base de datos.
- Programar con Estructuras de Control de Lenguaje Estructural Ejecutar una secuencia de sentencias condicionalmente. Ejecutar una secuencia de sentencias iterativamente, en un bucle. Ejecutar individualmente los registros devueltos por una consulta de registros múltiples con cursores explícitos. Manejo de Errores Procesar los errores del servidor Oracle8 con rutinas de manejo de excepciones. Declarar condiciones de error definidas por el usuario y procesarlas con rutinas de manejo de excepciones.
- Tablas Utilizadas en el Curso Utilizaremos tres tablas principales: EMP, que da los detalles de los empleados. DEPT, que da los detalles de los departamentos. SALGRADE, que da los detalles de los salarios para varios grados. La estructura de los datos para todas las tablas se detallan en el Apéndice B.
- Resumen Los sistemas de gestión de bases de datos relacionales se componen de objetos o relaciones.. Se gestionan mediante operaciones y se rigen por restricciones de integridad de datos. Oracle Corporation produce productos y servicios para cubrir nuestras necesidades de sistema de gestión de la base de datos.. El principal producto es el servidor Oracle8 que nos permite almacenar y gestionar la información utilizando SQL y el motor PL/SQL para construcciones procedurales. SQL El servidor Oracle8 soporta SQL con el estándar ANSI y contiene extensiones SQL es el lenguaje utilizado para comunicarse con el servidor con el fin de acceder, manipular o controlar datos. PL/SQL El lenguaje PL/SQL extiende el lenguaje SQL ofreciendo construcciones procedurales en forma de bloques, combinadas con capacidades SQL no procedurales.
- Objetivo Con el fin de extraer datos de la base de datos se necesita usar el comando SELECT del Lenguaje de Consulta Estructurado (SQL). Puede ser necesario restringir las columnas que son recuperadas. Esta lección explica todos los comandos que se usarán para ejecutar esas acciones. Tal vez, quiera crear sentencias SELECT que puedan ser reutilizadas. En esta lección también veremos cómo salvar sus sentencias para su posterior uso.
- La Sentencia SELECT de SQL Una sentencia SELECT recupera información de la base de datos. Utilizando una sentencia SELECT, podemos hacer lo siguiente: Seleccion : Podemos utilizar la capacidad de selección de SQL para seleccionar los registros de la tabla que queramos, devueltos por una consulta. Podemos utilizar varios criterios para restringir de manera selectiva los registros que queremos ver. Proyección : Podemos utilizar la capacidad de proyección para seleccionar las columnas en la tabla que queramos, devueltas por nuestra consulta. Podemos seleccionar tantas tablas como necesitemos. Unión : Podemos utilizar la capacidad de unión de SQL para extraer los datos almacenados en diferentes tablas mediante la creación de enlaces entre una columna y las dos tablas compartidas. Veremos más acerca de las uniones (“joins”) en una lección posterior.
- Sentencia SELECT Básica En su forma más simple, una sentencia SELECT debe incluir: Una cláusula SELECT, la cual especifica las columnas a visualizar. Una cláusula FROM, la cual especifica la tabla que contiene las columnas relacionadas en la cláusula SELECT. En la sintaxis: SELECT es una lista de una o más columnas DISTINCT suprime duplicados * recupera todas las columnas column recupera la columna nombrada alias asigna a la columna recuperada un encabezamiento diferente FROM table especifica la tabla que contiene las columnas Nota: A lo largo de este curso utilizaremos las palabras: keyword (palabra clave), cláusula y sentencia. Una keyword hace referencia a un elemento SQL individual. Por ejemplo, SELECT y FROM son keywords. Una cláusula es una parte de una sentencia SQL.Por ejemplo, “SELECT empno, ename, …“ es una cláusula. Una sentencia es una combinación de dos o más cláusulas. Por ejemplo, “SELECT * FROM emp” es una sentencia SQL.
- Escritura de Sentencias SQL Siguiendo estas reglas, podremos construir sentencias válidas fáciles de leer y editar: • Las sentencias SQL no son sensibles a mayúsculas-minúsculas, a menos que se indique. Las sentencias SQL pueden constar de una o varias líneas.. Normalmente las cláusulas son ubicadas en diferentes líneas por legibilidad y facilidad de edición. • Las abreviaturas y separaración de las palabras clave (Keywords) no están permitidas. Típicamente, las palabras claves y los comandos se escriben en mayúsculas, mientras que el resto de las palabras, tales como nombres de tabla y columnas, se introducen en minúsculas. Un comando SQL se introduce en el prompt de SQL y las líneas subsiguientes están numeradas. Esto se llama búfer SQL.. Sólo puede haber una sentencia actual dentro del búfer. Ejecución de Sentencias SQL Colocar un punto y coma (;) al final de la última cláusula. Colocar un punto y coma o una barra (/) en la última línea del búfer. Colocar una barra (/) en el prompt de SQL. Comando Run de SQL*Plus desde el prompt de SQL.
- Selección de Todas las Columnas y Todos los Registros Podemos visualizar todas las columnas de los datos mediente SELECT con un asterisco (*). En el ejemplo de la diapositiva, la tabla del departamento contiene tres columnas: DEPTNO, DNAME y LOC. La tabla contiene cuatro registros, uno para cada departamento. También podemos visualizar todas las columnas de datos sacando un listado de todas las columnas después de SELECT. Por ejemplo, la siguiente sentencia SQL, como el ejemplo de la diapositiva, visualiza todas las columnas y todos los registros de la tabla DEPT. SQL> SELECT deptno, dname, loc 2 FROM dept;
- Selección de Columnas Específicas y Todos los Registros Podemos utilizar la sentencia SELECT para visualizar columnas específicas de la tabla, mediante la especificación de los nombres de columna, separados por comas. El ejemplo de la parte superior, visualiza todos los números de departamento y las localidades desde la tabla DEPT. En la cláusula SELECT, se especifican las columnas que queremos ver, en el orden que queramos. Por ejemplo, para visualizar una localidad antes del número de departamento, utilizamos la siguiente sentencia: SQL> SELECT loc, deptno 2 FROM dept; LOC DEPTNO ------------- --------- NEW YORK 10 DALLAS 20 CHICAGO 30 BOSTON 40
- Etiquetas de Columna por Defecto Las columnas de caracteres del encabezamiento, los datos, el encabezamiento de la columna fecha y los datos se justifican a la izquierda dentro del ancho de la columna. Los encabezamientos de los números y los datos se justifican a la derecha. Los encabezamientos de la columna de caracteres y datos pueden truncarse, pero los encabezamientos de números no. Las etiquetas de las columnas aparecen por defecto en mayúsculas. Podemos sobreescribir la etiqueta de la columna con un alias. Los alias de columna se verán más adelante en esta lección. SQL> SELECT ename, hiredate, sal 2 FROM emp; ENAME HIREDATE SAL ---------- --------- --------- KING 17-NOV-81 5000 BLAKE 01-MAY-81 2850 CLARK 09-JUN-81 2450 JONES 02-APR-81 2975 MARTIN 28-SEP-81 1250 ALLEN 20-FEB-81 1600 ... 14 rows selected.
- Expresiones Aritméticas Puede ser necesario modificar la forma en que se visualizan los datos, se realizan los cálculos o se miran los escenarios “ what-if ”. Esto es posible utilizando expresiones aritméticas. Una expresión aritmética puede contener nombres de columna, valores numéricos constantes y operadores aritméticos. Operadores Aritméticos La diapositiva muestra los operadores aritméticos disponibles en SQL. Podemos utilizar los operadores aritméticos en cualquier sentencia de SQL, excepto en la cláusula FROM.
- Uso de Operadores Aritméticos El ejemplo de la diapositiva usa el operador de suma para calcular un incremento de salario de 300$ para todos los empleados y visualiza una columna nueva, SAL+300. Observamos que el resultante de la columna SAL+300ó no es una columna nueva en la tabla EMP; solo es para su visualización. Por defecto, surge del cálculo el nombre de una columna nueva; en este caso, sal+300. Nota : SQL*Plus ignora los espacios en blanco antes y después de un operador aritmético.
- Precedencia de Operaciones Si una expresión aritmética contiene más de un operador, la multiplicación, y la división se evalúan primero. Si los operadores dentro de una expresión tienen la misma prioridad, entonces se evalúa la expresión de izquierda a derecha. Podemos utilizar paréntesis para obligar que la expresión entre parétesis se evalúe primero.
- Preferencia de Operadores El ejemplo de la diapositiva visualiza el nombre, el salario y la compensación anual de los empleados. Calcula la compensación anual multiplicando por 12 el salario mensual y sumando 100$ de bonificación. Nota: Usar paréntesis para modificar el orden estándar de precedencia o para mejorar la claridad. Por ejemplo, la expresión anterior puede ser escrita como (12*sal)+100 sin producir cambios en el resultado.
- Uso de Paréntesis Podemos sobreescribir las reglas de precedencia utilizando paréntesis para especifiar el orden en que se ejecutan los operadores. El ejemplo de la parte superior, visualiza el nombre, salario y compensación anual de los empleados. Calcula la compensación anual sumando el salario mensual y la bonificación mensual de 100$, multiplicado por 12. Debido a los paréntesis, la suma tienen prioridad sobre la multiplicación.
- Valores Nulos Si un registro carece de un valor para una columna en particular, se dice que es un valor null , o que contine un null. NULL es un valor inaccesible, sin valor, desconocido o inaplicable. Un valor nulo no representa ni un cero ni un espacio el blanco. El cero es un número y el espacio es un carácter. Las columnas de cualquier tipo de datos pueden contener valores nulos, a menos que hayan sido definidas como NOT NULL o como una clave primaria (PRIMARY KEY), cuando se creó la tabla. En la columna COMM en la tabla EMP, observamos que solo un SALESMAN puede ganar comisión. El resto de los empleados no están acreditados para ganar comisión. Un valor nulo representa el hecho anteriormente mencionado. El representante de ventas “Turner” no gana ninguna comisión. Observe que esta comisión es cero y no un valor nulo.
- Valores Nulos Si en una expresión, cualquier valor es nulo, el resultado también lo es. Por ejemplo, si intentamos ejecutar una división por cero, se obtendrá un error. Sin embargo, si se divide por un valor nulo, el resultado es nulo. El ejemplo de la parte superior, el empleado KING no es un SALESMAN y no gana ninguna comisión. Debido a que la columna COMM en la expresión arimética es null, el resultado es nulo. Para más información, ver: Referencia SQL del Servidor Oracle8, Versión 8.0, “Elementos de SQL.”
- Alias de Columna Al mostrar el resultado de una consulta, SQL*Plus normalmente usa los nombres de las columnas seleccionadas como el encabezamiento de las mismas. En muchos casos, dicha etiqueta puede ser difícil de entender o carecer de significado. Se puede cambiar un encabezamiento de columna usando alias.. El alias se especifica después de la columna en la lista SELECT con un espacio en blanco de separación. Por defecto, los encabezamientos alias aparecerán en mayúsculas y no pueden contener espacios en blanco, a menos que el alias esté encerrado entre comillas dobles (“ “).
- Alias de Columna (continuación) El primer ejemplo muestra el nombre y el salario mensual de todos los empleados. Podemos observar que la keyword opcional AS ha sido utilizada antes del nombre del alias de columna. El resultado de la consulta sería la misma si se utiliza AS o no. También observamos que la sentencia SQL tiene los alias de columna, nombre y salario en minúsculas, mientra que el resultado de la consulta se visualiza en los encabezamientos en mayúsculas. Como mencionamos en la diapositiva anterior, los encabezamientos de las columnas aparecen por defecto en mayúsculas. El segundo ejemplo visualiza el nombre y el salario anual de todos los empleados. Debido a que el Salario Anual contiene espacios, éste se ha incluido entre comillas dobles. Observamos que el encabezamiento de la columna es exacto al alias de la columna.
- Operador de Concatenación Con el operador de concatenación (||) se pueden vincular columnas con otras columnas, expresiones aritméticas o valores constantes con el fin de crear una expresión de caracteres. Las columnas de cualquiera de los lados del operador se combinan para formar una sola columna resultante.
- Operdador de Concatenación (continuación) En el ejemplo, EMPNO y ENAME son concatenados y se les ha dado el alias Employees. Podemos observar que el número y el nombre del empleado están combinados para hacer una única salida de columna. La palabra clave AS delante del alias hace a la cláusula SELECT más fácil de leer.
- Cadena de Caracteres Literales Un literal es cualquier carácter, expresión o número incluído en la lista SELECT excepto un nombre o un alias de columna. Por cada registro devuelto se imprime una cadena de caracteres. Las cadenas de caracteres con formato de texto libre se pueden incluir en el resultado de la consulta y se tratan como una columna de la lista SELECT. Los valores literales de tipo fecha y carácter deben estar encerrados dentro de comillas simples (´´); mientras que los literales de tipo número no.
- Cadenas de Caracteres Literales El ejemplo de la parte superior, visualiza los nombres completos de todos los empleados y sus títulos con el encabezamiento “Employees Details”. Observamos el espacio en blanco que existe en la sentencia SELECT. Los espacios mejoran la lectura de la salida.
- Registros Duplicados A menos que se especifique lo contrario, SQL*Plus visualiza los resultados de una consulta sin eliminar los registros duplicados. El ejemplo de la parte superior, muestra todos los números de departamento de la tabla EMP. Observamos que algunos números de departamento están repetidos.
- Registros Duplicados (continuación) Para eliminar los registros duplicados en el resultado, incluir la palabra clave DISTINCT en la cláusula SELECT inmediatamente después del comando. El ejemplo de la parte superior, la tabla EMP contiene actualmente cuarenta registros pero solo hay tres números de departamentos únicos en la tabla. Podemos especificar columnas múltiples despues del cualificador DISTINCT. DISTINCT afecta a todas las columnas seleccionadas, y el resultado representa una combinación distinta de las columnas. DEPTNO JOB ------ --------- 10 CLERK 10 MANAGER 10 PRESIDENT 20 ANALYST ... 9 rows selected. SQL> SELECT DISTINCT deptno, job 2 FROM emp;
- SQL y SQL*Plus SQL es un lenguaje de comandos para la comunicación con el servidor Oracle8 desde cualquier herramienta o aplicación. El SQL de Oracle contiene muchas extensiones. Cuando introducimos una sentencia SQL, esta se almacena en una parte de la memoria llamada búfer SQL y permanece allí hasta que introduzcamos una nueva sentencia. SQL*Plus es una herramienta de Oracle que reconoce y envía sentencias SQL al servidor Oracle para su ejecución y contiene su propio lenguaje de comandos. Características de SQL Puede utilizarse por diferentes perfiles de usuario, incluyendo aquéllos con poca o ninguna experiencia en programación. Es un lenguaje no procedural. Reduce la cantidad de tiempo requerido para crear y manipular los sistemas. Es parecido al Inglés. Características de SQL*Plus Acepta la entrada “ad hoc” de sentencias. Acepta la entrada SQL desde fichero. Proporciona un editor de línea para modificar sentencias SQL. Controla las definiciones del entorno. Formatea los resultados de las consultas en informes básicos. Accede a bases de datos locales y remotas.
- SQL y SQL*Plus (continuación) La siguiente tabla compara SQL y SQL*Plus.
- SQL*Plus SQL*Plus es un entorno en el cual podemos: Ejecutar sentencias SQL para recuperar, modificar, añadir y quitar datos de la base de datos. Formatear, realizar cálculos, almacenar e visualizar los resultados de una consulta en forma de informes. Crear ficheros script que almacenan sentencias SQL para ser reutilizadas. En SQL*Plus, los comandos pueden dividirse en las siguientes categorías principales:
- Conexión a SQL*Plus La forma de llamar a SQL*Plus, depende del tipo de sistema operativo o entorno Windows que se esté ejecutando. Para conectarse a través de un entorno Windows: 1. Seleccionar Inicio—>Programas—>Oracle for Windows NT—>SQL*Plus 8.0. 2. Rellenar el nombre del usuario, password y base de datos. Para conectarse a través de la Línea de Comandos: 1. Llamar a SQL*Plus. 2. Introducir la conexión a SQL*Plus, tal como se muestra en la diapositiva superior. En el comando: username es el nombre de usuario de la base de datos. password es la palabra de paso del usuario de la base de datos. @database es la cadena de conexión a la base de datos. Nota: Para asegurar la integridad de la palabra de paso, no la introduzca desde el prompt del S.O. sino sólo el nombre de usuario. Luego entroduzca la palabra de paso en el prompt “Password”. Una vez que nos hemos conectado con éxito a SQL*Plus, veremos el siguiente mensaje: SQL*Plus : Release 8.0.3.0.0 - Production on Mon Oct 06 16:03:43 1998 (c) Copyright 1997 Oracle Corporation. All rights reserved.
- Visualización de la Estructura de una Tabla En SQL*Plus, se puede mostrar la estructura de una tabla empleando el comando DESCRIBE. El resultado será un listado de nombres de columnas, tipos de datos y una especificación para saber si una columna debe contener datos. En la sintaxis:: tablename es el nombre de cualquier tabla, vista o sinónimo accesible por el usuario.
- Visualización de la Estructura de una Tabla (continuación) El ejemplo de la parte superior, muestra la información sobre la estructura de la tabla DEPT. En el resultado: Null? indica si lacolumna debe contener datos; NOT NULL indica que la columna debe contener datos obligatoriamente. Type muestra el tipo de dato para la columna. Los tipos de datos se describen en la siguiente tabla:
- Comandos de Edición de SQL*Plus Los comandos SQL*Plus se introducen de línea en línea y no se almacenan el el búfer SQL. Guía de Escritura: Si presionamos [Return] antes de completar un comando, SQL*Plus mostrará un número de línea. Al introducir uno de los caracteres de finalización (punto y coma o slash ) o presionando [Return] dos veces, se sale del búfer SQL. A continuación, verá el prompt de SQL.
- Comandos de Edición del SQL*Plus (continuación) Sólo podemos introducir un comando SQL*Plus desde el prompt de SQL. Los comandos SQL*Plus no se almacenan en el búfer. Para continuar con un comando SQL*Plus en la línea siguiente, se teclea un guión (-) al final del renglón .
- Comandos de Archivos SQL*Plus Las sentencias SQL se comunican con el Servidor Oracle. los comandos SQL*Plus controlan el entorno, formatean los resultados de las consultas y manejan archivos. Podemos utilizar los comandos identificados en la sisguiente tabla:
- La Sentencia SELECT En esta lección hemos aprendido el método para recuperar información de una tabla de la base de datos con la sentencia SELECT. SQL*Plus SQL*Plus es un entorno ejecutable a través del cual se envían comandos SQL al servidor de la base de datos; además dichos comandos se editan y guardan. Los comandos se ejecutan desde el prompt SQL o desde un archivo de comandos. SELECT [DISTINCT] {*, column [ alias ],...} FROM table;
- Objetivo Al recuperar datos de la base de datos, puede ser necesario restringir las filas de datos que se visualizan, o especificar el orden en el cual se muestran. Esta lección explica los comandos que se usarán para ejecutar dichas acciones.
- Restricción de Filas Usando una Selección El ejemplo de la parte superior, suponemos que queremos recuperar todos los empleados del departamento 10. El conjunto de filas que aparecen resaltadas con un valor de 10 en la columna DEPTNO, son las únicas que son devueltas. Este método de restricción, es el fundamento de la cláusula WHERE en SQL.
- Restricción de las Filas Seleccionadas Podemos restringir las filas recuperadas usando la cláusula WHERE. Una cláusula WHERE contiene una condición que se debe cumplir y se escribe a continuación de la cláusula FROM. En la sintaxis:: WHERE restringe la consulta a las filas que cumplen una condición. condición se compone de nombres de columnas, expresiones y operadores de comparación. La cláusula WHERE puede comparar los valores en las columnas, valores literales, expresiones aritméticas o funciones. La cláusula WHERE consta de tres elementos: Nombre de columna Operador de comparación Nombre de columna, constante o lista de valores
- Uso de la Cláusula WHERE En el ejemplo, la sentencia SELECT recupera el nombre, oficio y número de departamento de todos los empleados cuyo oficio es CLERK (empleado). Podemos observar que el oficio CLERK ha sido especificado en mayúsculas para asegurarse de que se corresponde con el valor de la columna oficio en la tabla EMP. Las cadenas de caracteres son, por tanto, “case sensitive”, es decir, sensibles a mayúsculas/minúsculas.
- Cadenas de Caracteres y Fechas Las cadenas de caracteres y las fechas se encierran entre comillas simples (´ ´) en la cláusula WHERE. Sin embargo los valores numéricos no se encierran entre comillas. Todas las búsquedas de caracteres son “case sensitive”. En el siguiente ejemplo, no se devuelve ninguna fila ya que la tabla EMP almacena todos los datos en mayúsculas. SQL> SELECT ename, empno, job, deptno 2 FROM emp 3 WHERE job=’clerk’; Oracle almacena las fechas en un formato numérico interno, representado por el siglo, año, mes, día, hora, minutos y segundos. La fecha por defecto se visualiza como DD-MON-YY. Notas: En la lección 3 veremos como cambiar el formato de la fecha. Los valores de los números no se incluyen entre comillas.
- Operadores de Comparación Los operadores de comparación se utilizan en las condiciones que comparan una expresión con otra. Se utilizan en la cláusula WHERE con el siguiente formato: Sintaxis … WHERE expr operator value Ejemplo: … WHERE hiredate=’01-JAN-95’ … WHERE sal>=1500 … WHERE ename=’SMITH’
- Uso de los Operadores de Comparación En el ejemplo, la sentencia SELECT recupera el nombre, salario y comisión de la tabla EMP, donde el salario del empleado es menor o igual al importe de su comisión. Observamos que no hay dado un valor explícito para la cláusula WHERE. Los dos valores que se comparan vienen dados por los valores de las columnas SAL y COMM en la tabla EMP.
- El Operador BETWEEN Podemos visualizar filas que se encuentran dentro de un rango de valores usando el operador BETWEEN. El rango que se especifica contiene un valor inferior y otro superior. El ejemplo de la parte superior, devuelve las filas de la tabla EMP, de cualquier empleado cuyo salario esté entre 1000$ y 1500$. Los valores especificados con el operador BETWEEN se incluyen en la operación. Se debe especificar primero el límite inferior del rango.
- El Operador IN Utilice el operador IN para evaluar los valores dentro de una lista especificada. El ejemplo de la parte superior, visualiza el número de empleado, nombre, salario y número del jefe del empleado de todos los empleados cuyo número de jefe sea 7902, 7566, 7788. El operador IN puede utilizarse con cualquier tipo de dato. El siguiente ejemplo devuelve una fila de la tabla EMP para cualquier empleado cuyo nombre este incluido en la lista de nombres en la cláusula WHERE. SQL> SELECT empno, ename, mgr, deptno 2 FROM emp 3 WHERE ename IN (’FORD’ , ’ALLEN’); Si se usan caracteres o fechas en la lista, se deben encerrar entre comillas simples (‘ ‘).
- El Operador LIKE No siempre se conoce el valor exacto a buscar. Se pueden seleccionar filas que coincidan con un patrón de caracteres usando el operador LIKE. La operación de coincidencia se conoce como una búsqueda que incluye comodines . Se pueden utilizar dos símbolos para construir la búsqueda. El ejemplo de la parte superior, devuelve el nombre de empleado desde la tabla EMP para cualquier empleado cuyo nombre empiece por “S”. Observamos que “S” está en mayúsculas. Los nombres que empiecen por “s” no serán recuperados. El operador LIKE puede utilizarse como una abreviatura para algunas comparaciones BETWEEN. El siguiente ejemplo visualiza los nombres y las jerarquías de todos los empleados que entraron en el año 81. SQL> SELECT ename, hiredate 2 FROM emp 3 WHERE hiredate LIKE ’%81’;
- Combinación de Comodines Los símbolos ”%” y “_” pueden ser utilizados en cualquier combinación con caracteres literales. El ejemplo de la diapositiva visualiza los nombres de todos los empleados cuyo nombre tiene una “A” como segundo carácter. La Opción ESCAPE Cuando se necesita una coincidencia exacta para los comodines “%” y “_”, se usa la opción ESCAPE. Dicha opción especifica cual es el carácter ESCAPE. Para visualizar los nombres de los empleados cuyo nombre contiene “A_B”, utilizar la siguiente sentencia SQL: La opción ESCAPE identifica la barra (\\) como el carácter ESCAPE. En la plantilla, el carácter ESCAPE precede al “_”. Esto hace que el servidor Oracle8 interprete el “_” literalmente. SQL> SELECT name 2 FROM emp 3 WHERE name LIKE ’%A\\_%B’ ESCAPE ’\\’;
- El Operador IS NULL El operador IS NULL comprueba los valores que son nulos. Un valor nulo significa que el valor es inaccesible, sin valor, desconocido o inaplicable. Por lo tanto, no se puede comprobar con el símbolo “=“ porque un valor nulo no puede ser igual o distinto a otro valor. El ejemplo de la parte superior, recupera el nombre y el jefe de todos los empleados que no tienen jefe. Por ejemplo, para visualizar el nombre, oficio y comisión de todos los empleados que no tienen derecho a comisión, utilizar la siguiente sentencia SQL: SQL> SELECT ename, job, comm 2 FROM emp 3 WHERE comm IS NULL; ENAME JOB COMM -------- ----------- ------ KING PRESIDENT BLAKE MANAGER CLARK MANAGER ...
- Operadores Lógicos Un operador lógico combina el resultado de dos condiciones para producir un único resultado o para invertir el resultado de una condición simple. Hay tres operadores lógicos disponibles en SQL. AND OR NOT Todos los ejemplos han especificado como mucho una sola condición en la cláusula WHERE. Podemos utilizar varias condiciones en una cláusula WHERE utilizando los operadores AND y OR.
- El Operador AND En el ejemplo, ambas condiciones deben ser ciertas para cualquier registro a seleccionar. Por lo tanto, será seleccionado cualquier empleado con oficio “CLERK”, o gane más de 1100$. Todas las búsquedas de caracteres son “case sensitive”. Las filas no se devuelven si CLERK no está en mayúsculas. Las cadenas de caracteres deben incluirse entre comillas. La Tabla AND La siguiente tabla muestra los resultados de combinar dos expresiones con AND:
- El Operador OR En el ejemplo, ambas condiciones pueden ser verdaderas para cualquier registro a seleccionar. Por lo tanto, será seleccionado cualquier empleado con oficio “CLERK”, o gane más de 1100$. La Tabla OR La siguiente tabla muestra los resultados de combinar dos expresiones con OR:
- El Operador NOT El ejemplo de la parte superior, muestra el nombre y oficio de todos los empleados cuyo título no es CLERK, MANAGER o ANALYST.. La Tabla NOT La siguiente tabla muestra el resultado de aplicar el operador NOT a una condición: Nota: El operador NOT también puede utilizarse con otros operadores SQL como BETWEEN, LIKE y NULL. ... WHERE sal NOT BETWEEN 1000 AND 1500 ... WHERE ename NOT LIKE ’%A%’ ... WHERE comm IS NOT NULL
- Ejemplo de Precedencia del Operador AND En el ejemplo, hay dos condiciones: La primera condición es que el oficio sea PRESIDENT y el salario mayor de 1500$. La segunda condición es que el oficio sea SALESMAN. Por lo tanto, la sentencia SELECT lee lo siguiente: “ Seleccionar los registros de los empleados cuyo oficio sea PRESIDENT y gane más de 1500$, o si su oficio es un SALESMAN”.
- Uso de Paréntesis En el ejemplo, hay dos condiciones: La primera condición es que el título sea PRESIDENT o SALESMAN. La segunda condición es que el salario sea mayor de 1500. Por lo tanto, la sentencia SELECT leerá los siguiente: “ Seleccionar los registros de los empleados cuyo oficio sea PRESIDENT o SALESMAN y ganen más de 1500$”.
- La Claúsula ORDER BY El orden de las filas recuperadas por el resultado de una consulta es indefinido. La cláusula ORDER BY se utiliza para ordenar las filas. Si se usa, será la última cláusula. Para ordenar, se puede especifiar un expresión o un alias. Sintaxis: donde: ORDER BY especifica el orden en que se muestran las filas recuperadas. ASC ordena las finas en forma ascendente. Este es el valor por defecto. DESC Ordena las filas en forma descendente. Si la cláusula ORDER BY no se utiliza, el orden es indefinido y Oracle8 no puede recuperar dos veces filas en el mismo orden para la misma consulta. Utilizar la cláusula ORDER BY para visualizar las filas en un orden especifico. SELECT expr FROM table [WHERE condition (s) ] [ORDER BY {column, expr} [ASC|DESC]];
- El Orden por Defecto de los Datos El orden por defecto es ascendente: Los valores numéricos se muestran con el valor más bajo en primer lugar; por ejemplo 1-999. Los valores de fecha se muestran con el valor más antiguo en primer lugar; por ejemplo 01-JAN-92 antes que 01-JAN-95. Los valores de caracteres se muestran en orden alfabéetico, por ejemplo primero la A y al final la Z. Los valores nulos se muestran los últimos en las secuencias ascendentes y los primeros en las secuencias descendentes. Inversión del Orden por Defecto Para invertir el orden en el cual se visualizan las filas, se especifca la keyword DESC después del nombre de la columna en la cláusula ORDER BY. El ejemplo de la parte superior, ordena el resultado por el ultimo empleado contratado.
- Ordenar con Alias de Columnas Podemos utilizar un alias de columna en la cláusula ORDER BY. El ejemplo de la parte superior, ordena los datos por el salario anual.
- Ordenamiento por Varias Columnas Podemos ordenar el resultado de una consulta por más de una columna. El límite es la cantidad de columnas de la tabla. En la cláusula ORDER BY se especifican los nombres de las columnas separados por comas. Si se desea invertir el orden de una columna, se especifica DESC después de su nombre o posición. Se puede ordenar por columnas que se se encuentran en la cláusula SELECT.. Ejemplo Muestra el nombre y salario de todos los empleados. Ordena el resultado por número de departamento y después en orden descendiente por salario. SQL> SELECT ename, salary 2 FROM emp 3 ORDER BY deptno, sal DESC;
- Resumen En esta lección, hemos aprendido puntos importantes acerca de la restricción y la ordenación de las filas devueltas por la sentencia SELECT. También hemos aprendido cómo implementar varios operadores.
- Objetivo Las funciones se utilizan para dar mayor potencia a las consultas y se usan para manipular datos. Esta es la primera lección que analiza las funciones. Nos centraremos en las funciones para cadenas de caracteres, númericas y de fechas, así como en aquellas funciones que convierten los datos de un tipo a otro, por ejemplo, de caracteres a números.
- Funciones SQL Las Funciones consituyen una característica muy poderosa de SQL y se pueden utilizar para: Realizar cálculos sobre datos. Modificar items de datos individuales. Manipular la salida de grupos de filas. Modificar formatos de los datos para su presentación. Convertir los tipos de datos de las columnas. Las funciones SQL aceptan argumento(s) y devuelven valor (o valores). Nota: La mayoría de las funciones descritas en esta lección son específicas para la versión de Oracle de SQL. En este curso veremos más sobre esta versión, Oracle SQL Specifics .
- Funciones SQL Existen dos tipos distintos de funciones: Funciones a nivel de fila. Funciones a nivel de grupos de filas. Funciones a Nivel de Filas Estas funciones operan solo sobre filas y devuelven un único resultado por cada una ellas. Hay diferentes tipos. En esta lección veremos las siguientes: Carácter Número Fecha Conversión Funciones a Nivel de Grupos de Filas Estas funciones manipulan grupos de filas y devuelven un resultado por cada uno de ellos. Para más información, ver: Referencia SQL de Oracle 8 Server, Versión 8 para la lista completa de todas las funciones y sintaxis disponibles.
- Funciones a Nivel de Fila Las funciones a nivel de fila se usan para manipular items de datos. Aceptan uno o más argumentos y devuelven un valor por cada fila que recupera la consulta. Un argumento puede ser: Una constante suministrada por el usuario Un valor de variable Un nombre de columna Una expresión Características de las Funciones a Nivel de Fila Pueden actuar sobre cada fila recuperada por la consulta. Devuelve un resultado por cada fila. Puede devolver un dato de diferente tipo que el referenciado. Pueden aceptar uno o más argumentos del usuario. Se pueden usar en las claúsulas SELECT, WHERE y ORDER BY. Se pueden anidar. En la sintaxis: function_name es el nombre de la función columna es una columna de la base de datos expresión es una cadena de caracteres o una expresión calculada arg1, arg2 es cualquier argumento a ser usado por la función
- Funciones a Nivel de Fila En esta lección veremos las siguientes funciones a nivel de fila: Funciones de caracteres. Aceptan caracteres como datos de entrada y puede devolver caracteres o números. Funciones de números: Aceptan números como datos de entrada y devuelven valores numéricos. Funciones de fecha. Operan con valores de dato de tipo fecha. Todas las funciones devuelve un valor de tipo fecha excepto la función MONTHS_BETWEEN, que devuelve un número. Funciones de conversión. Convierten un valor de un tipo de dato a otro. Funciones generales: Función NVL Función DECODE
- Funciones de Caracteres Las funciones de caracteres a nivel de fila aceptan caracteres como datos de entrada y pueden devolver caracteres o números. Pueden dividirse en dos: Funciones de conversión “case” Funciones de manipulación de caracteres Nota: Esta lista es un subconjunto de las funciones de carácter disponibles. Para más información, ver Referencia al SQL de Oracle8 Server, Versión 8 , “Funciones de Caracteres.”
- Funciones de Conversión “Case” LOWER, UPPER, y INITCAP son tres tipos de funciones de conversión case: LOWER Convierte en minúsuculas las cadenas de caracteres en mayúsculas o mixtos. UPPER Convierte en mayúsculas las cadenas de caracteres en minúsuculas o mixtos. INITCAP Convierte la primera letra de cada palabla en mayúsulas y el resto de las letras en minúscula. SQL> SELECT ’The job title for ’||INITCAP(ename)||’ is ’ 2 ||LOWER(job) AS &quot;EMPLOYEE DETAILS&quot; 3 FROM emp; EMPLOYEE DETAILS ----------------------------------------- The job title for King is president The job title for Blake is manager The job title for Clark is manager ... 14 rows selected.
- Funciones de Conversión de Mayúsculas/Minúsculas El ejemplo de la parte superior, muestra el número de empleado, nombre y numero de departamento del empleado BLAKE. La cláusula WHERE de la primera sentencia SQL, especifica el nombre del empleado como ´blake´. Ya que todos los datos en la tabla EMP se almacenan en mayúsculas, el nombre ´blake´ con encontrará una correspondencia en la lata EMP y no se realizará la selección de las filas. La cláusula WHERE de la segunda sentencia SQL especifica que el nombre del empleado en la tabla EMP se convertirá en minúsuculas y se comparará con ´blake´. Ya que ambos nombres están en minúsculas, se encuentra una correspondencia y se selecciona una fila. La cláusula WHERE se puede reescribir de la siguiente forma. para producir el mismo resultado: El nombre en la salida aparece como si estuviera almacenado en la base de datos. Para visualizar el nombre con la primera letra en mayúsculas, utilizar la función INITCAP en la sentencia SELECT. … WHERE ename = ’BLAKE’ SQL> SELECT empno, INITCAP(ename), deptno 2 FROM emp 3 WHERE LOWER(ename) = ’ blake ’ ;
- Funciones de Manipulación de Caracteres CONCAT, SUBSTR, LENGTH, INSTR, y LPAD son las cinco funciones de manipulación de caracteres que se ven en esta lección. CONCAT Combina valores. Estamos limitados al uso de dos parámetros con CONCAT. SUBSTR Extrae una cadena de una medida determinada. LENGTH Muestra la longitud de una cadena como un valor numérico. INSTR Encuentra la posición numérica de un carácter nombrado. LPAD Justifica a la derecha el valor del carácter. Nota: RPAD justifica el valor del carácter a la izquierda.
- Funciones de Manipulación de Caracteres El ejemplo de la parte superior, visualiza el nombre del empleado junto con el oficio, la longitud del nombre del empleado y la posición numérica de la letra A en el nombre del empleado, para todos los empleados que están en el departamento de Ventas. Ejemplo Modificar la sentencia SQL anterior, para visualizar los datos de aquellos empleados cuyos nombre termine con una N. SQL> SELECT ename, CONCAT(ename, job), LENGTH(ename), INSTR(ename, ’ A ’ ) 2 FROM emp 3 WHERE SUBSTR(ename, -1, 1) = ’ N ’ ; ENAME CONCAT(ENAME,JOB) LENGTH(ENAME) INSTR(ENAME,’A’) -------- ------------------- ------------- ---------------- MARTIN MARTINSALESMAN 6 2 ALLEN ALLENSALESMAN 5 1
- Funciones Numéricas Las funciones numéricas aceptan números como datos de entrada y devuelven valores numéricos. Esta sección describe algunas de ellas: Nota: Esta lista es un subconjunto de las funciones numéricas disponibles. Para más información, ver: Referencia al SQL de Oracle8 Server,Versión 8, “Funciones Numéricas.”
- Función ROUND La función ROUND redondea la columna, expresión o valor a n lugares decimales. Si el segundo argumento es 0 o falta, el valor se redondea a cero lugares decimales. Si el segundo argumento es 2, el valor se redondea a dos lugares decimales o al centenar. Si el segundo argumento es -2, el valor se redondea a dos lugares decimales a la izquierda o al centenar. La función ROUND también puede utilizarse con funciones de fecha. Veremos ejemplos más tarde. SYS.DUAL es una tabla virtual de la base de datos que mantiene información necesaria sobre el sistema. Se verá más adelante en esta lección.
- Función TRUNC La función TRUNC trunca la columna, expresió o valor en n lugares decimales. La función TRUNC funciona con argumentos similares de la función ROUND. Si el segundo argumento ex 0 no falta, el valor se trunca en cero lugares decimales. Si el segundo argumento es 2, el valor se trunca en dos lugares decimales o centenar. Si el segundo argumento es -2, el valor se trunca en dos lugares decimales a la izquierda, o centenar. Como la función ROUND, la función TRUNC también puede utilizarse con funciones de fecha.
- Función MOD La función MOD encuentra el resto del valor1 dividido por el valor2. El ejemplo de la parte superior, calcula el remanente del ratio del salario a la comisión para todos los empleados cuyo oficio es salesman (vendedor).
- Formato de Fechas en Oracle Oracle almacena las fechas en un formato numérico interno, representando el siglo, año, día, horas, minutos y segundos. El formato de visualización y entrada de cualquier fecha por defecto es DD-MON-YY. Las fechas válidas para Oracle se encuentran entre el 1º de Enero de 4712 A.C y el 31 de Diciembre de 9999 D.C. SYSDATE SYSDATE es ua función de fecha que devuelve la fecha y la hora actual. Podemos utilizar SYSDATE como lo utilizaríamos cualquier otro nombre de columna. Por ejemplo, podemos visualizar la fecha actual seleccionando SYSDATE desde una tabla. Es usual seleccionar SYSDATE desde una tabla virtual de la base de datos llamada DUAL. DUAL La tabla DUAL es propiedad del usuario SYS y puede ser accedida por todos los usuarios. Contiene una columna, DUMMY y una fila con el valor X. La tabla DUAL es útil cuando se quiere devolver un valor una sola vez, por ejemplo, el valor de una constante, pseudo-columna o expresión que no se deriva a partir de una tabla con datos de usuarios. Ejemplo Mostrar la fecha actual usando la tabla DUAL. SQL> SELECT SYSDATE 2 FROM SYS.DUAL;
- Operadores Aritméticos de Fechas Ya que la base de datos almacena las fechas como números, se pueden ejecutar cálculos usando operadores aritméticos tales como suma y resta. Se pueden sumar o restar constantes numéricas así como fechas. Se pueden ejecutar las siguientes operaciones:
- Operadores Aritméticos de Fechas El ejemplo de la diapositiva visualiza el nombre y el número de semanas utilizadas para todos los empleados en el departamento 10. Resta la tabla actua (SYSDATE) de la fecha en la que el empleado fue contratado y divide el resulta entre 7 para calcular el número de semanas que ha estado empleado un trabajador. Nota: SYSDATE es una función SQL que devuelve la fecha y la hora actual. Los resultados pueden ser diferentes a los del ejemplo.
- Funciones de Fechas Las funciones de fecha operan sobre fechas Oracle. Todas ellas devuelven como resultado un valor de tipo FECHA, excepto MONTHS_BEWEEN que devuelve un valor numérico. MONTHS_BETWEEN( fecha1,fecha2 ) Devuelve la cantidad de días entre fecha1 y fecha2 . El resultado puede ser positivo o negativo. Si fecha1 es mayor, el resultado es positivo; si no, es negativo. La parte no entera de un resultado representa la porción de un més. ADD_MONTHS( fecha, n ): Agrega n meses a fecha. n debe ser un número entero y puede ser negativo. NEXT_DAY( fecha, ‘caracter’ ): Devuelve la fecha del día especificado (´ carácter ´) siguiente a fecha. carácter puede ser un número representando un día o una cadena de caracteres. LAST_DAY( fecha ): Devuelve la fecha del último día del mes que contiene fecha. ROUND( fecha [,‘ fmt ’]): Cuando no se especifica ningún formato fmt, devuelve la fecha del primer día del mes contenido en fecha. Si fmt=YEAR, encuentra el primer día del año. Esto es útil cuando se comparan fechas que pueden tener diferentes horarios. TRUNC( fecha [, ‘ fmt ’]): Devuelve la fecha con la porción del día truncado en la unidad especificada por el modelo de formato fmt. Si se omite el formato fmt, la fecha se trunca en el día más próximo. Esta lista es un subconjunto de las funciones de fechas disponibles. Los modelos de formatos se verán más adelante en esta lección. Ejemplos de modelos de formato son mes y año.
- Funciones de Fechas (continuación) Para todos los trabajadores empleados por menos de 200 meses, visualizar el número de empleado, fecha de contratación, número de meses empleados, fecha de revisión de seis meses, primer viernes después de la fecha de contratación y el último dia del més en que se contrataron. SQL> SELECT empno, hiredate, 2 MONTHS_BETWEEN(SYSDATE, hiredate) TENURE, 3 ADD_MONTHS(hiredate, 6) REVIEW, 4 NEXT_DAY(hiredate, ’ FRIDAY ’ ), LAST_DAY(hiredate) 5 FROM emp 6 WHERE MONTHS_BETWEEN (SYSDATE, hiredate)<200; EMPNO HIREDATE TENURE REVIEW NEXT_DAY( LAST_DAY( --------- --------- --------- --------- --------- --------- 7839 17-NOV-81 192.24794 17-MAY-82 20-NOV-81 30-NOV-81 7698 01-MAY-81 198.76407 01-NOV-81 08-MAY-81 31-MAY-81 ... 11 rows selected.
- Funciones de Fechas (continuación) Las funciones ROUND y TRUNC pueden utilizarse para valores numéricos y de fechas. Cuando utilizamos estas funciones con fechas, se redondean o se truncan en el modelo de formato especificado. Por lo tanto, se pueden redondear fechas al mes o año más cercano. Ejemplo: Comparar las fechas de contratación de todos los empleados que empezaron en 1987.. Visualizar el número del empleado, fecha de contratación y el mes que empezaron, utilizando las funciones ROUND y TRUNC. SQL> SELECT empno, hiredate, 2 ROUND(hiredate, ’ MONTH ’ ), TRUNC(hiredate, ’ MONTH ’ ) 3 FROM emp 4 WHERE hiredate like ’ %87 ’ ; EMPNO HIREDATE ROUND(HIR TRUNC(HIR --------- --------- --------- --------- 7788 19-APR-87 01-MAY-87 01-APR-87 7876 23-MAY-87 01-JUN-87 01-MAY-87
- Funciones de Conversión Además de los tipos de dato de Oracle, las columnas de las tablas en una base de datos Oracle8 pueden definirse utilizando tipos de datos ANSI, DB2, y SQL/DS. Sin embargo, Oracle8 convierte internamente estos tipos de datos en tipos de datos propios. En algunos casos, Oracle8 permite datos de un tipo donde se esperaba encontrar datos de un tipo diferente. Esto se permite cuando Oracle8 puede convertir automáticamente los datos al tipo de dato esperado. El servidor Oracle8 puede hacer esta conversión implícitamente o el usuario puede hacerla explícitamente. Las conversiones implícitas funcionan según las reglas explicadas en las dos diapositivas siguientes. Las conversiones explícitas se hacen utilizando funciones de converisión. Las funciones de conversión convierte un valor de un tipo de dato a otro. Generalmente, el formato de los nombres de función siguen la convención ” tipo de dato TO tipo de dato” . El primer tipo de dato es el de entrada, el último, es el de salida. Nota: Aunque la conversión implícita está disponible, se recomienda utilizar la conversión explícita para asegurarse de la fiabilidad de las sentencias SQL.
- Converión Implícita Por asignaciones, Oracle8 puede convertir automáticamente: VARCHAR2 o CHAR a NUMBER VARCHAR2 o CHAR a DATE NUMBER ao VARCHAR2 DATE a VARCHAR2 La asignación se realiza si Oracle8 puede convertir el tipo de dato del valor utilizado en la asignación, en el tipo de dato que era el objetivo de la asignación.
- Conversión Implícita Por evaluación de la expresión, Oracle8 Server puede convertir automáticamente: VARCHAR2 o CHAR a NUMBER VARCHAR2 o CHAR a DATE En general, Oracle8 utiliza la regla para la expresión cuando se necesita una conversión del tipo de dato en lugares no cubiertos por una regla de asignación de conversiones. Nota: Las conversiones CHAR a NUMBER se realizan solo si la cadena de caracteres representan un valor válido. Las conversiones CHAR a DATE se realizan solo si la cadena de caracteres tiene por defecto el formato DD-MON-YY.
- Conversión Explícita del Tipo de Dato SQL proporciona tres funciones para convertir un valor de un tipo de dato en otro. Nota: Esta lista es un subconjunto de las funciones de conversión disponibles. Para más información, ver: Referencial al SQL de Oracle8 Server, Versión 8 , “Funciones de Conversión.”
- Visualización de una Fecha en un Formato Específico Anteriormente, todas las fechas Oracle se mostraban en el formato DD-MON-YY. La función TO_CHAR permite convertir el formato de una fecha por defecto a otro. Guía de Escritura El formato se debe encerrar entre comillas simples y es “case-sensitive”. El formato puede incluir cualquier elemento de formato de fecha válido. Separar la fecha del formato con una coma. Los nombres de días y meses se rellenan automáticamente con espacios en blanco. Usar el elemento fm (fill mode) para borrar espacios en blanco de relleno o suprimir ceros a la izquierda. Se puede cambiar el ancho de visualización del campo de carácter resultante con el comando COLUMN de SQL*Plus. El ancho de la columna resultante es de 80 caracteres por defecto. SQL> SELECT empno, TO_CHAR(hiredate, ’MM/YY’) Month_Hired 2 FROM emp 3 WHERE ename = ’BLAKE’;
- Muestra de los Elementos de Formato de Fechas Válidos
- Formatos de Tiempo Se usan los formatos listados en las siguientes tablas para visualizar información del tiempo y literales, así como cambiar los numerales por números deletreados. Otros Formatos Especificación de Sufijos para influenciar la visualización de los Números.
- El Elemento del Formato de Fecha RR El formato de fecha RR es similar al elemento YY, pero permite especificar diferentes siglos. Se puede usar RR en lugar de YY, de esta manera el siglo del valor devuelto varía de acuerdo a los dos dígitos del año especificado y a los dos últimos dígitos del año actual. La tabla de la diapositiva resume el comportamiento de RR.
- Función TO_CHAR con Fechas El ejemplo de la parte superior, visualiza el nombre y las fechas de contratación de todos los empleados. La fecha de contratación aparece como 17 November 1981. Ejemplo Modificar el ejemplo anterior, para visualizar las fechas en un formato que aparezca como Seventh of February 1981 08:00:00 AM. SQL> SELECT ename, 2 TO_CHAR(hiredate, ’fmDdspth &quot;of&quot; Month YYYY fmHH:MI:SSAM’) 3 HIREDATE 4 FROM emp; Observamos que el mes sigue el modelo de formato especificado (INITCAP). ENAME HIREDATE ---------- ------------------------------------------------ KING Seventeenth of November 1981 12:00:00 AM BLAKE First of May 1981 12:00:00 AM ... 14 rows selected.
- FUNCION TO_CHAR Utilizada con Números Si se convierte un tipo de datos caracter que transforma los dígitos en números, se puede usar la lista de elementos de la tabla siguiente:
- Guía de Escritura El Servidor Oracle8 muestra una cadena de símbolos cardinales (#) cuando un número excede la cantidad de dígitos provistos por el formato. El Servidor Oracle8 redondea el valor almacenado a un número con la cantidad de lugares decimales provistos por el formato.
- Funciones TO_NUMBER y TO_DATE Puede ser necesario convertir una cadena de caracteres a un formato de número o de fecha. Con el fin de llevar a cabo esta tarea, se usan las funciones TO_NUMBER y TO_DATE. El formato elegido se basará en los elementos mostrados anteriormente. Ejemplo: Mostrar los nombres y las fechas de contratación de todos los empleados que se incorporaron el 22 de Febrero de 1981. SQL> SELECT ename, hiredate 2 FROM emp 3 WHERE hiredate = TO_DATE(’February 22, 1981’, ’Month dd, YYYY’); ENAME HIREDATE ---------- -------- WARD 22-FEB-81
- La Función NVL Para convertir un valor nulo en un valor actual, utilizamos la función NVL. Sintaxis NVL ( expr1 , expr2 ) donde: expr1 es el valor fuente o empresión que podría contener el valor nulo. expr2 es el valor para convertir el valor nulo. Podemos utilizar la función NVL para convertir cualquier tipo de objeto, pero el valor devuelto siempre es el mismo que para el tipo de dato expr1 . Conversiones NVL para Varios Tipos de Datos
- Función NVL Para calcular la compensación anual de todos los empleados, necesitamos multiplicar el salario mensual por 12 y añadirle la comisión. SQL> SELECT ename, sal, comm, (sal*12)+comm 2 FROM emp; ENAME JOB (SAL*12)+COMM ---------- --------- ------------- KING PRESIDENT BLAKE MANAGER CLARK MANAGER JONES MANAGER MARTIN SALESMAN 16400 ... 14 rows selected. Podemos observar que la compensación anual se calcula solo para aquellos empleados que ganan comisión. Si cualquier valor de columna en una expresión es nulo, el resultado es nulo. Para calcular los valores para todos los empleados, debemos convertir el valor nulo en un número antes de aplicar el operador aritmético. En el ejemplo de la diapositiva, la función NVL se utiliza para convertir valores nulos a cero.
- La función DECODE La función DECODE descifra una expresión de forma similar que la lógica IF-THEN-ELSE, utilizada en varios lenguajes. La función DECODE descifra una expresión después de compararla con cada valor de búsqueda. Si la expresión es la misma que la búsqueda , se devuelve el resultado. Si se omite el valor por defecto, se devolverá un valor nulo donde una búsqueda no coincida con ninguno de los valores resultantes.
- Uso de la Función DECODE El ejemplo de la parte superior, el valor de JOB está descifrado. Si JOB es ANALYST, el salario se incrementa en un 10%; si JOB es CLERK, el salario se incremento en un 15%; si JOB es MANAGER, el salario se incrementa en un 20%. Para los otros títulos, no hay incremento del salario. La misma sentencia puede escribirse como una sentencia IF-THEN-ELSE. IF job = ’ANALYST’ THEN sal = sal*1.1 IF job = ’CLERK’ THEN sal = sal*1.15 IF job = ’MANAGER’ THEN sal = sal*1.20 ELSE sal = sal
- Anudamiento de Funciones Las funciones a nivel de fila puede ser anidadas hasta cualquier profundidad. Estas se evalúan desde el nivel más interno hasta el más externo. Los ejemplos que siguen muestran la flexibilidad de estas funciones.
- Anudamiento de Funciones El ejemplo de arriba muestra la cabeza de una compañía, que no tiene director. La evaluación de la sentencia SQL conlleva dos pasos: 1. Evaluar la función más interna para convertir el valor de un número en una cadena de caracteres. Result1 = TO_CHAR(mgr) 2. Evaluar la función más externa para reemplazar el valor nulo por una cadena de texto. NVL(Result1, ‘No Manager’) La expresión entera se convierte en el encabezamiento de la columna ya que no se ha dado un alias de columna. Ejemplo: Visualizar la fecha del próximo Viernes que se lleva seis meses con la fecha de contratación. La fecha resultante debería tener el formato Friday, March 12th, 1982. Ordenar los resultados por fecha de contratación. SQL> SELECT TO_CHAR(NEXT_DAY(ADD_MONTHS 2 (hiredate, 6), ’FRIDAY’), 3 ’fmDay, Month ddth, YYYY’) 4 &quot;Next 6 Month Review&quot; 5 FROM emp 6 ORDER BY hiredate;
- Funciones a Nivel de Fila Las funciones a nivel de fila puede anidarse hasta cualquier nivel. Estas funciones pueden manipular: Caracteres LOWER, UPPER, INITCAP, CONCAT, SUBSTR, INSTR, LENGTH Números ROUND, TRUNC, MOD Fechas MONTHS_BETWEEN, ADD_MONTHS, NEXT_DAY, LAST_DAY, ROUND, TRUNC Las fechas también pueden usar operadores aritméticos. Las funciones de conversión puede transformar caracteres, fechas y números. TO_CHAR, TO_DATE, TO_NUMBER SYSDATE y DUAL SYSDATE es una función de fecha que devuelve la fecha y hora actual. Es usual seleccionar SYSDATE desde una tabla virtual llamada DUAL.
- Visión General de la Práctica En esta práctica se realizarán diversos ejemplos, que utilizan diferentes funciones disponibles para caracteres, números y fechas. Recuerde que para las funciones anidadas, los resultados se evalúan desde la función más interna a la más externa.
- Objetivo Esta lección explica cómo obtener datos a partir de varias tablas a través de diferentes métodos disponibles.
- Datos de Varias Tablas En ocasiones necesitamos utilizar datos de más de una tabla al mismo tiempo. El ejemplo de la parte superior, muestra un informe con datos a partir de dos tablas distintas. EMPNO existe en la tabla EMP. DEPTNO existe en las tablas EMP y DEPT. LOC existe en la tabla DEPT. Para producir el informe, necesitamos unir las tablas EMP y DEPT y acceder a los datos a partir de ambas.
- Definición de Joins Cuando se necesitan datos de más de una tabla en la base de datos, se utiliza una condición join. Las filas en una tabla puede unirse a filas en otra tabla según los valores comunes existentes en las columnas correspondiente, ésto es, columnas de clave externa y de clave primaria. Para visualizar los datos desde dos o más tablas relacionadas, escribr una condición de join simple en la claúsula WHERE. En la sintaxis:: tabla.columna denota la tabla y columna a partir de la cual se recuperan los datos. tabla1.columna1 = es la condición que combina (o relaciona) las tablas. tabla2.columna2 Guía de Escritura Cuando se escribe una sentencia SELECT que combina varias tablas, preceder el nombre de la columna con el nombre de la tabla por claridad y para mejorar el acceso a la base de datos. Si el mismo nombre de columna aparece en más de una tabla, entonces se debe prefijar con el nombre de la tabla correspondiente. Para combinar tablas, se necesita como mínimo una cantidad de condiciones de join equivalentes a la cantidad de tablas menos uno. Por lo tanto, para combinar cuatro tablas, se requerirían un mínimo de tres condiciones. Esta regla no se puede aplicar si la tabla tiene una clave primaria concatenada, en cuyo caso se requieren más de una columna para identificar unívocamente a cada fila. Para más información, ver Manual de Referencia del Lenguaje SQL de Oracle8 Server, “SELECT.”
- Producto Cartesiano Cuando una condición de join no es válida o se omite completamente, el resultado es un Producto Cartesiano, en el cual, se muestran las combinaciones de todas las filas. Se combinan todas las filas de la primera tabla con todas las filas de las segunda. Un Producto Carteriano tiende a generar una gran cantidad de filas y este tipo de resultados es raramente útil. Se debería incluir siempre una condición de join válida en la claúsula WHERE, a menos que exista la necesidad específica de combinar todas las filas de todas las tablas.
- Producto Cartesiano Un producto Carteisano se genera si se omite una condición de join. El ejemplo de la diapositiva muestra el nombre de empleado y nombre de departamento de las tablas EMP y DEPT. Debido a que no se ha especificado la claúsula WHERE, todas las filas (14 filas) de la tabla EMP se han unido con todas las filas (4 filas) en la tabla DEPT, generando por lo tanto 56 filas en la salida. SQL> SELECT ename, dname 2 FROM emp, dept; ENAME DNAME ---------- -------------- KING ACCOUNTING BLAKE ACCOUNTING ... KING RESEARCH BLAKE RESEARCH ... 56 rows selected.
- Tipos de Joins Hay dos tipos principales de condiciones de join: Equijoins Non-equijoins Los métodos adicionales de join incluyen: Outer joins Self joins Set operators Nota: Para más información sobre los set operators, ver: SQL y SQL*Plus Avanzados..
- Equijoins Para determinar el nombre del departamento del empleado, se compara el valor de la columna DEPTNO en la tabla EMP con los valores de DEPTNO en la tabla DEPT. La relación entre las tablas EMP y DEPT es un equijoin , ésto quiere decir que los valores en la columna DEPTNO en ambas tablas deben ser iguales. Frecuentemente, este tipo de joins incluyen complementos de clave primaria y externa. Nota: Los equijoins también se llaman joins simples o inner joins.
- Recuperación de Registros con Equijoins En el ejemplo de la parte superior: La claúsula SELECT especifica los nombre de columna a recuperar: nombre de empleado, número de empleado y número de departamento, los cuales son columnas en la tabla EMP. número de departamento, nombre de departamento y localidad, los cuales son columnas en la tabla EMP. La claúsula FROM especifica las dos tablas a las que debe acceder la base de datos: Tabla EMP. Tabla DEPT. La claúsula WHERE especifica cómo se van a unir las tablas: EMP.DEPTNO=DEPT.DEPTNO Ya que la columna DEPTNO es igual en ambas tablas, ésta debe ir prefijada por el nombre de la tabla para evitar la ambigüedad.
- Calificación de Nombres de Columnas Ambiguos Con el fin de evitar la ambigüedad, es necesario calificar los nombres de las columnas en la claúsula WHERE usando los nombres de las tablas. Sin los prefijos, la columna DEPTNO podría ser de la tabla DEPT o de la tabla EMP. Es necesario añadir la tabla como prefijo para ejecutar la consulta. Si no existen nombres repetidos en distinas tablas, entonces no es necesario calificar las columnas. Sin embargo, se ganará una mejora del rendimiento con el uso de prefijos, ya que de esta manera le decimos exactamente a Oracle8 Server a donde ir para encontrar las columnas. Los requerimientos para calificar a los nombres de columna ambiguos también son aplicables para las columnas que también podrían ser ambiguas en otras claúsulas como SELECT u ORDER BY.
- Condiciones Adicionales de Búsqueda Además del join, existen criterios adicionales para la claúsula WHERE. Por ejemplo, para visualizar el numero de empleado de King, el nombre, número de departamento y localidad, necesitamos una condición adicional en la claúsula WHERE. SQL> SELECT empno, ename, emp.deptno, loc 2 FROM emp, dept; 3 WHERE emp.deptno = dept.deptno 4 AND INITCAP(ename) = 'King'; EMPNO ENAME DEPTNO LOC --------- ---------- --------- ------------- 7839 KING 10 NEW YORK
- Alias de Tablas Calificar las tablas con los nombres de tabla puede llevar mucho tiempo, especialmente si los nombres son largos. Podemos utilizar alias de tablas en lugar de nombres de tablas. Así como los alias de columnas dan a una columna otro nombre, los alias de tablas dan a una tabla otro nombre. Los alias de tablas ayudan a mantener reducido el código SQL, utilizando por lo tanto menos memoria. Observar en el ejemplo cómo los alias de tablas se identifican en la claúsula FROM. El nombre de la tabla se especifica por completo, seguido de un espacio y después el alias de la tabla. A la tabla EMP se le ha dado un alias de E, mientras que la tabla DEPT tiene un alias de D. Guía de Escritura Los alias de tablas pueden tener más de 30 caracteres de longitud, pero es mejor que sean más cortos. Si se usa un alias para un nombre de tabla en particular en la claúsula FROM, entonces debe ser sustituída a través de toda la sentencia SELECT. Los alias de tablas deberían ser significativos. El alias de tabla es válido solo en la sentencia SELECT actual.
- Condiciones de Búsqueda Adicionales En ocasiones necesitaremos unir más de dos tablas. Por ejemplo, para visualizar el nombre, los pedidos realizados, los números de elementos, el total para cada elemento y el total de cada pedido para el cliente TKB SPORT SHOP, tendremos que unir las tablas CUSTOMER, ORD e ITEM. SQL> SELECT c.name, o.ordid, i.itemid, i.itemtot, o.total 2 FROM customer c, ord o, item i 3 WHERE c.custid = o.custid 4 AND o.ordid = i.ordid 5 AND c.name = 'TKB SPORT SHOP'; NAME ORDID ITEMID ITEMTOT TOTAL ------------ --------- --------- --------- --------- TKB SPORT SHOP 610 3 58 101.4 TKB SPORT SHOP 610 1 35 101.4 TKB SPORT SHOP 610 2 8.4 101.4
- Non-Equijoins La relación entre las tablas EMP y SALGRADE en un non-equijoin, lo cual significa que ninguna columna en la tabla EMP se corresponde directamente con una columna en la tabla SALGRADE. La relación entre las dos tablas es que la columna SAL en la tabla EMP está entre las columnas LOSAL y HISAL de la tabla SALGRADE. La relación se obtiene utilizando un operador distinto del igual (=).
- Non-Equijoins (continuación) El ejemplo de la parte superior, crea un non-equijoin para evaluar el grado de salario de un empleado. El salario debe estar entre cualquier par de los rangos de salario alto y bajo. Es importante observar que todos los empleados aparecen exactamente una vez cuando se ejecuta una consulta. Ningún empleado se repite en la lista. Hay dos razones para ésto: Ninguna de las filas en la tabla del grado del salario contiene grados que se solapen. Esto significa que el valor del salario de un empleado solo puede estar entre el salario más bajo y el más alto de una de las filas en la tabla del grado del salario. Todos los salarios de los empleados están dentro de los límites proporcionados por la tabla del grado del salario. Esto significa que ningún empleado gana menos del valor más bajo contenido en la columna LOSAL ni más del valor más alto contenido en la columna HISAL. Nota: Se pueden utilizar otro operadores como <= y >=, pero BETWEEN es el más simple. Al utilizar BETWEEN recordar especificar primero el valor más bajo y por último el valor más alto. Los alias de tablas se han especificado por cuestiones de rendimiento, no por ambigüedad.
- Devolución de Registros sin Coincidencias Directas con Outer Joins Si una fila no satisface una condición de join, no aparecerá en el resultado de la consulta. Por ejemplo, en la condición de equijoin de las tablas EMP y DEPT, el departamento OPERATIONS no aparece porque nadie trabaja es ese departamento. SQL> SELECT e.ename, e.deptno, d.dname 2 FROM emp e, dept d 3 WHERE e.deptno = d.deptno; ENAME DEPTNO DNAME ---------- --------- ------------- KING 10 ACCOUNTING BLAKE 30 SALES CLARK 10 ACCOUNTING JONES 20 RESEARCH ... ALLEN 30 SALES TURNER 30 SALES JAMES 30 SALES ... 14 rows selected.
- Devolución de Registros sin Coincidencias Directas con Outer Joins La(s) fila(s) que faltan pueden ser recuperadas si en la condición de join se uns un operador outer join. El operador es un signo más encerrado entre paréntesis (+) y se coloca en el “lado” del join que es deficiente en información. Este operador tiene el efecto de crear una o más filas NULL para que aquellas filas de la tabla sin valores conicidentes en la otra puedan ser combinadas. En la sintaxis: tabla1.columna = es la condición que combina ambas tablas tabla2.columna (+) es el símbolo de outer join, el cual se puede ubicar en cualquier lado de una condición de cláusula WHERE, pero no en ambos. Ubicar el símbolo dentrás del nombre de la tabla sin filas coincidentes.
- Devolución de Resgistros sin Coincidencias Directas on Outer Joins El ejemplo de arriba muestra los números y los nombres de todos los departamentos. El departamento OPERATIONS, que no tiene ningún empleado, también se visualiza. Restricciones Outer Join El operador outer join puede aparecer solo en un lado de la expresión: el lado al que le falta la información. Este recupera aquellas filas de una tabla que no tiene correspondencia directa en otra tabla. Una condición que incluye un outer join no puede utilizar el operador IN o unirse a otra condición por el operador OR.
- Combinación de una Tabla Consigo Misma En alguna ocasión necesitaremos combinar una tabla consigo misma. Para encontrar el nombre de cada jefe de empleado necesitamos combinar la tabla EMP consigo misma. Por ejemplo, para encontrar el nombre del jefe de Blake, necesitamos: Encontrar a Blake en la tabla EMP mirando en la columna ENAME. Encontrar el número de jefe de Blake mirando en la columna MGR. El número de jefe de Blake es 7839. Encontrar el nombre del jefe con EMPNO 7839 mirando en la columna ENAME. En número de empleado de King es 7839. Por lo tanto, King es el jefe de Blake. En este proceso, miramos dos veces en la tabla. La primera vez miramos en la tabla para encontrar a Blake en la columna ENAME y en MGR para encontrar el valor 7839. La segunda vez miramos en la columna EMPNO para encontrar 7839 y la columna ENAME para encontrar a King.
- Combinación de una Tabla Consigo Misma (continuación) El ejemplo de la parte superior, combina la tabla EMP consigo misma. Para simular dos tablas en la claúsula FROM, hay dos alias, WORKER y MANAGER, para la misma tabla, EMP. En este ejemplo, la claúsula WHERE contiene la combinación que significa “dónde un jefe de un trabajador coincide con el número de empleado para el jefe”.
- Resumen Hay varias formas de combinar tablas. Todas las formas tienen en común la necesidad de vincularlas a través de una condición en la claúsula WHERE. El método que elijamos estará basado en el resultado y en las estructuras de datos disponibles. Types of Joins Equijoin Non-equijoin Outer join Self join Cartesian Products Omission of the WHERE clause will result in a Cartesian product, in which all combinations of rows will be displayed. Table Aliases Table aliases speed up database access. Table aliases can help to keep SQL code smaller, therefore conserving memory. SELECT table.column, table.column FROM table1, table2 WHERE table1.column1 = table2.column2 ;
- Objetivo Esta lección presenta un estudio más profundo de las funciones. Se centrará en la obtención de información resumen, tales como promedios para grupos de filas. Se discutirá cómo agrupar filas de una tabla en conjuntos más pequeños y cómo especificar criterios de búsqueda para los mismos.
- Funciones de Grupo A diferencia de las funciones a nivel de fila, las funciones de grupo operan sobre conjuntos de filas para dar un resultado por cada uno de ellos. Dichos grupos pueden estar constituidos por la tabla entera o por partes de la misma. Este tipo de funciones aparecen en las cláusulas SELECT y HAVING.
- Funciones de Grupo Cada una de las funciones acepta un argumento. La siguiente tabla identifica las opciones que puede usar en la sintaxis:
- Guía para el Uso de Funciones de Grupo DISTINCT hace que la función considere solo los valores no duplicados; mientras que ALL incluye todos. Por defecto se toma ALL y por lo tanto no es necesario especificarla. Los tipos de datos de los argumentos de expr pueden ser CHAR, VARCHAR2, NUMBER o DATE. Todas las funciones de grupo excepto COUNT(*) ignoran los valores nulos. Usar la función NVL para sustituir un valor nulo por otro valor.
- Funciones de Grupo Puede utilizar las funciones AVG, SUM, MIN, y MAX contra columnas que puedan almacenar datos numéricos. El ejemplo de la parte superior, visualiza la media, salario más alto, más bajo y suma mensual para todos los vendedores.
- Funciones de Grupo (continuación) Puede utilizar las funciones MAX y MIN para cualquier tipo de dato. El ejemplo de la parte superior, visualiza el empleado más nuevo y el más antiguo. El ejemplo de la parte inferior, visualiza el nombre del empleado que figura en primer lugar y el último, según el nombre de los empleados en orden alfabético. Nota : Las funciones AVG y SUM sólo pueden ser utilizadas con valores numéricos. SQL> SELECT MIN(ename), MAX(ename) 2 FROM emp; MIN(ENAME) MAX(ENAME) ---------- ---------- ADAMS WARD
- La Función COUNT La función COUNT tiene dos formatos: COUNT(*) COUNT( expr ) COUNT(*) devuelve la cantidad de filas de una tabla incluyendo filas duplicadas y aquellas que contienen valores nulos. En contraste, COUNT(expr) devuelve el número de registros no nulos, en la columna identificada por “expr”. El ejemplo de la parte superior, visualiza el número de empleados del departamento 30.
- La Función COUNT (continuación) El ejemplo de la parte superior, visualiza el número de empleados del departamento 30 que tienen derecho a comisión. Observe que el resultado es cuatro, porque dos de los empleados del departamento 30 no tienen comisión y contienen un valor nulo en la columna comisión (COMM). Ejemplo: Visualizar el número de departamentos en la tabla EMP: Visualizar el número de departamentos distintos en la tabla EMP: SQL> SELECT COUNT(deptno) 2 FROM emp; COUNT(DEPTNO) ------------- 14 SQL> SELECT COUNT(DISTINCT (deptno)) 2 FROM emp; COUNT(DISTINCT(DEPTNO)) ----------------------- 3
- Funciones de Grupo y Valores Nulos Todas la funciones de grupo excepto COUNT (*) ignoran los valores nulos de las columnas. En el ejemplo de la parte superior, la media es calculada basada solamente en los registros de la tabla donde existía un valor válido almacenado para la columna COMM. La media es calculada como la comisión total pagada a todos los empleados, dividida por el número de empleados que reciben comisión (4).
- Funciones de Grupo y Valores Nulos (continuación) La función NVL obliga a las funciones de grupo a incluir valores nulos. El ejemplo de la parte superior, la media se calcula basada en todos los registros en la tabla, sin tener en cuenta los valores nulos almacenados en la columna COMM. La media se calcula como la comisión total pagada a todos los empleados, dividida por el número total de empleados en la compañía (14).
- Grupos de Datos Hasta ahora, todas las funciones de grupo trataban la tabla como un gran grupo de información. A veces, necesita dividir la tabla de información en grupos más pequeños. Esto puede ser hecho usando la cláusula GROUP BY.
- La Cláusula GROUP BY Se usa la cláusula GROUP BY con el propósito de repartir las filas de una tabla en grupos más pequeños. Por lo tanto, se pueden usar las funciones de grupo para devolver información resumida para cada grupo. En la sintaxis: group_by_expression Especifica columnas cuyos valores determinan la base para agrupar registros. Guía de Uso de Group By Si se incluye una función de grupo en una cláusula SELECT, no se puede seleccionar resultados individuales a menos que la columna aparezca en la cláusula GROUP BY. Si no se incluyen las columnas correspondientes en la lista se recibirá un mensaje de error. Con el uso de la cláusula WHERE, se puede excluir filas antes de la división en grupos. No se puede usar la notación de posición o el alias de columna en la cláusula GROUP BY. Por defecto, las filas se ordenan en forma ascendente de acuerdo a la lista GROUP BY. Esto se puede modificar haciendo uso de la cláusula ORDER BY.
- La cláusula GROUP BY (continuación) Cuando use la cláusula GROUP BY, asegúrese que todas las columnas en el listado de SELECT que no están en las funciones del grupo están incluidos en la cláusula GROUP BY. El ejemplo de arriba muestra el número de departamento y el salario medio para cada departamento. Así es como la expresión SELECT citada anteriormente, conteniendo una cláusula GROUP BY, es evaluada: La cláusula SELECT especifica las columnas a recuperar: La columna de número de Departamento en la tabla EMP La media de todos los salarios del grupo que usted especificó en la cláusula GROUP BY La cláusula FROM especifica las tablas a las que debe acceder la base de datos: la tabla EMP. La cláusula WHERE especifica las filas a recuperar. Si no existe la cláusula WHERE, se recuperarán las filas por defecto. La cláusula GROUP BY especifica como deben ser agrupadas las filas. Las filas están siendo agrupadas por el número de departamento, por lo que la función AVG que está siendo aplicada a la columna del salario calculará el salario medio para cada departamento.
- La cláusula GROUP BY (continuación) La columna GROUP BY no tiene que estar en la cláusula SELECT. Por ejemplo, la expresión SELECT muestra los salarios medios para cada departamento sin mostrar los respectivos números de departamento. Sin embargo, sin los números de departamento los resultados no parecen ser significativos. Puede usar la función grupo con la cláusula ORDER BY SQL> SELECT deptno, AVG(sal) 2 FROM emp 3 GROUP BY deptno 4 ORDER BY AVG(sal); DEPTNO AVG(SAL) ---------- ------------ 30 1566.6667 20 2175 10 2916.6667
- Grupos Dentro de Grupos Algunas veces es necesario ver los resultados de grupos dentro de grupos. La diapositiva de arriba muestra un informe con el salario total pagado a cada cargo, dentro de cada departamento. La tabla EMP está agrupada primero por el número de departamento y luego dentro de cada grupo está agrupada por cargos. Por ejemplo, los dos empleados en el departamento 20 están agrupados juntos y con un único resultado (salario total) producido por todos los vendedores del grupo.
- Grupos Dentro de Grupos (continuación) Usted puede devolver resultados resumen para grupos y subgrupos listando mas de un columna GROUP BY. Puede determinar el tipo de orden por defecto de los resultados por el orden de las columnas en la cláusula GROUP BY. Así es como la expresión SELECT, conteniendo una cláusula GROUP BY, es evaluada: La cláusula SELECT especifica la columna a recuperar: Número de departamento en la tabla EMP Cargo en la tabla EMP La suma de todos los salarios en el grupo que usted especificó mediante la cláusula GROUP BY La cláusula FROM especifica las tablas a las que debe acceder la base de datos : la tabla EMP. La cláusula GROUP BY especifica como debe agrupar las filas: Primero, las filas son agrupadas por el número de departamento. Segundo, dentro de los grupos de número de departamento, las filas son agrupadas por cargo. La función SUM está siendo aplicada a la columna del salario para todos los cargos dentro de cada número de grupo de departamento.
- Consultas No Válidas Usando Funciones de Grupo Cada vez que se usa una mezcla de ítems individuales (REGION_ID) y funciones de grupo (COUNT) en la misma sentencia SELECT, se debe incluir una cláusula GROUP BY que especifique los ítems individuales (en este caso, REGION_ID). Si la cláusula GROUP BY no se encuentra presente, aparecerá el mensaje de error “not a single-group group function” y un asterisco (*) apuntaría la columna errónea. Cualquier columna o expresión en la SELECT que no sea una función agregada, tiene que estar en la cláusula GROUP BY. SQL> SELECT deptno, COUNT(ename) 2 FROM emp 3 GROUP BY deptno; DEPTNO COUNT(ENAME) ---------- ------------ 10 3 20 5 30 6
- Consultas No Válidas Usando Funciones de Grupo (continuación) La cláusula WHERE no puede utilizarse con el fin de restringir grupos. El ejemplo de la parte superior, da error porque utiliza la cláusula WHERE para restringir la media de salarios de aquellos departamentos que tienen una media superior a 2000$. Puede corregir el error, usando una cláusula HAVING para restringir grupos. SQL> SELECT deptno, AVG(sal) 2 FROM emp 3 GROUP BY deptno 4 HAVING AVG(sal) > 2000; DEPTNO AVG(SAL) ---------- -------------- 10 2916.6667 20 2175
- Limitando los Resultados de un Grupo De la misma manera que utiliza la cláusula WHERE para restringir los registros que selecciona, utilizará la cláusula HAVING para restringir grupos.. Para localizar el máximo salario de cada departamento, pero mostrar sólo aquéllos cuyo máximo es superior a 2900$, necesita hacer estas dos cosas: 1. Averigüe la media de salarios para cada dpto. agrupando por nº de departamento. 2. Limite los grupos a aquellos departamentos con un salario máximo mayor que 2900$.
- La cláusula HAVING Puede utilizar la cláusula HAVING para especificar qué grupos se visualizarán. Por tanto, puede limitar grupos de forma precisa,, en base a información agregada. En la sintaxis: Condición_grupo Limita los grupos de registros devueltos, a los aquéllos para los que la condición especificada es TRUE. El servidor Oracle8 realiza los siguientes pasos, al utilizar la cláusula HAVING: Agrupa los registros. La función de grupo, se aplica al grupo. Se visualizan los grupos que se correspondan con el criterio especificado en la cláusula HAVING. La cláusula HAVING puede preceder a la cláusula GROUP BY, pero se recomienda que se ponga en primer lugar la cláusula GROUP BY, porque es más lógico. Los grupos se forman, y las funciones de grupo se calculan antes de que la cláusula HAVING sea aplicada a los grupos en la SELECT.
- La cláusula HAVING (continuación) El ejemplo de la parte superior, visualiza los números de dpto. y máximo salario, para aquellos departamentos cuyo salario máximo sea superior a 2900$. Puede utilizar la cláusula GROUP BY sin utilizar una función de grupo en la SELECT. Si limita los registros basados en el resultado de una función de grupo, tiene que tener una cláusula GROUP BY, así como una cláusula HAVING. SQL> SELECT deptno 2 FROM emp 3 GROUP BY deptno 4 HAVING MAX(sal) > 2900; DEPTNO --------- 10 20
- La cláusula HAVING (continuación) El ejemplo de la parte superior, visualiza el oficio y salario mensual total, para cada oficio con un payroll total superior a 5000$. El ejemplo excluye a vendedores y clasifica la lista por el salario mensual total.
- Anidando Funciones de Grupo Las funciones de grupo se pueden anidar. El ejemplo de la parte superior, visualiza la máxima media de salarios.
- Resumen En SQL, disponemos de siete funciones de grupo: AVG COUNT MAX MIN SUM STDDEV VARIANCE Puede crear subgrupos por medio de la cláusula GROUP BY. Los grupos pueden ser excluidos por medio de la cláusula HAVING. Escriba las cláusulas HAVING y GROUP BY después de la cláusula WHERE en la sentencia. La cláusula ORDER BY irá al final de la sentencia. El servidor Oracle8 evalúa las cláusulas en el siguiente orden: Examina la cláusula WHERE. Identifica los grupos especificados en la cláusula GROUP BY. Examina la cláusula HAVING.
- Objetivos En esta lección aprenderá características avanzadas de las sentencias SELECT. Puede escribir una subconsulta en la cláusula WHERE de otra sentencia SQL para obtener valores basados en valores condicionales desconocidos. Esta lección cubre subconsultas mono-registro y multi-registro.
- Uso de una Subconsulta para resolver un problema Supongamos que quiere escribir una consulta para localizar aquellos empleados que ganan un salario superior al de Jones. Para resolver este problema, necesitará dos consultas: una que averigüe el salario de Jones y una segunda para encontrar a los empleados que ganan más de esta cantidad. Puede resolver el problema combinando las dos consultas, escribiendo una consulta dentro de otra. La consulta más interna o subconsulta, devuelve un valor que será utilizado por la consulta principal (la consulta más externa). Usar una subconsulta es equivalente a realizar dos consultas secuencialmente y utilizar el resultado de la primera que se ejecuta (subconsulta), como valor para la segunda consulta que se ejecuta o consulta principal.
- Una subconsulta es una sentencia SELECT que está incluida en una cláusula de otra sentencia SQL. Se pueden construir comandos simples y potentes usando subconsultas. Pueden ser muy útiles cuando se necesita seleccionar filas de una tabla con una condición que depende de los datos que están en la misma tabla. Se puede poner la subconsulta en algunas de las cláusulas de un comando SQL: cláusula WHERE cláusula HAVING cláusula FROM de una sentencia SELECT o DELETE En la sintaxis operator incluir un operador de comparación como >,= o IN Nota: Los operadores de comparación se dividen en dos clases : operadores de fila simple (>, =, >=, <, <>, <=) y operadores de filas múltiples (IN, NOT IN). Frecuentemente se refiere a una subconsulta como un SELECT anidado, un sub-SELECT, o una sentencia select interna. Generalmente la subconsulta se ejecuta primero y su resultado es usado para completar la condición para la consulta principal, o externa .
- Uso de una subconsulta En la transparencia, la consulta más interna determina el salario del empleado 7566. La consulta más externa toma el resultado y lo utiliza para visualizar todos los empleados, que ganan más de esta cantidad.
- Guía para la escritura correcta de subconsultas - Encierre una subconsulta entre paréntesis. - Coloque la subconsulta después del operador de comparación. - No agregar una cláusula ORDER BY a una subconsulta. Se puede tener solamente una cláusula ORDER BY para una sentencia SELECT y específicamente, debe ser la última cláusula en la sentencia SELECT principal. - Para las subconsultas se utilizan dos clases de operadores de comparación: operadores mono-registro (single-row) y operadores multi-registro (multiple-row).
- Tipos de Subconsultas Subconsultas mono-registro: devuelve únicamente un registro, de la sentencia SELECT anidada. Subconsultas multi-registro: devuelven más de un registro, de la sentencia SELECT anidada. Subconsultas multi-columna: devuelven más de una columna, de la sentencia SELECT anidada.
- Subconsultas mono-registro (single-row) Una subconsulta mono-registro, devuelve únicamente un registro, desde la sentencia SELECT anidada. Ejemplo Visualizar los empleados que tienen el mismo oficio que el empleado nº 7369: SQL> SELECT ename, job 2 FROM emp 3 WHERE job = 4 (SELECT job 5 FROM emp 6 WHERE empno = 7369); ENAME JOB ---------- --------- JAMES CLERK SMITH CLERK ADAMS CLERK MILLER CLERK
- Ejecución de Subconsultas Mono-registro Una sentencia SELECT puede ser considerada como un bloque de consulta. El ejemplo de la parte superior, visualizará aquellos empleados cuyo oficio sea el mismo que el del el empleado 7369, y cuyo salario sea superior al del empleado 7876. El ejemplo consiste en tres bloques de consulta: la consulta más externa y dos consultas más internas. Los bloques de consulta más internos se ejecutan primero, y dan como resultado CLERK y 1100, respectivamente. El bloque de consulta más externo se procesa a continuación y utiliza los valores devueltos por las consultas más internas para completar sus criterios de búsqueda. Ambas consultas internas devuelven un solo valor (CLERK y 1100, respectivamente), por tanto esta sentencia SQL recibe el nombre de subconsulta mono-registro.
- Uso de Funciones de Grupo en una Subconsulta Puede visualizar datos de una consulta principal, por medio de una función de grupo en una subconsulta, para devolver un único registro. La subconsulta estará entre paréntesis y va a continuación del operador de comparación. El ejemplo de la parte superior, visualiza el nombre, oficio y salario, de todos los empleados cuyo salario es igual al mínimo salario. La función de grupo MIN devuelve un único valor (800), a la consulta principal.
- Cláusula HAVING con Subconsultas Además de la cláusula WHERE, las subconsultas también se pueden usar en la cláusula HAVING. El Servidor Oracle8 ejecuta la subconsulta y el resultado es devuelto a la cláusula HAVING de la consulta principal. La sentencia SQL de la transparencia, visualiza todos los departamentos que tienen un mínimo salario mayor que el del departamento 20. Ejemplo: Averiguar el oficio con la media más baja de salarios. DEPTNO MIN(SAL) --------- --------- 10 1300 30 950 SQL> SELECT job, AVG(sal) 2 FROM emp 3 GROUP BY job 4 HAVING AVG(sal) = (SELECT MIN(AVG(sal)) FROM EMP GROUP BY job);
- Errores con Subconsultas I Un error común en subconsultas es que una de ellas devuelva más de un registro, cuando se esperaba solamente uno. En la sentencia SQL de la parte superior, la subconsulta contiene una cláusula GROUP BY (deptno), que implica que la subconsulta devolverá varios registros, uno para cada grupo que encuentre. En este caso, el resultado de la subconsulta será 800, 1300, y 950. La consulta más externa toma los resultados de la subconsulta (800, 950, 1300) y utiliza estos resultados en su cláusula WHERE. La cláusula WHERE contiene un operador (=), un operador de comparación mono-registro que espera un único valor. El operador = no puede aceptar más de un valor de la subconsulta y por tanto genera un error. Para corregir este error, cambie el operador = por IN.
- Errores con Subconsultas II Otro error común es que la subconsulta no devuelva ningún registro. En la sentencia SQL de la parte superior, la subconsulta contiene una cláusula WHERE (ename='SMYTHE'). Posiblemente, la intención es averiguar datos sobre el empleado cuyo nombre es “Smythe”. La sentencia parece ser correcta, pero no devuelve ningún registro al ser ejecutada. El problema es que “Smythe” está mal escrito. No hay ningún empleado con ese nombre; por tanto, la subconsulta no devuelve registros. La consulta principal toma los resultados de la más interna (null) y utiliza éstos para su cláusula WHERE. La consulta principal no encuentra empleados con un oficio igual a nada (null), y por eso no devuelve registros.
- Subconsultas Multi-registro Las subconsultas que devuelven más de una fila se denominan subconsultas de multi-registro. Se debe usar un operador multi-registro, tal como IN, en lugar de un operador mono-registro. Este operador espera uno o más valores. Ejemplo: Averiguar qué empleados ganan un salario igual a cualquiera de los mínimos por departamento: SQL> SELECT ename, sal, deptno 2 FROM emp 3 WHERE sal IN (SELECT MIN(sal) 4 FROM emp 5 GROUP BY deptno); La consulta más interna se ejecuta primero, y devuelve tres registros: 800, 950 y1300. A continuación se procesa la consulta principal y utiliza los valores para completar su condición de búsqueda. De hecho, la consulta principal sería interpretada así, por el servidor Oracle8: SQL> SELECT ename, sal, deptno 2 FROM emp 3 WHERE sal IN (800, 950, 1300);
- Subconsultas Multi-registro El operador ANY (y su sinónimo SOME) compara un valor con cada valor devuelto por una subconsulta. El ejemplo de la parte superior visualiza los empleados cuyo salario es menor que el de cualquier empleado o no empleado. El máximo salario que gana un empleado (clerk) es 1300$. La sentencia SQL visualiza todos los empleados que no son empleados (clerks), pero ganan más de 1300$. <ANY significa menos que el mínimo. >ANY significa más que el máximo. =ANY es equivalente a IN.
- Subconsultas Multi-registro El operador ALL compara un valor con cada valor devuelto por una subconsulta. El ejemplo de la parte superior visualiza a aquellos empleados cuyo salario es superior que la media de salarios de todos los departamentos. La media de salarios más alta de un departamento es 2916.66$, por tanto la consulta devuelve aquellos empleados cuyo salario es superior a 2916.66$. >ALL significa más que el máximo <ALL significa menos que el mínimo El operador NOT puede ser utilizado con los operadores IN, ANY, y ALL.
- Resumen Las subconsultas son útiles cuando una consulta se basa en un criterio desconocido. Subconsultas Puede pasar una fila de datos a la sentencia principal que contiene un operador de mono-registro, tal como =, <>, >, >=, <, o <=. Puede pasar múltiples filas de datos a la sentencia principal que contiene un operador multi-registro, tal como IN. El Servidor Oracle8 las procesa primero, y luego la cláusula WHERE o HAVING usa el resultado. Puede contener funciones de grupos.