CAPÍTULO 1.

Introducción

Bases de la sentencia SELECT

En una BD relacional, los datos son almacenados en tablas. Un ejemplo de tabla puede contener el DNI,
el nombre y la Dirección:

Tabla_direcciones_empleados

DNI Apellidos Nombre Dirección Ciudad

23987739 García Antonio C/ Mayor 2 Valencia

45623890 López Juan Pl. Ayuntamiento Alicante

Ahora, vamos a ver que habría que hacer para ver las direcciones de todos los empleados. Utiliza la
sentencia SELECT de la siguiente manera:

SELECT Nombre, Apellidos, Dirección, Ciudad, Provincia

FROM Tabla_direcciones_empleados;

Los siguiente es el resultado de tu consulta de la BD:

Nombre Apellidos Dirección Ciudad Provincia

------------------------------------------------------
Antonio García C/ Mayor2 Valencia Valencia
Juan López Pl. Ayuntamiento Alicante Alicante

La explicación de lo que acabas de hacer es la siguiente, has preguntado por todos los datos de la
Tabla_direcciones_empleados, y específicamente, has preguntado por la columnas llamadas Nombre,
Apellidos, Dirección, Ciudad y Provincia. Observa que los nombre de las columnas y los nombres de las
tablas no tienen espacios...éstos deben ser escritos con una palabra; y que la sentencia acaba con un punto
y coma (;). La forma general para una sentencia SELECT, recuperando las filas de una tabla es:

SELECT NombreColumna, NombreColumna, ...

FROM NombreTabla;

Para coger todas las columnas de una tabla sin escribir todos los nombres de columna, usa:

SELECT * FROM NombreTabla;

Cada administrador de BD's (DBMS, "Data Management System") y tipo de software de BD's tienen
diferentes métodos para identificarse en la base de datos e introducir comandos SQL.

Selección Condicional

Para un mayor estudio de la sentencia SELECT, echa un vistazo a una nueva tabla de ejemplo:

Tabla_estadistica_empleados

Cod_empleado Salario Beneficios Cargo

101 75000 15000 Encargado

105 65000 15000 Encargado

152 60000 15000 Encargado

215 60000 12500 Encargado

244 50000 12000 Técnico

300 45000 10000 Técnico

335 40000 10000 Técnico

400 32000 7500 Aprendiz

441 28000 7500 Aprendiz

Operadores Relacionales

Hay seis operadores relacionales en SQL:

= Igual
< ó != No igual (ver manual para más información)
< Menor que
> Mayor que
 <= Menor o igual a
>= Mayor o igual que

La cláusula WHERE es usada para especificar que sólo ciertas filas de la tabla sean mostradas,
basándose en el criterio descrito en esta cláusula WHERE. Es más fácil de entender viendo un par de
ejemplos:

Si quieres ver el Cod_empleado de aquellos que tengan un salario por encima de 50.000, usa la siguiente
expresión:

SELECT Cod_empleado
FROM Tabla_estadistica_empleados
WHERE Salario >= 50000;

Observa que el signo >= (mayor o igual que) ha sido usado, ya que queremos ver listados juntos aquellos
que ganen más de 50.000 o igual a 50.000 . Esto muestra:

Cod_empleado
---------------
010
105
152
215
244

La descripción " WHERE Salario = 50.000" es conocida como condición. Lo mismo puede ser utilizado
para la columnas de tipo texto:

SELECT Cod_empleado
FROM Tabla_estadistica_empleados
WHERE Cargo = 'Encargado';

Esto muestra la código de todos los encargados. Generalmente, con las columnas de texto, usa igual o no
igual a, y comprueba que el texto que aparece en la condición está dentro de comillas simples.

Más Condiciones Complejas: Condiciones Compuestas

El operador AND junta dos o más condiciones, y muestra sólo las filas que satisfacen TODAS las
condiciones listadas. Por ejemplo:

SELECT Cod_empleado
FROM Tabla_estadistica_empleados
WHERE Salario 40000 AND Cargo = ‘Técnico’
El operador OR junta dos o más condiciones, y devuelve una fila si ALGUNA de las condiciones listadas
en verdadera. Para ver todos aquellos que ganan menos de 40.000 o tienen menos de 10.000 en beneficios
listados juntos, usa la siguiente consulta:

SELECT ID_EMPLEADO
FROM TABLA_ESTADISTICA_EMPLEADOS
WHERE SALARIO < 40000 OR BENEFICIOS < 10000;

AND & OR pueden ser combinadas, por ejemplo:

SELECT ID_EMPLEADO
FROM TABLA_ESTADISTICA_EMPLEADOS
WHERE CARGO = 'Encargado' AND SALARIO > 60000 OR BENEFICIOS > 12000;

Primero SQL encuentra las filas donde el salario es mayor de 60.000 y la columna del cargo es igual a
Encargado, una vez tomada esta nueva lista de filas, SQL buscará si hay otras filas que satisfagan la
condición AND previa o la condición que la columna de los Beneficios sea mayor de 12.000.
Consecuentemente, SQL solo muestra esta segunda nueva lista de filas, recordando que nadie con
beneficios sobre 12.000 será excluido ya que el operador OR incluye una fila si el resultado de alguna de
las partes es VERDADERO.
Observa que la operación AND tiene prioridad sobre la OR.

Para generalizar este proceso, SQL realiza las operaciones AND para determinar las filas donde las
operaciones AND se mantienen VERDADERO (recordar: todas las condiciones son verdaderas),
entonces estos resultados son usados para comparar con las condiciones OR, y solo muestra aquellas filas
donde las condiciones unidas por el operador OR se mantienen ciertas para alguna de las partes de la
condición..

Para realizar OR antes de AND debes de usar paréntesis, p.e., si quisieras ver una lista de empleados
ganando un gran salario (50.000) o con un gran beneficio (10.000), y sólo quieres que lo mire para los
empleados con el cargo de Encargado:

SELECT ID_EMPLEADO
FROM TABLA_ESTADISTICA_EMPLEADOS
WHERE CARGO = 'Encargado' AND (SALARIO > 50000 OR BENEFICIO > 10000);

IN & BETWEEN

Un método fácil de usar condiciones compuestas es usando IN o BETWEEN. Por ejemplo si quieres listar
todos los encargados y técnicos:

SELECT ID_EMPLEADO
FROM TABLA_ESTADISTICA_EMPLEADOS
WHERE CARGO IN ('Encargado', 'Técnico');

O para listar aquellos que ganen más o 30.000, pero menos o igual que 50.000, usa:

SELECT ID_EMPLEADO
FROM TABLA_ESTADISTICA_EMPLEADOS
WHERE SALARIO BETWEEN 30000 AND 50000;
Para listar todos los que no están en este rango, intenta:

SELECT ID_EMPLEADO
FROM TABLA_ESTADISTICA_EMPLEADOS
WHERE SALARIO NOT BETWEEN 30000 AND 50000;

De forma similar, NOT IN lista todas las filas excluyendo aquellas de la lista IN.

Usando LIKE

Observa la Tabla_estadistica_empleados, y di que quieres ver todas las personas en las cuales su apellido
comience por "l":, intenta:

SELECT ID_EMPLEADO
WHERE APELLIDOS LIKE 'L%';
FROM TABLA_ESTADISTICA_EMPLEADOS

