Introduccion a sql

Introducción al lenguaje SQL

Manual del Alumno

INNOVA Desarrollos Informáticos, SL

Paseo Mallorca, 34 Entlo. C 07012 Palma de Mallorca Tel. 971 721404 http://www.balearsinnovacio.com

Título: Introducción al lenguaje SQL Fecha Edición: 22 de Junio de 2004 Autores: Javier Jofre González-Granda

INNOVA Desarrollos Informáticos, SL Pág. 3

INTRODUCCIÓN

Prólogo El lenguaje SQL (Structured Query Language) permite a los

desarrolladores la generación de las estructuras de información y el acceso a los datos en los sistemas gestores de bases de datos relacionales, como Oracle, Informix, Sybase, Microsoft SQL Server, Access y otros. Nos permite, por tanto, describir la estructura de los datos, y manipularlos. La descripción de la estructura de datos es la propia definición de la base de datos, mientras que la manipulación de estos incluye la inserción, borrado, actualización y, por supuesto, consulta.

A grandes rasgos, podríamos decir que SQL posee dos sublenguajes: el sublenguaje de SQL que permite la creación de bases de datos es lo que se llama DDL (Data Description Language). La manipulación de datos, por otra parte, es lo que se llama DML (Data Manipulation Language).

Aquí describiremos algunos aspectos relacionados con la definición de las bases de datos (DDL), y nos centraremos más profundamente en el sublenguaje de manipulación de datos (DML).

Metodología del módulo La metodología que se va a utilizar para la impartición del curso se

basa en:

• Ejercicios prácticos de seguimiento del módulo.

Evaluación del módulo Un examen final con varios ejercicios y apartados a corregir.


ÍNDICE

INTRODUCCIÓN................................................................. 3 Prólogo............................................................................................................... 3 Metodología del módulo.................................................................................. 3 Evaluación del módulo .................................................................................... 3

ÍNDICE .............................................................................. 4

FICHA INFORMATIVA DEL MÓDULO. .................................. 6 Nombre .............................................................................................................. 6 Meta .................................................................................................................... 6 Responsable del diseño del módulo y de la elaboración del Manual ........ 6 Bibliografía......................................................................................................... 6

1 UNIDAD 2: DDL LENGUAJE DE DEFINICIÓN DE DATOS .. 7 Objetivo general de la unidad ......................................................................... 7 Objetivos específicos........................................................................................ 7 Contenidos......................................................................................................... 7 Cuaderno de notas............................................................................................ 8 Actividades....................................................................................................... 10 1.1 Creación de tablas...................................................................................... 11 1.2 Cambios en la estructura de una tabla .................................................... 15 1.3 Borrado de tablas ....................................................................................... 15 1.4 Creación de índices.................................................................................... 16 1.5 Borrado de índices..................................................................................... 17 1.6 Creación de secuencias.............................................................................. 17 1.7 Borrado de secuencias............................................................................... 18 1.8 Dando privilegios de acceso..................................................................... 18 1.9 Quitando privilegios de acceso ................................................................ 19 1.10 Creación de sinónimos ............................................................................ 19 1.11 Borrado de sinónimos ............................................................................. 20 1.12 Vaciar una tabla ........................................................................................ 20

2 UNIDAD 3: DML LENGUAJE DE MANIPULACIÓN DE

DATOS ............................................................................. 21 Objetivo general de la unidad ....................................................................... 21

Introducción al lenguaje SQL Índice


Objetivos específicos...................................................................................... 21 Contenidos....................................................................................................... 21 Cuaderno de notas.......................................................................................... 22 Actividades....................................................................................................... 24 2.1 Introducción............................................................................................... 25 2.2 Inserción de datos...................................................................................... 25 2.3 Borrar datos ................................................................................................ 25 2.4 Actualización de datos .............................................................................. 26 2.5 Consultas..................................................................................................... 27 2.6 Enlaces ........................................................................................................ 32 2.7 Subconsultas ............................................................................................... 36 2.8 Fuciones de agrupación ............................................................................ 38 2.9 Las Cáusulas GROUP BY y HAVING ................................................. 39 2.10 Combinación con Subconsultas............................................................. 39 2.11 Las Cláusulas EXISTS, ALL y ANY..................................................... 40 2.12 Unión, intersección y resta entre consultas .......................................... 41 2.13 Outer Joins................................................................................................ 42 2.14 Funciones de SQL ................................................................................... 44 2.15 Acceso a secuencias ................................................................................. 50 2.16 Optimización en las consultas................................................................ 50 2.17 Vistas.......................................................................................................... 50 2.18 Sentencias de control de transacciones................................................. 51

3 UNIDAD 4: EJERCICIOS .................................................. 54 Objetivo general de la unidad ....................................................................... 54 Objetivos específicos...................................................................................... 54 Contenidos....................................................................................................... 54 Cuaderno de notas.......................................................................................... 55 Actividades....................................................................................................... 57 3.1 Ejercicios sobre DDL ............................................................................... 59 3.2 Ejercicios sobre DML............................................................................... 61


FICHA INFORMATIVA DEL

MÓDULO.

Nombre Introducción al lenguaje SQL

Meta Que el alumno adquiera los conocimientos básicos del lenguaje SQL

de Oracle para formar parte de cualquier grupo de desarrollo como desarrollador junior.

Responsable del diseño del módulo y de la elaboración del Manual

Javier Jofre González-Granda

Bibliografía Manual de referencia de SQL de Oracle y varios cursos de

introducción a SQL de internet.


1 UNIDAD 2: DDL LENGUAJE

DE DEFINICIÓN DE DATOS

Objetivo general de la unidad Aprender a crear bases de datos entendiendo los conceptos de

implantación y relacionándolos con el modelo relacional de bases de datos.

Objetivos específicos Crear tablas, restricciones, índices, secuencias, sinónimos, aprender a

otorgar privilegios y demás funciones básicas del DDL.

Contenidos Creación de tablas, cambio en la estructura de las tablas, borrado de

tablas, índices (creación y borrado), secuencias (creación y borrado), otorgar y quitar privilegios sobre objetos, creación y borrado de sinónimos.


Cuaderno de notas

Introducción al lenguaje SQL Unidad 2: DDL Lenguaje de definición de datos



Actividades Seguir las sesiones teóricas y realizar los ejercicios de la Unidad

correspondientes a la teoría dada.


1.1 Creación de tablas

1.1.1 Sintaxis Cuando se diseña una base de datos relacional, es necesario conocer

cómo implementar dicha filosofía en un sistema gestor de base de datos. SQL nos permite crear tablas con claves primarias, campos y relaciones a través de las claves extranjeras o foráneas. La definición de una tabla permite crear la estructura que soportará los verdaderos datos.

Una tabla, en general, se crea sobre un esquema (usuario) y, además de múltiples parámetros relacionados con el mantenimiento de la estructura por parte del sistema gestor de base de datos, es necesario definir los campos (atributos) y tipos de datos de cada uno. Paralelamente es necesario describir las restricciones (constraints) asociadas a la definición propia de la tabla (constraints de clave primaria, foránea, única o de tipo check).

SQL posee la siguiente sintaxis (resumida) para la definición de nuevas tablas:

CREATE TABLE <TABLE NAME>

(<COLUMN_1 NAME> <DATA TYPE> [(<SIZE>)] <COLUMN_1 CONSTRAINT>,

<COLUMN_2 NAME> <DATA TYPE> [(<SIZE>)] <COLUMN_2 CONSTRAINT>,

...);

Dónde <TABLE NAME> es el nombre de la tabla, <COLUMN_1 NAME> es el nombre de la primera columna (campo o atributo), <COLUMN_2 NAME> es el nombre de la segunda columna, etc.

<DATA TYPE> es el tipo de datos que contendrá la columna.

<COLUMN_1 CONSTRAINT> es una parte de la sentencia que nos permite definir las constraints asociadas a la columna 1, y así sucesivamente para el resto de columnas.

Introducción al lenguaje SQL Unidad 3: DML Lenguaje de manipulación de datos


1.1.2 Tipos de datos Oracle Los tipos de datos dependen del sistema gestor de bases de datos. En

el caso de Oracle tenemos los siguientes (entre otros):

a)VARCHAR2(SIZE):

Una columna de este tipo contendrá caracteres. Este tipo de datos requere del atributo SIZE especificado en la sintaxis de la sentencia CREATE TABLE. Si una columna es de tipo VARCHAR2(100), podrá contener hasta 100 caracteres, aunque en la base de datos, no se reservan 100 espacios de ocupación, sino que sólo se ocupan los que se usan por los datos. En Oracle 7 sólo es posible crear tablas con columnas de tipo VARCHAR2 con un máximo de 2000 caracteres. En Oracle 8 se ha incrementado hasta 4000 caracteres.

b)CHAR(X):

La columna contendrá una cadena de caracteres de un número de bytes igual a la longitud especificada en X.

c)NUMBER (X,Y):

Especifica columnas que contendrán números reales. X indica la longitud máxima en dígitos de la parte entera del número real, mientras que Y indica la longitud máxima de la parte decimal. Por ejemplo, una columna de tipo NUMBER(4,2) podrá contener, como máximo el número 99.99

d)DATE:

Para Oracle, es un número especial que puede ser visualizado en varios formatos. En su momento veremos los formatos de fechas y las funciones de cambio de tipo de datos entre caracteres, números y fechas.

e)LONG :

Desaparecerá en Oracle 8.x y es sustituido por BLOB. Sirve para que la columna pueda contener una cadena de caracteres de hasta 2 gigabytes.

f) RAW(X):

Contendrá una cadena binaria de cómo máximo X bytes. X no puede ser mayor que 255.

g)LONG RAW:

La columna contendrá una cadena binaria no superior a 2 gigabytes.



1.1.3 Definición de restricciones La definición de las restricciones de una columna, incluye las siguientes

posibilidades:

1.- CONSTRAINT <NOMBRE_CONSTRAINT> NULL | NOT NULL:

La cláusula NOT NULL significa que la columna debe tener un valor en cada registro, esto es, no puede estar vacía en ningún registro, mientras que la cláusula NULL significa que puede estar vacía en cualquier registro. <NOMBRE_CONSTRAINT> será el nombre de la restricción y es opcional en cualquier restricción que se especifique de esta manera.

2.- CONSTRAINT <NOMBRE_CONSTRAINT> UNIQUE:

Fuerza a que no existan dos registros con valores iguales en dicha columna.

3.- CONSTRAINT <NOMBRE_CONSTRAINT> PRIMARY KEY:

