Lenguaje SQL PDF

JCAS
1

LENGUAJE SQL
Contenido
MANTENIMIENTO DE BASE DE DATOS ........................................................................................................................ 2
CREACION DE BASES DE DATOS ............................................................................................................................... 2
SQL CREATE TABLE ................................................................................................................................................... 3
SQL CONSTRAINT ..................................................................................................................................................... 4
SQL CLAVE PRIMARIA ............................................................................................................................................... 5
SQL CREATE INDEX >> .............................................................................................................................................. 9
SQL ALTER TABLE >> ............................................................................................................................................... 10
SQL DROP TABLE >> ............................................................................................................................................... 13
SQL TRUNCATE TABLE >> ....................................................................................................................................... 13
SQL UPDATE >> ...................................................................................................................................................... 15
SQL DELETE FROM >> ............................................................................................................................................. 16
CONSULTAS SQL ......................................................................................................................................................... 17
SQL SELECT ............................................................................................................................................................. 17
SQL DISTINCT .......................................................................................................................................................... 18
SQL WHERE >> ....................................................................................................................................................... 18
SQL AND OR >>....................................................................................................................................................... 19
SQL IN >> ................................................................................................................................................................ 20
SQL BETWEEN >> ................................................................................................................................................... 21
SQL LIKE >> ............................................................................................................................................................. 22
SQL ORDER BY >> ................................................................................................................................................... 23
SQL Fonciones >> ................................................................................................................................................... 25
SQL COUNT >> ........................................................................................................................................................ 26
SQL GROUP BY >> ................................................................................................................................................... 27
SQL HAVING >> ...................................................................................................................................................... 28
SQL Alias >> ............................................................................................................................................................ 29
SQL Join >> ............................................................................................................................................................. 30
SQL Outer Join >> ................................................................................................................................................... 31
SQL Concatenar >> ................................................................................................................................................. 33
SQL SUBSTRING >> ................................................................................................................................................. 34
SQL TRIM >> ........................................................................................................................................................... 35
SQL AVANZADO .......................................................................................................................................................... 36
JCAS
2

SQL UNION ............................................................................................................................................................. 36
SQL UNION ALL >> .................................................................................................................................................. 37
SQL INTERSECT >> .................................................................................................................................................. 39
SQL MINUS >> ........................................................................................................................................................ 40
SQL Subconsulta >> ................................................................................................................................................ 41
SQL EXISTS >> ......................................................................................................................................................... 43
SQL CASE >> ........................................................................................................................................................... 44
REFERENCIA................................................................................................................................................................ 45

MANTENIMIENTO DE BASE DE DATOS

CREACION DE BASES DE DATOS

Una base de datos en un sistema relacional est compuesta por un conjunto de tablas, que
corresponden a las relaciones del modelo relacional. En la terminologa usada en SQL no se
alude a las relaciones, del mismo modo que no se usa el trmino atributo, pero s la palabra
columna, y no se habla de tupla, sino de lnea. A continuacin se usarn indistintamente ambas
terminologas, por lo que tabla estar en lugar de relacin, columna en el de atributo y lnea en
el de tupla, y viceversa.
Prcticamente, la creacin de la base de datos consiste en la creacin de las tablas que la
componen. En realidad, antes de poder proceder a la creacin de las tablas, normalmente hay
que crear la base de datos, lo que a menudo significa definir un espacio de nombres separado
para cada conjunto de tablas. De esta manera, para una DBMS se pueden gestionar diferentes
bases de datos independientes al mismo tiempo sin que se den conflictos con los nombres que
se usan en cada una de ellas. El sistema previsto por el estndar para crear los espacios
separados de nombres consiste en usar las instrucciones SQL "CREATE SCHEMA". A menudo,
dicho sistema no se usa (o por lo menos no con los fines y el significado previstos por el
estndar), pero cada DBMS prev un procedimiento propietario para crear una base de datos.
Normalmente, se ampla el lenguaje SQL introduciendo una instruccin no prevista en el
estndar: "CREATE DATABASE". La sintaxis empleada por PostgreSQL, pero tambin por las
DBMS ms difundidas, es la siguiente:

CREATE DATABASE nombre_base de datos

Una vez creada la base de datos, se pueden crear las tablas que la componen.
JCAS
3

SQL CREATE TABLE
Las tablas son la estructura bsica donde se almacena la informacin en la base de datos.
Dado que en la mayora de los casos, no hay forma de que el proveedor de base de datos sepa
con antelacin cuales son sus necesidades de almacenamiento de datos, es probable que
necesite crear tablas en la base de datos usted mismo. Muchas herramientas de base de datos
le permiten crear tablas sin ingresar SQL, pero debido a que las tablas son los contenedores de
toda la informacin, es importante incluir la sintaxis CREATE TABLE en esta gua de
referencia.
Antes de sumergirnos en la sintaxis SQL para CREATE TABLE, es una buena idea
comprender lo que se incluye en una tabla. Las tablas se dividen en filas y columnas. Cada fila
representa una parte de los datos, y cada columna puede pensarse como la representacin de
un componente de aquella parte de los datos. Entonces, por ejemplo, si tenemos una tabla
para registrar la informacin del cliente, las columnas pueden incluir informacin tal como
Primer Nombre, Apellido, Direccin, Ciudad, Pas, Fecha de Nacimiento y dems. Como
resultado, cuando especificamos una tabla, incluimos los ttulos de columna y los tipos de datos
para esta columna en particular.
Entonces Qu son los tipos de datos? Generalmente, los datos se generan en formas
variadas. Podra ser un entero (tal como 1), un nmero real (tal como 0,55), una lnea (tal como
'sql'), una fecha/expresin de tiempo (tal como '25-ene-2000 03:22:22'), o incluso en formato
binario. Cuando especificamos una tabla, necesitamos especificar el tipo de dato asociado con
cada columna (es decir, especificaremos que First_Name es de char(50) tipo lo que significa
que es una lnea con 50 caracteres). Una cosa a tener en cuenta es que las diferentes bases
de datos relacionales permiten diferentes tipos de datos, entonces es prudente consultar
primero una referencia especfica de base de datos.
La sintaxis SQL para CREATE TABLE es
CREATE TABLE "nombre_tabla"
("columna 1" "tipo_de_datos_para_columna_1",
"columna 2" "tipo_de_datos_para_columna_2",
... );
Entonces, si debemos crear una tabla para el cliente tal como se especifica anteriormente,
ingresaramos
CREATE TABLE Customer
(First_Name char(50),
Last_Name char(50),
Address char(50),
City char(50),
Country char(25),
Birth_Date datetime);
JCAS
4

A veces, deseamos brindar un valor predeterminado a cada columna. Se utiliza un valor
predeterminado cuando no especifica un valor de columna cuando ingresa datos a la tabla.
Para establecer un valor predeterminado, agregue [valor] Predeterminado luego de la
instruccin de tipo de datos. En el ejemplo anterior, si deseamos predeterminar una columna
Address como Desconocida y Ciudad como Barcelona, ingresaramos
(First_Name char(50),
Last_Name char(50),
Address char(50) default 'Unknown',
City char(50) default 'Barcelona',
Country char(25),
Birth_Date datetime);
Tambin puede limitar el tipo de informacin que una tabla /columna puede mantener. Esto se
realiza a travs de la palabra clave CONSTRAINT, que se describe a continuacin.
SQL CONSTRAINT