El tanto por ciento (%) es usado para representar un posible carácter (sirve como comodín), ya sea
número, letra o puntuación, o para seleccionar todos los caracteres que puedan aparecer después de "L".
Para encontrar las personas con el apellidos terminado en "L", usa ‘%L’, o si quieres la ‘L’ en medio de la
palabra ‘%L%’. El ‘%’ puede ser usado en lugar de cualquier carácter en la misma posición relativa a los
caracteres dados. NOT LIKE muestra filas que no cumplen la descripción dada. Otras posibilidades de
uso de LIKE, o cualquiera de las condiciones anteriores, son posibles, aunque depende de qué DBMS
estés usando; lo más usual es consultar el manual, o tu administrador de sistema sobre la posibilidades del
mismo, o sólo para estar seguro de que lo que estás intentando hacer es posible y correcto. Éste tipo de
peculiaridades serán discutidas más adelante. Esta sección sólo pretende dar una idea de las posibilidades
de consultas que pueden ser escritas en SQL.
 CAPÍTULO 2. Uniones

Uniones

En esta sección, sólo estudiaremos la unión y la intersección, que en general son las más usadas.

Un buen diseño de una BD sugiere que cada lista de tabla de datos sea considerada como una simple
entidad, y que la información detallada puede ser obtenida, en una BD relacional, usando tablas
adicionales y uniones.

Primero considera los siguientes ejemplos de tablas:

Propietarios_Antigüedades

ID_Propietario ApellidoPropietario NombrePropietario

01 Jones Bill

02 Smith Bob

15 Lawson Patricia

21 Akins Jane

50 Fowler Sam

Pedidos

ID_Propietario ProductoPedido

02 Table

02 Armario

21 Silla

15 Espejo

Antigüedades
ID_vendedor ID_comprador Producto

01 50 Cama

02 15 Mesa

15 02 Silla

21 50 Espejo

50 01 Armario

01 21 Cabinet

02 21 Cofee Table

15 50 Cahair

01 15 Jewelry Box

02 21 Pottery

21 02 Librería

50 01 Plant Stand

Claves

Primero vamos a estudiar el concepto de claves. Una clave primaria es una columna o conjunto de
columnas que identifican unívocamente el resto de datos en cualquiera fila. Por ejemplo, en la tabla
Propietarios_Antigüedades, la columna ID_Propietario identifica unívocamente esa fila. Esto significa
dos cosas: dos filas no pueden tener el mismo ID_Propietario y, aunque dos propietarios tuvieran el
mismo nombre y apellidos, la columna ID_Propietario verifica que no serán confundidos, porque la
columna ID_Propietario podrá ser usada por el Administrador de la Base de Datos (DBMS) para
diferenciarlos, aunque los nombres sean los mismos.

Una clave ajena es una columna en una tabla que es clave primaria en otra tabla, lo que significa que
cada dato en una columna con una clave ajena debe de corresponder con datos, en otra tabla, cuya
columna es clave primaria. En el lenguaje DBMS esta correspondencia es conocida como integridad
referencial. Por ejemplo, en la tabla Antigüedades, tanto el ID_comprador como el ID_vendedor son
claves ajenas de la clave primaria de la tabla Propietarios_Antigüedades (ID_Propietario; por supuesto,
debe haber un propietario antiguo antes de poder comprar o vender cualquier producto), por lo tanto, en
ambas tablas, las columnas ID son usadas para identificar los propietarios o compradores y vendedores, y
por lo tanto ID_Propietario es la clave primaria de la tabla Propietarios_Antigüedades. En otras palabras,
todos estos datos "ID" son usados para referirse a los propietarios, compradores, o vendedores de
antigüedades, sin necesidad de usar sus nombres reales.

Creando una Unión

El propósito de estas claves es el poder referirse a datos de diferentes tablas, sin tener que repetir los datos
en cada una de ellas, este es el poder de las bases de datos relacionales. Por ejemplo, se pueden encontrar
los nombres de los que han comprado una silla sin tener que listar el nombre completo del comprador en
la tabla Antigüedades...puedes conseguir el nombre relacionando aquellos que compraron una silla con
los nombres en la tabla de Propietarios_Antigüedades usando el ID_Propietario, el cual relaciona los
datos en las dos tablas. Para encontrar los nombres de aquellos que compraron una silla, usa la siguiente
consulta:

SELECT APELLIDOPROPIETARIO, NOMBREPROPIETARIO

FROM PROPIETARIOS_ANTIGÜEDADES, ANTIGÜEDADES
WHERE ID_COMPRADOR = ID_PROPIETARIO AND PRODUCTO = 'Silla';

Observa que las tablas involucradas en la relación son listadas en la cláusula FROM de la sentencia. En la
cláusula WHERE, primero observa que el PRODUCTO=’Silla’ restringe el listado a aquellos que han
comprado una silla. Segundo, observa como las columnas ID son relacionadas de una tabla a otra por el
uso de la cláusula ID_COMPRADOR=ID_PROPIETARIO. Sólo cuando los ID coinciden y el objeto
comprado es una silla (por el AND), los nombres de la tabla Propietarios_Antigüedades serán listados.
Debido a que la condición de unión usada es el signo igual, esta unión se denomina intersección. El
resultado de esta consulta son dos nombres: Smith, Bob & Fowler, Sam.

Para evitar ambigüedades se puede poner el nombre de la tabla antes del de la columna, algo como:

SELECT PROPIETARIOS_ANTIGÜEDADES.APELLIDOPROPIETARIO,
PROPIETARIOS_ANTIGÜEDADES.NOMBREPROPIETARIO
FROM PROPIETARIOS_ANTIGÜEDADES, ANTIGÜEDADES
WHERE ANTIGÜEDADES.ID_COMPRADOR =
PROPIETARIOS_ANTIGÜEDADES.ID_PROPIETARIO AND ANTIGÜEDADES.PRODUCTO =
'Silla';

Sin embargo, como los nombres de las columnas en cada tabla son diferentes, esto no es necesario.

DISTINCT y Eliminando Duplicados

Consideremos que quieres ver los ID y los nombres de toda aquellas persona que haya vendido una
antigüedad. Obviamente, quieres una lista donde cada vendedor sea listado una vez, y no quieres saber
cuántos artículos a vendido una persona, solamente el nombre de las personas que han vendido alguna
antigüedad (para contar, ver la sección próxima Funciones Agregadas). Esto significa que necesitarás
decir en SQL que quieres eliminar las filas de vendedores duplicadas, y sólo listar cada persona una vez.
Para hacer esto, uso la palabra clave DISTINCT.

Primero, necesitaremos una intersección para la tabla de Propietarios_Antigüedades para conseguir los
datos detallados de las personas, apellidos y nombre.

Sin embargo, recuerda que la columna ID_vendedor de la tabla Antigüedades es una clave ajena para la
tabla Propietarios_Antigüedades, y por tanto, un vendedor podría ser listado más de una vez, por cada
producto de la tabla Antigüedades, listando el ID y sus datos, como queremos eliminar múltiples
coincidencias del ID_vendedor en nuestra lista, usaremos DISTINCT en la columna donde las
repeticiones pueden ocurrir.