Obliga a que la columna sea la única que es clave primaria en la tabla.

4.- CONSTRAINT <NOMBRE_CONSTRAINT> CHECK (CONDICION):

Obliga a que se chequee una condición determinada en el momento en que se inserte o actualice un valor en la columna. Por ejemplo: CHECK (PRECIO > 0) obliga al sistema a comprobar que la columna PRECIO sea mayor que 0 antes de insertar o actualizar su valor en un registro.

5.- DEFAULT <VALOR>:

Inserta el valor especificado en la columna cuando se crea un nuevo registro y no se inserta un valor específico en dicha columna.

6.-CONSTRAINT <NOMBRE_CONSTRAINT> FOREIGN KEY REFERENCES <TABLE NAME> (<COLUMN NAME>):

Es similar a PRIMARY KEY, pero obliga a que la columna sea clave extranjera y provenga de la clave primaria de otra tabla.

Un ejemplo de esta sentencia podría ser el siguiente:

CREATE TABLE ORDERS

(OWNERID INTEGER NOT NULL,

ITEMDESIRED VARCHAR2(40) NOT NULL);

Este ejemplo crea una tabla con el nombre de ORDERS y con dos campos; OWNERID que contendrá valores enteros y no vacíos, y



ITEMDESIRED que contendrá una cadena de caracteres de cómo máximo 40 y no vacíos.

Otro ejemplo más complicado podría ser el siguiente:

CREATE TABLE PADRON

(PID NUMBER(6) COSNTRAINT PK_PATRON PRIMARY KEY,

NAME VARCHAR2(30) NOT NULL,

GENDER VARCHAR2(1));

En este caso, hemos creado una tabla llamada PADRON que contendrá una clave primaria asociada al campo PID, una columna llamada NAME que contendrá una cadena de caractéres (como máximo 30) y no podrá estar vacía, y GENDER que contendrá un único carácter, y podrá estar vacía. PK_PATRON es el nombre de la constraint de clave primaria. Si no se especifica nombre, como en el caso de la constraint de tipo NOT NULL, en la columna NAME, su nombre es definido por defecto por el sistema gestor de base de datos.

En el caso en que una restricción de tipo clave primaria o foránea, involucre a varias columnas, la sintaxis de la sentencia cambia, y obliga a especificar el conjunto de columnas al final de la sentencia. Veamos un par de ejemplos:

CREATE TABLE REQUEST

(CALLNO VARCHAR2(10) CONSTRAINT FK_CALLNO

REFERENCES BOOK (CALLNO),

PID NUMBER(6) CONSTRAINT FK_PID

REFERENCES PATRON (PID),

RDATE DATE,

CONSTRAINT PK_REQUEST PRIMARY KEY (CALLNO, PID));



1.2 Cambios en la estructura de una tabla Para modificar la estructura de una tabla, es necesario utilizar la

siguiente sentencia (con sintaxis resumida):

ALTER TABLE <TABLE NAME>

ADD <COLUMN_A NAME> <DATA TYPE> [(<SIZE>)] <COLUMN_1 CONSTRAINT>|

ADD <CONSTRAINT_1 NAME>|

MODIFY <COLUMN_B NAME> <COLUMN_C NAME> <DATATYPE>[(<SIZE>)]

<COLUMN_BCONSTRAINT>|

DROP PRIMARY KEY|

DROP UNIQUE <COLUMN_D NAME>|

DROP CONSTRAINT <CONSTRAINT_2 NAME>;

Permite añadir nuevas columnas y constraints, modificar los tipos de datos de las columnas o constraints existentes, y borrar las constraints existentes. Oracle 7 no permitía borrar una columna una vez estuviera creada, pero Oracle 8 ya lo permite (aunque no entraremos en detalle de como hacerlo).

Veamos un par de ejemplos:

ALTER TABLE PATRON DROP CONSTRAINT PK_PATRON;

Borra la clave primaria de la tabla PATRON.

ALTER TABLE ANTIQUES ADD (PRICE NUMBER(8,2) NULL);

Crea una nueva columna PRICE de tipo NUMBER en la tabla ANTIQUES que puede estar vacía en algún registro.

1.3 Borrado de tablas Para borrar una tabla de la base de datos es necesario ejecutar una

sentencia con la siguiente sintaxis:

DROP TABLE <TABLE NAME>;

Por ejemplo, la siguiente sentencia borra la tabla ANTIQUES de la base de datos:

DROP TABLE ANTIQUES;



1.4 Creación de índices Los índices permiten al sistema gestor de base de datos acceder a los

datos de una manera más rápida, por lo que ayuda a disminuir el tiempo de respuesta de las consultas. El sistema crea una estructura de datos interna que retorna las filas de una consulta más rápidamente cuando dicha consulta se basa en las mismas columnas que el índice. El índice retorna al sistema gestor de base de datos el lugar exacto en su estructura de información en donde está almacenada una cierta fila dada, según las columnas de la consulta. Se parece mucho al sistema de glosario que utilizan los libros para localizar las palabras en las páginas que aparecen.

La sintaxis de la sentencia SQL de creación de índices es la siguiente:

CREATE [UNIQUE] INDEX <INDEX NAME>

ON <TABLE NAME> (<COLUMN LIST>);

Veamos un par de ejemplos de creación de índices en SQL:

CREATE INDEX OID_IDX ON ANTIQUEOWNERS (OWNERID);

CREATE INDEX NAME_IDX ON ANTIQUEOWNERS (OWNERLASTNAME, OWNERFIRSTNAME) ;

En el primer ejemplo, hemos creado un índice llamado OID_IDX en la tabla ANTIQUEOWNERS y sobre la columna OWNERID. Al hacer una consulta en la base de datos sobre la columna OWNERID, el índice permitirá que dicha consulta se ejecute más rápidamente. En el segundo caso hemos creado un índice sobre una tabla diferente, pero esta vez sobre dos columnas, OWNERLASTNAME y OWNERFIRSTNAME. El orden de las columnas en la definición del índice es esencial para que este funcione correctamente.

Algunos consejos para la creación de índices podrían ser:

a) Si una tabla posee un tamaño de algunos cientos de filas o más, es preferible indexarla. Una tabla grande con índices mejorará el tiempo de respuesta en las consultas.

b) Es mejor no crear más de dos o tres índices en una tabla. El exceso de índices incrementa el espacio de almacenamiento en disco y el tiempo de respuesta en las inserciones, el borrado y las actualizaciones de filas en la tabla.

c) Hay que indexar las columnas más utilizadas en las condiciones de consulta, no las que se consultan.



1.5 Borrado de índices Para borrar un índece se utiliza la siguiente sintaxis:

DROP INDEX <INDEX NAME>;

Así, por ejemplo:

DROP INDEX OID_IDX;

Borra el índice OID_IDX

1.6 Creación de secuencias Una secuencia es un conjunto de números generados

automáticamente. El contenido de una secuencia en cierto momento es un numérico que cambia según ciertos parámetros expuestos en su definición y que, según Oracle, es accesible en cierto momento por una sola sesión, y además, por cada acceso el valor de la secuencia cambia.

Así, es lo que se podría llamar un autonumérico, esto es, un objeto que por cada acceso retorna un número diferente. La sentencia SQL que define una secuencia es:

CREATE SEQUENCE <NOM_SEQUENCE>

[INCREMENT BY <integer>]

[START WITH <integer 2>]

[MAXVALUE <integer 3> | NOMAXVALUE]

[MINVALUE <integer 4> | NOMINVALUE]

[CYCLE |NOCYCLE]

[CACHE <integer 5> | NOCACHE]

[ORDER | NOORDER]

Dónde <NOM_SEQUENCE> es el nombre de la secuencia nueva, <integer> es la razón del incremento del autonumérico (decremento si es negativo), <integer 2> el valor inicial, <integer 3> el valor máximo a alcanzar, <integer 4> el valor mínimo posible, CYCLE permite que, una vez alcanzado el valor máximo o mínimo, se vuelva a empezar, <integer 5> especifica el número de valores a guardar en la caché de la secuencia (con el fin de acceder a ellos más rápidamente), y ORDER implica un orden en la demanda de los números de la secuencia.

Un ejemplo podría ser:



CREATE SEQUENCE cod_empresa

INCREMENT BY 1

START WITH 1

MAXVALUE 100000

MINVALUE 1

NOCYCLE

NOCACHE

ORDER;

Crea una secuencia que retornará un número que empieza po 1 y como máximo llegará hasta 100000 (ordenadamente).

El acceso a una secuencia se explica en la siguiente unidad.

1.7 Borrado de secuencias El borrado de una secuencia se realiza mediante la siguiente sentencia

SQL:

DROP SEQUENCE <NOM_SEQUENCE>;

Por ejemplo, la siguiente sentencia borra una secuencia llamada cod_empresa:

DROP SEQUENCE cod_empresa;

1.8 Dando privilegios de acceso Una tabla en Oracle es un objeto del repositorio. A medida que nos

vayamos adentrando en la filosofía de gestión de bases de datos Oracle, nos daremos cuenta de que existen muchos tipos de objetos. Por ejemplo, un índice o una secuencia, son objetos de Oracle.

Podría ocurrir que en cierto esquema tuviéramos una serie de objetos (propiedad del propietario del esquema), que queremos compartir. La compartición de un objeto se realiza dando privilegios de acceso sobre ese objeto a otro esquema, o incluso a un rol de Oracle. A continuación vamos a ver la sintaxis resumen de la sentencia SQL que permite asignar privilegios de acceso a objetos:

GRANT <LISTA_PRIV> ON <NOM_OBJ> TO <USUARIO>;

Dónde <LISTA_PRIV> es la lista de privilegios, serparados por comas. Podemos dar privilegios de acceso de consulta (SELECT), inserción (INSERT), actualización (UPDATE), y borrado (DELETE) sonbre una tabla, y de INDEX para indexar sobre una tabla. ALL da todos los privilegios sobre la tabla.



<NOM_OBJ> es el nombre del objeto sobre el que damos los privilegios, y <USUARIO> es el esquema al que se lo damos. PUBLIC crea privilegios del objeto sobre todos los usuarios de la base de datos.

Veamos un ejemplo:

GRANT SELECT,INSERT,UPDATE ON TABLA1 TO USU1;

La sentencia anterior, supuestamente ejecutada en el usuario propietario de la tabla TABLA1, da privilegios de lectura, inserción y actualización de datos en TABLA1 al esquema USU1.

