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

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.

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

Í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

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


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.


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

Aprender a insertar, borrar, actualizar y consultar datos de tablas.

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
d) MIN (COLUMN): Retorna el valor mínimo de la columna
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

Tener ejemplos resueltos de ejercicios sobre el curso

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


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:

EMP SALGRADE

DUMMY

DEPT

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.



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.


Introduccion a sql

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (16)

En vedette

En vedette (20)

Similaire à Introduccion a sql

Similaire à Introduccion a sql (20)

Plus de Israel Hernandez

Plus de Israel Hernandez (8)

Dernier

Dernier (20)

Introduccion a sql