Para complicarlo un poco más, además queremos la lista ordenada alfabéticamente por el Apellido,
después por el Nombre, y por último por su ID_Propietario. Para ello, usaremos la clausula ORDER BY.
SELECT DISTINCT ID_VENDEDOR, APELLIDOPROPIETARIO, NOMBREPROPIETARIO
FROM ANTIGÜEDADES, PROPIETARIOS_ANTIGÜEDADES
WHERE ID_VENDEDOR = ID_PROPIETARIO
ORDER BY APELLIDOPROPIETARIO, NOMBREPROPIETARIO, ID_PROPIETARIO;

En este ejemplo, obtendremos un listado de todos los propietarios, en orden alfabético por el Apellido.
Para futuras referencias (y si alguien pregunta), este tipo de uniones son consideradas en la categoría
de uniones interiores.

Alias & IN/Subconsultas

En esta sección, hablaremos sobre los Alias, IN y el uso de las subconsultas, y como éstas pueden ser
usadas en un ejemplo con tres tablas. Primero, observa esta consulta que imprime el apellido de aquellos
propietarios que han formulado un pedido y en qué consiste éste, solamente listando aquellos cuyos
pedidos pueden ser atendidos (esto es, hay un vendedor que posee el producto pedido)

SELECT OWN.APELLIDOPROPIETARIO Apellido, ORD.PRODUCTOPEDIDO

ProductoPedido
FROM PEDIDOS ORD, PROPIETARIOS_ANTIGÜEDADES OWN
WHERE ORD.ID_PROPIETARIO = OWN.ID_PROPIETARIO
AND ORD.PRODUCTOPEDIDO IN
(SELECT PRODUCTO
FROM ANTIGÜEDADES);

Esto devuelve:

Apellidos Producto Pedido

--------------------------------
Smith Mesa
Smith Armario
Akins Silla
Lawson Espejo

Hay algunas cosas a tener en cuenta sobre esta consulta:

1. Primero, el "Apellido" y el "Producto Pedido" en las líneas Select devuelve los títulos en la
salida.
2. El OWN & ORD son alias; éstos son dos nuevos nombres para las dos tablas listadas en la
cláusula FROM que son usadoS como prefíjos para toda las notaciones con punto de los
nombres de las columnas en la consulta (ver arriba). Esto elimina ambigüedades, especialmente
en la cláusula de intersección WHERE donde ambas tablas tienen la columna ID_Propietario, y
la notación con punto dice al SQL que estamos refiriéndonos de dos diferentes ID_Propietario de
dos tablas diferentes.
3. Observa que la tabla de Pedidos está utilizada primero en la cláusula FROM; esto asegura que el
listado hecho basándose en esta tabla, y la tabla Antigüos_Propietarios es solamente usado para
la información complementaria (apellidos).
4. Más importante, el AND en la cláusula WHERE fuerza en la subconsulta el ser invocada
("=ANY" or "=SOME", son dos equivalente usos de IN). Esto significa que la subconsulta se
realiza, devolviendo todos los productos que pertenecen a alguien de la tabla de Antigüedades,
como si no hubiera la cláusula WHERE. Así pues, para que una fila de la tabla de Pedidos sea
listada, el ProductoPedido debe de ser devuelto en la lista de productos con propietario de la
tabla de Antigüedades, ésta lista un producto sólo si el pedido puede ser cumplido por otro
propietario. Puedes pensar que este es el camino: la subconsulta devuelve un conjunto de
productos los cuales son comparados con los de la tabla Pedidos; la condición IN es verdadera
sólo si el producto deseado está en el conjunto devuelto de la tabla Antigüedades. Además,
observa que en este caso, en el que hay una antigüedad disponible para cada demanda,
obviamente no será siempre el caso. Además, observa que cuando IN, "=ANY", o "=SOME" es
usada, estas palabras claves se refieren a cualquier posible fila seleccionada, no a columnas
seleccionadas...esto es, no puedes poner múltiples columnas en una.
 CAPÍTULO 3. Misceláneo de Sentencias SQL

Funciones Agregadas

Vamos a ver cinco importantes funciones agregadas: SUM, AVG, MAX , MIN y COUNT. Son llamadas
funciones agregadas porque resumen el resultado de una consulta.

devuelve el total de todas las fila, satisfaciendo todas las condiciones de una columna dada,
SUM ()
cuando la columna dada es numérica.
AVG () devuelve la media de una columna dada.
MAX () devuelve el mayor valor de una columna dada.
MIN () devuelve el menor valor en una columna dada.
COUNT(*) devuelve el número de filas que satisfacen las condiciones.

Viendo las tablas del principio del documento, veamos tres ejemplos:

SELECT SUM(SALARIO), AVG(SALARIO)

FROM TABLA_ESTADISTICA_EMPLEADOS;

Esta consulta muestra el total de todos los salarios de la tabla, y la media salarial de todas las entradas en
la tabla.

SELECT MIN(BENEFICIOS)
FROM TABLA_ESTADISTICA_EMPLEADOS
WHERE CARGO = 'Encargado';

Esta consulta devuelve el menor valor de la columan de beneficios, de los empleados que son
Encargados, la cual es 12.500.

SELECT COUNT(*)
FROM TABLA_ESTADISTICA_EMPLEADOS
WHERE CARGO = 'Técnico';

Esta consulta nos dice cuantos empleados tienen la categoría de Técnico (3).
Vistas

En SQL puedes (comprueba tu DBA) tener acceso a crear vistas por ti mismo. Lo que una vista hace es
permitirte asignar resultados de una consulta a una tabla nueva y personal , que puedes usar en otras
consultas, pudiendo utilizar el nombre dado a la tabla de tu vista en la cláusula FROM. Cuando accedes a
una vista, la consulta que está definida en la sentencia que crea tu lista está relacionada (generalmente), y
los resultados de esta consulta son como cualquier otra tabla en la consulta que escribiste invocando tu
vista. Por ejemplo, para crear una vista:

CREATE VIEW ANTVIEW AS SELECT PRODUCTOPEDIDO FROM PEDIDOS;

Ahora, escribe una consulta usando esta vista como tabla, donde la tabla es una listado de todos los
Productos Pedidos de la tabla Pedidos:

SELECT ID_VENDEDOR
FROM ANTIGÜEDADES, ANTVIEW
WHERE PRODUCTOPEDIDO = PRODUCTO;

Esta consulta muestra todos los ID_vendedor de la tabla de Antigüedades donde el producto, en esta
tabla, aparece en la vista Antview, la cual no es más que todos los productos deseados de la tabla Pedidos.
El listado es generado yendo uno por uno por los Productos Antigüos hasta donde hay una coincidencia
con la vista Antview. Las vistas pueden ser usadas para restringir el acceso a las bases de datos, así como
para simplificar una consulta compleja.

Creando nuevas tablas

Toda tabla de una base de datos debe de ser creada alguna vez... veamos como hemos creado la tabla de
Pedidos:

CREATE TABLE PEDIDOS

(ID_PROPIETARIO INTEGER NOT NULL,
PRODUCTOPEDIDO CHAR(40) NOT NULL);

Esta sentencia devuelve el nombre de la tabla e informa a la DBMS sobre cada columna en la tabla.
Observa que esta sentencia usa tipos de datos genéricos, y que los tipos de datos pueden ser diferentes
dependiendo del DBMS que estes usando. Algunos tipos de datos genéricos son:

- Char(x) - Una columna de caracteres, donde x es el número máximo de caracteres permitido en la