1.9 Quitando privilegios de acceso Igual que damos privilegios de acceso, los podemos quitar (siempre

sonbre objetos propiedad del que otorga o deniega el privilegio). La sintaxis resumida es la siguiente:

REVOKE <LISTA_PRIV> ON <NOM_OBJ> FROM <USUARIO>;

Dónde <LISTA_PRIV> es la lista de privilegios, serparados por comas. En este caso ocurre lo mismo que antes, esto es, podemos quitar privilegios de acceso de consulta (SELECT), inserción (INSERT), actualización (UPDATE), y borrado (DELETE) sonbre una tabla, y de INDEX sobre un índice.

<NOM_OBJ> es el nombre del objeto sobre el que quitamos los privilegios, y <USUARIO> es el esquema al que se lo quitamos.

Por ejemplo:

REVOKE INSERT,UPDATE ON TABLA1 FROM USU1;

La sentencia anterior, supuestamente ejecutada en el usuario propietario de la tabla TABLA1, quita los privilegios de inserción y actualización de datos en TABLA1 al esquema USU1.

1.10 Creación de sinónimos Un sinónimo es un nombre alternativo para un objeto, por ejemplo

una tabla. Un sinónimo es otro objeto en sí, por lo que podríamos crear un sinónimo de otro sinónimo.

Para crear un sinónimo, existe la siguiente sentencia SQL:

CREATE SYNONYM <NOM_SYN> FOR <NOM_OBJ>;

Dónde <NOM_SYN> es el nombre del sinónimo, y <NOM_OBJ> es el nombre del objeto sobre el que estoy creando del sinónimo. Veamos un ejemplo:

CREATE SYNONYM TABLA1 FOR USU0.TABLA1;



Este ejemplo, crea un sinónimo TABLA1 sobre la TABLA1 del esquema USU0, en el esquema que ejecuta la sentencia.

En Oracle, la identificación de un objeto se realiza mediante la siguiente sintaxis:

SCHEMA.OBJECT @ DBLINK

Dónde SCHEMA es el nombre del esquema (usuario), OBJECT es el nombre del objeto (el nombre de una tabla, por ejemplo), y DBLINK (conocido como Database Link) es el nombre de un enlace a una base de datos remota. Por ejemplo, supongamos que la base de datos ORCL, contiene la tabla EJEMPLO, en el esquema JAVI. La manera de referenciarla es:

JAVI.EJEMPLO @ ORCL

Así, supongamos que ejecutamos en el esquema JAVI la siguiente sentencia:

GRANT SELECT ON EJEMPLO TO LUIS;

Esta sentencia permitirá al esquema LUIS consultar los registros de la tabla EJEMPLO de JAVI.

Entonces, para referenciar la tabla EJEMPLO desde LUIS, debemos emplear el nombre JAVI.EJEMPLO. Sin embargo, si quisiéramos emplear otro nombre (sólo EJEMPLO, en vez de JAVI.EJEMPLO) deberíamos crear el siguiente sinónimo:

CREATE SYNONYM EJEMPLO FOR JAVI.EJEMPLO;

1.11 Borrado de sinónimos Podemos borrar un sinónimo con la siguiente sentencia SQL:

DROP SYNONYM <NOM_SYN>;

Por ejemplo:

DROP SYNONYM EJEMPLO;

Borra el sinónimo EJEMPLO del repositorio.

1.12 Vaciar una tabla Podemos vaciar una tabla con la sentencia siguiente:

TRUNCATE TABLE <NOM_TAB>;

Por ejemplo:

TRUNCATE TABLE EMP;



2 UNIDAD 3: DML LENGUAJE

DE MANIPULACIÓN DE

DATOS

Objetivo general de la unidad Aprender a insertar, borrar, actualizar y consultar datos de tablas.

Objetivos específicos Hacer énfasis en las consultas de datos y los métodos de desarrollo de

consultas.

Contenidos Inserción, actualización, borrado y consulta (con todas sus

posibilidades) de datos en las tablas.


Cuaderno de notas


Actividades Seguir las sesiones prácticas y realizar los ejercicios correspondientes a

los conceptos de la unidad.


2.1 Introducción Acabamos de ver las sentencias básicas necesarias para crear bases de

datos relacionales. A continuación, veremos cómo es posible, insertar, borrar, actualizar y consultar datos de las tablas creadas mediante sentencias SQL.

2.2 Inserción de datos La sentencia SQL para insertar datos en una tabla tiene la siguiente

sintaxis:

INSERT INTO <TABLE NAME> [(<COLUMN LIST>)] VALUES (<VALUE LIST>);

Dónde <TABLE NAME> es el nombre de la tabla en dónde queremos insertar los datos, <COLUMN LIST> es la lista, separada por comas, de las columnas de la tabla que queremos insertar, y <VALUE LIST> es la lista, también separada por comas, de los valores a introducir en las columnas especificadas. Los valores se insertarán en las columnas según el orden de <COLUMN LIST>.

Veamos un ejemplo:

INSERT INTO ANTIQUES VALUES (21, 01, 'Ottoman', 200.00);

Al no especificar la lista de columnas, el intérprete de SQL toma por defecto todas las columnas de la tabla y en el orden de éstas (por lo general el orden de creación de las columnas en la tabla).

INSERT INTO ANTIQUES (BUYERID, SELLERID, ITEM) VALUES (01, 21, 'Ottoman');

En este ejemplo, podemos ver como es fácil insertar datos en una tabla en el orden que queramos, siempre que especifiquemos dicho orden en la lista de columnas a insertar.

2.3 Borrar datos La sentencia SQL que borra filas de una tabla tiene la siguiente

sintaxis:

DELETE FROM <TABLE NAME> WHERE <CONDITION>;

Dónde <TABLE NAME> es el nombre de la tabla de la cuál queremos borrar filas y <CONDITION> es la condición que cumplirán todas las filas que queremos borrar. Veamos un ejemplo:

DELETE FROM ANTIQUES WHERE ITEM = 'Ottoman';



La sentencia anterior borra todas la filas de la tabla ANTIQUES que cumplan la condición de que en la columna ITEM tengan exactamente el valor ‘Ottoman’. Veamos otro ejemplo:

DELETE FROM ANTIQUES WHERE ITEM = 'Ottoman' AND BUYERID = 01 AND SELLERID = 21;

En este caso, borraremos sólo las filas de la tabla que cumplan que la columna ITEM sea exactamente ‘Ottoman’, y que la columna BUYERID sea 01 y que la columna SELLERID sea 21.

2.4 Actualización de datos La siguiente sentencia SQL permite actualizar los datos de una o varias

filas, dependiendo de la condición de actualización:

UPDATE <TABLE NAME> SET <COLUMN_1 NAME> = <VALUE_1>, <COLUMN_2 NAME> = <VALUE_2>, ... [WHERE <CONDITION>];

<TABLE NAME> es el nombre de la tabla en donde están los datos que queremos actualizar, <COLUMN_1 NAME> es el nombre de la primera columna que queremos actualizar y <VALUE_1> el nuevo valor que queremos actualizar. Es posible actualizar todas las columnas de una tabla en una misma sentencia. Por otra parte, para actualizar las filas de una tabla, es necesario especificar mediante una condición cuales, de entre todas las de la tabla, van a ser actualizadas, por lo que si es necesario, habrá que añadir una condición como se ve en <CONDITION>.

Veamos un ejemplo:

UPDATE ANTIQUES SET PRICE=500.00 WHERE ITEM = 'Chair';

La sentencia anterior actualiza, de la tabla ANTIQUES, la columna PRICE a 500.00, de todas las filas en las que la columna ITEM sea ‘Chair’.



2.5 Consultas En las bases de datos relacionales, los datos se guardan en tablas como

la siguiente:

EmployeeAaddressTable

SSN FirstName LastName Address City State

512687458 Joe Smith 83 First Street Howard Ohio

758420012 Mary Scott 842 Vine Ave Losantiville Ohio

102254896 Sam Jones 33 Elm St Paris New York

876512563 Sarah Ackerman 440 U.S. 110 Upton Michigan

La sintaxis de una sentencia de consulta podría resumirse en:

SELECT [DISTINCT|ALL] <LIST OF COLUMNS, FUNCTIONS, CONSTANTS, ETC.>

FROM <LIST OF TABLES OR VIEWS>

[WHERE <CONDITION(S)>]

[GROUP BY <GROUPING COLUMN(S)>]

[HAVING <CONDITION>]

[ORDER BY <ORDERING COLUMN(S)> [ASC|DESC]];

Veamos un ejemplo para comprender las consultas:

SELECT FirstName, LastName, Address, City, State

FROM EmployeeAddressTable;

El ejemplo anterior nos retornaría una porción de la tabla de ejemplo, de la siguiente manera:

FirstName LastName Address City State

Joe Smith 83 First Street Howard Ohio

Mary Scott 842 Vine Ave Losantiville Ohio

Sam Jones 33 Elm St Paris New York

Sarah Ackerman 440 U.S. 110 Upton Michigan

Acabamos de consultar la tabla EmployeeAddressTable, solicitando todas las filas, pero únicamente, por cada fila, las columnas FirstName, LastName, Address, City y State.



Si quisiéramos consultar todas las columnas de una tabla, bastaría con utilizar la siguiente sintaxis:

SELECT * FROM <TABLE NAME>;

Supongamos ahora que tenemos la siguiente tabla:

EmployeeStatisticsTable

EmployeeIDNo Salary Benefits Position

010 75000 15000 Manager

105 65000 15000 Manager

152 60000 15000 Manager

215 60000 12500 Manager

244 50000 12000 Staff

300 45000 10000 Staff

335 40000 10000 Staff

400 32000 7500 Entry-Level

441 28000 7500 Entry-Level

Y veamos el siguiente ejemplo de consulta:

SELECT EMPLOYEEIDNO

FROM EMPLOYEESTATISTICSTABLE

WHERE SALARY >= 50000;

El resultado de la consulta nos devolverá el contenido de la columna EMPLOYEEIDNO de todas las filas que cumplan la condición siguiente: que el contenido de la columna SALARY sea mayor o igual a 50000.

El resultado de la consulta será el siguiente:

EMPLOYEEIDNO

010

105

152

215

244



Una condición o filtro de una consulta es un conjunto de sentencias lógicas unidas mediante operadores lógicos y/o relacionales. Los operadores relacionales que permite SQL en su sintaxis son:

= Igual

¡= ó <> Diferente

< Menor que

> Mayor que

<= Menor o igual que