Puede colocar restricciones para limitar el tipo de dato que puede ingresarse en una tabla.
Dichas restricciones pueden especificarse cuando la tabla se crea por primera vez a travs de
la instruccin CREATE TABLE, o luego de crear la tabla a travs de la instruccin ALTER
TABLE.
Los tipos comunes de restricciones incluyen las siguientes:
- NOT NULL
- UNIQUE
- CHECK
- Clave primaria
- Clave externa
Cada uno se describe en detalle a continuacin.
NOT NULL
En forma predeterminada, una columna puede ser NULL. Si no desea permitir un valor NULL
en una columna, querr colocar una restriccin en esta columna especificando que NULL no es
ahora un valor permitido.
Por ejemplo, en la siguiente instruccin,
(SID integer NOT NULL,
JCAS
5

Last_Name varchar (30) NOT NULL,
First_Name varchar(30));
Las columnas SID y Last_Name no incluyen NULL, mientras que First_Name puede incluir
NULL.
UNIQUE
La restriccin UNIQUE asegura que todos los valores en una columna sean distintos.
(SID integer Unique,
Last_Name varchar (30),
La columna SID no puede incluir valores duplicados, mientras dicha restriccin no se aplica
para columnas Last_Name y First_Name.
Por favor note que una columna que se especifica como clave primaria tambin puede ser
nica. Al mismo tiempo, una columna que es nica puede o no ser clave primaria.
CHECK
La restriccin CHECK asegura que todos los valores en una columna cumplan ciertas
condiciones.
(SID integer CHECK (SID > 0),
Last_Name varchar (30),
La columna SID slo debe incluir enteros mayores a 0.
Por favor note que la restriccin CHECK no sea ejecutada por MySQL en este momento.
Clave primaria y Clave externa se comentan en las siguientes dos secciones.
SQL CLAVE PRIMARIA
La clave primaria se utiliza para identificar en forma nica cada lnea en la tabla. Puede ser
parte de un registro real, o puede ser un campo artificial (uno que no tiene nada que ver con el
JCAS
6

registro real). Una clave primaria puede consistir en uno o ms campos en una tabla. Cuando
se utilizan mltiples campos como clave primaria, se los denomina claves compuestas.
Las claves primarias pueden especificarse cuando se crea la tabla (utilizando CREATE
TABLE) o cambiando la estructura existente de la tabla (utilizando ALTER TABLE).
A continuacin se presentan ejemplos para la especificacin de una clave primaria cuando se
crea una tabla:
MySQL:
(SID integer,
Last_Name varchar(30),
First_Name varchar(30),
PRIMARY KEY (SID));
Oracle:
(SID integer PRIMARY KEY,
SQL Server:
(SID integer PRIMARY KEY,
A continuacin se presentan ejemplos para la especificacin de una clave primaria al modificar
una tabla:
MySQL:
ALTER TABLE Customer ADD PRIMARY KEY (SID);
Oracle:
SQL Server:
JCAS
7

Nota: Antes de utilizar el comando ALTER TABLE para agregar una clave primaria, necesitar
asegurarse de que el campo est definido como 'NOT NULL' -- en otras palabras, NULL no
puede aceptarse como valor para ese campo.
SQL Clave externa >>
SQL > Manipulacin de Tabla > Create View
Las vistas pueden considerarse como tablas virtuales. Generalmente hablando, una tabla tiene
un conjunto de definiciones, y almacena datos fsicamente. Una vista tambin tiene un conjunto
de definiciones, que se construye en la parte superior de la(s) tabla(s) u otra(s) vista(s), y no
almacena datos fsicamente.
La sintaxis para la creacin de una vista es la siguiente:
CREATE VIEW "NOMBRE_VISTA" AS "Instruccin SQL";
La Instruccin SQL puede ser cualquiera de las instrucciones SQL que hemos descripto en
esta gua de referencia.
Utilicemos un ejemplo simple para ilustrar. Supongamos que tenemos la siguiente tabla:
Tabla Customer
Nombre de Columna Tip de Datos
First_Name char(50)
Last_Name char(50)
Address char(50)
City char(50)
Country char(25)
Birth_Date datetime
y deseamos crear una vista denominada V_Customer que contiene slo las columnas
First_Name, Last_Name y Pas de esta tabla, ingresaramos
CREATE VIEW V_Customer
AS SELECT First_Name, Last_Name, Country
FROM Customer;
Ahora tenemos una vista llamada V_Customer con la siguiente estructura:
View V_Customer
JCAS
8

First_Name char(50)
Last_Name char(50)
Country char(25)
Podemos utilizar tambin una vista para aplicar uniones a dos tablas. En este caso, los
usuarios slo ven una vista en vez de dos tablas, y la instruccin SQL que los usuarios
necesitan emitir se vuelve mucho ms simple. Digamos que tenemos las siguientes dos tablas:
Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
Boston 700 08-Jan-1999
Tabla Geography
Region_Name Store_Name
East Boston
East New York
West Los Angeles
West San Diego
y deseamos construir una vista que tenga ventas organizadas segn la regin. Colocaramos la
siguiente instruccin SQL:
CREATE VIEW V_REGION_SALES
AS SELECT A1.Region_Name REGION, SUM(A2.Sales) SALES
FROM Geography A1, Store_Information A2
WHERE A1.Store_Name = A2.Store_Name
GROUP BY A1.Region_Name;
Esto nos brinda una vista, V_REGION_SALES, que se ha definido para las ventas de los
negocios segn los registros de la regin. Si deseamos saber el contenido de esta vista,
ingresamos,
SELECT * FROM V_REGION_SALES;
Resultado:
REGION SALES
JCAS
9

East 700
West 2050

SQL CREATE INDEX >>

Los ndices nos ayudan a obtener datos de las tablas en forma ms rpida. Utilicemos un
ejemplo para ilustrar este punto: Digamos que estamos interesados en leer en un libro de
jardinera acerca de cmo cultivar pimientos. En vez de leer el libro desde el comienzo hasta
que encontremos una seccin sobre pimientos, es mucho ms rpido para nosotros ir a la
seccin ndice al final del libro, ubicar qu pginas contienen la informacin sobre pimientos, y
luego dirigirnos a esas pginas directamente. Al dirigirnos al ndice primero ahorramos tiempo y
seguramente es el mtodo ms eficiente para ubicar la informacin que necesitamos.
El mismo principio se aplica para la obtencin de datos desde una tabla de base de datos. Sin
un ndice, el sistema de base de datos lee a travs de toda la tabla (este proceso se denomina
escaneo de tabla) para localizar la informacin deseada. Con el ndice correcto en su lugar, el
sistema de base de datos puede entonces primero dirigirse al ndice para encontrar de dnde
obtener los datos, y luego dirigirse a dichas ubicaciones para obtener los datos necesarios.
Esto es mucho ms rpido.
Por lo tanto, generalmente se recomienda crear ndices en tablas. Un ndice puede cubrir una o
ms columnas. La sintaxis general para la creacin de un ndice es:
CREATE INDEX "NOMBRE_NDICE" ON "NOMBRE_TABLA" (NOMBRE_COLUMNA);
Digamos que tenemos la siguiente tabla:
Tabla Customer
First_Name char(50)
Last_Name char(50)
Address char(50)
City char(50)
Country char(25)
Birth_Date datetime
Si deseamos crear un ndice tanto en Ciudad como en Pas, ingresaramos,
CREATE INDEX IDX_CUSTOMER_LAST_NAME
ON Customer (Last_Name);
JCAS
10

Pour crer un index dans City et Country, il faut saisir
CREATE INDEX IDX_CUSTOMER_LOCATION
ON Customer (City, Country);
No hay una regla estricta respecto de cmo nombrar un ndice. El mtodo generalmente
aceptado es colocar un prefijo, tal como IDX_, antes del nombre de un ndice para evitar la
confusin con otros objetos de la base de datos. Tambin es una buena idea brindar
informacin sobre qu tabla y columna(s) se utilizar el ndice.
Por favor note que la sintaxis exacta para CREATE INDEX puede ser distinta segn las
diferentes bases de datos. Debera consultar con su manual de referencia de base de datos
para obtener la sintaxis precisa.
SQL ALTER TABLE >>

Una vez que se crea la tabla en la base de datos, hay muchas ocasiones donde uno puede
desear cambiar la estructura de la tabla. Los casos tpicos incluyen los siguientes:
- Agregar una columna
- Eliminar una columna
- Cambiar el nombre de una columna
- Cambiar el tipo de datos para una columna
Por favor note que lo anterior no es una lista exhaustiva. Hay otras instancias donde ALTER
TABLE se utiliza para cambiar la estructura de la tabla, tales como cambiar la especificacin
de la clave primaria o agregar una restriccin nica para una columna.
La sintaxis SQL para ALTER TABLE es
ALTER TABLE "nombre_tabla"
[modificar especificacin];
[modificar especificacin] depende del tipo de modificacin que deseamos realizar. Para los
usos mencionados anteriormente, las instrucciones [modificar especificacin] son:
Agregar una columna: ADD columna 1 tipos de datos para columna 1
Eliminar una columna: DROP columna 1
Cambiar el nombre de una columna: CHANGE nombre antiguo de la columna
nuevo nombre de la columna tipos de datos para la nueva columna".
Cambiar el tipo de datos para una columna: MODIFY columna 1 nuevo tipo de
datos
JCAS
11

Recorramos ejemplos para cada uno de lo anteriormente mencionado, utilizando la tabla
cliente creada en la seccin CREATE TABLE, il convient de se reporter aux exemples
mentionns ci-dessus.
Tabla Customer
First_Name char(50)
Last_Name char(50)
Address char(50)
City char(50)
Country char(25)
Birth_Date datetime
Primero, deseamos agregar una columna denominada Gender a esta tabla. Para hacerlo,
ingresamos,
ALTER TABLE Customer ADD Gender char(1);
Estructura de la tabla resultante:
Table Customer
First_Name char(50)
Last_Name char(50)
Address char(50)
City char(50)
Country char(25)
Birth_Date datetime
Gender char(1)
Luego, deseamos renombrar Address" a Addr. Para hacerlo, ingresamos,
ALTER TABLE Customer CHANGE Address Addr char(50);
Table customer
JCAS
12

First_Name char(50)
Last_Name char(50)
Addr char(50)
City char(50)
Country char(25)
Birth_Date datetime
Gender char(1)
Luego, lo que queremos es cambiar el tipo de datos para Addr a 30 caracteres. Para
hacerlo, ingresamos,
ALTER TABLE Customer MODIFY Addr char(30);
Table Customer
First_Name char(50)
Last_Name char(50)
Addr char(30)
City char(50)
Country char(25)
Birth_Date datetime
Gender char(1)
Finalmente, deseamos eliminar la columna Gender. Para hacerlo, ingresamos,
ALTER TABLE Customer DROP Gender;
Table Customer
First_Name char(50)
Last_Name char(50)
JCAS
13

Addr char(30)
City char(50)
Country char(25)
Birth_Date datetime

SQL DROP TABLE >>
A veces podemos decidir que necesitamos eliminar una tabla en la base de datos por alguna
razn. De hecho, sera problemtico si no podemos hacerlo ya que esto creara una pesadilla
de mantenimiento para DBA. Afortunadamente, SQL nos permite hacerlo, ya que podemos
utilizar el comando DROP TABLE. La sintaxis para DROP TABLE es
DROP TABLE "nombre_tabla";
Entonces, si deseamos eliminar una tabla denominada cliente que creamos en la
seccin CREATE TABLE, simplemente ingresamos
DROP TABLE Customer;

SQL TRUNCATE TABLE >>

A veces deseamos eliminar los datos en una tabla. Una forma de hacer esto es con DROP
TABLE, que vimos en la ltima seccin Pero Si deseamos simplemente deshacernos de
los datos pero no de la tabla en s? Para esto, podemos utilizar el comando TRUNCATE
TABLE. La sintaxis para TRUNCATE TABLE es
TRUNCATE TABLE "nombre_tabla";
Entonces, si deseamos truncar una tabla denominada cliente que creamos en SQL
CREATE TABLE, simplemente ingresamos
TRUNCATE TABLE Customer;
SQL INSERT INTO >>
SQL > Manipulacin de Tabla > Insert Into
En las secciones anteriores, hemos visto cmo obtener informacin de tablas. Pero Cmo se
ingresan estas filas de datos en estas tablas en primer lugar? Esto es lo que se trata en esta
seccin, que explica la instruccin INSERT, y en la siguiente seccin, que explica la
instruccin UPDATE.
JCAS
14

En SQL, hay fundamental y bsicamente dos formas para INSRER datos en una tabla: Una
es insertar una fila por vez, y la otra es insertar filas mltiples por vez. Primero observemos
como podemos INSRER datos a travs de una fila por vez:
La sintaxis para insertar datos en una tabla mediante una fila por vez es la siguiente:
INSERT INTO "nombre_tabla" ("columna1", "columna2", ...)
VALUES ("valor1", "valor2", ...);
Suponiendo que tenemos una taba con la siguiente estructura,
Store_Name char(50)
Sales float
Txn_Date datetime
y ahora deseamos insertar una fila adicional en la tabla que represente los datos de ventas
para Los ngeles el 10 de enero de 1999. En ese da, este negocio tena $900 dlares
estadounidenses en ventas. Por lo tanto, utilizaremos la siguiente escritura SQL:
INSERT INTO Store_Information (Store_Name, Sales, Txn_Date)
VALUES ('Los Angeles', 900, '10-Jan-1999');
El segundo tipo de INSERT INTO nos permite insertar filas mltiples en una tabla. A diferencia
del ejemplo anterior, donde insertamos una nica fila al especificar sus valores para todas las
columnas, ahora utilizamos la instruccin SELECT para especificar los datos que deseamos
insertar en la tabla. Si est pensando si esto significa que est utilizando informacin de otra
tabla, est en lo correcto. La sintaxis es la siguiente:
INSERT INTO "tabla1" ("columna1", "columna2", ...)
SELECT "columna3", "columna4", ...
FROM "tabla2";
Note que esta es la forma ms simple. La instruccin entera puede contener fcilmente
clusulas WHERE,GROUP BY, y HAVING, as como tambin uniones y alias.
Entonces por ejemplo, si deseamos tener una tabla Store_Information, que recolecte la
informacin de ventas para el ao 1998, y ya conoce en donde reside la fuente de datos en
tabala Sales_Information, ingresaremos:
INSERT INTO Store_Information (Store_Name, Sales, Txn_Date)
SELECT Store_Name, Sales, Txn_Date
JCAS
15

FROM Sales_Information
WHERE Year (Txn_Date) = 1998;
Aqu hemos utilizado la sintaxis de Servidor SQL para extraer la informacin anual por medio
de una fecha. Otras bases de datos relacionales pueden tener sintaxis diferentes. Por ejemplo,
en Oracle, utilizarTO_CHAR (Txn_Date, 'yyyy') = 1998.
SQL UPDATE >>
Una vez que hay datos en la tabla, podramos tener la necesidad de modificar los mismos. Para
hacerlo, utilizamos el comando UPDATE. La sintaxis para esto es,
UPDATE "nombre_tabla"
SET "columna_1" = [nuevo valor]
WHERE "condicin";
Por ejemplo, digamos que actualmente tenemos la tabla a continuacin:
y notamos que las ventas para Los Angeles el 08/01/1999 es realmente de 500 en vez de
300 dlares estadounidenses, y que esa entrada en particular necesita actualizarse. Para
hacerlo, utilizamos el siguiente SQL:
UPDATE Store_Information
SET Sales = 500
WHERE Store_Name = 'Los Angeles'
AND Txn_Date = '08-Jan-1999';
La tabla resultante ser vera
JCAS
16

En este caso, hay slo una fila que satisface la condicin en la clusula WHERE. Si hay
mltiples filas que satisfacen la condicin, todas ellas se modificarn.
Tambin es posible UPDATE mltiples columnas al mismo tiempo. La sintaxis en este caso se
vera como la siguiente:
UPDATE "nombre_tabla"
SET colonne 1 = [[valor1], colonne 2 = [valor2]
WHERE "condicin";

SQL DELETE FROM >>
A veces podemos desear deshacernos de los registros de una tabla. Para ello, utilizamos el
comando DELETE FROM. La sintaxis para esto es,
DELETE FROM "nombre_tabla"
WHERE "condicin";
Es ms fcil utilizar un ejemplo. Por ejemplo, digamos que actualmente tenemos la siguiente
tabla:
y decidimos no mantener ninguna informacin sobre Los ngeles en esta tabla. Para lograrlo,
ingresamos el siguiente SQL:
DELETE FROM Store_Information
WHERE Store_Name = 'Los Angeles';
Ahora el contenido de la tabla se vera,
JCAS
17


CONSULTAS SQL

SQL SELECT
Para qu utilizamos los comandos SQL? El uso comn es la seleccin de datos desde tablas
ubicadas en una base de datos. Inmediatamente, vemos dos palabras claves:
necesitamos SELECT la informacin FROM una tabla. (Note que la tabla es un contenedor que
reside en la base de datos donde se almacena la informacin. Para obtener ms informacin
acerca de cmo manipular tablas, consulte la Seccin Manipulacin de Tabla). Por lo tanto
tenemos la estructura SQL ms bsica:
SELECT "nombre_columna" FROM "nombre_tabla";
Para ilustrar el ejemplo anterior, suponga que tenemos la siguiente tabla:
Podemos utilizar esta tabla como ejemplo a lo largo de la gua de referencia (esta tabla
aparecer en todas las secciones). Para seleccionar todos los negocios en esta tabla,
ingresamos,
SELECT Store_Name FROM Store_Information;
Resultado:
Store_Name
Los Angeles
San Diego
Los Angeles
Boston
JCAS
18

Pueden seleccionarse los nombres de columnas mltiples, as como tambin los nombres de
tablas mltiples.

SQL DISTINCT
La palabra clave SELECT nos permite tomar toda la informacin de una columna (o columnas)
en una tabla. Esto, obviamente, significa necesariamente que habr redundancias. Qu
sucedera si slo deseamos seleccionar cada elemento DISTINCT? Esto es fcil de realizar en
SQL. Todo lo que necesitamos hacer es agregar DISTINCT luego de SELECT. La sintaxis es la
siguiente:
SELECT DISTINCT "nombre_columna"
FROM "nombre_tabla";
Por ejemplo, para seleccionar todos los negocios distintos en la Tabla Store_Information,
Ingresamos,
SELECT DISTINCT store_name FROM Store_Information;
Resultado:
Store_Name
Los Angeles
San Diego
Boston

SQL WHERE >>

Luego, podramos desear seleccionar condicionalmente los datos de una tabla. Por ejemplo,
podramos desear slo recuperar los negocios con ventas mayores a 1.000 dlares
estadounidenses. Para ello, utilizamos la palabra clave WHERE. La sintaxis es la siguiente:
JCAS
19

SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "condicin";
Por ejemplo, para seleccionar todos los negocios con ventas mayores a 1000 dlares
estadounidenses en la Tabla Store_Information,
Ingresamos,
SELECT Store_Name
FROM Store_Information
WHERE Sales > 1000;
Resultado:

SQL AND OR >>

En la seccin anterior, hemos visto que la palabra clave WHERE tambin puede utilizarse para
seleccionar datos condicionalmente desde una tabla. Esta condicin puede ser una condicin
simple (como la que se presenta en la seccin anterior), o puede ser una condicin compuesta.
Las condiciones compuestas estn formadas por mltiples condiciones simples conectadas
por AND u OR. No hay lmites en el nmero de condiciones simples que pueden presentarse
en una sola instruccin SQL.
La sintaxis de una condicin compuesta es la siguiente:
FROM "nombre_tabla"
WHERE "condicin simple"
{[AND|OR] "condicin simple"}+;
Store_Name
Los Angeles
JCAS
20

{}+ significa que la expresin dentro de las llaves ocurrir una o ms veces. Note
que AND u OR pueden utilizarse indistintamente. Adems, podemos utilizar el smbolo
parntesis ( ) para indicar el orden de la condicin.
Por ejemplo, podemos desear seleccionar todos los negocios con ventas mayores a 1000
dlares estadounidenses o todos los negocios con ventas menores a 500 dlares
estadounidenses pero mayores a 275 dlares estadounidenses en la
Tabla Store_Information,
San Francisco 300 08-Jan-1999
Ingresamos,
SELECT Store_Name
WHERE Sales > 1000
OR (Sales < 500 AND Sales > 275);
Resultado:
Store_Name
Los Angeles
San Francisco
SQL IN >>

En SQL, hay dos usos de la palabra clave IN, y esta seccin introduce aqul relacionado con la
clusulaWHERE. Cuando se lo utiliza en este contexto, sabemos exactamente el valor de los
valores regresados que deseamos ver para al menos una de las columnas. La sintaxis para el
uso de la palabra clave IN es la siguiente:
FROM "nombre_tabla"
WHERE "nombre_columna" IN (''valor1', ''valor2', ...);
El nmero de valores en los parntesis pueden ser uno o ms, con cada valor separado por
comas. Los valores pueden ser nmeros o caracteres. Si hay slo un valor dentro del
parntesis, este comando es equivalente a
JCAS
21

WHERE "nombre_columna" = 'valor1'
Por ejemplo, podramos desear seleccionar todos los registros para los negocios de Los
ngeles y San Diego en la Tabla Store_Information,
Ingresamos,
SELECT *
WHERE Store_Name IN ('Los Angeles', 'San Diego');
Resultado:

SQL BETWEEN >>

Mientras que la palabra clave IN ayuda a las personas a limitar el criterio de seleccin para
uno o ms valores discretos, la palabra clave BETWEEN permite la seleccin de un rango.
La sintaxis para la clusulaBETWEEN es la siguiente:
FROM "nombre_tabla"
WHERE "nombre_columna" BETWEEN 'valor1' AND 'valor2';
Esto seleccionar todas las filas cuya columna tenga un valor entre 'valor1' y 'valor2'.
Por ejemplo, podramos desear seleccionar la visualizacin de toda la informacin de ventas
entre el 06 de enero de 1999, y el 10 de enero de 1999, en la Tabla Store_Information,
JCAS
22

Ingresamos,
SELECT *
WHERE Txn_Date BETWEEN '06-Jan-1999' AND '10-Jan-1999';
Tenga en cuenta que la fecha puede almacenarse en diferentes formatos segn las
diferentes bases de datos. Esta gua de referencia simplemente elige uno de los formatos.
Resultado:

SQL LIKE >>

LIKE es otra palabra clave que se utiliza en la clusula WHERE. Bsicamente, LIKE le permite
hacer una bsqueda basada en un patrn en vez de especificar exactamente lo que se desea
(como en IN) o determinar un rango (como en BETWEEN). La sintaxis es la siguiente:
FROM "nombre_tabla"
WHERE "nombre_columna" LIKE {patrn};
{patrn} generalmente consiste en comodines. Aqu hay algunos ejemplos:
'A_Z': Toda lnea que comience con 'A', otro carcter y termine con 'Z'. Por ejemplo,
'ABZ' y 'A2Z' deberan satisfacer la condicin, mientras 'AKKZ' no debera (debido a que
hay dos caracteres entre A y Z en vez de uno).
'ABC%': Todas las lneas que comienzan con 'ABC'. Por ejemplo, 'ABCD' y 'ABCABC'
ambas deberan satisfacer la condicin.
JCAS
23

'%XYZ': Todas las lneas que terminan con 'XYZ'. Por ejemplo, 'WXYZ' y 'ZZXYZ' ambas
deberan satisfacer la condicin.
'%AN%': : Todas las lneas que contienen el patrn 'AN' en cualquier lado. Por ejemplo,
'LOS ANGELES' y 'SAN FRANCISCO' ambos deberan satisfacer la condicin.
Digamos que tenemos la siguiente tabla:
LOS ANGELES 1500 05-Jan-1999
SAN DIEGO 250 07-Jan-1999
SAN FRANCISCO 300 08-Jan-1999
BOSTON 700 08-Jan-1999
Deseamos encontrar todos los negocios cuyos nombres contengan AN. Para hacerlo,
ingresamos,
SELECT *
WHERE Store_Name LIKE '%AN%';
Resultado:
LOS ANGELES 1500 05-Jan-1999
SAN DIEGO 250 07-Jan-1999
SAN FRANCISCO 300 08-Jan-1999

SQL ORDER BY >>

Hasta ahora, hemos visto cmo obtener datos de una tabla utilizando los
comandos SELECT y WHERE. Con frecuencia, sin embargo, necesitamos enumerar el
resultado en un orden particular. Esto podra ser en orden ascendente, en orden descendente,
o podra basarse en valores numricos o de texto. En tales casos, podemos utilizar la palabra
clave ORDER BY para alcanzar nuestra meta.
La sintaxis para una instruccin ORDER BY es la siguiente:
FROM "nombre_tabla"
JCAS
24

[WHERE "condicin"]
ORDER BY "nombre_columna" [ASC, DESC];
[ ] significa que la instruccin WHERE es opcional. Sin embargo, si existe una
clusula WHERE, viene antes de la clusula ORDER BY ASC significa que los resultados se
mostrarn en orden ascendente, y DESCsignifica que los resultados se mostrarn en orden
descendente. Si no se especifica ninguno, la configuracin predeterminada es ASC.
Es posible ordenar por ms de una columna. En este caso, la clusula ORDER BY anterior se
convierte en
ORDER BY "nombre1_columna" [ASC, DESC], "nombre2_columna" [ASC, DESC]
Suponiendo que elegimos un orden ascendente para ambas columnas, el resultado se
clasificar en orden ascendente segn la columna 1. Si hay una relacin para el valor de la
columna 1, se clasificar en orden ascendente segn la columna 2.
Por ejemplo, podramos desear enumerar los contenidos de la Tabla Store_Information segn
la suma en dlares, en orden descendente:
Ingresamos,
ORDER BY Sales DESC;
Resultado:
Adems del nombre de la columna, podramos utilizar la posicin de la columna (segn la
consulta SQL) para indicar en qu columna deseamos aplicar la clusula ORDER BY. La
JCAS
25

primera columna es 1, y la segunda columna es 2, y as sucesivamente. En el ejemplo anterior,
alcanzaremos los mismos resultados con el siguiente comando:
ORDER BY 2 DESC;

SQL Fonciones >>
Ya que hemos comenzado trabajando con nmeros, la siguiente pregunta natural a realizarse
es si es posible hacer clculos matemticos con aquellos nmeros, tales como sumas, o sacar
un promedio. La respuesta es s! SQL tiene varias funciones aritmticas, y estas son:
AVG
COUNT
MAX
MIN
SUM
La sintaxis para el uso de funciones es,
SELECT "tipo de funcin"("nombre_columna")
Por ejemplo, si deseamos obtener la sumatoria de todas las ventas de la siguiente tabla,
ingresaramos
SELECT SUM(Sales) FROM Store_Information;
Resultado:
SUM(Sales)
2750
JCAS
26

2750 dlares estadounidenses representa la suma de todas las entradas de Ventas: 1500 +
250 + 300 + 700.
Adems de utilizar dichas funciones, tambin es posible utilizar SQL para realizar tareas
simples como suma (+) y resta (-). Para ingresar datos del tipo caracter, hay tambin varias
funciones de cadenas disponibles, tales como funciones de concatenacin, reduccin y
subcadena. Los diferentes proveedores RDBMS tienen diferentes implementaciones de
funciones de cadenas, y es mejor consultar las referencias para sus RDBMS a fin de ver cmo
se utilizan estas funciones.
SQL COUNT >>

Otra funcin aritmtica es COUNT. Esto nos permite COUNT el nmero de filas en una tabla
determinada. La sintaxis es,
SELECT COUNT("nombre_columna")
FROM "nombre_columna";
Por ejemplo, si deseamos encontrar el nmero de entradas de negocios en nuestra tabla,
ingresamos,
SELECT COUNT (Store_Name)
FROM Store_Information;
Resultado:
COUNT (Store_Name)
4
COUNT y DISTINCT pueden utilizarse juntos en una instruccin para determinar el nmero de
las distintas entradas en una tabla. Por ejemplo, si deseamos saber el nmero de los distintos
negocios, ingresaramos,
JCAS
27

SELECT COUNT (DISTINCT Store_Name)
Resultado:
COUNT (DISTINCT Store_Name)
3

SQL GROUP BY >>

Ahora regresamos a las funciones de agregados. Recuerda que utilizamos la palabra
clave SUM para calcular las ventas totales para todos los negocios? Y si quisiramos calcular
el total de ventas para cadanegocio? Entonces, necesitamos hacer dos cosas: Primero,
necesitamos asegurarnos de que hayamosseleccionado el nombre del negocio as como
tambin las ventas totales. Segundo, debemos asegurarnos de que todas las sumas de las
ventas estn GROUP BY negocios. La sintaxis SQL correspondiente es,
SELECT "nombre1_columna", SUM("nombre2_columna")
FROM "nombre_tabla"
GROUP BY "nombre1-columna";
Ilustremos utilizando la siguiente tabla,
Deseamos saber las ventas totales para cada negocio. Para hacerlo, ingresaramos,
SELECT Store_Name, SUM(Sales)
GROUP BY Store_Name;
Resultado:
Store_Name SUM(Sales)
Los Angeles 1800
San Diego 250
JCAS
28

Boston 700
La palabra clave GROUP BY se utiliza cuando estamos seleccionado columnas mltiples
desde una tabla (o tablas) y aparece al menos un operador aritmtico en la
instruccin SELECT. Cuando esto sucede, necesitamos GROUP BY todas las otras columnas
seleccionadas, es decir, todas las columnas excepto aquella(s) que se operan por un operador
aritmtico.
SQL HAVING >>
Otra cosa que la gente puede querer hacer es limitar el resultado segn la suma
correspondiente (o cualquier otra funcin de agregado). Por ejemplo, podramos desear ver
slo los negocios con ventas mayores a 1 500 , dlares. En vez de utilizar la
clusula WHERE en la instruccin SQL, a pesar de que necesitemos utilizar la
clusula HAVING, que se reserva para funciones de agregados. La clusula HAVING se coloca
generalmente cerca del fin de la instruccin SQL, y la instruccin SQL con la clusula HAVING.
puede o no incluir la clusula GROUP BY sintaxis para HAVING es,
SELECT "nombre1_columna", SUM("nombre2_columna")
FROM "nombre_tabla"
GROUP BY "nombre1_columna"
HAVING (condicin de funcin aritmtica);
Nota: La clusula GROUP BY es opcional.
En nuestro ejemplo, tabla Store_Information,
ingresaramos,
SELECT Store_Name, SUM(Sales)
GROUP BY Store_Name
HAVING SUM(Sales) > 1500;
Resultado:
JCAS
29

Store_Name SUM(Sales)
Los Angeles 1800

SQL Alias >>

Nos concentraremos ahora en el uso de alias. Hay dos tipos de alias que se utilizan con mayor
frecuencia. Alias de columna y alias de tabla.
Resumiendo, los alias de columna existen para ayudar en la organizacin del resultado. En el
ejemplo anterior, cualquiera sea el momento en que vemos las ventas totales, se enumeran
como SUM(Sales). Mientras esto es comprensible, podemos ver casos donde el ttulo de la
columna pueden complicarse (especialmente si incluye varias operaciones aritmticas). El uso
de un alias de columna hara el resultado mucho ms legible.
El segundo tipo de alias es el alias de tabla. Esto se alcanza al colocar un alias directamente
luego del nombre de tabla en la clusula FROM. Esto es conveniente cuando desea obtener
informacin de dos tablas separadas (el trmino tcnico es 'realizar uniones'). La ventaja de
utiliza un alias de tablas cuando realizamos uniones es rpidamente aparente cuando
hablamos de uniones.
Antes de comenzar con las uniones, miremos la sintaxis tanto para el alias de columna como
de tabla:
SELECT "alias_tabla"."nombre1_columna" "alias_columna"
FROM "nombre_tabla" "alias_tabla";
Brevemente, ambos tipos de alias se colocan directamente despus del elemento por el cual
generan el alias, separados por un espacio en blanco. Nuevamente utilizamos nuestra
tabla, Store_Information,
Utilizamos el mismo ejemplo que en la seccin SQL GROUP BY, salvo que hemos colocado
tanto el alias de columna como el alias de tabla:
JCAS
30

SELECT A1.Store_Name Store, SUM(A1.Sales) "Total Sales"
FROM Store_Information A1
GROUP BY A1.Store_Name;
Resultado:
Store Total Sales
Los Angeles 1800
San Diego 250
Boston 700
Note la diferencia en el resultado: los ttulos de las columnas ahora son diferentes. Ese es el
resultado de utilizar el alias de columna. Note que en vez de Sum(Sales) de algn modo
enigmtico, ahora tenemos Total Sales, que es ms comprensible, como ttulo de columna. La
ventaja de utilizar un alias de tablas no es fcil de ver en este ejemplo. Sin embargo, se tornar
evidente en la siguiente seccin.

SQL Join >>
Ahora miremos las uniones. Para realizar uniones en SQL se requieren mucho de los
elementos que ya hemos presentado. Digamos que tenemos las siguientes dos tablas:
Tabla Geography
East Boston
East New York
West Los Angeles
West San Diego
y queremos saber las ventas por regin. Vemos que la tabla Geography incluye informacin
sobre regiones y negocios, y la tabla Store_Information contiene informacin de ventas para
JCAS
31

cada negocio. Para obtener la informacin de ventas por regin, debemos combinar la
informacin de las dos tablas. Al examinar las dos tablas, encontramos que estn enlazadas a
travs del campo comn nombre_negocio Primero presentaremos la instruccin SQL y
explicaremos el uso de cada segmento despus:
SELECT A1.Region_Name REGION, SUM(A2.Sales) SALES
WHERE A1.Store_Name = A2.Store_Name
GROUP BY A1.Region_Name;
Resultado:
REGION SALES
East 700
West 2050
Las primeras dos lneas le indican a SQL que seleccione dos campos, el primero es el campo
"Region_Name" de la tabla Geography (denominado REGION), y el segundo es la suma del
campo "Sales" de la tablaStore_Information (denominado SALES). Note como se utilizan los
alias de tabla aqu: Geography se denomina A1, e Store_Information se denomina A2. Sin los
alias, la primera lnea sera
SELECT Geography.region_name REGION, SUM(Store_Information.Sales) SALES
que es mucho ms problemtica. En esencia, los alias de tabla facilitan el entendimiento de la
totalidad de la instruccin SQL, especialmente cuando se incluyen tablas mltiples.
Luego, pongamos nuestra atencin en la lnea 2, la instruccin WHERE. Aqu es donde se
especifica la condicin de la unin. En este caso, queremos asegurarnos que el contenido en
"Store_Name" en la tablaGeography concuerde con la tabla Store_Information, y la forma de
hacerlo es igualarlos. Esta instruccinWHERE es esencial para asegurarse de que obtenga el
resultado correcto. Sin la correcta instruccin WHEREse producir una Unin Cartesiana. Las
uniones cartesianas darn por resultado que de la consulta se arroje toda combinacin posible
de las dos tablas (o cualquiera que sea el nmero de tablas en la instruccinFROM). En este
caso, una unin cartesiana resultara en un total de 4x4 = Se presenta un resultado de16 filas.
SQL Outer Join >>
Anteriormente, hemos visto una unin izquierda, o interna, donde seleccionamos filas comunes
a las tablas que participan en la unin. Qu sucede en los casos donde estamos interesados
en la seleccin de elementos en una tabla sin importar si se encuentran presentes en la
segunda tabla? Ahora necesitaremos utilizar el comando SQL OUTER JOIN.
La sintaxis para realizar una unin externa en SQL depende de la base de datos. Por ejemplo,
en Oracle, colocaremos un "(+)" en la clusula WHERE del otro lado de la tabla para la que
queremos incluir todas las filas.
JCAS
32

Digamos que tenemos las siguientes dos tablas:
Tabla Geography
East Boston
East New York
West Los Angeles
West San Diego
y queremos saber la suma de las ventas de todos los negocios. Si realizamos una unin
regular, no podramos obtener lo que deseamos debido a que habramos omitido New York"
ya que no aparece en la tabla Store_Information. Por lo tanto, necesitamos realizar una unin
externa respecto de las dos tablas anteriores:
SELECT A1.Store_Name, SUM(A2.Sales) SALES
WHERE A1.Store_Name = A2.Store_Name (+)
GROUP BY A1.Store_Name;
Note que en este caso, estamos utilizando la sintaxis Oracle para unin externa.
Resultado:
Store_Name SALES
Boston 700
New York
Los Angeles 1800
San Diego 250
Nota: Se devuelve NULL cuando no hay coincidencia en la segunda tabla. En este caso, New
York" no aparece en la tabla Store_Information, por lo tanto su columna "SALES"
correspondiente es NULL.
JCAS
33

SQL Concatenar >>

Algunas veces es necesario combinar en forma conjunta (concatenar) los resultados de varios
campos diferentes. Cada base de datos brinda una forma para realizar esto:
MySQL: CONCAT( )
Oracle: CONCAT( ), ||
SQL Server: +
La sintaxis para CONCAT( ) es la siguiente:
CONCAT (cad1, cad2, cad3, ...)
Concatenar cad1, cad2, cad3, y cualquier otra cadena juntas. Por favor note que la funcin
CONCAT( ) de Oracle slo permite dos argumentos slo dos cadenas pueden colocarse
juntas al mismo tiempo utilizando esta funcin. Sin embargo, es posible concatenar ms de dos
cadenas al mismo tiempo en Oracle utilizando '||'.
Observemos algunos ejemplos. Supongamos que tenemos la siguiente tabla:
Tabla Geography
East Boston
East New York
West Los Angeles
West San Diego
Ejemplo 1
MySQL/Oracle:
SELECT CONCAT (Region_Name, Store_Name) FROM Geography
WHERE Store_Name = 'Boston';
Resultado:
'EastBoston'
Ejemplo 2
Oracle:
JCAS
34

SELECT Region_Name || ' ' || Store_Name FROM Geography
Resultado:
'East Boston'
Ejemplo 3
SQL Server:
SELECT Region_Name + ' ' + Store_Name FROM Geography
Resultado:
'East Boston'

SQL SUBSTRING >>

La funcin de subcadena en SQL se utiliza para tomar una parte de los datos almacenados.
Esta funcin tiene diferentes nombres segn las diferentes bases de datos:
MySQL: SUBSTR( ), SUBSTRING( )
Oracle: SUBSTR( )
SQL Server: SUBSTRING( )
Los usos ms frecuentes son los siguientes (utilizaremos SUBSTR( ) aqu):
SUBSTR (str, pos)
Selecciona todos los caracteres de <str> comenzando con posicin <pos>. Note que esta
sintaxis no es compatible en SQL Server.
SUBSTR (str, pos, len)
Comienza con el carcter <pos> en la cadena <str> y selecciona los siguientes caracteres
<len>.
Supongamos que tenemos la siguiente tabla:
Tabla Geography
East Boston
JCAS
35

East New York
West Los Angeles
West San Diego
Ejemplo 1
SELECT SUBSTR (Store_Name, 3)
FROM Geography
WHERE Store_Name = 'Los Angeles';
Resultado:
's Angeles'
Ejemplo 2
SELECT SUBSTR (Store_Name, 2, 4)
FROM Geography
WHERE Store_Name = 'San Diego';
Resultado:
'an D'

SQL TRIM >>

La funcin TRIM en SQL se utiliza para eliminar un prefijo o sufijo determinado de una cadena.
El patrn ms comn a eliminarse son los espacios en blanco. Esta funcin tiene diferentes
nombres segn las diferentes bases de datos:
MySQL: TRIM( ), RTRIM( ), LTRIM( )
Oracle: RTRIM( ), LTRIM( )
SQL Server: RTRIM( ), LTRIM( )
La sintaxis para estas funciones de reduccin es:
TRIM( [[ LOCATION] [remstr] FROM ] str): [LOCATION] puede ser LDER, REMANENTE, o
AMBAS. Esta funcin se deshace del patrn [remstr] tanto para el comienzo de la cadena como
para el final, o para ambos. Si no se especifica ningn [remstr], los espacios en blanco se
eliminarn.
LTRIM (str): Elimina todos los espacios en blanco del comienzo de la cadena.
RTRIM (str): Elimina todos los espacios en blanco del final de la cadena.
JCAS
36

Ejemplo 1
SELECT TRIM(' Sample ');
Resultado:
'Sample'
Ejemplo 2
SELECT LTRIM(' Sample ');
Resultado:
'Sample '
Ejemplo 3
SELECT RTRIM(' Sample ');
Resultado:
' Sample'

SQL AVANZADO

SQL UNION
El propsito del comando SQL UNION es combinar los resultados de dos consultas juntas. En
este sentido,UNION es parecido a Join, ya que los dos se utilizan para informacin relacionada
en mltiples tablas. Una restriccin de UNION es que todas las columnas correspondientes
necesitan ser del mismo tipo de datos. Tambin, cuando utilizamos UNION, slo se
seleccionan valores distintos (similar a SELECT DISTINCT).
La sintaxis es la siguiente:
[Instruccin SQL 1]
UNION
[Instruccin SQL 2];
Supongamos que tenemos las siguientes dos tablas,
JCAS
37

Tabla Internet_Sales
Txn_Date Sales
07-Jan-1999 250
10-Jan-1999 535
11-Jan-1999 320
12-Jan-1999 750
y deseamos saber de todas las fechas donde hay una operacin de venta. Para hacerlo,
utilizamos la siguiente instruccin SQL:
SELECT Txn_Date FROM Store_Information
UNION
SELECT Txn_Date FROM Internet_Sales;
Resultado:
Txn_Date
05-Jan-1999
07-Jan-1999
08-Jan-1999
10-Jan-1999
11-Jan-1999
12-Jan-1999
Por favor note que si ingresamos "SELECT DISTINCT Txn_Date" para cada o ambas
instrucciones SQL, obtendremos el mismo conjunto de resultados.
SQL UNION ALL >>
El propsito del Comando SQL UNION ALL es tambin combinar los resultados de dos
consultas juntas. La diferencia entre UNION ALL y UNION es que, mientras UNION slo
selecciona valores distintos, UNION ALLselecciona todos los valores.
La sintaxis para UNION ALL es la siguiente:
JCAS
38

[Instruccin SQL 1]
UNION ALL
[Instruccin SQL 2];
Utilicemos el mismo ejemplo de la seccin anterior para ilustrar la diferencia. Supongamos que
tenemos las siguientes dos tablas,
Txn_Date Sales
07-Jan-1999 250
10-Jan-1999 535
11-Jan-1999 320
12-Jan-1999 750
y deseamos encontrar las fechas en donde se realiz una operacin de venta en un negocio
como as tambin las fechas donde hay una venta a travs de Internet. Para hacerlo, utilizamos
la siguiente instruccin SQL:
UNION ALL
Resultado:
Txn_Date
05-Jan-1999
07-Jan-1999
08-Jan-1999
08-Jan-1999
07-Jan-1999
10-Jan-1999
11-Jan-1999
JCAS
39

12-Jan-1999

SQL INTERSECT >>

Parecido al comando UNION, INTERSECT tambin opera en dos instrucciones SQL. La
diferencia es que, mientras UNION acta fundamentalmente como un operador OR (O) (el valor
se selecciona si aparece en la primera o la segunda instruccin), el
comando INTERSECT acta como un operador AND (Y) (el valor se selecciona si aparece en
ambas instrucciones).
[Instruccin SQL 1]
INTERSECT
[Instruccin SQL 2];
Digamos que tenemos las siguientes dos tablas:
Txn_Date Sales
07-Jan-1999 250
10-Jan-1999 535
11-Jan-1999 320
12-Jan-1999 750
y deseamos encontrar todas las fechas donde hay ventas tanto en el negocio como en Internet.
Para hacerlo, utilizamos la siguiente instruccin SQL:
INTERSECT
JCAS
40

Resultado:
Txn_Date
07-Jan-1999
Por favor note que el comando INTERSECT slo arrojar valores distintivos.
SQL MINUS >>
MINUS opera en dos instrucciones SQL. Toma todos los resultados de la primera instruccin
SQL, y luego sustrae aquellos que se encuentran presentes en la segunda instruccin SQL
para obtener una respuesta final. Si la segunda instruccin SQL incluye resultados que no
estn presentes en la primera instruccin SQL, dichos resultados se ignoran.
[Instruccin SQL 1]
MINUS
[Instruccin SQL 2];
Continuemos con el mismo ejemplo:
Txn_Date Sales
07-Jan-1999 250
10-Jan-1999 535
11-Jan-1999 320
12-Jan-1999 750
y deseamos encontrar todas las fechas donde hay ventas en el negocio, pero no aquellas
realizadas por Internet. Para hacerlo, utilizamos la siguiente instruccin SQL:
JCAS
41

MINUS
Resultado:
Txn_Date
05-Jan-1999
08-Jan-1999
'05-Jan-1999', '07-Jan-1999',et '08-Jan-1999' son los valores distintivos arrojados
desde SELECT Txn_Date FROM Store_Information. Tambin se arroja '07-Jan-1999' de la
segunda instruccin SQL, SELECT Txn_Date FROM Internet_Sales, de este modo se lo
excluye del conjunto final de resultados.
Por favor note que el comando MINUS slo arrojar valores distintos.
Algunas bases de datos pueden utilizar EXCEPT en vez de MINUS. Por favor verifique la
documentacin para su base de datos especfica para el uso apropiado.
SQL Subconsulta >>
Es posible incorporar una instruccin SQL dentro de otra. Cuando esto se hace en las
instrucciones WHERE oHAVING, tenemos una construccin de subconsulta.
SELECT "nombre1_columna"
FROM "nombre1_tabla"
WHERE "nombre2_columna" [Operador de Comparacin]
(SELECT "nombre3_columna"
WHERE "Condicin");
[Operador de Comparacin] podran ser operadores de igualdad tales como =, >, <, >=, <=.
Tambin puede ser un operador textual como "LIKE". La parte en rojo se considera como la
"consulta interna", mientras que la parte en verde se considera como la "consulta externa".
Utilisons le mme exemple que celui que nous avons utilis pour illustrer les jointures SQL :
Table Store_Information
JCAS
42

Table Geography
East Boston
East New York
West Los Angeles
West San Diego
et en utilisant une sous-requte pour trouver les ventes de tous les magasins dans la rgion
West (Ouest), il faudra utiliser linstruction SQL suivante :
SELECT SUM(Sales) FROM Store_Information
WHERE Store_Name IN
(SELECT Store_Name FROM Geography
WHERE Region_Name = 'West');
Resultado:
SUM(Sales)
2050
Dans cet exemple, au lieu de joindre directement les deux tables et dajouter seulement le
montant des ventes des magasins de la rgion West (Ouest), nous allons dabord utiliser la
sous-requte pour trouver les magasins situs dans la rgion West (Ouest), puis additionner le
montant des ventes de ces magasins.
Dans lexemple ci-dessus, la requte interne est dabord excute, puis le rsultat est envoy
la requte externe. Ce type de sous-requte est appel sous-requte simple. Si la requte
interne dpend de la requte externe, nous aurons une sous-requte corrle. Vous trouverez
ci-dessous un exemple de de sous-requte corrle :
SELECT SUM(a1.Sales) FROM Store_Information a1
WHERE a1.Store_Name IN
(SELECT Store_Name FROM Geography a2
WHERE a2.Store_Name = a1.Store_Name);
Notez la clause WHERE dans la requte interne, o la condition ncessite une table de la
requte externe.
JCAS
43

SQL EXISTS >>
En la seccin anterior, utilizamos IN para enlazar la consulta interna y la consulta externa en
una instruccin de subconsulta. IN no es la nica forma de hacerlo uno puede utilizar muchos
operadores tales como >, <, o =. EXISTS es un operador especial que describiremos en esta
seccin.
EXISTS simplemente verifica si la consulta interna arroja alguna fila. Si lo hace, entonces la
consulta externa procede. De no hacerlo, la consulta externa no se ejecuta, y la totalidad de la
instruccin SQL no arroja nada.
La sintaxis para EXISTS es
SELECT "nombre1_columna"
WHERE EXISTS
(SELECT *
WHERE "Condicin");
Por favor note que en vez de *, puede seleccionar una o ms columnas en la consulta interna.
El efecto ser idntico.
Utilizamos las mismas tablas de ejemplos:
Table Geography
East Boston
East New York
West Los Angeles
West San Diego
colocaramos la siguiente consulta SQL:
JCAS
44

SELECT SUM(Sales) FROM Store_Information
WHERE EXISTS
(SELECT * FROM Geography
WHERE region_name = 'West');
Obtendremos el siguiente resultado:
SUM(Sales)
2750
Al principio, esto puede parecer confuso, debido a que la subsequencia incluye la condicin
[Region_Name = 'West'], an as la consulta sum los negocios para todas las regiones. Si
observamos de cerca, encontramos que debido a que la subconsulta arroja ms de 0 filas, la
condicin EXISTS es verdadera, y la condicin colocada dentro de la consulta interna no
influencia la forma en que se ejecuta la consulta externa.
SQL CASE >>
CASE se utiliza para brindar un tipo de lgica "si-entonces-otro" para SQL. Su sintaxis es:
SELECT CASE ("nombre_columna")
WHEN "condicin1" THEN "resultado1"
WHEN "condicin2" THEN "resultado2"
...
[ELSE "resultadoN"]
END
"condicin" puede ser un valor esttico o una expresin. La clusula ELSE es opcional.
En nuestra Tabla Store_Information de ejemplo,
si deseamos multiplicar las sumas de ventas de 'Los Angeles' por 2 y las sumas de ventas de
'San Diego' por 1,5, ingresamos,
JCAS
45

SELECT Store_Name, CASE Store_Name
WHEN 'Los Angeles' THEN Sales * 2
WHEN 'San Diego' THEN Sales * 1.5
ELSE Sales
END
"Nuevas Ventas",
Txn_Date
"Nuevas Ventas" es el nombre que se le otorga a la columna con la instruccin CASE.
Resultado:
Store_name Nuevas Ventas Txn_Date

REFERENCIA.
http://www.1keydata.com/es/sql/

Lenguaje SQL PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Lenguaje SQL PDF

Cargado por

Copyright:

Formatos disponibles

JCAS

También podría gustarte