columna.
- Integer – Una columna de números enteros, positivos o negativos.
- Decimal(x, y) – Una columna de números decimales, donde x es el número máximo de digitos del
número decimal en la columna e y el número máximo de dígitos después del punto decimal. Ejemplo:
(4,2): 99.99.
- Date - Una columna fecha tiene un formato especial en cada DBMS.
- Logical – Una columna que sólo puede tomar dos valores: TRUE o FALSE (verdadero o falso).

Otra nota, NOT NULL significa que la columna debe tener un valor en cada fila. Si NULL es usado, la
columna podría tener un valor vacio en una de sus filas.
Modificando Tablas

Vamos a añadir una columna a la tabla Antigüedades para permitir introducir el precio de un producto
dado:

ALTER TABLE ANTIGÜEDADES ADD (PRECIO DECIMAL(8,2) NULL);

Los datos para esta nueva columna pueden ser actualizados o insertados como se muestra a continuación.

Añadiendo Datos

Para insertar filas en una tabla, haz lo siguiente:

INSERT INTO ANTIGÜEDADES VALUES (21, 01, 'Ottoman', 200.00);

Esto inserta los datos en la tabla, como una nueva fila, columna por columna, en el orden pre-definido.
Veamos como modificar el orden y dejar el Precio en blanco:

INSERT INTO ANTIGÜEDADES (ID_COMPRADOR, ID_VENDEDOR, PRODUCTO)

VALUES (01, 21, 'Ottoman');

Borrando datos

Vamos a borrar esta nueva fila de la base de datos:

DELETE FROM ANTIGÜEDADES

WHERE PRODUCTO = 'Ottoman';

Pero si hay otra fila que contiene ‘Ottoman’, esta fila también será borrada. Para diferenciar la fila de
otra, lo que haremos será añadir datos:

DELETE FROM ANTIGÜEDADES

WHERE PRODUCTO = 'Ottoman' AND ID_COMPRADOR = 01 AND ID_VENDEDOR = 21;

Actualizando Datos

Vamos a actualizar el Precio en una fila que todavía no tiene el precio:

UPDATE ANTIGÜEDADES SET PRECIO = 500.00 WHERE PRODUCTO = 'Silla';

Esto pone el precio de todas las sillas a 500.00, como en el caso anterior, añadiendo más condicionantes
en la cláusula WHERE, podemos especificar más aquellas filas que queremos modificar.
 CAPÍTULO 4. Misceláneo de Tópicos

Índices

Los índices permiten a DBMS acceder a los datos más rápidamente (esto no ocurre en todos los sistemas).
El sistema crea esta estructura de datos interna (el índice) con la cual se puede seleccionar filas (cuando la
selección se basa en columnas indexadas, esto se hace más rápidamente). Este índice le dice a la DBMS
donde esta cierta fila dando el valor de una columna indexada, como un libro, cuyo índice te dice en que
páginas aparece una cierta palabra. Vamos a crear un índice por el ID_Propietario en la tabla
Propietarios_Antigüedades:

CREATE INDEX OID_IDX ON PROPIETARIOS_ANTIGÜEDADES (ID_PROPIETARIO);

Ahora en los nombres:

CREATE INDEX NAME_IDX ON PROPIETARIOS_ANTIGÜEDADES

(APELLIDOPROPIETARIO, NOMBREPROPIETARIO);

Para borrar un índice, utiliza la sentencia DROP:

DROP INDEX OID_IDX;

Así mismo, también puedes "borrar" una tabla (DROP TABLE nombretabla). En el segundo ejemplo, el
índice se mantine en las dos columnas, agregado junto.

Algunos DBMS no fuerzan la existencia de claves primarias; en otras palabra, la unicidad de una columna
no es forzada automáticamente. Lo que significa que, por ejemplo, si intento insertar otra fila dentro de la
tabla Propietarios_Antigüedades con el ID_Propietario de 02, algunos sistemas lo permitirán hacer,
incluso, si esta columna es la única de la tabla (cada fila se supone que es diferente). Una forma de evitar
esto es crear un único índice en la columna que queramos que sea la clave primaria para forzar al sistema
a prohibir los duplicados.

CREATE UNIQUE INDEX OID_IDX ON PROPIETARIOS_ANTIGÜEDADES

(ID_PROPIETARIO);

GROUP BY & HAVING

Un uso especial de GROUP BY es asociar una función agregada (especialmente COUNT) con grupos de
filas. Primero, imagina que la tabla Antigüedades tiene la columna Precio, y que cada fila tiene un valor
para esta columna. Queremos ver el precio del producto más caro comprado por cada comprador.
Tenemos que decirle a SQL que agrupe cada tipo de compra, y nos diga la compra que tenga el máximo
precio:
SELECT ID_COMPRADOR, MAX(PRECIO)
FROM ANTIGÜEDADES
GROUP BY ID_COMPRADOR;

Ahora, queremos decir que sólo queremos ver la precio máximo de la compra si éste es sobre $1000, así
que usamos la cláusula HAVING:

SELECT ID_COMPRADOR, MAX(PRECIO)

FROM ANTIGÜEDADES
GROUP BY ID_COMPRADOR
HAVING PRECIO > 1000;

Más subconsultas

Otro uso común de las subconsultas involucra el uso de operadores para permitir a una condición
WHERE incluir la salida de un Select de una subconsulta. Primero, lista los compradores que compraron
un producto caro (el precio del producto es $100 mayor que la media de precio de todos los productos):

SELECT ID_COMPRADOR
FROM ANTIGÜEDADES
WHERE PRECIO
(SELECT AVG(PRECIO) + 100
FROM ANTIGÜEDADES);

La subconsulta calcula la media del Precio más $100, y usando esta figura, los ID_Propietario son
impresos por cada producto que cuesta más. Se puede usar DISTINCT ID_PROPIETARIO, para eliminar
duplicados.

Lista los apellidos de aquellos de la tabla Propietarios_Antigüedades SÓLO si han comprado un

producto:

SELECT APELLIDOPROPIETARIO
FROM PROPIETARIOS_ANTIGÜEDADES
WHERE ID_PROPIETARIO IN
(SELECT DISTINCT ID_COMPRADOR
FROM ANTIGÜEDADES);

La subconsulta devuelve la lista de compradores, y el apellido es impreso para un antigüo propietario si y

sólo si el ID_Propietario aparece en la lista de la subconsulta (también llamada lista de candidatos). Nota:
en algunas DBMS, el igual puede ser usado de la misma forma que IN, aunque, por previsión, IN es una
mejor elección.

Para un ejemplo de actualización, nosotros sabemos que el hombre que compró la librería tiene el
Nombre equivocado en la base de datos, éste debería ser John:

UPDATE PROPIETARIOS_ANTIGÜEDADES
SET NOMBREPROPIETARIO = 'John'
WHERE ID_PROPIETARIO =
(SELECT ID_COMPRADOR
 FROM ANTIGÜEDADES
WHERE PRODUCTO = 'Librería');

Primero, la subconsulta encuentra el ID_comprador de la persona(s) que compró la librería, después la

consulta de salida actualiza el apellido.

Recuerda esta regla sobre las subconsultas: cuando tienes una subconsulta como parte de una condición
WHERE, la cláusula Selec en la subconsulta tiene que tener columnas que concuerden en número y tipo
con aquellas que formen parte de la condición WHERE de la subconsulta. En otras palabras, si tienes
"WHERE ColumnName = (SELECT...);", Select debe de tener sólo una columna en ella, para coincidir
con la salida en la cláusula Where, y estas deberán de coincidir en tipo