>= Mayor o igual que

BETWEEN ... AND ... Entre ... y ...

IS NULL Es nulo

IN(lista) EN (lista)

LIKE Como

Veamos el siguiente ejemplo:

SELECT EMPLOYEEIDNO


WHERE POSITION = 'Manager';

Este ejemplo retorna el contenido de la columna EMPLOYEEIDNO de todas aquellas filas de la tabla del ejemplo que contengan en la columna POSITION el valor ‘Manager’.

Veamos otro ejemplo:

SELECT EMPLOYEEIDNO


WHERE POSITION IS NULL;

La consulta retornará aquellas filas que contengan la columna POSITION de la tabla EMPLOYEESTATISTICSTABLE vacía.



A continuación veremos una tabla de evaluación en dónde están involucrados valores a NULL:

Si A es: Condición: Resultado:

10 A IS NULL FALSE

10 A IS NOT NULL TRUE

NULL A IS NULL TRUE

NULL A IS NOT NULL FALSE

10 A = NULL UNKNOWN

10 A ¡= NULL UNKNOWN

NULL A = NULL UNKNOWN

NULL A ¡= NULL UNKNOWN

NULL A = 10 UNKNOWN

NULL A ¡= 10 UNKNOWN

Por otra parte, existen tres operadores lógicos que unen las condiciones, que son AND (y), OR (o) y NOT (negación). El operador AND une varias condiciones y en una consulta retorna el número de filas que cumplen todas las condiciones.

Por ejemplo:

SELECT EMPLOYEEIDNO


WHERE SALARY > 40000 AND POSITION = 'Staff';

Retorna el contenido de la columna EMPLOYEEIDNO de las filas cuya columna SALARY es mayor de 40000 y además cuya columna POSITION es igual a ‘Staff’.

El operador lógico OR une varias condiciones, pero en una consulta retorna aquellas filas que cumplen cualquiera de las condiciones unidas. Por ejemplo:

SELECT EMPLOYEEIDNO


WHERE SALARY < 40000 OR BENEFITS < 10000;

En este caso, la consulta retornará el contenido de la columna EMPLOYEEIDNO de las filas que, o bien la columna SALARY sea menor que 40000, o bien la columna BENEFITS sea menor que 10000.



Obviamente, es posible combinar AND y OR en una misma consulta. Veamos un ejemplo:

SELECT EMPLOYEEIDNO


WHERE (POSITION = 'Manager' AND SALARY > 60000)

OR BENEFITS > 12000;

La consulta retorna el valor de la columna EMPLOYEEIDNO de las filas que cumplan, o bien que la columna POSITION es ‘Manager’ y que SALARY es mayor que 60000, o bien que la columna BENEFITS es mayor que 12000. Veamos ahora el siguiente ejemplo:

SELECT EMPLOYEEIDNO


WHERE POSITION = 'Manager'

AND (SALARY > 60000 OR BENEFITS > 12000);

La consulta retorna el valor de la columna EMPLOYEEIDNO de las filas que cumplan que la columna POSITION es ‘Manager’ y que, o bien SALARY es mayor que 60000, o bien que la columna BENEFITS es mayor que 12000. Fijémonos en que ambas consultas podrían devolvernos diferentes resultados, ya que el orden de ejecución (que depende de los paréntesis) condiciona totalmente los resultados.

Un ejemplo de consulta utilizando el operador IN podría ser el siguiente:

SELECT EMPLOYEEIDNO


WHERE POSITION IN ('Manager', 'Staff');

La consulta retornará los valores de las filas que cumplan que la columna POSITION sea o bien ‘Manager’, o bien ‘Staff’. Este operador se comporta más como lógico que como relacional. Sin embargo, el operador BETWEEN aplica una mezcla entre ambos tipos de operadores:

SELECT EMPLOYEEIDNO


WHERE SALARY BETWEEN 30000 AND 50000;

Retorna los valores de las filas que cumplen que la columna SALARY está entre 30000 y 50000.



Por último, el operador NOT, niega el contenido de la condición, como en el siguiente ejemplo:

SELECT EMPLOYEEIDNO


WHERE SALARY NOT (BETWEEN 30000 AND 50000);

En donde las filas seleccionadas son aquellas que no cumplen que la columna SALARY contengá valores entre 30000 y 50000.

El operador relacional LIKE permite seleccionar las filas cuyo campo en la condición no coincida exactamente, sino en parte con una cadena constante. Por ejemplo:

SELECT EMPLOYEEIDNO


WHERE LASTNAME LIKE 'L%';

La consulta retornará aquellas filas cuya columna LASTNAME contenga una cadena que se inicie con ‘L’. El símbolo % se usa como comodín, para indicar que no importa el resto de la cadena. Una condición del tipo LASTNAME LIKE ‘%L’ retoraría aquellas filas cuya columna LASTNAME acabara en ‘L’. Incluso la condición LASTNAME=’%L%’ es posible, y retornaría aquellas filas cuya columna LASTNAME contuviera una ‘L’. El carácter _ sustituye a un carácter comodín en lugar de a una cadena.

2.6 Enlaces Supongamos que en nuestra base de datos tenemos las siguientes

tablas llenas de la siguiente manera.

AntiqueOwners

OwnerID OwnerLastName OwnerFirstName

01 Jones Bill

02 Smith Bob

15 Lawson Patricia

21 Akins Jane

50 Fowler Sam



Orders

OwnerID ItemDesired

02 Table

02 Desk

21 Chair

15 Mirror

Antiques

SellerID BuyerID Item

01 50 Bed

02 15 Table

15 02 Chair

21 50 Mirror

50 01 Desk

01 21 Cabinet

02 21 Coffee Table

15 50 Chair

01 15 Jewelry Box

02 21 Pottery

21 02 Bookcase

50 01 Plant Stand

En las tablas anteriores podemos ver como OwnerID es clave foránea de la tabla ORDERS (un propietario puede tener varios pedidos). Además, en la tabla ANTIQUES, SellerID y BuyerID son claves foráneas referenciadas desde la columna OwnerID de la tabla ANTIQUEOWNERS.

A continuación veremos ejemplos de cómo crear enlaces entre valores de columnas de diferentes tablas (enlaces de claves foráneas o integridad referencial).



Para consultar los nombres de los que han comprado una silla, realizaremos la siguiente sentencia:

SELECT OWNERLASTNAME, OWNERFIRSTNAME

FROM ANTIQUEOWNERS, ANTIQUES

WHERE BUYERID = OWNERID

AND ITEM = 'Chair';

Hay que fijarse en que el truco se basa en crear una condición en la que se igualan las dos claves de las tablas que están unidas por una relación. Por otra parte, al estar utilizando dos columnas de diferentes tablas, es necesario que ambas tablas estén incluidas en la consulta.

El resultado de la consulta es:

OWNERLASTNAME OWNERFIRSTNAME

Smith Bob

Fowler Sam

¿Qué pasa si ambas columnas se llaman de la misma manera?. Por ejemplo, supongamos el caso en que quisiéramos consultar los nombres y apellidos de aquellos propietarios que tuvieran algún pedido:

SELECT OWNERLASTNAME, OWNERFIRSTNAME

FROM ANTIQUEOWNERS, ORDERS

WHERE OWNERID = OWNERID;

Esta sentencia está mal escrita ya que posee una ambigüedad en las columnas y no se garantiza que devuelva lo que queremos. Así, podemos referenciar las columnas de una tabla escribiendo <NOMBRE_TABLA>.<NOMBRE_COLUMNA>.

El ejemplo anterior quedaría de la siguiente manera:

SELECT ANTIQUEOWNERS.OWNERLASTNAME,

ANTIQUEOWNERS.OWNERFIRSTNAME

FROM ANTIQUEOWNERS, ORDERS

WHERE ANTIQUEOWNERS.OWNERID =

ORDERS.OWNERID;



Además, podemos definir alias tanto para las columnas como para las tablas. Por ejemplo:

SELECT OWNERLASTNAME apellido, OWNERFIRSTNAME

nombre FROM ANTIQUEOWNERS tab1, ORDERS tab2

WHERE tab1.OWNERID=tab2.OWNERID;

El resultado de esta consulta devolverá un conjunto de filas y podremos referenciar cada columna mediante el alias (apellido y nombre, respectivamente). El resultado de la anterior consulta nos queda, por tanto:

apellido nombre

Smith Bob

Smith Bob

Akins Jane

Lawson Patricia

Como se puede apreciar en el ejemplo, al hacer ciertas consultas con enlaces derivados de relaciones, es posible que se retornen filas duplicadas. Para evitarlo, podemos utilizar la clausula DISTINCT, como en el ejemplo:

SELECT DISTINCT OWNERLASTNAME apellido, OWNERFIRSTNAME nombre

FROM ANTIQUEOWNERS tab1, ORDERS tab2

WHERE tab1.OWNERID=tab2.OWNERID;

Supongamos además, un ejemplo en donde queremos que las filas nos sean retornadas de la base de datos ordenadas según cierto criterio. Un buen ejemplo sería la consulta de identificador, nombre y apellidos de los vendedores de anticüedades, que no sólo se repiten y lo que queremos es que no se repitan, sino que además, queremos que las filas de la consulta estén ordenadas por apellido y nombre. Para ello, hay que utilizar la cláusula ORDER BY <LISTA_COLUMNAS> DESC|ASC al final de la sentencia SELECT. <LISTA_COLUMNAS> es el nombre de las columnas (o aliases de columnas) separadas por comas, por los que queremos que ordene las filas. Esta clausula admite que el orden sea descendente (DESC) o ascendente ASC. Si no especificamos el tipo de orden, se presupone ascendente:



SELECT DISTINCT SELLERID, OWNERLASTNAME, OWNERFIRSTNAME

FROM ANTIQUES, ANTIQUEOWNERS

WHERE SELLERID = OWNERID

ORDER BY OWNERLASTNAME, OWNERFIRSTNAME;

2.7 Subconsultas Una subconsulta es una sentencia de consulta incluida dentro de otra.

Como ya hemos visto antes, las clausulas SELECT, permiten restringir las filas de la consulta con un operador relacional que permite ver si el valor de cierta columna está incluido en cierto conjunto de valores. Estamos hablando del operador IN, y su utilización puede verse mediante el siguiente ejemplo:

SELECT OWNERLASTNAME

FROM ANTIQUEOWNERS t1, ORDERS t2

WHERE t1.OWNERID=t2.OWNERID

AND ITEMDESIRED IN (‘Chair’,’Mirror’);

Esta consulta retorna aquellas apellidos de los ANTIQUEOWNERS que tengan algún ORDER y cuyo ITEMDESIRED esté en el conjunto especificado (‘Chair’,’Mirror’). Esta sentencia se puede reescribir mediante el operador lógico OR.

Sin embargo, puede haber ocasiones en que sea necesario especificar un conjunto de valores que son el resultado de otra consulta. En estos casos, en vez de escribir entre paréntesis la lista de los valores posibles, es posible poner una sentencia SELECT (la subconsulta de la que hablábamos). Por ejemplo:

SELECT OWN.OWNERLASTNAME Last Name, ORD.ITEMDESIRED Item Ordered

FROM ORDERS ORD, ANTIQUEOWNERS OWN

WHERE ORD.OWNERID = OWN.OWNERID

AND ORD.ITEMDESIRED IN

(SELECT ITEM

FROM ANTIQUES);



Esta sentencia retorna lo siguiente:

Last Name Item Ordered

Smith Table

Smith Desk

Akins Chair

Lawson Mirror

Debemos destacar:

1.- Hemos creado aliases especiales para identificar mejor el resultado de las columnas en cada fila.

2.- Hemos creado también aliases para los nombres de las tablas, con el fin de eliminar la ambigüedad.

3.- Al ejecutarse la subconsulta, el operador IN (equivalente a un montón de condiciones OR) permite que la consulta geeral retorne todos los items deseeados por los propietarios, sea el que sea, ya que la subconsulta nos asegura que el item pertenecerá a la tabla de antigüedades.

4.- No es posible crear una subconsulta que retorne más de una columna, o una columna que no sea del mismo tipo de la que precede al operador IN.

Ya que acabamos de ver las subconsultas, saber que:

a) Podemos utilizar una subconsulta dentro de una consulta, no sólo a través del operador IN, también es posible hacerlo a través de otros operadores (incluso algunos los veremos más adelante), como =, aunque en este caso la subconsulta debe retornar un único valor (no varias filas).

b) Es posible crear una tabla nueva (en columnas y contenido) mediante la sentencia CREATE TABLE tabla AS SELECT ...; donde la subconsulta determinará tanto las columnas de la nueva tabla como las filas que contendrá ésta. Fijémonos que una consulta puede implicar a varias tablas, por lo que podemos crear tablas especiales mezclando columnas de varias tablas.

c) Es posible insertar masivamente filas de una tabla a través del comando INSERT INTO tabla(col1,col2,...) SELECT ...; donde las columnas de la subconsulta deben coincidir en número, orden y tipo con col1,col2,... del comando INSERT.

d) Es posible realizar una actualización de una o varias columnas de una tabla mediante el comando UPDATE tabla SET col1=(SELECT ...) WHERE ...;, o bien mediante UPDATE tabla SET (col1,col2, ...)=(SELECT ...) WHERE ...;, dónde si sólo actualiamos una columna, la subconsulta ha de retornar una sola columna, mientras que si



actualizamos varias, la subconsulta retornará el mismo número de columnas, en el orden adecuado y del tipo adecuado.

2.8 Fuciones de agrupación Una función de agrupación es una función que se aplica sobre un

parámetro (por lo general una columna de una consulta) y que permite agrupar el valor de la columna aplicando una función, y retorna un único registro en vez de un conjunto de registros.

En Oracle existen varias funciones de agrupación, y estudiaremos las siguientes:

a) SUM (COLUMN): Retorna la suma total del valor de la columna COLUMN en todas las filas de la consulta. Obviamente el valor de la columna debe ser numérico.

b) AVG (COLUMN): Retorna la media de los valores de la columna COLUMN de todas las filas de la consulta.

c) MAX (COLUMN): Retorna el valor máximo de la columna COLUMN de todas las filas de la consulta.

d) MIN (COLUMN): Retorna el valor mínimo de la columna COLUMN de todas las filas de la consulta.

e) COUNT(‘x’): Retorna el número de filas de la consulta.

Veamos algunos ejemplos:

SELECT SUM(SALARY), AVG(SALARY)

FROM EMPLOYEESTATISTICSTABLE;

Esta consulta retorna el total de todos los salarios de la tabla EMPLOYEESTATISTICSTABLE y el salario medio de todas las filas.

SELECT MIN(BENEFITS)


WHERE POSITION = 'Manager';

Esta consulta retorna el mínimo beneficio que ha obtenido un empleado del tipo ‘Manager’.

SELECT COUNT(‘x’)


WHERE POSITION = 'Staff';

Esta consulta retorna el número de empleados cuya posición es ‘Staff’.



2.9 Las Cáusulas GROUP BY y HAVING Si en una consulta queremos agrupar (aplicar una función de

agrupación como podría ser COUNT), a un determinado conjunto de filas de una consulta (no a todas) y somos capaces de identificar de manera diferente a cada grupo, podemos emplear la cláusula GROUP BY.

Supongamos, por ejemplo, que queremos saber el precio de la antigüedad más cara que ha comprado cada propietario (BUYERID). Un propietario puede haber comprado varias, pero queremos saber la más cara de cada uno:

SELECT BUYERID, MAX(PRICE)

FROM ANTIQUES

GROUP BY BUYERID;

Supongamos que queremos añadir una condición especial a la consulta, de manera que además de agrupar, queremos condicionar las filas en función de la propia columna agrupada. En ese caso utilizaremos la cláusula HAVING como en el siguiente ejemplo:

SELECT BUYERID, MAX(PRICE)

FROM ANTIQUES

GROUP BY BUYERID

HAVING PRICE > 1000;

El resultado de la consulta es el mismo que la del anterior ejemplo, pero sólo sacará aquellas filas cuyo precio sea superior a 1000.

Obviamente, Oracle permite combinar las cáusulas WHERE y HAVING dentro de una misma sentencia SELECT. En este caso, Oracle procede de la siguiente manera:

1º).- Aplica WHERE a las filas seleccionadas.

2º).- Forma los grupos y calcula las funciones de grupo.

3º).- Aplica la cláusula HAVING a los grupos seleccionados.

2.10 Combinación con Subconsultas Podemos combinar subconsultas con funciones de agrupación, como

en el siguiente ejemplo, que listamos todos aquellos compradores, cuyo precio de las antigüedades supere estrictamente en 100 unidades monetarias la media del precio de todas las antigüedades:



SELECT BUYERID

FROM ANTIQUES

WHERE PRICE >

(SELECT AVG(PRICE) + 100

FROM ANTIQUES);

El siguiente ejemplo, combina una consulta con una subconsulta con una cláusula DISTINCT. Concretamente lista los apellidos de los propietarios de las antigüedades que son compradores de alguna en la tabla ANTIQUES:

SELECT OWNERLASTNAME

FROM ANTIQUEOWNERS

WHERE OWNERID IN

(SELECT DISTINCT BUYERID

FROM ANTIQUES);

Recordemos que es posible utilizar de la misma forma, sentencias SELECT (como subconsultas) en la sentencia de actualización. En el siguiente ejemplo, actualizaremos el nombre de la persona que ha comprado una antigüedad de tipo ‘Bookcase’:

UPDATE ANTIQUEOWNERS

SET OWNERFIRSTNAME = 'John'

WHERE OWNERID =

(SELECT BUYERID

FROM ANTIQUES

WHERE ITEM = 'Bookcase');

Tan sólo hacer énfasis en que si tenemos una subconsulta incluida en la parte del WHERE de una consulta, la sentencia SELECT de la subconsulta debe coincidir en número y tipo de datos con las columnas que se pretenden asociar a la subconsulta en la parte del WHERE.

2.11 Las Cláusulas EXISTS, ALL y ANY La cláusula EXISTS utiliza una subconsulta como condición, dónde la

condición es cierta si la subconsulta retorna alguna fila, y falsa si no retorna ninguna. En el siguiente ejemplo, visualizaremos los nombres y apellidos de las personas que hayan comprado una antigüedad de tipo ‘Chair’:



SELECT OWNERFIRSTNAME, OWNERLASTNAME

FROM ANTIQUEOWNERS

WHERE EXISTS

(SELECT *

FROM ANTIQUES

WHERE ITEM = 'Chair');

La cláusula ALL es más fácil de explicar con un ejemplo. Supongamos que tenemos la siguiente consulta:

SELECT BUYERID, ITEM

FROM ANTIQUES

WHERE PRICE >= ALL

(SELECT PRICE

FROM ANTIQUES);

El resultado de la consulta devolverá la fila o filas (identificador del comprador y antigüedad) que sea o sean más caras. La subconsulta retorna todos los precios de las antigüedades y la consulta general (mediante la cláusula WHERE) va mirando que se cumpla para cada una de las antigüedades, que su precio sea mayor o igual que cada uno de los precios que retorna la subconsulta. Si cumple que el precio es mayor o igual para todos los casos que devuelva la subconsulta, entonces retorna la fila, sino excluye la fila.

Un ejemplo con la cláusula ANY, podría ser el siguiente:

SELECT * FROM EMP

WHERE SAL=ANY

(SELECT SAL FROM EMP WHERE DEPTNO=30);

Retorna todos los datos de los empleados cuyo salario es igual a alguno de los salarios de los empleados del departamento número 30. En este caso, no se debe cumplir la subconsulta para cada fila retornada por ésta, sino que basta que se cumpla para una fila cualquiera.

2.12 Unión, intersección y resta entre consultas

Hay ocasiones en que puede ser útil realizar la unión, intersección o resta de las filas derivadas de una serie de consultas. SQL nos permite realizar estas operaciones mediante UNION, INTERSECT y MINUS. Veamos a continuación un ejemplo de cada una:



SELECT BUYERID

FROM ANTIQUES

UNION

SELECT OWNERID

FROM ORDERS;

Une los valores de las columnas BUYERID de ANTIQUES y OWNERID de ORDERS en una sola consulta. El número de columnas de dos sentencias de consulta unidas debe ser el mismo, además de que en el orden deben coincidir en el tipo. En el ejemplo anterior, BUYERID y OWNERID son del mismo tipo. La cláusula UNION elimina automáticamente los duplicados, como debería ser en una unión lógica de conjuntos de filas. En el caso de querer mantener filas duplicadas, utilizaríamos UNION ALL.

La intersección y la resta se usan de manera similar, usando INTERSECT y MINUS, respectivamente.

2.13 Outer Joins Para entender el concepto de Outer Join, empezaremos explicando el

siguiente ejemplo de consulta:

SELECT OWNERID, 'is in both Orders & Antiques'

FROM ORDERS, ANTIQUES

WHERE OWNERID = BUYERID

UNION

SELECT BUYERID, 'is in Antiques only'

FROM ANTIQUES

WHERE BUYERID NOT IN

(SELECT OWNERID

FROM ORDERS);

La primera consulta retorna los valores de la columna OWNERID de la tabla ORDERS que cumplen la condición de estar además en ANTIQUES (son compradores). La unión nos permite añadir a la lista las filas de la segunda consulta, que retorna la lista de los compradores que no están en la tabla ORDERS.

Hay casos de consultas en que, sin utilizar UNION, ni consultas poco óptimas para el motor de base de datos, es posible retornar un conjunto de filas similar al del ejemplo, es decir, realizando una “join” para



conseguir los identificadores de los propietarios que están en ORDERS y que cuya clave foránea puede ser nula en la tabla ANTIQUES.

Supongamos ahora el caso de la típica relación maestro-detalle, en donde un vendedor puede tener cero o varios clientes. Si listamos la lista de vendedores partiendo de la lista de clientes, habrá vendedores que no aparecerán. Por ejemplo:

SELECT NOMCLI,APECLI,NOMVEN,APEVEN

FROM CLIENTES,VENDEDORES

WHERE CLIENTES.IDVEN=VENDEDORES.IDVEN;

Está claro que los vendedores que no tienen clientes no saldrían listados.

Una “outer join” se utiliza para que la consulta retorne toda la lista de vendedores, incluso los que no tienen clientes, poniendo un nulo en el lugar de su nombre y apellido. La sintaxis de Oracle se ve en el anterior ejemplo resuelto:

SELECT NOMCLI,APECLI,NOMVEN,APEVEN

FROM VENDEDORES,CLIENTES

WHERE CLIENTES.IDVEN(+)=VENDEDORES.IDVEN;

Veamos un ejemplo más. Supongamos la siguiente tabla de empleados EMPLOYEE:

Name Department

1 10

2 10

3 20

4 30

5 30

Y supongamos la tabla de departamentos DEPARTMENT:

Department

10

20

30

40

Supongamos ahora que queremos enlazar las tablas, lanzando una consulta de todos los empleados y todos los departamentos. Si nos



fijamos en las tablas anteriores, el departamento 40 no tiene empleados, por lo que queremos que aparezca sin empleados (vacío). Para ello, tendremos que incluir una “outer join”:

SELECT E.NAME, D.DEPARTMENT

FROM DEPARTMENT D, EMPLOYEE E

WHERE E.DEPARTMENT(+) = D.DEPARTMENT;

Obteniendo el siguiente resultado:

Name Department

1 10

2 10

3 20

4 30

5 30

40

2.14 Funciones de SQL En las consultas, podemos aplicar directamente funciones especiales

de tratamiento de valores, con el fin de obtener directamente resultados apropiados. Existen funciones matemáticas que se aplican a valores numéricos, funciones aplicadas a cadenas de caracteres que retornan cadenas o números, funciones de fechas,y funciones de conversión entre tipos de datos Oracle. Veremos algunas de ellas.

2.14.1 Funciones Matemáticas - ABS(n): Retorna el valor absoluto de n.

Ejemplo: SELECT ABS(-15) FROM DUAL;

Resultado: 15

- CEIL(n): Retorna el entero más pequeño mayor o igual que n

Ejemplo: SELECT CEIL(15.7) FROM DUAL;

Resultado: 16

- FLOOR(n): Retorna el entero más grande menor o igual a n.

Ejemplo: SELECT FLOOR(15.7) FROM DUAL;

Resultado: 15

- MOD(m,n): Retorna el resto de dividir m entre n. Retorna m si n es cero.



Ejemplo: SELECT MOD(11,4) FROM DUAL;

Resultado: 3

- POWER(m,n): Retorna m elevado a n (m y n pueden ser reales, pero si m es negativo, n debe ser entero).

Ejemplo: SELECT POWER(3,2) FROM DUAL;

Resultado: 9

- ROUND(n[,m]): Retorna n redondeado m veces contando desde el primer número después de la coma. n es un real, pero m debe ser un entero, y en el caso de ser negativo se redonceará a partir de la izquierda de la coma.

Ejemplo 1: SELECT ROUND(15.193,1) FROM DUAL;

Resultado 1: 15.2

Ejemplo 2: SELECT ROUND(15.193,-1) FROM DUAL;

Resultado 2: 20

- SIGN(n): Si n es menor que cero, retorna –1, si n es igual a cero, retorna 0, y si es mayor que cero, retorna 1.

Ejemplo: SELECT SIGN(-15) FROM DUAL;

Resultado: -1

- SQRT(n): Retorna la raíz cuadrada de n (que no puede ser negativo).

Ejemplo: SELECT SQRT(26) FROM DUAL;

Resultado: 5.09901951

- TRUNC(n[,m]): Retorna n truncado m lugares decimales. m puede ser negativo si queremos truncar hacia la izquierda de la coma.

Ejemplo 1: SELECT TRUNC(15.79,1) FROM DUAL;

Resultado 1: 15.7

Ejemplo 2: SELECT TRUNC(15.79,-1) FROM DUAL;

Resultado 2: 10

2.14.2 Funciones de caracteres que retornan caracteres

- UPPER(<string>): Convierte la cadena a mayúsculas.

Ejemplo: SELECT UPPER(‘Large’) FROM DUAL;

Resultado: LARGE



- LOWER(<string>): Convierte la cadena a minúsculas.

Ejemplo: SELECT LOWER(‘MR. SCOTT MCMILLAN’) FROM DUAL;

Resultado: mr. Scott mcmillan

- INITCAP(<string>): Convierte la cadena a letras capitales.

Ejemplo: SELECT INITCAP(‘the soap’) FROM DUAL;

Resultado: The Soap

- Concatenación <string>||<string>: Concatena cadenas.

Ejemplo: SELECT ‘Soy ‘||’un ‘||’melón’ FROM DUAL;

Resultado: Soy un melón

- LPAD(<string>,X,<string 2>): Añade a la parte izquierda de la cadena <string>, la cadena <string 2> tantas veces como sea necesario con el fin de que el resultado sean X caracteres.

Ejemplo: SELECT LPAD(‘Page 1’,15,’*.’) FROM DUAL;

Resultado: *.*.*.*.*Page 1

- RPAD(<string>,X,<string 2>): Añade a la parte derecha de la cadena <string>, la cadena <string 2> tantas veces como sea necesario con el fin de que el resultado sean X caracteres.

Ejemplo: SELECT RPAD(‘MORRISON’,12,’ab’) FROM DUAL;

Resultado: MORRISONabab

- SUBSTR(<string>,n,m): Retorna la cadena que comprende <string>, pero a partir del carácter n-esimo y m caracteres de longitud.

Ejemplo: SELECT SUBSTR(‘ABCDEF’,4,4) FROM DUAL;

Resultado: DEF

- REPLACE(<string>,<string 2>,<string 3>): Reemplaza en la cadena <string> la cadena <string2> por la cadena <string 3>.

Ejemplo: SELECT REPLACE(‘JACK and JUE’,’J’,’BL’) FROM DUAL;

Resultado: BLACK and BLUE



2.14.3 Funciones de caracteres que retornan números

- LENGTH(<string>): Retorna la longitud de la cadena (en número de caracteres).

Ejemplo: SELECT LENGTH(‘Candide’) FROM DUAL;

Resultado: 7

- INSTR(<string>,<string2>[,n[,m]]): Busca en la cadena <string>, a partir del carácter n-ésimo, la m-ésima ocurrencia de la cadena <string2>, y retorna la posición.

Ejemplo: SELECT INSTR(‘CORPORATE FLOOR’,’OR’,3,2) FROM DUAL;

Resultado: 14

2.14.4 Funciones de fechas - SYSDATE: Es una variable de Oracle que retorna el momento

exacto en el que estamos.

Ejemplo: SELECT SYSDATE FROM DUAL;

Resultado: 26-03-2000 12:07:48

- LAST_DAY(<date>): Retorna la fecha del último día del mes de <date>.

Ejemplo: SELECT LAST_DAY(SYSDATE) FROM DUAL;

Resultado: 31-03-2000

- TRUNC(<date>): Trunca la fecha <date>, restándole las horas, minutos y segundos.

Ejemplo: SELECT TRUNC(SYSDATE) FROM DUAL;

Resultado: 26-03-2000

2.14.5 Funciones de conversión - TO_CHAR (<date>[,<format>,[ ‘<nls_params>’ ]]): Retorna

una cadena de caracteres según <format> de la fecha <date> y aplicando los parámetros de conversión de <nls_param>. Podemos ver la lista de formatos posibles en la siguiente tabla:



Formato Significado

DAY Nombre del día

D Día de la semana

DD Día del mes

DDD Día del año

HH24 Hora del día

MI Minuto de la hora

MM Número de mes

MONTH Nombre del mes

SS Segundo del minuto

SSSSS Segundos transcurridos desde la medianoche

YYYY Año

<nls_params> será ‘NLS_DATE_LANGUAGE= lenguaje’, donde el lenguaje escogido será en el que deseemos convertir la fecha.

Ejemplo: SELECT TO_CHAR(SYSDATE,’MONTH DD, YYYY’) FROM DUAL;

Resultado: MARCH 27, 2000

- TO_CHAR(<number>,[<format>,[ ’<nls_params>’ ]]): Convierte un número en una cadena de caracteres. El formato a emplear para la conversión puede verse en la siguiente tabla:

Elemento Ejemplo Descripción

9 9999 Retorna el valor según el número de dígitos especificados, teniendo en cuenta que si el

número es negativo estará precedido por un “-“ y si es positivo estará precedido por un blanco.

0 0999 Retorna el valor según el número de dígitos especificados, de manera que si el número tiene menos cifras, pone ceros según el número de

ceros.

S S9999 Retorna “+” o “-“ en lugar de la S si el número es positivo o negativo, respectivamente.

FM FM9999 Retorna el número en el formato adecuado, pero sin insertar blancos delante ni detrás.



Ejemplo: SELECT TO_CHAR(‘FM0099’,297) FROM DUAL;

Resultado: 0297

- TO_DATE(<string>,[<format>,[ ’<nls_params>’ ]]): Convierte la cadena <string> en una fecha de Oracle, teniendo en cuenta los parámetros de <format> de fechas y <nls_params>.