EXISTS & ALL

EXISTS usa una subconsulta como condición, donde la condición es verdadera si la subconsulta devuelve
alguna fila, y falsa si la subconsulta no devuelve ninguna fila; esta es una característica no intuitiva con
sólo algunos usos. Sin embargo, si un empleado quiere ver la lista de Propietarios sólo si hay sillas
disponibles, intenta:

SELECT NOMBREPROPIETARIO, APELLIDOPROPIETARIO

FROM PROPIETARIOS_ANTIGÜEDADES
WHERE EXISTS
(SELECT *
FROM ANTIGÜEDADES
WHERE PRODUCTO = 'Silla');

Si hay alguna silla en la columna Antigüedades, la subconsulta devolverá una o varias filas, haciendo la
cláusula EXISTS verdadera, haciendo que SQL liste los antigüos propietarios. Si no ha habido sillas,
ninguna fila será devuelta por la subconsulta.

ALL es otra construcción poco usual , como las consultas ALL pueden ser usadas con diferentes y
simples métodos, veamos un ejemplo de consulta:

SELECT ID_COMPRADOR, PRODUCTO

FROM ANTIGÜEDADES
WHERE PRECIO = ALL
(SELECT PRECIO
FROM ANTIGÜEDADES);

Esto devolverá el precio de producto más alto (o más de un producto si hay un empate), y su comprador.
La subconsulta devuelve una lista de todos los precios de la tabla Antigüedades, y la consulta de salida va
fila por fila de la tabla Antigüedades y si el precio es mayor o igual a todos (o ALL) precios en la lista, es
listado, dando el precio del producto más caro. La razón de "=" es que el mayor precio en la lista puede
ser igual al de la lista, ya que este producto está en la lista de precios.
UNION & Uniones de salida

Hay ocasiones donde puedes querer ver los resultados de múltiples consultas a la vez combinando sus
salidas; usa UNION. Por ejemplo, si queremos ver todos los ID_COMPRADOR de la tabla de
Antigüedades junto con los ID_PROPIETARIO de la tabla de PEDIDOS, usaremos:

SELECT ID_COMPRADOR
FROM ANTIGÜEDADES
UNION
SELECT ID_PROPIETARIO
FROM PEDIDOS;

SQL requiere que la lista de Select (de columnas) coincida, columna por columna, en el tipo de datos. En
este caso ID_comprador y ID_Propietario son del mismo tipo (integer). Además, SQL elimina
automáticamente los duplicados cuando se usa UNION (como si ellos fuera dos "conjuntos"); en las
consultas simples, tienes que usar DISTINCT.

La unión de salida es usada cuando una consulta de unión está "unida" con filas no incluidas en la unión,
y son especialmente útiles si las "flags" son incluidas. Primero observa la consulta:

SELECT ID_PROPIETARIO, 'está en ambos Pedidos & Antigüedades'

FROM PEDIDOS, ANTIGÜEDADES
WHERE ID_PROPIETARIO = ID_COMPRADOR
UNION
SELECT ID_COMPRADOR, 'sólo está en Antigüedades'
FROM ANTIGÜEDADES
WHERE ID_COMPRADOR NOT IN
(SELECT ID_PROPIETARIO
FROM PEDIDOS);

Esta consulta hace una unión para listar todos los propietarios que están en ambas tablas, y pone una línea
etiqueta después de ID repitiendo la cita. La UNION une esta lista con al siguiente lista. La segunda lista
es generada primero listando aquellos ID que no están en la tabla Pedidos, generando una lista de ID
excluidos de la consulta de unión. Entonces, cada fila en la tabla Antigüedades es escaneada, y si el
ID_comprador no está en esta lista de exclusión, es listado con su cita etiqueta. Debe haber un modo más
sencillo de hacer esta lista, pero es difícil generar la informativa cita de texto.

Este concepto es muy útil en situaciones donde la clave primaria está relacionada con una clave ajena,
pero el valor de la clave ajena para algunas claves primarias es NULL. Por ejemplo, en una tabla, la clave
primaria es vendedor, y en otra tabla es clientes, con el nombre de los vendedores en la misma fila. Sin
embargo, si un vendedor no tiene clientes, el nombre de esta persona no aparecerá en la tabla de clientes.
La unión de salida es usada si el listado de todos los vendedores va ha ser impreso, junto con sus clientes,
aunque el vendedor no esté en la tabla de clientes, pero está en la tabla de vendedores. En otro caso, el
vendedor será listado con cada cliente.
 CAPÍTULO 5. SQL EMBEBIDO

SQL embebido

Un feo ejemplo (no escribas un programa como este ...esto es sólo con propósitos educativos)

/* - Para verlo, aquí tienes un programa ejemplo que usa SQL embebido. SQL embebido permite
a los programadores conectar con una base de datos e incluir código SQL en su programa, y poder usar,
manipular y procesar datos de la base de datos..
- Este ejemplo de programa en C (usando SQL embebido) imprimirá un informe.
- Este programa deberá ser precompilado para las sentencias SQL, antes de la compilación normal.
- Las partes EXEC SQL son las mismas (estándar), pero el código C restante deberá ser cambiado,
incluyendo la declaración de variables si estás usando un lenguaje diferente.
-SQL embebido cambia de sistema a sistema, así que, una vez más, comprueba la documentación,
especialmente la declaración
de variables y procedimientos, en donde las consideraciones del DBMS y el sistema operativo son
cruciales.
*/
/* ***************************************************/
/* ESTE PROGRAMA NO ES COMPILABLE O EJECUTABLE */
/* SU PROPOSITO ES SÓLO DE SEVIR DE EJEMPLO */
/****************************************************/
#include <stdio.h>

/* Esta sección declara las variables locales, estas deberán ser las variables que tu programa use, pero
también
las variables SQL podrán ser utilizadas para tomar o dar valores */

EXEC SQL BEGIN DECLARE SECTION;

int ID_comprador;
char Nombre[100], Apellidos[100], Producto[100];
EXEC SQL END DECLARE SECTION;

/* Esto incluye la variable SQLCA , aquí puede haber algún error si se compilase. */

EXEC SQL INCLUDE SQLCA;

main() {

/* Este es un posible camino para conectarse con la base de datos */

EXEC SQL CONNECT UserID/Password;

/* Este código informa si estás conectado a la base de datos o si ha habido algún error durante la
conexión*/
if(sqlca.sqlcode)
{
printf(Printer, "Error conectando al servidor de la base de datos.\n");
exit();
}
printf("Conectado al servidor de la base de datos.\n");

/* Esto declara un "Cursor". Éste es usado cuando una consulta devuelve más de una fila, y una operación
va a ser realizada en cada fila resultante de la consulta. Con cada fila establecida por esta consulta, lo
usare en el informe. Después "Fetch" será usado para sacar cada fila, una a una, pero para la consulta que
está actualmente ejecutada, se usará el estamento "Open". El "Declare" simplemente establece la
consulta.*/

EXEC SQL DECLARE ProductoCursor CURSOR FOR

SELECT PRODUCTO, ID_COMPRADOR
FROM ANTIGÜEDADES
ORDER BY PRODUCTO;

EXEC SQL OPEN ProductoCursor;

/* +-- Podrías desear poner un bloque de chequeo de errores aquí. --+ */

/* Fetch pone los valores de la "siguiente" fila de la consulta en las variables locales, respectivamente. Sin
embargo, un "priming fetch" (tecnica de programación) debe ser hecha antes. Cuando el cursor está fuera
de los datos, un código SQL debe de ser generado para permitirnos salir del bucle. Para simplificar, el
bucle será dejado cuando ocurra cualquier código SQL, incluso si es una código de error. De otra manera,
un código de chequeo específico debería de ser preparado*/

EXEC SQL FETCH ProductoCursor INTO :Producto, :ID_comprador;

while(!sqlca.sqlcode)
{

/* Con cada fila, además hacemos un par de cosas. Primero, aumentamos el precio $5 (honorarios por
tramitaciones) y extraemos el nombre del comprador para ponerlo en el informe. Para hacer esto,
usaremos Update y Select, antes de imprimir la línea en la pantalla. La actuaclización, sin embargo,
asume que un comprador dado sólo ha comprado uno de todos los productos dados, o sino, el precio será
incrementado demasiadas veces. Por otra parte, una "FilaID" podría haber sido utilizada (ver
documentación). Además observa los dos puntos antes de los nombres de las variables locales cuando son
usada dentro de sentencias de SQL.*/

EXEC SQL UPDATE ANTIGÜEDADES

SET PRECIO = PRECIO + 5
WHERE PRODUCTO = :Producto AND ID_COMPRADOR = :ID_comprador;

EXEC SQL SELECT NOMBREPROPIETARIO, APELLIDOPROPIETARIO

INTO :Nombre, :Apellidos
FROM PROPIETARIOS_ANTIGÜEDADES
WHERE ID_COMPRADOR = :ID_comprador;

printf("%25s %25s %25s", Nombre, Apellidos, Producto);

/* Feo informe- sólo para propositos de ejemplo!. Veamos la siguiente fila */
EXEC SQL FETCH ProductoCursor INTO :Producto, :ID_comprador;
}
/* Cierra el cursor, entrega los cambios (ver debajo), y sale del programa */
EXEC SQL CLOSE ProductoCursor;
EXEC SQL COMMIT RELEASE;
exit();
}

CAPÍTULO 6. Cuestiones Comunes & Tópicos Avanzados

¿Por qué no puede preguntar simplemente por las tres primeras filas de la tabla? Porque en las bases
de datos relacionales, las filas son insertadas en un orden particular, esto es, el sistema las inserta en un
orden arbitrario; así, que sólo puedes pedir filas usando un válida construcción SQL, como ORDER BY,
etc.

¿Qué es eso de DDL y DML?. DDL (Data Definition Language) se refiere (en SQL) a la sentencia de
creación de tabla... DML (Data Manipulation Language) se refiere a las sentencia Select, Update, Insert y
Delete.

¿No son las tablas de las bases de datos como ficheros? Bueno, el DBMS almacena los datos en ficheros
declarados por los administrados del sistema antes de que nuevas tablas sean creadas (en grandes
sistemas), pero el sistema almacena los datos en un formato especial, y puede diseminar los datos de una
tabla sobre muchos archivos. En el mundo de la base de datos, un conjunto de archivos creados por la
base de datos es llamado "tablespace". En general, en pequeños sistemas, todos lo relacionado con una
base de datos (definiciones y todo los datos de la tabla) son guardados en un archivo.

¿Són las tablas de datos como hojas diseminadas? No, por dos razones. Primera, las hojas diseminadas
pueden tener datos en una celda, pero una celda es más que una simple intersección de fila-columna.
Dependiendo del software de diseminación de hojas, una celda puede contener formulas y formatos, los
cuales no pueden ser tenidos por una tabla de una base de datos. Segundo, las celdas diseminadas son
usualmente dependientes de datos en otras celdas. En las bases de datos, las celdas son independientes,
excepto que las columnas estén lógicamente relacionadas (por suerte, una fila de columnas, describe, en
conjunto, una entidad), y cada fila en una tabla es independiente del resto de filas.

¿Cómo puedo importar un archivo texto de datos dentro de una base de datos? Bueno, no puedes
hacerlo directamente... debes usar una utilidad, como "Oracle’s SQL*Loader", o escribir un programa
para cargar los datos en la base de datos. Un programa para hacerlo simplemente iría de registro en
registro de un archivo texto, dividiéndolo en columnas, y haciendo un Insert dentro de la base de datos.

¿Qué es un esquema? Un esquema es un conjunto lógico de tablas, como la base de datos Antigüedades
arriba... usualmente, se piensa en él simplemente como "la base de datos", pero una base de datos puede
contener más de un esquema. Por ejemplo, un esquema estrella está compuesto de tablas, donde una gran
y central tabla tiene toda la información importante, con la que se accede, vía claves ajenas, a tablas
dimensionales, las cuales tienen información de detalle, y pueden ser usadas en una unión para crear
informes detallados.

¿Hay algún filtro en general que pueda usar para hacer mis consultas SQL y bases de datos mejores y
más rápidas (optimizadas)? Puedes intentar, si puedes, evitar expresiones en Selects, tales como
SELECT ColumnaA + Columna B, etc. La consulta optimizada de la base de datos, la porción de la
DBMS que determina el mejor camino para conseguir los datos deseados fuera de la base de datos, tiene
expresiones de tal forma que puede requerir más tiempo recuperar los datos que si las columnas fueran
seleccionadas de forma normal, y las expresiones se manejaran programáticamente.
  Si estas usando una unión, trata de tener las columnas unidas por índices (desde ambas tablas).
 Cuando tengas dudas, índice.
 A no ser que tengas múltiples cuentas o consultas complejas, usa COUNT(*) (el número de filas
generadas por la consulta) mejor que COUNT(Nombre_Columna).

¿Qué es normalización? Normalización es una técnica de diseño de bases de datos que sugiere un cierto
criterio en la construcción del diseño de una tabla (decidir que columnas tendrá cada tabla, y creando la
estructura de claves), donde la idea es eliminar la redundancia de los datos no-claves entre tablas.
Normalización se refiere usualmente a condiciones de forma, y sólo introduciré las tres primeras, aunque
es usual el uso de otras más avanzadas, como la cuarta, quinta, Boyce-Codd...

 La Primera Forma Normal se refiere a mover los datos en diferentes tablas donde los datos de
cada tabla son de tipo similar, dando a cada tabla una clave primaria.
 Poner los datos en la Segunda Forma Normal se refiere a remover a otras tablas datos que sólo
dependen de parte de la clave. Por ejemplo, si hubiera dejado los nombres de antiguos
propietarios en la tabla de productos, esta no estará en la Segunda Forma Normal, porque los
datos serán redundantes; el nombre será repetido para cada producto del que se sea propietario;
teniendo en cuenta que los nombres están almacenados en su propia tabla. Los nombre en si
mismos no tienen nada que hacer con los productos, sólo las identidades de los compradores y
vendedores.
 La Tercera Forma Normal involucra deshacerse de todo aquello de las tablas que no dependa
solamente de la clave primaria. Solo incluye información que es dependiente de la clave, y
mueve a otras tablas que son independientes de la clave primaria, y crea claves primarias para las
nuevas tablas.