Ejemplo: SELECT TO_DATE(‘26-03-2000’,’DD-MM-YYYY’) FROM DUAL;

Resultado: 26-03-2000 00:00:00

- TO_NUMBER(<string>,[<format>,[ ‘<nls_params>’ ]]): Convierte la cadena <string> a un numérico de Oracle según <format> numérico y <nls_params>.

Ejemplo: SELECT TO_NUMBER(‘0123’,’FM0999’) FROM DUAL;

Resultado: 123

2.14.6 Otras funciones - NVL(<column>,<value>): Retorna <column> si <column> no

es nulo, sino retorna <value>.

Ejemplo 1: SELECT NVL(NULL,’Melón’) FROM DUAL;

Resultado 1: Melón

Ejemplo 2: SELECT NVL(‘Sandía’,’Melón’) FROM DUAL;

Resultado 2: Sandía

- USERENV(‘<option>’): Retorna un valor diferente según la opción:

‘LANGUAGE’: Retorna el código del lenguaje actual de uso.

‘TERMINAL’: Retorna el sistema operativo del cliente que tiene abierta la sesión.

‘SESSIONID’: Retorna el número de sesión (número único por acceso).

‘INSTANCE’: Retorna el número de identificación de la instancia.

Ejemplo: SELECT USERENV(‘SESSIONID’) FROM DUAL;

Resultado: 6732



2.15 Acceso a secuencias El acceso a una secuencia se realiza mediante una consulta a una serie

de campos de la secuencia:

- CURRVAL: Retorna el valor actual de la secuencia.

- NEXTVAL: Incrementa la secuencia y retorna el valor siguiente.

Por ejemplo, para acceder al valor actual de la secuencia cod_empresa:

SELECT cod_empresa.CURRVAL FROM DUAL;

Podemos también insertar un valor nuevo en la tabla empresa mediante la secuencia cod_empresa:

INSERT INTO empresa(codigo,nombre)

VALUES(cod_empresa.NEXTVAL,’Nueva empresa’);

2.16 Optimización en las consultas a) Hay que evitar siempre que sea posible la aplicación directa de

funciones matemáticas y de otro tipo directamente en las columnas de una sentencia de consulta, ya que rompe los índices e incrementan el tiempo necesario del optimizador de las consultas, parte del motor de base de datos encargado de encontrar la mejor manera para acceder a los datos de la consulta.

b) Minimizar el número de columnas involucradas en la cláusula GROUP BY.

c) Las columnas involucradas en las “joins” (claves primarias y claves foráneas), deberían estar indexadas en ambas tablas.

d) En las consultas en las que es necesario contar los registros es más óptimo utilizar COUNT(‘x’) en lugar de COUNT(*) o COUNT(<column>).

2.17 Vistas Una vista es un objeto de la base de datos similar a un filtro. Una vista

es una consulta a la que podemos referenciar como si se tratara de una tabla (en modo lectura). De hecho, la sintaxis de creación de una vista es:

CREATE VIEW <VIEW NAME> AS <QUERY>;

Dónde <VIEW NAME> es el nombre de la vista y <QUERY> es una sentencia SQL de consulta. Veamos un ejemplo:

CREATE VIEW files_text AS SELECT filno,filname

FROM files WHERE filext=’TXT’;



Para crear una vista es necesario tener los privilegios de inserción, actualización, borrado y consulta de todas las tablas o vistas en las que está basada la nueva vista a crear. En el ejemplo anterior, deberíamos tener dichos privilegios sobre la tabla FILES.

Para borrar una vista, hay que utilizar la siguiente sentencia SQL:

DROP VIEW <VIEW NAME>;

Por ejemplo:

DROP VIEW luis.files_text;

2.18 Sentencias de control de transacciones Al realizar ciertas sentencias sobre la base de datos, la sentencia ocurre

localmente, es decir, para la sesión en curso. Por ejemplo, al insertar ciertos datos en una tabla mediante la sentencia INSERT, es posible consultar la tabla y ver que los datos existen, siempre que la consulta se realice desde la misma sesión que la que lanzó la sentencia INSERT. Sin embargo, tras ejecutar la inserción, los datos no existen si la consulta de esto se realiza desde otras sesiones. Para validar en la base de datos que una sentencia de este tipo tiene lugar de manera definitiva, para cualquier sesión actual o futura, es necesario utilizar la sentencia de control de transacciones COMMIT;

Si al realizar una transacción quisiéramos volver al estado anterior, es decir, deshacer los cambios, sería necesario, en lugar de validar, volver a atrás mediante el comando ROLLBACK;

El uso de los comandos COMMIT y ROLLBACK nos permite utilizar el verdadero concepto de transacción en las bases de datos, ya que una sesión puede realizar un conjunto de operaciones en serie, y al validarlas, el sistema gestor de base de datos tomará a dicho conjunto de operaciones como la transacción y garantizará su validación total y no por operaciones realizadas como parte de la transacción.

Oracle nos proporciona un conjunto de primitivas especiales para el control de la integridad de datos, no sólo implementando el concepto de transacción mediante los comandos citados, sino que es capaz de romper automáticamente deadlocks y además nos permite el tratamiento de bloqueos. Un bloqueo de datos puede realizarse a nivel de tabla o de conjunto de registros.

Para bloquear una tabla por un usuario hay que utilizar la siguiente sentencia SQL:

LOCK TABLE <TABLE NAME> IN <MODETYPE> MODE [NOWAIT];



El bloqueo de una tabla es causa directa de la posibilidad de compartición de datos. Puede ocurrir que en cierta ocasión sea necesario que otras sesiones de la base de datos puedan realizar operaciones sobre cierta o ciertas tablas o vistas. En ciertos casos, será necesario utilizar la sentencia anterior (para mantener la integridad de datos), teniendo en cuenta que <TABLE NAME> es el nombre de la tabla o vista a bloquear, <MODETYPE> es el tipo de modo de bloqueo, que puede ser ROW SHARE, ROW EXCLUSIVE, SHARE UPDATE, SHARE, SHARE ROW EXCLUSIVE y EXCLUSIVE. Oracle garantiza que sólo una de las sesiones ejecutará antes una sentencia LOCK TABLE, de manera que sólo una será la primera en coger en el modo especificado el acceso a la tabla. En el caso en que el resto de sesiones no deseen esperar a que la sesión que ha conseguido el poder del bloqueo, libere la tabla, hay que incluir la cláusula NOWAIT en la sentencia. La liberación de una tabla se realiza mediante el comando COMMIT.

Los tipos de modos se describen según la siguiente tabla:

Tipo Descripción

ROW SHARE Permite acceso concurrente a la tabla bloqueada, pero impide que otros usuarios bloqueen toda la tabla de manera exclusiva

ROW EXCLUSIVE Permite acceso concurrente a la tabla bloqueada, pero impide que otros usuarios bloqueen toda la tabla de manera exclusiva o también de manera compartida.

SHARE UPDATE Es lo mismo que ROW SHARE.

SHARE Permite el acceso concurrente a la tabla, pero impide que se actualicen datos en ésta.

SHARE ROW EXCLUSIVE Permite el acceso concurrente a la tabla, pero impide que se actualicen datos en ésta y que ésta sea bloqueada en modo exclusivo o compartido.

EXCLUSIVE Permite el acceso a la tabla mediante consulta, pero nada más.

Veamos un ejemplo:



LOCK TABLE emp IN EXCLUSIVE MODE NOWAIT;

Bloquea la tabla emp en modo exclusivo, pero no espera a que otro usuario la libere si la ha bloqueado antes, con el fin de tomar el control de ésta.

Para bloquear un conjunto de registros seleccionados de manera exclusiva, hay que utilizar la sentencia SELECT, añadiendo al final de ésta la cláusula FOR UPDATE OF. Por ejemplo:

SELECT * FROM emp WHERE deptno=30

FOR UPDATE OF SAL,COMM;

El ejemplo bloquea todas las filas de la tabla emp que cumplen que la columna deptno es igual a 30. Es obligatorio, tras ejecutar el SELECT...FOR UPDATE c1,c2,...cn; realizar una sentencia UPDATE que modifique los campos c1,c2,...,cn, esto es:

UPDATE emp SET sal=1.1*sal,comm=NULL

WHERE deptno=30;

COMMIT;

En el momento de realizar el UPDATE, se realiza un bloqueo exclusivo de toda la tabla.



3 UNIDAD 4: EJERCICIOS

Objetivo general de la unidad Tener ejemplos resueltos de ejercicios sobre el curso

Objetivos específicos Conseguir que el alumno asimile la filosofía SQL y su sintaxis.

Contenidos Enunciados de ejercicios a resolver en clase y de apoyo al resto de

unidades.


Cuaderno de notas

Introducción al lenguaje SQL Unidad 4: Ejercicios



Actividades Realizar los ejercicios en función de la teoría dada y corregirlos en

clase.


3.1 Ejercicios sobre DDL 1.- Supongamos que tenemos una tabla con la siguiente estructura:

Nombre: proj

Columnas: projno (numérico y no nulo), pname (carácter de, obligatoriamente, 10 dígitos), budget (numérico con, como máximo 8 dígitos enteros y dos decimales).

No hay clave primaria ni extrangeras.

Se pide: Implementar mediante SQL la tabla en una base de datos Oracle.

2.- Tras una serie de revisiones del análisis, se toma la decisión de que la columna budget puede llegar hasta nueve dígitos en su parte entera, pero la tabla ya ha sido creada en la base de datos.

Se pide: Modificar la tabla para que cumpla estas nuevas características, sin borrarla, por supuesto y razonar lo que pasaría si ésta ya contuviera datos.

3.- Tras otra serie de revisiones, se decide tomar a la columna projno como un numérico de nueve dígitos enteros y dos decimales, pero como NO obligatoria.

Se pide: Modificar la tabla para que dicha columna NO sea obligatoria con los cambios asociados al tipo de datos de dicha columna. Razonar la respuesta sobre las consecuencias de la modificación.

4.- Supongamos que tenemos una tabla (de nombre emp) a la que queremos añadir una columna (llamada projno1) de tipo numérico.

Se pide: Implementar en SQL la sentencia necesaria para realizar dicha modificación en la tabala emp (que ya existe). ¿Qué pasaría si quisiéramos que dicha columna tuviera la restricción de no vacía?. Razonar la respuesta.



5.- Veamos el siguiente esquema relacional:

DEPT (depaartamentos) es una tabla con las columnas: deptno que es un entero de, como máximo dos dígitos, dname que contendrá una cadena de, como máximo 14 caracteres, loc que contendrá una cadena de, como máximo 13 caracteres. La columna depto es la clave primaria de la tabla.

EMP (empleados) es una tabla que contiene las siguientes columnas: empno que es un número de, como máximo cuatro dígitos, y que es la clave primaria de la tabla, ename (nombre del empleado) que contendrá una cadena de cómo máximo 10 caracteres, job que será similar, pero como máxnimo contendrá 9 caracteres, mgr (jefe) que será un número de empleado (clave foránea de emp), hiredate que será de tipo fecha, sal (salario) que será un numérico de siete dígitos enteros y dos decimales, comm (comisión), similar a sal, y deptno que será la clave extranjera de la tabla DEPT.

SALGRADE contendrá tres columnas (grade, losal, hisal) que contendrán valores numéricos.

DUMMY que contendrá una columna (dummy) de tipo numérica.

Se pide: Utilizando únicamente sentencias CREATE TABLE, implementar la base de datos definida en Oracle.

6.- Conceder al esquema ADAMS de la instancia DESA el privilegio de consulta sobre la tabla DEPT.

7.- Conceder (usando una única sentencia SQL) los privilegios de consulta e inserción sobre la tabla EMP a los usuarios ADAMS (de la instancia DESA) y ANDREW de la instancia FILIAL.

EMP

DEPT

SALGRADE

DUMMY



8.- Conceder todos los privilegios de la tabla DEPT al usuario ADAMS de nuestra misma instancia.

9.- Conceder el privilegio de consulta sobre la tabla DEPT a todos los usuarios de la base de datos.

10.- Quitarle todos los privilegios de la tabla DEPT al usuario ADAMS de nuestra base de datos.

11.- Crear un índice para columna ENAME de la tabla EMP.

3.2 Ejercicios sobre DML 12.- Supongamos que tenemos las tablas EMP y DEPT.

Se pide: Generar un fichero, al que hay que llamar “emp_dept.txt”, que contenga todas las filas de la tabla EMP y todas las filas de la tabla DEPT.

13.- Consultar los posibles trabajos de un empleado.

14.- Consultar el nombre, salario y número de departamento de los empleados cuyo trabajo sea SALESMAN, el departamento sea el número 30 y el salario sea mayor que 1300.

15.- Consultar todos los datos de un empleado que no trabaje ni como MANAGER ni como CLERK y que sean del departamento 10.

16.- Consultar el nombre, trabajo y salario de los empleados cuyo salario no esté entre 1200 y 1300.

17.- Consultar el nombre, trabajo y departamento de los empleados que no trabaje ni como MANAGER ni como CLERK, ni como SALESMAN (sin utilizar los operadores lógicos AND y OR).



18.- Consultar el nombre del empleado, el trabajo y el departamento cuyo nombre empiece por ‘M’.

19.- Consultar el nombre, trabajo y salario de la base de datos de empleados, teniendo en cuenta que el resultado debe estar ordenado en orden descendente por trabajo y salario.

20.- Consultar el nombre y localidad del departamento de los empleados cuyo nombre sea ALLEN.

21.- Consultar todos los campos del departamento y el nombre del empleado y trabajo, ordenado por el número de departamento y cuyo número de departamento sea 20 o 30.

22.- Consultar el grado, trabajo, nombre y salario de un empleado, ordenado por grado y trabajo, cuyo salario esté entre el salario más alto y el más bajo definido en el sistema.

23.- Consultar el código y nombre de departamento, el trabajo y el nombre del empleado, ordenados por código de departamento, y que aparezcan deparamentos que no tengan empleados, pero en caso de tener empleados listar sólo los del departamento 30 o 40.

24.- Lista de los departamentos que no tienen empleados asociados.

25.- Listar los nombres y salarios de todos los empleados junto con los de sus jefes, siempre y cuando el salario del empleado sea mayor que el del jefe.

26.- En una única sentencia consultar el nombre, salario, comisión y total a cobrar por todos los empleados cuyo trabajo sea SALESMAN.

27.- Consultar, mediante una única sentencia, el nombre, salario y comisión de los empleados, cuya comisión sea mayor que el 25% del salario.



28.- Empleando una sola sentencia de consulta, listar el nombre del empleado, el coeficiente de comisión(=comisión/salario), la comisión y el salario en donde el trabajo sea SALESMAN y esté ordenado por el coeficiente de comisión (de mayor a menor).

29.- Consultar el nombre del empleado, salario, el salario dividido entre 22, el salario dividido entre 22 (redondeado con cero dígitos decimales), el salario dividido entre 22 (redondeado con 2 dígitos decimales) dónde el departamento del empleado es 30.

30.- Consultar el promedio del salario de los empleados cuyo trabajo es CLERK.

31.- Consultar el total a pagar en salarios y comisiones a todos los empleados que trabajan como SALESMAN.

32.- Sacar la media anual de salarios(con comisiones incluidas) de los empleados que trabajen como SALESMAN.

33.- Consultar el salario máximo, el mínimo y la diferencia entre ambos de los empleados.

34.- Consultar el número de empleados que tienen comisión.

35.- Consultar el número de tipos de trabajo que existen en el departamento 30.

36.- Consultar el número de empleados que hay en el departamento 30.

37.- Retornar el nombre, el trabajo y el salario del empleado que tenga el salario más alto.

38.- Calcular el salario medio de cada departamento (con una única consulta).



39.- Calcular el salario promedio anual de cada departamento, excluyendo a los directivos (MANAGER y PRESIDENT).

40.- Calcular la media anual del salario y el número de empleados por tipo de trabajo dentro de cada departamento.

41.- Listar el salario promedio anual para todos los tipos de trabajo de más de dos empleados.

42.- Listar todos los departamentos con, por lo menos dos empleados cuyo tipo de trabajo sea CLERK.

43.- Listar los tipos de trabajo cuyo salario promedio mensual sea mayor que el de los del tipo MANAGER.

44.- Listar el nombre, tipo de trabajo, salario, comisión y total a cobrar de los empleados del departamento 30.

45.- Consultar todos los nombres y tipos de trabajo de los empleados con el mismo tipo de trabajo que JONES.

46.- Consultar el salario, trabajo, nombre y departamento de los empleados cuyo salario es mayor que cualquiera de los salarios del departamento 30.

47.- Consultar el salario, trabajo, nombre y departamento de los empleados cuyo salario es mayor que todos los salarios del departamento 30.

48.- Consultar el nombre y trabajo de los empleados del departamento 10 que tengan el mismo trabajo que algún empleado del departamento 30.

49.- Listar los nombres y trabajos de los empleados del departamento 10 que tienen un trabajo que no existe en el departamento 30.



50.- Consultar el nombre, trabajo y salario de los empleados cuyo tipo de trabajo y salario sean exactamente iguales que el empleado FORD.

51.- Obtener la lista de empleados con el mismo trabajo que JONES, o un salario mayor o igual que el de FORD, ordenado por trabajo y salario.

52.- Obtener la lista de los nombres y trabajos de los empleados del departamento 10 con el mismo trabajo que alguno del departamento con el nombre SALES.

53.- Listar los nombres, trabajos y salarios de los empleados cuyos salarios sean igual al de SCOTT o al de WARD (sin utilizar la cláusula OR).

54.- Encontrar los nombres y trabajos de los empleados cuyo trabajo es el mismo que los que trabajan en CHICAGO.

55.- Consultar el departamento, nombre y salario de los empleados cuyo salario es mayor del promedio de su propio departamento, ordenados por número de departamento.

56.- Consultar el trabajo, nombre, número de empleado y de departamento de los empleados que tengan jefe, ordenados por número de empleado.

57.- Insertar en la tabla emp los valores 7954, CARTER, SALESMAN, 7698, 7-ABR-2000, 1500, Vacío y 30 según el orden preestablecido en la creación de la tabla.

58.- Insertar las columnas empno, ename, hiredate, deptno, sal de la tabla emp con los valores 7955, WILSON, 22-ABR-84, 30 y 1500, respectivamente.

59.- Insertar las columnas de la tabla emp con los valores 7657, MASON, ANALYST, 4/24/84, 3400, Vacío, y 20 según el orden establecido en la creación de la tabla, utilizando la función de cambio de tipo.



60.- Insertar las columnas de la tabla emp con los valores 7658, CHAN, ANALYST, 3-MAY-84 9:30, 3400, Vacío, y 20 según el orden establecido en la creación de la tabla, utilizando la función de cambio de tipo.

61.- La tabla Bonu, contiene los campos ename, job, sal y comm (similares en tipo y longitud a los de la tabla emp). Se trata de, en una única sentencia, insertar todos los empleados cuyo trabajo sea MANAGER o que su comisión sea mayor que el 25% de su salario.

62.- Actualizar el trabajo a SALESMAN, hiredate a la fecha actual e incrementar el salario un 10% al empleado WILSON.

63.- Incrementar el salario un 15% a los que trabajan como ANALYST y a los CLERK del departamento 20.

64.- Aumentar un 5% el salario de cada empleado en la tabla emp, que aparezca en la tabla bonu.

65.- Aumentar el salario de todos los SALESMAN un 10% del salario promedio de todos los empleados del mismo tipo.

66.- Borrar todos los empleados con el mismo trabajo que JONES de la tabla bonu.

67.- Crear una vista con el nombre de emp10 que contenga los números, nombres y trabajos de los empleados del departamento 10.

68.- Consultar el nombre y trabajo de la vista emp10 de los empleados cuyo número sea mayor que 7800.

69.- Cambiar el trabajo a CLERK del empleado MILLER, utilizando la vista emp10.



70.- Crear una vista (con nombre pay) que posea los siguientes campos: name (nombre del empleado), monthly_sal (salario), annual_sal (salario anual del empleado), deptno (número de departamento).

71.- Crear la vista dept_comp que posee los campos deptno (número de departamento), losal (salario mínimo de los empleados), medsal (salario medio de los empleados), hisal (salario máximo de los empleados), totsal (total de los salarios de los empleados) de cada departamento.

72.- Crear una vista pub_emp qye excluya los campos sal y comm de la tabla emp y otorgar privilegios de consulta a todos los esquemas.

73.- Crear una vista que retorne a cada MANAGER de cada departamento los datos de sus empleados, dando privilegios de consulta sobre la vista a todos los usuarios (suponer que el nombre del esquema coincide con el nombre del empleado y que la variable global USER contiene el nombre del esquema).

Introduccion a sql

Education

Transcript of Introduccion a sql