Hay alguna redundancia en cada forma, y si los datos están en la 3FN , también lo estarán en la 1FN y en
la 2FN, y si lo están en la 2FN, también lo estarán en la 1FN. En términos de diseño de datos, almacenar
los datos, de tal manera, que cualquier columna no-clave primaria esté en dependencia sólo de la entera
clave primaria. Si observas el ejemplo de base de datos, verás que la única forma de navegar através de la
base de datos es utilizando uniones usando columnas clave.

Otros dos importantes puntos en una base de datos es usar buenos, consistentes, lógicos, y enteros
nombres para las tablas y las columnas, y usar nombres completos en la base de datos también. En el
último punto, mi base de datos es falta de nombres, así que uso códigos numéricos para la identificación.
Es usualmente mejor, si es posible, tener claves que, por si misma, sea expliquen, por ejemplo, a clave
mejor puede ser las primeras cuatro letras del apellido y la primera inicial del propietario, como JONEB
por Bill Jones (o para evitar redundancias, añadir un número, JONEB1, JONEB2 ...).

¿Cuál es la diferencia entre una simple consulta de fila y una múltiple consulta de filas y por qué es
importante conocer la diferencia? Primero, para cubrir lo obvio, una consulta de una sólo fila es una
consulta que sólo devuelve una fila como resultado, y una consulta de múltiples filas es una consulta que
devuelve más de una fila como resultado. Si una consulta devuelve una fila o más esto depende
enteramente del diseño (o esquema) de las tablas de la base de datos. Como escritor de consultas, debes
conocer el esquema, estar seguro de incluir todas las condiciones, y estructurar tu sentencia SQL
apropiadamente, de forma que consigas el resultado deseado (aunque sea una o múltiples filas). Por
ejemplo, si quieres estar seguro que una consulta de la tabla Propietarios_Antigüedades devuelve sólo una
fila, considera una condición de igualdad de la columna de la clave primaria, ID_Propietario. Tres
razones vienen inmediatamente a la mente de por qué esto es importante. Primero, tener múltiples filas
cuando tú sólo esperabas una, o viceversa, puede significar que la consulta es errónea, que la base de
datos está incompleta, o simplemente, has aprendido algo nuevo sobre tus datos. Segundo, se estás
usando una sentencia Update o Delete, debes de estar seguro que la sentencia que estás escribiendo va a
hacer la operación en la fila (o filas) que tú quieres... o sino, estarás borrando o actualizando más filas de
las que querías. Tercero, cualquier consulta escrita en SQL embebido debe necesitar ser construida para
completar el programa lógico requerido. Si su consulta, por otra parte, devuelve múltiples filas, deberás
usar la sentencia Fetch, y muy probablemente, algún tipo de estructura de bucle para el procesamiento
iterativo de las filas devueltas por la consulta.

¿Qué hay de las relaciones? Otra cuestión de diseño... el término "relaciones" usualmente se refiere a las
relaciones entre claves ajenas y primarias entre tablas. Este concepto es importante porque cuando las
tablas de una base de datos relacional es diseñada, estas relaciones debe de ser definidas porque
determinan que columnas son o no claves primarias o claves ajenas. Debes de haber oido algo sobre el
Diagrama de Entidad-Relación, que es una vista gráfica de las tablas en el esquema de una base de datos,
con líneas conectando columnas relacionadas entre tablas. Mira el diagrama en el final de esta sección o
algunos de los sitios debajo relacionados con éste tópico, ya que hay diferentes maneras de dibujar
diagramas de E-R. Pero primero, veamos cada tipo de relación ...

 Una relación Uno-a-Uno significa que tienes una columna clave primaria que está relacionada
con una columna clave ajena, y que para cada valor de la clave primaria, hay un valor de clave
ajena. Por ejemplo, en el primer ejemplo, la tabla de direcciones de empleados, nosotros
añadimos una columna ID_EMPLEADO. Entonces, la tabla de direcciones de empleados está
relacionada con la Tabla_estadistica_empleados (segundo ejemplo de tabla) por medio de este
ID_EMPLEADO. Específicamente, cada empleado en la tabla de direcciones de empleados tiene
estadísticas (una fila de datos) en la Tabla_estadistica_empleados. Incluso, piensa que este es un
ejemplo efectuado, es una relación de "1-1". Además, ten en cuenta, el "tiene" en fuerte... cuando
se expresa una relación, es importante describir la relación con un verbo.
 Las otras dos tipos de relaciones pueden o no puede usar claves primarias lógicas y claves ajenas
necesariamente... esto es estrictamente una llamada del sistema. La primera de éstas es la
relación Uno-a-Muchos ("1-M"). Esto significa que para cada valor de la columna en una tabla,
hay uno o más valores relaciones en otra tabla. Habrá que añadir de forma necesaria claves en el
diseño o, posiblemente, algún tipo de columna identificador deberá ser usado para establecer la
relación. Un ejemplo podría ser que para todos ID_Propietario en la tabla
Propietarios_Antigüedades, hubierán uno o mas (cero también pude ser) productos comprados
en la tabla Antigüedades (verbo: comprar).
 Finalmente, la relación de Muchos-a-Muchos ("M-M") generalmente no involucra claves, y
usualmente involucra columnas identificativas. La inusual ocurrencia de un "M-M" significa que
una columna en una tabla está relacionada con otra columna en otra tabla, y para cada valor de
uno de estas dos columnas, hay uno o más valores relacionados en la correspondiente columna
en la otra tabla (y viceversa), o más comúnmente posible, dos tablas tienen una relación "1-M"
para cada una (dos relaciones, una 1-M para cada camino). Un (malo) ejemplo o ésta más común
situación podría ser si tuvieras una base de datos que asignara trabajo, donde una tabla tuviera
una fila por cada empleado y trabajo asignado, y otra tabla tuviera una fila por trabajo por cada
uno de los trabajadores asignados. Aquí, podrías tener múltiples filas por cada empleado en la
primera tabla, o pro cada trabajo asignado, y múltiples filas por cada trabajo en la segunda tabla,
una por empleado asignado al proyecto. Estas tablas tienen un M-M: cada empleado en la
primera tabla puede tener tantos trabajos asignados de la segunda tabla como trabajos haya en
ella, y cada trabajo puede tener tanto empleados como empleados haya en la primera tabla. Esto
es la punta del iceberg en este tópico... mira los links abajo para más información.

¿Qué hay de algunas construcciones no estándar importantes de SQL (pregunta extremadamente

común)? Bueno, veamos la siguiente sección...
 CAPÍTULO 7. SQL no estándar

INTERSECT y MINUS son como la sentencia UNION, excepto que INTERSECT produce filas que
aparecen en ambas consultas, y MINUS introduce filas que resultan de la primera consulta, pero no de la
segunda.

Generación de construcciones de informe: la cláusula COMPUTE es puesta al final de una consulta para
poner el resultado en una función agregada al final del listado, como COMPUTE SUM(PRECIO); Otra
opción es usar el break lógico: definir un break para dividir un resultado de una consulta dentro de grupos
basados en una columna, como BREAK ON ID_COMPRADOR. Entonces, para producir un resultado
después de listar un grupo, usa COMPUTE SUM OF PRECIO ON ID_COMPRADOR. Si, por ejemplo,
usas las tres cláusulas juntas (BREAK primero, COMPUTE después del BREAK, y COMPUTE sobre
todo ), obtendrás un informe que agrupe los productos por su ID_comprador, listando la suma de Precios
después de cada grupo de productos de un ID_comprador, y , después que todos los grupos sean listados,
la suma de todos los Precios listados, todos con cabeceras y líneas generados por SQL.

Además, algunos DBMS permiten usar más funciones en listas Select, excepto que estas funciones
(algunas funciones de carácter permite resultados de múltiples filas) vayan a ser usadas con un valor
individual (no grupos), en consultas de simples filas. Las funciones deben ser usada sólo con tipos de
datos apropiados. Aquí hay algunas funciones Matemáticas:

Funciones numéricas:

ABS(X) Valor absoluto. Convierte número negativos en positivos, o deja sólo números positivos.
CEIL(X) X es un valor decimal que será redondeado hacia arriba.
FLOOR(X) X es un valor decimal que será redondeado hacia abajo.
GREATEST(X,Y) Devuelve el más grande de los dos valores.
LEAST(X,Y) Devuelve el más pequeño de los dos valores.
MOD(X,Y) Devuelve el resto de X/Y.
 POWER(X,Y) Devuelve X elevado a Y
ROUND(X,Y) Redondea X a Y lugares decimales. Si se omite Y, X se redondea al entero más próximo.
SIGN(X) Devuelve menos si X<0, sino un más.
SQRT(X) Devuelve la raiz cuadrada de X.

Funciones de Caracteres

LEFT(<string,X) Devuelve los X caracteres más a la izquierda de la cadena.

RIGHT(<string,X) Devuelve los X caracteres más a la derecha de la cadena.
UPPER(<string) Convierte la cadena a mayúsculas.
LOWER(<string) Convierte la cadena a minúsculas.
INITCAP(<string) Convierte el primer carácter de la cadena a mayúscula.
LENGTH(<string) Devuelve el número de carácteres de cadena.
<string||<string Concatena dos cadenas de texto.
Rellena la cadena por la izquierda con el * (o el carácter que haya entre las comillas), para hacer la
LPAD(<string,X,'*')
cadena X caracteres más larga.
Rellena la cadena por la derecha con el * (o con el carácter que haya entre las comillas), para hacer la
RPAD(<string,X,'*')
cadena X caracteres más larga.
SUBSTR(<string,X,Y) Extrae Y letras de la cadena comenzando en la posición X.
Cualquier Null de la <column será sustituido por lo que haya en <value. Si el valor de la columna no el
NVL(<column,<value)
NULL, NVL no tiene efecto
 CAPÍTULO 8. Resumen de Sintaxis & Links importantes

Resumen de Sintaxis. Sólo para usuarios avanzados.

Aquí están las formas generales de las sentencias que hemos visto en este tutorial, además de alguno
información extra de algunas. RECUERDA que todos estas sentencias pueden o no pueden estar
disponibles en tu sistema, así que comprueba la documentación del mismo.

ALTER TABLE <TABLE NAME ADD|DROP|MODIFY (COLUMN SPECIFICATION[S]...ver

Create Table);

Te permite añadir, borrar o modificar una columna o columnas de la tabla, o cambiar la especificación
(tipo de datos, etc) de una columna existente; esta sentencia también es usada para las especificaciones
físicas de la tabla (como está almacenada, etc.), pero estas definiciones estas especificadas en el DBMS,
así que léete la documentación. También, estas especificaciones físicas son usada con la sentencia Create
Table, cuando una tabla es creada por primera vez. Además, solo una opción puede ser realizada por la
sentencia Alter Table en una simple sentencia: add, drop o modificar.

COMMIT;

Hace cambios hechos por algún sistema permanente de base de datos (desde el último COMMIT;
conocido por transacción)

CREATE [UNIQUE] INDEX <INDEX NAME

ON <TABLE NAME (<COLUMN LIST); --UNIQUE es opcional; entre corchetes.

CREATE TABLE <TABLE NAME

(<COLUMN NAME <DATA TYPE [(<SIZE)] <COLUMN CONSTRAINT,
...otras columnas; (también valido con ALTER TABLE)
--donde SIZE sólo se utiliza en determinados tipos, y CONSTRAIN incluye las siguientes posibilidades
(forzado automático por la DBMS; causas de fallos y generación de errores):

1.NULL o NOT NULL (ver arriba)

2.UNIQUE fuerza que dos filas no puedan tener el mismo valor para esa columna.

3.PRIMARY KEY le dice a la base de datos que la columna es la columna clave primaria (sólo usado si
la clave primaria es sólo un columna, sino, la sentencia PRIMARY KEY(columna, columna,...) aparece
después de la definición de la última columna)

4.CHECK permite que se comprueba una condición cuando un dato es esa columna es actualizado o
insertado; por ejemplo, CHECK(PRECIO 0), hace que el sistema compruebe que el precio de la
columna es mayor de cero antes de aceptar el valor... algunas veces implementado como sentencia
CONSTRAINT.

5.DEFAULT inserta el valor por defecto en la base de datos si una fila es insertada sin insertar ningún
dato en la columna; por ejemplo: BENEFICIOS INTEGER DEFAULT=10000;

6.FOREIGN KEY hace lo mismo que la clave primaria, pero es seguida por:: REFERENCES <TABLE
NAME (<COLUMN NAME), que hacen referencia a la clave primaria relacionada.

CREATE VIEW <TABLE NAME AS <QUERY;

DELETE FROM <TABLE NAME WHERE <CONDITION;

INSERT INTO <TABLE NAME [(<COLUMN LIST)]

VALUES (<VALUE LIST);

ROLLBACK; --deshace los cambios en la base de datos que hallas hecho desde el último Commit...
cuidado! Algunos software usan automáticamente Commit’s en sistemas que usan construcciones de
transacción, así que el comando RollBack podría no ir.

SELECT [DISTINCT|ALL] <LISTA DE COLUMNAS, FUNCTIONES, CONSTANTES, ETC.

FROM <LISTA DE TABLAS OR VISTAS
[WHERE <CONDICION(S)]
[GROUP BY <GROUPING COLUMN(S)]
[HAVING <CONDITION]
[ORDER BY <ORDERING COLUMN(S) [ASC|DESC]]; --donde ASC|DESC permite ordenas en
orden ASCendente o
DESCendente

UPDATE <TABLE NAME

SET <COLUMN NAME = <VALUE
[WHERE <CONDITION]; - si no se completa la cláusula Where, todas las filas serán actualizadas de
acuerdo con la sentencia SET.

Links Importantes

Computing & SQL/DB Links: Netscape -- Oracle -- Sybase -- Informix --Microsoft

SQL Reference Page -- Ask the SQL Pro -- SQL Pro's Relational DB Useful Sites
Programmer's Source -- DBMS Sites -- inquiry.com -- DB Ingredients
Web Authoring -- Computing Dictionary -- DBMS Lab/Links -- SQL FAQ -- Query List
RIT Database Design Page -- Database Jump Site -- Programming Tutorials on the Web
DB Stuff -- DBMS/IS Pages -- Access on the Web -- Online Books -- A Good DB Course
Tutorial Page -- DBMS Magazine -- Database Mining

Miscellaneous: CNN -- USA Today -- Pathfinder -- ZDNet -- CNet -- TechWeb -- LookSmart

Buscadores:: Yahoo -- Alta Vista -- Excite -- WebCrawler -- Lycos -- Infoseek -- search.com