Valorar ventajas las inconvee nientes de las las distintasopciones opciones
válidas para realizar una consulta
Con este tema, se detalla Ia sintaxis completa de 1a sentencia SELECT en toda su extensión. Se proporciona a1 estudiante métodos para construir consultas simples y complejas de forma estructurada, con ltros, agrupaciones y ordenaciones.
133
Bases de
Datos
4.1. El
lenguaje DML
Las sentencias DML del lenguaje SQL son las siguientes: siguientes: - La sentencia SELECT, que se utiliza para extraer información de la base de datos, ya sea de una tabla tabla o de varias. ILa
sentencia INSERT, cuyo cometido es insertar uno o varios registros en alguna tabla.
ILa
sentencia DELETE, que borra registros de una tabla.
ILa
sentencia UPDATE, que modica modica
registros de una tabla.
Cualquier ejecución de un comando comando en un SGBD se denomina.CONSULTA, denomina.CONSULTA, término derivado del anglosajón QUERY. Este término debe ser entendido entendido más que corno una consulta consulta de información, como una orden, esdecir, esdecir, las QUERYS o CONSULTAS no son solo solo SELECT, sino también cualquier sentencia de tipo UPDATE, INSERT, CREATE, DROP, DROP, etc, entendidas entendidas todas todas ellas como peticiones peticiones al SGBD para realizar realizar una operación
determinada.
4.2. La
sentencia SELECT
La sentencia SELECT es la sentencia más versátil de todo SQL, y por tanto la más compleja de todas. Como se ha expuesto anteriormente, anteriormente, se utiliza para consultar información de determinadas tablas. Es posible ejecutar sentencias muy sencillas que muestran todos los registros de una tabla: #esta consulta selecciona todos los campos #registros de la tabla empleados SELECT * FROM empleados;
y muestra
todos los
O incluso consultas que obtienen información ltrada de múltiples tablas, usando relaciones entre tablas e incluso tablas tablas virtuales creadas a partir de una consulta. #esta consulta #de los
clientes de
obtiene el
total de
los pedidos
una tienda
SELECT NombreC1iente,tot.Cantidad FROM C1ientes,Pedidos,
(SELECT sum(Cantidad*PrecioUnidad) sum(Cantidad *PrecioUnidad) FROM Deta11ePedidos
BY GROUP
as Cantidad,NumeroPedido Cantidad,Num eroPedido NumeroPedido) tot
WHERE Clientes.NumeroC1iente=Pedidos.NumeroC Clientes.NumeroC1iente=Pedidos.NumeroC1iente 1iente
AND Pedidos.numeroPedido=tot.NumeroPedido
134
BY ORDER
Cantidad;
Bases de
Datos
4.1. El
lenguaje DML
Las sentencias DML del lenguaje SQL son las siguientes: siguientes: - La sentencia SELECT, que se utiliza para extraer información de la base de datos, ya sea de una tabla tabla o de varias. ILa
sentencia INSERT, cuyo cometido es insertar uno o varios registros en alguna tabla.
ILa
sentencia DELETE, que borra registros de una tabla.
ILa
sentencia UPDATE, que modica modica
registros de una tabla.
Cualquier ejecución de un comando comando en un SGBD se denomina.CONSULTA, denomina.CONSULTA, término derivado del anglosajón QUERY. Este término debe ser entendido entendido más que corno una consulta consulta de información, como una orden, esdecir, esdecir, las QUERYS o CONSULTAS no son solo solo SELECT, sino también cualquier sentencia de tipo UPDATE, INSERT, CREATE, DROP, DROP, etc, entendidas entendidas todas todas ellas como peticiones peticiones al SGBD para realizar realizar una operación
determinada.
4.2. La
sentencia SELECT
La sentencia SELECT es la sentencia más versátil de todo SQL, y por tanto la más compleja de todas. Como se ha expuesto anteriormente, anteriormente, se utiliza para consultar información de determinadas tablas. Es posible ejecutar sentencias muy sencillas que muestran todos los registros de una tabla: #esta consulta selecciona todos los campos #registros de la tabla empleados SELECT * FROM empleados;
y muestra
todos los
O incluso consultas que obtienen información ltrada de múltiples tablas, usando relaciones entre tablas e incluso tablas tablas virtuales creadas a partir de una consulta. #esta consulta #de los
clientes de
obtiene el
total de
los pedidos
una tienda
SELECT NombreC1iente,tot.Cantidad FROM C1ientes,Pedidos,
(SELECT sum(Cantidad*PrecioUnidad) sum(Cantidad *PrecioUnidad) FROM Deta11ePedidos
BY GROUP
as Cantidad,NumeroPedido Cantidad,Num eroPedido NumeroPedido) tot
WHERE Clientes.NumeroC1iente=Pedidos.NumeroC Clientes.NumeroC1iente=Pedidos.NumeroC1iente 1iente
AND Pedidos.numeroPedido=tot.NumeroPedido
134
BY ORDER
Cantidad;
Capítulo 4. Realización de Consultas
4.3. Consultas
básicas
El formato básico para hacer una consulta es el siguiente: SELECT [DISTINCT] se1ect_expr [,select_expr] select_expr: nombre_co1umna nombre_co1umn a [AS
[FROM
tabla]
alias]
| 4:
I expresión
nombre_columna indica un nombre de columna, es decir, se puede seleccionar de una tabla una serie de columnas, o todas si se usa *, o una expresión algebraica compuesta por operadores, operandos y funciones. El parámetro opcional DISTINCT fuerza que solo se muestren los registros con valores distintos, o, dicho de otro modo, que suprima las repeticiones. En la página siguiente, se muestran algunos ejemplos del uso de la sentencia
SELECT. Hay que prestaratención a algunas curiosidadesl: n En la consulta 4 se selecciona una columna calculada (1+5), con la selección de los registros de una tabla, incorporándose esa nueva columna creada al conjunto de las devueltas por el gestor. - En la consulta número 5 se hace uso de una expresión algebraica para crear una columna cuyo resultado será el de sumar 1 y6. Para hacer esto, en MySQL no es necesario indicar la cláusula FROM, pero en Oracle, hay que poner la cláusula FROM con la tabla dual. Al no haber una tabla real seleccionada, el resultado será
una única
la con
el resultado.
- En la consulta 3 se hace uso de la función concat cuyo cometido cometido es concatenar dos columnas creando creando una única columna. En Oracle, la función concat solo admite dos parámetros, mientras que en MySQL se puede concatenar múltiples parámetros. Para concatenar en oracle múltiples múltiples columnas se puede hacer uso del operador operador I I. Véase Sección6.4. IEn las consultas 6 y7 se muestran las marcas de los vehículos. La diferencia entre ambas consultas consultas está en el uso del DISTINCT, que elimina las repeticiones. r epeticiones. Hay do dos s vehículos seat en la consulta 6 y un uno o en la 7. ¡La ejecuciónde ejecuciónde lasconsultas lasconsultas quese muestraa muestraa continuación continuaciónestá realizadaen realizadaen MySQL, pero son perfectamente compatibles con Oracle, excepto la consulta 5, que hay que añadir FROM dual. 135
Bases
de
Datos
#consu1ta #consu1ta 1 SELECT
*
4
SELECT matricula, FROM ve vehiculos;
FROM ve vehiculos; + --------+ I matricula I +
I 1129FGT
ibiza
I 1132GHT
leon
I M6836YX I 7423FZY
corolla coupe
I 3447BYD
a3 tdi
mode1o,1+5
gI t 1I05cv
tdi
gI 6
-+-----+ modelo I
--+----+ --+----+
1129FGT I
ibiza
1132GHT I
leon
M6836YX I I 7I423FZY
1I30cv
gI t tdi
corolla coupe I
3447BYD I +
1+5 I
--+
a3 tdi +
6I 1I05cv
gI 6
#consu1ta 5 SELECT #consu1ta
2
1+6;
+-----+
m I odelo
SELECT matricula,
1+6 I
FROM vehiculos;
+-----+ 7I I +---+ +---+
1129FGT I 1132GHT
ibiza gt leon t105cv di
I M6836YX | 7423FZY coupe
corolla
I 3447BYD a3
t di
#consu1ta SELECT marca
I
gI 6
6 FROM vehiculos; vehiculos;
+--------+ | marca I + -------
130cv
- -+
I seat I I seat I
l tIoyota I hyundai I #consu1ta 3 SELECT
I audi I
matricula, +
-------
concat(marca,mode1o)
as
coche #consu1ta 7
FROM FROM vehi vehicu culo los; s; + ----------+ -------------------
+
I matricula I
I
SELECT DISTINCT
FROM vehiculos; vehiculos;
1129FGT
seatibiza
1132GHT
seatleon
gt tdi
105cv
I M6836YX I 7423FZY
toyotacorolla hyundaicoupe
I 3447BYD
audia3
136
- -+
tdi
g6
130CV
marca
6I 6I
1I30cv
--------------
6I
6I --+-----+
Capítulo 4. Realización de Consultas
Actividad
4.1: Crea una tablaen tablaen MySQLcon MySQLcon lasiguiente lasiguiente estructura:
<>
MASCOTAS(Nombre, especie, raza, edad, sexo).
Introduce 6 registros2 y,a y,a continuación,codi continuación,codica ca las siguientes querys: IMuestra
el nombre y la especie de todas las mascotas.
n Muestra Muestra el nombre y el sexo de las mascotas mascotas poniendo un alias a los campos. IMuestra
el nombre y la fecha de nacimiento aproximada de las mascotas (con-
sulta la documentación deMySQL deMySQL y usa la función date_suby now). Realiza el mismo procedimiento creando 1a tabla en en Oracle.
4.4. Filtros Los ltros son condiciones que cualquier gestor de base de datos interpreta para seleccionar registros y mostrarles como resultado resultado de la consulta. En SQL la palabra clave para realizar ltros es la cláusula WHERE. A continuación
ltro es una ¡expresión que indicala condicióno condiciones que deben satisfacer satisfacer los registros para ser seleccionados. Un ejemplo de funcionamiento sería el siguiente: siguiente:
itselecciona los SELECT
vehículos de
*FROM
WHERE marca=
1a marca
seat
vehiculos seat
;
+
---------
--+ --------------
--+ -----
- +
| matricula + ---------
l modelo --+ --------------
--+ -----
--+
I seat --+ -----
--+
I 1129FGT | 1132GHT + ---------
I ibiza
gt
l leon tdi 105cv --+ --------------
2 VéaseCapítulo 5si es necesario. 137
Bases de
Datos
4.4.1. Expresiones
para ltros
Los ltros se construyen mediante expresiones. Una expresión, es una combinación de operadores, operandos y funciones que producen un resultado. Por ejemplo, una expresión puede ser: #expresión
1(oracle):
SELECT (2+3)*7
ttexpresión 2
(2+3)*7
from dual;
(mysql): (2+3)>(6*2)
SELECT (24-3)>(6*2);
#0 =falso,
es falso
que 5>12
itexpresión 3 (mysql): 1a fecha de SELECT date_sub(now(), interval 31
hoy -31 year);
+ ---------------------------------
+
I date_sub(now(),
interval 31
años;
year) |
Se detalla a continuación los elementos que pueden formar parte de las expresiones:
IOperandos: Los operandos pueden ser constantes. por ejemplo el número entero 3, el número real 2.3, la cadena de caracteres E spañao la fecha C201001-02; también pueden ser variables, por ejemplo el campo edad o o el campo
NombreMascota; ypueden sertambién otras expresiones 3. IOperadores aritméticos: +, -, *, /, 7c. El operador + yel operador-se utilizan para sumar o restar dos operandos(binario) o para poner el signo positivo o negativo a un operando (unario). El operador * es la multiplicación de dos operandosyel operador / es para dividir. El operador% o resto dela división entera a°7ob devuelve el resto de dividir a
entre b.
3Todas losoperandos numéricosya seanreales oenteros vansin comilla simple, ycualquier otra cosa que no sea número, por ejemplo, cadenas de caracteres o fechas, van entre comillas simples. 138
Capítulo 4. Realización de Consultas - Operadores relacionales: >, <, <>, >=, <=, =. Los operadores relacionales sirven para comparar dos operandos. Así, es posible preguntar si un campo es mayor que un valor, o si un valor es distinto de otro. Estos operadores devuelven un número entero, de tal manera que si el resultado de la expresión es cierto el resultado será 1, y si el resultado es falso el resultado será O. Por ejemplo, la expresión a >b devuelve 1 si a es estrictamente mayor que b y O en caso contrario. La. expresión d<>e devuelve 1 si d y e son valores distintos. IOperadores
lógicos: AND, OR, NOT. Los operadores lógicos toman como operandos valores lógicos, esto es, cierto o falso, en caso de SQL, 1 o O. Los operadores lógicos se comportan según las siguientes tablas de verdad: Operando 1
Operando 2
Opl AND
Op2 Opl
OR Op2
NOT Opl
falso falso
falso falso
cierto
falso cierto
falso cierto
cierto
cierto falso
falso cierto
falso
cierto cierto
cierto cierto
falso
Cuadro 4.1: Tabla de verdad de los operadores lógicos.
Por otro lado, se necesita un tratamiento de los valores nulos; hay que incluir como un posible operando el valor nulo: Operando 1
Operando 2
Opl AND
Op2 Opl
OR Op2
NOT Opl
falso falso
falso falso
cierto
falso cierto
falso cierto
cierto
cierto falso
falso cierto
falso
cierto cierto
cierto cierto
falso
nulo
nulo X
nulo nulo
nulo nulo
nulo
Cuadro 4.2: Tabla de verdad de los operadores lógicos con valores nulos.
-Paréntesis:
Los
operadores tienenuna prioridad, por ejemplo, en la ex-
presión 3+4*2, la multiplicación se aplica antes que la suma, se dice que el operador * tiene ¡nas prioridad que el operador +. Para alterar esta prioridad, se puede usar el operador paréntesis, cuyo cometido es precisamente dar máxi-
ma prioridad a una parte de una expresión.Así, (3+4)*2, no es lo mismo que 3+4*2. 139
Bases de
Datos
u Funciones: date_add, concat, left, right. . .. Cada SGBD incorpora su propio repertorio de funciones que en pocas ocasiones coincide con el de otros SGBD. En la tabla que se muestra a continuación aparecen los resultados que provoca la ejecución de algunos de los operadores descritos:
í í (1o>=1o AND
o<=1)+2
Cuadro 4.3: Tabla resumen de los operadores usados en expresiones.
4.4.2. Construcción
de ltros
A continuación, se muestran ejemplos de construcción de ltros para una base de datos de jugadores de la liga americana de baloncesto (NBA), todos ellos compatibles para Oracle y MySQL:
#1a tabla
jugadores contiene
describe jugadores; + l l l l l l l l l
l l l l
l l
+
l l l l
todos los
jugadores de
la nba
Capítulo 4. Realizaciónde Consultas I Kobe Bryant I |Í
I Pau Gasol
I
+ --------------------
--+
#Consu1ta que selecciona los jugadores españoles SELECT codigo,Nombre,Altura FROMjugadores WHERENombre_equipo=Lakers and Procedencia=Spain; + ------
--+ ---------
de los
Lakers
--+ -------+
Altura I codigo I Nombre | I --+ ----------+ -------+ + -----I + ------
Ademásde losoperadores presentados anteriormente(aritméticos,lógicos,etc.) se puedehacer uso del operadorde pertenenciaa conjuntosIN, cuya sintaxises la siguiente: nombre_co1umna IN (Valuel,
Va1ue2,
...)
Este operadorpermite comprobarsi una columnatiene un valor igual que cualquier de los que están incluidosdentro del paréntesis,así por ejemplo, si se desea seleccionarlosjugadoresespañoles,eslovenoso serbiosde los Lakers, se codi caría así
#
versión
larga
SELECT Nombre,
Altura,Procedencia
FROM jugadores
WHERENombre_equipo=Lakers
AND
(Procedencia=Spain OR Procedencia=S1ovenia OR Procedencia=Serbia
& Montenegro);
141
Bases de Datos
I Pau
Gasol
I Vladimir Radmanovic I I Sasha Vujacic I
Serbia & Montenegro I Slovenia
#versión corta (con el operador IN) SELECTNombre, A1tura,Procedencia FROM WHERENombre_equipo=Lakers
jugadores
AND
Procedencia IN (Spain,S 1ovenia,Serbia
& Montenegro);
+ -------------------
-+
-+
-------------------
-+
I Nombre I -------------------
-+
Altura I ------+
Procedencia -------------------
-+
+
I Pau Gasol I
I Vladimir Radmanovic I I Sasha Vujacic I + -------------------
4.4.4.
-+
Serbia & Slovenia I ------
-+
Montenegro I
-------------------
-+
Filtros con operador de rango
El operador de rango BETWEEN permite seleccionarlos registrosque estén incluidosen un rango. Su sintaxises: nombre_co1umna
BETWEEN Valuel
AND Va1ue2
y Por ejemplo, para seleccionarlosjugadoresde la nba cuyo pesoestéentre 270 300 libras secodicaría la siguientequery:
SELECT Nombre,Nombre_equipo,Peso WHERE Peso + --------------
BETWEEN 270 AND 300; -+ -------------+
I Nombre I
Nombre_equipo I
I Chris
Timberwolves
Richard I
I Paul Davis |
FROM jugadores ----
-+
Peso l
Clippers
I| I David
Harrison I
Pacers
#sería equivalente a SELECT Nombre,Nombre_equipo FROM jugadores WHEREPeso >= 970 AND Peso <=300;
142
Capítulo 4. Realización
de Consultas
<> Actividad 4.2: Saca el pesoen kilogramosde los jugadores dela NBA que pesen entre 120 y 150 kilos. Una libra equivale a 0.4535 kilos.
4.4.5. Filtros
con test
de Valor
nulo
Los operadores IS e IS NOT permiten vericar si un campo es o no es nulo respectivamente. De esta manera, es posible comprobar, por ejemplo, los jugadores cuya procedencia es desconocida: SELECT nombre,Nombre_equipo FROM jugadores WHERE Procedencia
IS null;
I Nombre_equipo + --------------
--+ -------------
I Anthony
Carter I
+ --------------
Nuggets I
--+ -------------
#1a query
I --+ --+
contraria saca
el resto
de jugadores
SELECT nombre,Nombre_equipo
FROM jugadores WHERE Procedencia IS NOT null; +--------------------
--+ -------------
I nombre
--+
I Nombre_equipo
+ --------------------
--+
I Corey Brever I I Greg Buckner I
Timberwolves I Timberwolves I
IMichael
Timberwolves I
| C.J.
Doleac I Watson |
I Brandan
I
--+ -------------
Warriors
Wright I
Warriors
+ --------------------
--+ -------------
4.4.6. Filtros
con test
--+
de patrón
Los ltros
con test patrón seleccionan los registros que cumplan una serie de características. Sepueden usarlos caracterescomodines 7o y _ para buscar unacadena de caracteres. Por ejemplo, seleccionar de la tabla de vehículos aquellos vehículos cuyo modelo sea t.di: SELECT * + ---------
FROM vehiculos --+ --------------
where modelo --+ -----
like %tdiZ; --+
143
Bases de
Datos
I matricula + ---------
I modelo
I 1132GHT
--+ | leon
tdi 105cv
I a3 tdi --+ --------------
I 3447BYD + ---------
El carácter incluso cero
I marca
--+
I seat
130cv I
I
audi I --+ ------+
comodín % busca caracteres.
I --+
El carácter
coincidencias de cualquier número de caracteres, comodín
_ busca
coincidencias de
exactamente
un carácter.
Para ilustrar el funcionamiento del carácter _ ,se consultan aquellos equipos que empiecen por R, que terminen por S y que tengan 7 caracteres.
SELECT Nombre,Conferencia
FROM equipos + -------
I Nombre + -------
--+
I Conferencia --+ -----------
I Raptors
I --+
I East
I Rockets ------+
WHERE Nombre like R_____s;
--+ -----------
I
I West --+ -----------
--+
Ambos comodines se pueden usar en un mismo ltro, por ejemplo, para sacar aquellos equipos que en su nombre como segunda letra la o, se usaría el patrón:
SELECT Nombre,Conferencia
FROM equipos WHERE Nombre +
--+ -----------
I Nombre +
--+
like _o%; --+
I Conferencia
I --+
I Bobcats
I East
I
I Hornets
I West
I
I Rockets +-------
I West --+ -----------
4.4.7. Filtros
I --+
por límite
de número
de registros
Este tipo de ltros no es estándar ysu funcionamiento varía con el SGBD. Consiste en limitar el número de registros devuelto por una consulta. En MySQL, la sintaxis
144
es:
Capítulo 4. Realización de Consultas [LIMIT [desplazamiento
,] nf
ilas]
nlas especica. el número de las a devolver y desplazamiento especica. a partir de qué la. se empieza a contar (desplazamiento).
#devuelve las
4primeras
filas
SELECT nombre,Nombre_equipo FROM jugadores limit 4; + --------------
--+ -------------
I nombre
--+
I Nombre_equipo
+--------------
--+
I Corey Brever I I Greg Buckner I
Timberwolves Timberwolves
I Michael
Timberwolves
Doleac I
I Randy Foye | +
Timberwolves --+ -------------
#devue1ve 3
I --+
filas a
partir de
--+
la sexta
SELECT nombre,Nombre_equipo
FROM jugadores + -----------------
5,3; LIMIT --+ -------------
I nombre
| Nombre_equipo
+ -----------------
--+ -------------
I Marko Jaric I I A1 Jefferson I I Mark
--+
I --+
Timberwolves Timberwolves
Madsen I
Timberwolves --+ -------------
+ -----------------
--+
Oracle limita el número de las apoyándose en una pseudo columna, de nombre rownum:
--Saca los
25 primeros
jugadores
SELECT *
FROM jugadores WHERE rownum
<= 25;
4.5. Ordenación Para mostrar ordenados un conjunto de registros se utiliza la cláusula de BY
Esta claúsula permite ordenar el conjunto de resultados de forma ascendente
(ASC) o descendente (DESC)por una o varias columnas. Si no se indica ASC o DESC por defecto es ASC. La columna por la que se quiere ordenar se puede expresar por el nombre de la columna, una expresión o bien la posición numérica del campo que se quiere ordenar. Por ejemplo: #estructura de la tabla DESCRIBE equipos;
I Nombre ICiudad I Conferencia lDivision
equipos
varchar(20) varchar(20) varchar(4) varchar(9)
#obtener los
equipos de
la conferencia
SELECT Nombre,Division
FROM equipos ÜRDER BY + -------------
wHERE Conferencia=west
Division ASC; --+ ---------
I Nombre + -------------
I --+
I Jazz
I Northwest
I
I Nuggets
I Northwest
I
I Trail Blazers I I Timberwolves
Northwest I I Northwest
I
I Supersonics I Clippers I Kings
I Northwest I Pacific I Pacific
I I I
I warriors
I Pacific
I
I Suns Í Lakers | Hornets
I Pacific I Pacific I Southwest
| I I
I Spurs
I Southwest
I
I Rockets I Mavericks I Grizzlies + -------------
146
I Division --+ ---------
--+
I Southwest I Southwest I Southwest --+ ---------
I I I --+
oeste de
la nba
ordenados por
división
Capítulo 4. Realizaciónde Consultas
#se puede ordenar
#división
por varios
campos, p.ej:
además de que cada
esté ordenada ascendentemente se ordene por nombre
#de equipo SELECT Division,Nombre
FROM equipos
WHERE Conferencia=west ORDER BY Division ASC,Nombre DESC; + ----------+ --------------+
I Division I + ---------
Nombre I --+ -------------
--+
I Northwest I
Trail
Blazers I
| Northwest I
Timberwolves |
I Northwest I I Northwest I
Supersonics I Nuggets I
I Northwest I
Jazz I
I Pacific I
warriors I
I Pacific I
Suns I
I Pacific I
Lakers I
I Pacific I I Pacific I I Southwest I
Kings I Clippers I Spurs l
I Southwest I
Rockets I
I Southwest I
Mavericks I
I Southwest I
Hornets I
I Southwest I
Grizzlies I +
4.6.
Consultas
de resumen
En SQL sepuedengenerarconsultasmáscomplejasqueresumencierta información,extrayendoinformacióncalculadade variosconjuntosde registros.Un ejemplo de consultaresumenseria la siguiente:
SELECT count(*)
FROMvehiculos;
Esta consultadevuelveel númerode registrosde la tabla vehículos,es decir, se generaun resumende la informacióncontenidaen la tabla vehículos.La expresión
count(*) esuna funciónquetoma comoentradalosregistrosde la tabla consultada 147
Bases de
Datos
y cuenta cuántos registros hay. El resultado
de la función count es un único valor (1
la, 1 columna) conel número5(número de registrosde la tabla vehículos). Para poder generar información resumida hay que hacer uso de las funciones de columna. Estas funciones de columna convierten un conjunto de registros en una información simple cuyo resultado es un cálculo. A continuación, se expone una lista de las funciones de columna disponibles en SQL: SUM (Expresión) AVG (Expresión) MIN (Expresión) MAX (Expresión)
#Suma los valores indicados en el #Ca1cu1a la media de los valores #Ca1cula el minimo #Ca1cu1a el máximo
(nbCo1umna) COUNT
#Cuenta el
#(excepto los
argumento
número de
valores de
una columna
número de
valores de
una fila
nulos)
(*) COUNT
#Cuenta el
#Inc1uyendo los
nulos.
A modo de ejemplo, se muestran algunas consultas resúmenes:
#consu1ta 1
#¿Cuánto pesa
el jugador
más pesado
de la
nba?
de la
nba?
SELECT max(peso) FROM jugadores; #consu1ta 2
#¿Cuánto mide
el jugador
SELECT min(a1tura) #consu1ta
más bajito
FROM jugadores;
3
#¿Cuántos jugadores
SELECT count(*)
tienen los
Lakers?
FROM jugadores WHERE Nombre_equipo=Lakers;
#consu1ta 4
#¿Cuánto pesan
avg(peso) SELECT
de media
los jugadores
de los
Blazers?
FROM jugadores WHERE Nombre_equipo=B1azers;
Con las consultas de resumen se pueden realizar agrupaciones de registros. Se denomina agrupación de registros a un conjunto de registros que cumplen que tienen una o varias columnas con el mismo valor. Por ejemplo, en 1a tabla vehículos:
SELECT *
FROM vehiculos;
Capítulo 4. Realización
I 1129FGT
ibiza gt
I 1132GHT
leon tdi
IM6836YX I 7423FZY
corolla g6 coupe
Í 3447BYD
a3 tdi
de Consultas
105cv
130CV
En esta consulta hay dos registros cuya marca=seat. Se puede agrupar estos dos registros formando un único grupo, de tal manera que el grupo seat tiene los modelos ibiza gt (1129FGT) y leon tdi 105cv (1132GHT). A este grupo de registros se le puede aplicar una función de columna para realizar determinados cálculos, por ejemplo, contarlos: SELECT marca,
count(*) FROM
vehiculos GROUP + --------+ --------
I marca
BY marca; --+
I count(*)
I
En este caso, si se agrupa (GROUP BY)
por el campo marca, salen 4 grupos
(audi, hyundai, seat y toyota). La función de columna, cuando se agrupa por un campo, actúa para cada grupo. En este caso, para cada. grupo se ha contado el número de registros que tiene. En el caso de seat, cuenta los 2 antes mencionados. La sintaxis para la sentencia SELECT con GROUP BY queda como sigue: SELECT [DISTINCT] select_expr [,select_expr] [FROM tabla]
[WHERE filtro]
[GROUP BYexpr [, expr] . ... [ORDER BY{nombre_columna I
] expr I
posición} [ASC
I DESC] , ...]
Se observa que GROUP BY va justo antes de la cláusula ORDER BY. A continuación, a modo de ejemplo, se muestran algunas consultas con grupos y funciones de columna.
149
Bases de Datos
#consu1ta
1
#¿Cuánto
pesa el
jugador
más pesado de cada equipo?
SELECTNombre_equipo, max(peso) FROM jugadores GROUP
BY Nombre_equipo;
#consulta
2
#¿Cuántos
equipos
tiene
cada conferencia
SELECTcount(*),conferencia FROM + ---------+
+
count(*) I --------
equipos GROUP
-----------
--+
conferencia I --+ -----------
--+
15 I
en la
--+ -----------
#¿Cuánto
pesan de media los
jugadores
de españa,
--+ -----------
francia BY
e italia?
procedencia;
--+
avg(peso) I
+ ---------
I
conferencia;
--+
SELECTavg(peso),procedencia jugadores FROM WHEREprocedencia IN (Spain,Ita1y,France) GROUP I
BY
East I
+ --------
+ ---------
nba?
procedencia I --+ ------------+
218.4000 I
France I
221.0000 I 208.6000 I
Italy I Spain
+ ---------
--+ -----------
--+
IMPORTANTE: Seobservaque para cadaagrupación.seha seleccionado también el nombrede la columnapor la cual seagrupa.Esto no esposiblesi no seincluye el BY. Por ejemplo: GROUP
150
Capítulo 4. Realización de Consultas
FROM mysq1> SELECT count(*),conferencia equipos; ERROR 1140 (42000): Mixing of GROUP Columns (MIN(),MAX(),COUNT()....) with no GROUP Columns if
is there
no GROUP
is illegal
BY clause
Precisamente, el SGBD advierte de que para mezclar funciones de columna y columnas de una tabla hay que escribir una cláusula GROUP BY.
4.6.1. Filtros
de Grupos
Los ltros de grupos deben realizarse mediante el uso de la cláusula HAVING puesto que WHERE actúa antes de agrupar los registros. Es decir, si se desealtrar resultados calculados mediante agrupaciones se debe usar la siguiente sintaxis: SELECT [DISTINCT] se1ect_expr [,se1ect_expr] tabla] [FROM
[WHERE filtro]
[GROUP BYexpr [, expr].... ] [HAVING fi1tro_grupos] [ORDER BY {nombre_co1umna I
expr I
posición} [ASC
HAVING aplica los mismos ltros que ilustran algunos ejemplos:
#query 1: #Seleccionar los
equipos de
la nba
| DESC] ,...]
la cláusula WHERE. A
continuación se
cuyos jugadores
#pesen de media más de 228 libras SELECT Nombre_equipo,avg(peso) jugadores FROM BY GROUP
Nombre_equipo
HAVING avg(peso)>228 + -------------
I Nombre_equipo
BY ORDER
--+ ---------
I avg(peso)
avg(peso);
--+
l
228.8462 229.6923
Bases de
Datos
#query 2 #seleccionar qué
equipos de
la nba
tienen más
de 1 jugador
español
SELECT Nombre_equipo,count(*) FROM jugadores WHERE procedencia=Spain GROUP BY Nombre_equipo HAVING count(*)>1; + -------------
--+ --------
I Nombre_equipo
--+
I count(*)
I
4.7. Subconsultas Las subconsultas se utilizan para realizar ltrados con los datos de otra consulta. Estos ltros pueden ser aplicados tanto en la cláusula WHERE para ltrar registros como en la cláusula HAVING para ltrar grupos. Por ejemplo, con la base de datos de la NBA, es posible codicar una consulta para pedir los nombres de los jugadores de la división SouthEast:
SELECT nombre WHERE Nombre_equipo
FROM jugadores IN
(SELECT Nombre FROM equipos WHRE division=SouthWest); +------------------I nombre + ------------------I Andre
Brown I
| Kwame
Brown I
I Brian
Cardinal I
| Jason
Collins I
--+ | --+
I + -------------------
--+
Se observa que la subconsulta es precisamente la sentencia SELECT encerrada entre paréntesis. De esta forma, se hace uso del operador in para tornar los equipos de la división SouthEast. Si se ejecuta la subconsulta por separado se obtiene: 152
Capítulo 4. Realización de Consultas SELECT Nombre FROM
equipos
WHERE division=SouthWest
;
"' """"" "+ La l Nmbre
subconsulta se convierte en algo equiva-
l lente
+ ---------
a:
--+
¡Hornets
I
¡ Spurs
¡WHERE | (Hornets
| Rockets
SELECT nombre FROM jugadores
Nombre_equipo IN Spurs
,
,Rockets
,
I ¡ Mavericks
I
I Grizzlies + ---------
Mavericks
,Grizzlies)
--+
En las siguientes secciones se detallan los posibles operadores que se pueden usar con las
subconsultas.
4.7.1. Test
de Comparación
Consiste en usar los operadores de comparación --, >=, <=, <>, >y
SELECT nombre WHERE altura
FROM jugadores =
(SELECT max(a1tura) + --------
--+
| nombre + --------
--+
FROM jugadores);
I Yao Ming | + --------
--+
Se puedecomprobar que la subconsulta produce un único resultado, utilizándolo para ltrar. Nótese que con este tipo de ltro la subconsulta solo debe producir un único
valor (una la y una columna), por tanto, si se codica algo del tipo: SELECT nombre
FROM jugadores
WHERE altura =(SELECT max(altura),max(peso) FROM jugadores); ERROR 1241 (21000): Operand should contain 1 co1umn(s)
También fallaría que la subconsulta devolviera más de una la: 153
Bases de
Datos
SELECT nombre FROM jugadores altura WHERE
=(SELECT
FROMjugadores GROUP ERROR1242 (21000):
max(a1tura)
BY Nombre_Equipo); Subquery returns more than
1 row
Una restricción importante es que la subconsulta debe estar siempre al lado derecho del operador de comparación. Es decir: Campo <= subconsulta
siendo invalida la expresión: subconsulta >=
Campo
4.7.2. Test
de pertenencia
a conjunto
Este test consiste en una variante del usado para consultas simples, y es el que se ha utilizado para ilustrar el primer ejemplo de la sección. Consiste en usar el operador IN para ltrar los registros cuya expresión coincida con algún valor producido por la subconsulta.
Por ejemplo, para extraer las divisiones de la nba donde juegan jugadores españoles: SELECT division
FROM equipos
WHERE nombre in
(SELECT Nombre_equipo FROM jugadores WHERE procedencia=Spain); + ---------
--+
I division + ---------
--+
I Atlantic I Northwest
|
I Pacific I Southwest
I I
+ ---------
--+
4.7.3. Test
de existencia
El test de existencia permite ltrar los resultados de una consulta si existen las en la subconsulta asociada, esto es, si la subconsulta genera un número de las distinto de
O.
Para usar el test de existencia se utiliza el operador EXISTS: 154
Capítulo 4. Realización de Consultas SELECT columnas
FROM tabla
(subconsulta) WHERE EXISTS
El operador ltrar si
EXISTS también
no existen
resultados en
SELECT columnas
NOT WHERE
puede ser precedido de la negación (NOT) para la subconsulta:
FROM tabla
(subconsulta) EXISTS
Para seleccionar los equipos que no tengan jugadores españoles sepodría usar la siguiente consulta: Nombre SELECT
FROM equipos
Nombre (SELECT
NOT WHERE
EXISTS
FROM jugadores
equipos.Nombre WHERE
jugadores.Nombre_Equipo =
AND procedencia=Spain); + ------------
--+
I Nombre + ------------
-+
I Bobcats
Para comprender la lógica de esta query, se puede asumir que cada registro devuelto por la consulta principal provoca la ejecución de la subconsulta, así, si la consulta principal (SELECT Nombre FROM Equipos) devuelve 30 registros, se entenderá que se ejecutan 30 subconsultas, una por cada nombre de equipo que retorne la consulta principal. Esto en realidad no es así, puesto que el SGBD optimiza la consulta para hacer tan solo dos consultas y una operación join que se estudiará más adelante, pero sirve de ejemplo ilustrativo del funcionamiento de esta consulta: Nombre SELECT
from equipos;
+ -------------
-+
I Nombre +
-+
|
I Bobcats
subconsulta ejecutada
#1
subconsulta ejecutada
#2
| l|
I Raptors l| + -------------
|
subconsulta ejecutada
#22
-+
155
Bases de
Datos
Cada subconsulta ejecutada sería como sigue: #subconsulta ejecutada
#1
SELECT Nombre FROM jugadores WHERE 76ers
jugadores.Nombre_Equipo =
AND procedencia=Spain;
Esta subconsulta no retorna resultados, por tanto, el equipo 76ers es seleccionado para ser devuelto en la consulta principal, puesto que no existen (NOT EXISTS) jugadores españoles. Sin embargo para el registro 22 de la consulta principal, aquel cuyo Nombre es Raptors, la consulta: #subconsu1ta ejecutada #22 SELECT Nombre FROM jugadores WHERE Raptors = jugadores.Nombre_Equipo
AND procedencia=Spain; ---------------
--+
+
I Nombre + --------------I Jose
I --+
Calderon
I Jorge
Garbajosa I
---------------
+
--+
devuelve 2 jugadores, por tanto, existen (EXISTS) registros de la subconsulta y por tanto el equipo RaptorsNO es seleccionadopor la consulta principal. En conclusión, se puede decir que la consulta principal enlaza los registros con los devueltos por las subconsultas.
4.7.4. Test
cuanticados ALL
y ANY
Los test cuanticados sirven para calcular la relación entre una expresión y todos los registros de la subconsulta (ALL) o algunos de los registros de la subconsulta
(ANY). De esta manera se podría saber los jugadores de la nba que pesan más que todos los jugadores españoles:
A1 igual queen el casodel operadorexists,sepuedeasumirquepor cada registro de la consultaprincipal se ejecuta una subconsulta.En tal caso,para el jugador Michae1Doleaccuyopesoes262 libras,secomprobaríasi 262esmayorque lospesos de todos losjugadoresespañoles,que son devueltospor la subconsulta(SELECT peso jugadoresWHERE procedenciafspain). FROM G) También se podría consultarlos bases(en inglésGuard posicion=G, que pesanmásque cualquier(ANY) pívot (en inglésCenter "C) posicion: C de la nba:
SELECT nombre,peso WHEREposicion=G peso > ANY
from jugadores AND
(SELECTpeso FROMjugadores where posicion=C);
I Joe Johnson I + ------------+ ----
--+
Secomprueba queenel casode Joe Johnson,supeso(235libras),esmayorque algún pesode algún pívot de la nba, dándoseasí el peculiar casode un basemás pesadoque algúnpívot. 4.7.5.
Subconsultas
anidadas
Se puede usar una subconsultapara ltrar los resultadosde otra subconsulta. De esta manera se anidan Subconsultas.Por ejemplo.si sedeseaobtener el nombre de la ciudad dondejuega el jugador más alto de la nba, habría que pensar cómo hacerlo de forma estructurada: 157
Bases de
Datos
1. Obtener la altura del jugador más alto: X <-
(SELECT max(a1tura)
from jugadores)
2. Obtener el nombre del jugador, a través de la altura se localiza al jugador y por tanto,
su equipo:
Y
Nombre__equipo from jugadores
WHERE Altura
=
X
la ciudad:
SELECT ciudad
FROM equipos
WHERE nombre= Y
Ordenando todo esto, se puede construir la consulta de abajo a. arriba: SELECT ciudad
Esta manera de generar consultas es muy sencilla, y a la vez permite explorar la información de la base de datos de forma. estructurada. En opinión de muchos autores esta forma. estructurada de generar consultas es la que dio a SQL su Sde Structured.
4.8. Consultas
multitabla
Una consulta multitabla es aquella en la que se puede Consultar información de más de una tabla. Se aprovechan los campos relacionados de las tablas para unirlas (join). Para poder realizar este tipo de consultas hay que utilizar la siguiente sintaxis: [DISTINCT] SELECT
se1ect_expr [,se1ect_expr]
...
[FROM referencias_tab1as] [WHERE filtro]
[GROUP BYexpr [, expr].... ] [HAVING fi1tro_grupos] [ORDER BY{nombre_co1umnas I
158
expr I
posición}
I [ASC
DESC] ,
.
.
Capítulo 4. Realización de Consultas La diferencia
con las
consultas sencillas
se halla
en la cláusula FROM.
Esta vez
en lugar de una tabla se puede desarrollar el token referencias_tablas: referencias_tablas:
referencia_tab1a[, referencia_tabla] I referencia_tabla
[INNER I
I referencia_tab1a l referencia_tabla
... CROSS] JOIN
referencia_tab1a [ON
LEFT [OUTER] JOIN referencia_tab1a RIGHT [OUTER] JOIN referencia_tab1a
condición]
ON condición ON condición
referencia_tab1a:
nombre_tab1a [[AS]
alias]
La primera opción, (referencia_tabla[.referenciajabla]
es típica de SQL 1
(SQL-86) para las uniones, que consisten en un producto cartesiano más un ltro por las columnas relacionadas, y el resto de opciones son propias de SQL 2 (SQL-92 y SQL-2003).
4.8.1. Consultas
multitabla SQL
1
El producto cartesiano de dos tablas son todas las combinaciones de las las de una tabla unidas a las las de la otra tabla. Por ejemplo, una base de datos de mascotas con dos tablas animales y propietarios: SELECT * FROM propietarios;
| 51993482Y
| José
I 28834177X
I Matías
I 37276317Z
I Francisco
+ ---------
SELECT * ------
I codigo ------
+
I1 |2 I3 ------
+
Fernández I Martínez I
--+ ------------------
--+
FROM animales; --+ --------
+
Pérez I
--+ -----
I nombre --+ --------
I tipo --+ -----
I Cloncho I Yoda I Sprocket --+ --------
I gato I gato I perro --+
--+ -----------
--+
I propietario --+ -----------
I --+
I 51993482Y I 51993482Y I 372763172 --+ -----------
I
I I --+
Un producto cartesiano de las dos tablas se realiza con la siguiente sentencia: 159
Bases de
Datos
Cloncho
Yoda Sprocket
Cloncho Yoda
SELECT *
Sprocket Cloncho
FROM animales,propietarios;
51993482Y
Yoda
51993482Y
372763172 Sprocket 51993482Y 51993482Y 372763172
519934
51993482Y
Capítulo 4. Realización de Consultas Este mismo procedimiento se puede aplicar con N tablas, por ejemplo, con la base de datos jardineria, cuyo gráco de relaciones es el siguiente:
cungc Nombrecliente
Nombrecontacu: ,. Apellidocontacu: .4;
Telefono Fax LheaD reccionl LineaD reccion2 Ciudad Region Pais Cod igoPostal
cuirrpbab
CodigoEITpleadoRepVentas LimiwCreditD
Nombr
Apellidol Apellid Extension Email Codigoofncina Cuidad Pais
Region
codigoJefe CodigoPostaI Telefono
Bases de
Datos
Se observa que en est.e casohay dos JOIN, el primer join entre la tabla Clientes y Pedidos, con la condición Clientes.CodigoCliente=Pedidos.CodigoCliente y la segunda join entre el resultado de la primera. join y la tabla Empleados (Empleados.CodigoEmpleado = Clientes.CodigoEmpleadoRepVentas). Nótese que los dos ltros de la join están unidas por el operador AND. De esta forma se va extrayendo de la base de datos toda la información relacionada, obteniendo así mucha más potencia en las consultas. También hay que jarse en que como hay dos campos CodigoCliente, para hacerles referencia, hay que precederlos desu nombre de tabla (p.e. PedidosCodigoCliente) para evitar que el SGBD informe de que hay una columna con nombre ambiguo. Realizar una consulta multitabla no limita las características de ltrado y agrupación que ofrece SQL, por ejemplo, si se desea realizar una consulta para obtener cuántos pedidos ha gestionado cada empleado, se modicaría la consulta anterior para agrupar por la columna Nombre de Empleado y contar la columna CodigoPedido:
SELECT Emp1eados.Nombre,
COUNT(Pedidos.CodigoPedido) as FROM Clientes,
NumeroDePedidos
Pedidos, Empleados
WHERE
Clientes.CodigoC1iente=Pedidos.CodigoC1iente AND
Emp1eados.CodigoEmp1eado
=Clientes.CodigoEmpleadoRepVentas
GROUP BY Emp1eados.Nombre ORDER BY
NumeroDePedidos;
I Michael I Lorena
4.8.2. Consultas SQL 2 introduce
multitabla SQL
2
otra sintaxis para los siguientes tipos de consultas multitablas:
las joins (o composiciones)internas, externasy productos cartesianos (tambiénllamadas composiciones cruzadas): 1. Join
Interna:
n De equivalencia (INNER JOIN) 162
Capítulo 4. Realización de Consultas uNatural
(NATURAL JOIN)
2. Producto Cartesiano (CROSS JOIN) 3. Join
Externa
n De tabla derecha(RIGHT OUTER JOIN) IDe tabla izquierda (LEFT OUTER JOIN) ICompleta (FULL OUTER JOIN) Composiciones internas.
INNER JOIN
Hay dos formas diferentes para expresar las INNER JOIN o composiciones internas. La primera, usa la palabra reservada JOIN, mientras que la segunda usa , para separar las tablas a combinar en la sentencia FROM, es decir, las de SQL 1. Con la operación INNER JOIN se calcula el producto cartesiano de todos los registros, después, cada registro en la primera tabla es combinado con cada registro de la segunda tabla, y solo se seleccionan aquellos registros que satisfacen las condiciones que se especiquen. Hay que tener en cuenta que los valores Nulos no se combinan.
Como ejemplo, la siguiente consulta toma todos los registros de la tabla animales y encuentra todas las combinaciones en la tabla propietarios. La JOIN compara los valores de las columnas dni y propiet.arío. Cuando no existe esta correspondencia entre algunas combinaciones, estas no se muestran; es decir, que si el dni de un propietario de una mascota no coincide con algún dni de la tabla de propietarios, no se mostrará el animal con su respectivo propietario en los resultados. SELECT *FROM animales INNER JOIN propietarios ON anima1es.propietario propietarios.dni; =
+ ------
--+ --------
I codigo + ------
--+ -----
I nombre --+
I tipo --+ -----
1 I Cloncho I 2 I Yoda I 3 I Sprocket I + -----#Nótese #select #where
--+ --------
--+ -----------
Í propietario --+ -----------
gato I gato I perro I
--+ -----
--+ ---------
I dni --+ ---------
51993482Y Í 51993482Y I 372763172 I
--+ -----------
que es una consulta equivalente a *from anima1es,propietarios animales.propietario=propietarios.dni;
--+ ------------------
--+
I nombre --+ ------------------
--+
51993482Y I José Pérez 51993482Y I José Pérez 372763172 I Francisco Martinez --+
--+
la vista
en el
I I I --+
apartado anterior
163
Bases de
Datos
Además, debe tenerse en cuenta que si hay un animal sin propietario no saldrá en el conjunto de resultados puesto que no tiene coincidencia en el ltro: INSERT INTO animales VALUES (nul1,Arco,p erro,nu11); SELECT * FROM animales; + -------+ ---------+
I codigo
+------
I I2 Í3 I4 +------
--+ 1I
I nombre
--+
I tipo
--+ -----
--+ --------
--+ --------
Icodigo
I propietario
--+ -----
--+ -----------
--+ -----
I nombre
--+ -----------
Itipo
I I I #nueva
mascota sin
propietario
--+
--+ -----
I l I3
1I
Cloncho I gato I 51993482Y I 2l Yoda l gato I 51993482Y l I Sprocket I perro I 372763172
+ ------
--+ --------
--+ -----
--+ ---------
I propietario
--+
MASCOTA N0
I
INNER JOIN propietarios =propietarios.dni;
+ ------
#LA NUEVA
--+
Cloncho I gato I 51993482Y I I Yoda I gato I 51993482Y I Sprocket I perro I 372763172 I Arco I perro I NULL
SELECT * FROM animales ON anima1es.propietario +------
--+
--+
--+ -----------
--+ -----------
I dni --+ ---------
--+ ------------------
--+
I nombre --+ ------------------
I --+
51993482Y I José Pérez I 51993482Y l José Pérez l I 372763172 I Francisco Martinez I --+ ---------
--+ ------------------
--+
APARECE!
Puede hacerse variantes de la inner join cambiando el operador del ltro, ejemplo:
2 Yoda I gato I 51993482Y I 51993482Y José I Pérez |I 1 I Cloncho I
gato I
51993482Y I
3 I
perro I perro I
372763172 I 372763172
Sprocket I 3 I Sprocket I + ------
--+ -----------
--+ --------
--+
--+
51993482Y I José Pérez
I
51993482Y I José Pérez I372763172 I Francisco Martínez
--+
--+ ------------------
--+
I I
Composiciones naturales.
NATURAL JOIN
Es una especialización de la INNER JOIN. En este caso se comparan todas las columnas que tengan el mismo nombre en ambas tablas. La tabla. resultante contiene solo una columna por cada par de columnas con el mismo nombre.
Capítulo 4. Realización de Consultas
DESCRIBE Empleados;
+ ------------
+----
--+-- + -------
II --+ ----
--+--+ -------
--+ |I --+
I CodigoEmpleado
II
I Nombre
I varchar(50)
I N0
II
NULL I
|
I Apellidol I Ape1lido2
| varchar(50) I varchar(50)
I N0 I YES
II II
NULL I NULL I
I I
IExtension
I varchar(10)
I N0
II
NULL I
|
| Email
I varchar(100)
I N0
II
NULL
I Codigoüficina I CodigoJefe
I varchar(10) I int(11)
I N0 I YES
II I|
NULL I NULL I
II
NULL I
I Puesto
II
I varchar(50)
+ --------------
--+ ------------
DESCRIBE Oficinas; + ---------------
--+ -----------
I Field
I Type
---------------
--+
+
I YES
II
II
I #relación I I
--+ ----
--+ --+ -------
--+
--+
--+ ----
--+ --+ -------
--+ -----
--+
I Null
I Key
--+ ----
I Default
--+--+
I Extra --+
I Codigoüficina
I varchar(10)
I N0
I PRI
I Ciudad
I varchar(30)
I N0
II
NULL I
I
I Pais
I varchar(50)
I N0
II
NULL I
I
I Region I CodigoPostal
I varchar(50) I varchar(10)
I YES I N0
II II
NULL I NULL I
I I
| Telefono
I varchar(20)
I N0
II
NULL I
|
I LineaDireccion1
I varchar(50)
I N0
II
NULL I
|
I LineaDireccion2 +
I varchar(50) --+ -----------
NULL I
|
#NATURAL JOIN
coge los
I NULL
I --+
I YES II --+ -----+--+ -------
mismos nombres
de campo,
II
--+ -----
en este
#relación
--+
caso Codigoüficina
CodigoEmpleado,Empleados.Nombre, SELECT
Oficinas.Codigo0ficina,0ficinas.Ciudad FROM EmpleadosJOIN NATURAL Oficinas; +--------------
--+ ---------------
I CodigoEmpleado
I Nombre
--+ -------------
I Codigoüficina
--+
I Ciudad
I
+ --------------
--+ ---------------
I
1I
Marcos I
TALES I
Talavera de
la Reina
l
2I
Ruben I
TAL-ES I
Talavera de
la Reina
I
I 31
I Mariko
--+ -------------
--+ --------------------
I SYD-AU I
--+ --------------------
Sydney
--+
I
Hay que jarse en que, aunque CodigoEmpleado es un campo que está en dos tablas, esta vez no es necesarioprecederlo del nombre de tabla puesto que NATURAL JOIN devuelve un único campo por cada pareja de campos con el mismo nombre. 165
Bases de
Datos
Producto cartesiano.CROSS
JOIN
Este tipo de sintaxis devuelve el producto cartesiano de dos tablas:
#equiva1ente a SELECT * FROM anima1es,propietarios; SELECT * FROM animales CROSS JOIN propietarios;
I codigo
I nombre
+ I l l l l I | I + l l l l | l | l l I
Cloncho Cloncho Yoda
Yoda
Capítulo 4. Realización de Consultas * SELECT FROM animales DN animales.propietario +------
--+ --------
I codigo I
nombre I
LEFT OUTER JOIN propietarios = propietarios.dni;
--+ -----
--+ -----------
tipo I
+ ------
--+ --------
I | I3 I
1I
Cloncho I 2 I Yoda I I Sprocket I 4 I Arco I
+ ------
--+ --------
--+ -----
propietario I
--+ -----------
gato I gato I perro I perro I
--+ -----
--+ ---------
dni I
--+ ---------
51993482Y I 51993482Y I 372763172 I NULL I
--+ -----------
--+ ------------------
nombre I
--+ ------------------
51993482Y I 51993482Y I 372763172 I NULL --+ ---------
--+
I
--+
José Pérez I José Pérez I Francisco Martinez I NULL I
--+ ------------------
--+
Se observa que se incluye el perro que no tiene propietario, por tanto, sus Arco campos relacionados aparecen con valor El sentido de esta.query podría ser, NULL. sacar todos los animales si tienen relación, sacar sus propietarios, si no tiene y y
propietario,índicarloconunvalorN ULO o conVACÍO. ¿Sabías que
...7
Oracleimplementabalas consultasexternasantesde
la aparición de las OUTER utilizando el operador (+)= en lugar del JOIN. operador = en la cláusula WHERE. Esta sintaxis aún está disponible en las nuevas versiones de este SGBD.
Si los registros que admiten no tener correspondencia son los que aparecen en la tabla de la derecha, se llama composición de tabla derecha JOIN (o RIGHT RIGHT OUTER JOIN): OUTER #ejemp1o de RIGHT JOIN OUTER #anima1es RIGHT JOIN propietarios #anima1es está a la izquierda #propietarios está a la derecha * SELECT FROM animales RIGHT OUTER JOIN propietarios ON anima1es.propietario = propietarios.dni; + ------
--+ --------
I codigo I
+ ------
nombre I
--+ --------
--+ -----
tipo I
--+ -----
1 I Cloncho I 2 l Yoda Í
--+
--+
propietario I
--+ -----------
gato I gato I
--+ ------------------
dni I
--+ ---------
51993482Y I 51993482Y I
--+
nombre I
--+ ------------------
--+
51993482Y I José Pérez I 51993482Y l José Pérez
l
NULL NULL I INULLNULL I I 2883477X | Matías Fernández I 3 I Sprocket I + ------
--+ --------
perro I
--+ -----
372763172 I
--+ -----------
372763172 I --+
--+
Francisco
Martinez
|
--+
167
Bases de
Datos
En este caso, losque aparecenson todos los propietarios, incluido Matías Fernández que no tiene una mascota. Se ve que el perro Arco no aparece, pues esta vez los registros que se deseanmostrar son todos los de la tabla derecha (es decir, propietarios). La operación que admite registros sin correspondencia tanto para la tabla izquierda como para la derecha, por ejemplo. animales sin propietario y propietarios sin animales, se llama composición externa completa o FULL JOIN (FULL OUTER JOIN). Esta operación presenta los resultados de tabla izquierda ytabla. derecha aunque no tengan correspondencia en la otra tabla. La tabla combinada contendrá, entonces, todos los registros de ambas tablas y presentará valores nulos para registros sin pareja.
#ejemp1o de FULL OUTER JOIN #anima1es FULL OUTER JOIN propietarios #anima1es está a la izquierda #propietarios está a la derecha SELECT * FROM animales FULL OUTER JOIN propietarios DN anima1es.propietario =propietarios.dni; + ------
-+
I codigo
-+
I nombre
-+ -----------
I tipo
Cloncho I
Yoda gato Sprocket perro
I propietario
-+ ---------
-+ ------------------
I dni
51993482Y 51993482Y
I 51993482Y I 372763172
51993482Y I 372763172 I
l NULL
NULL NULL
-+
I nombre l José
2883477X Matias
Pérez
José Pérez Francisco Martinez
I
Fernández
¿Sabías que . . . 7En SQL existe el operador UNION, queañade alconjunto de resultados producidos por una SELECT, los resultados de otra SELECT. La sintaxis SELECT
es: FROM
UNION [ALL] SELECT
FROM
El parámetro ALL incluye todos los registros de las dos SELECT, incluyendo los que son iguales. Si no se indica ALL, se excluyen los duplicados. Aunque MySQL no implementa la característica FULL OUTER JOIN, sí que se puede simular haciendo una unión de los resultados de un LEFT OUTER JOIN y 168
Capítulo 4. Realización de Consultas los resultados de un RIGHT OUTER JOIN, puesto que UNION, sin elimina los registros duplicados, por tanto, se podría codicar la JOIN anterior de la siguiente forma:
mysq1> SELECT * FROM animales LEFT -> ON anima1es.propietario ->
la opción ALL, FULL OUT ER
OUTER JOIN propietarios - propietarios.dni
UNION
-> SELECT * FROM animales -> anima1es.propietario ON +
-+
I codigo +
-+
I nombre
-+ -----
I Cloncho I Yoda I Sprocket I Arco
JOIN propietarios =propietarios.dni;
-+ -----------
I tipo
-+ --------
OUTER RIGHT
I propietario
NULL I
I 51993482Y I 51993482Y I 372763172 I NULL I
I
-+ ------------------
I 51993482Y I 51993482Y I372763172 NULL I
NULL 2883477X
-+
I nombre
-+ ---------
-+
I José Pérez I I José Pérez I I Francisco Martinez I NULL I Matias Fernández
I +
+
4.9. Consultas
-+
I dni
-+ -----------
I gato I gato I perro I perro
I I NULL +
-+
I
reexivas
A veces, es necesario obtener información de relaciones reexivas, por ejemplo, un informe de empleados donde junto a su nombre y apellidos apareciera el nombre y apellidos de su jefe. Para ello, es necesario hacer una JOIN entre registros de la misma tabla:
mysq1> desc
Empleados;
+ --------------
-+ ------------
I F1e1d +--------------
I Type -+ ------------
-+ ----
I Null -+ ----
+--+ -------
I Key
-+ -----
I Default
--+-----+ -------
I Extra -+ -----
I -+
I CodigoEmp1eado
I int(11)
I N0 I
I Nombre
I varchar(50)
I N0 I
I NULL I
I
| Apellidol I Ape11ido2
I varchar(50) I varchar(50)
I N0 I I YES
I NULL I I I NULL
I |
I Extension | Email
I varchar(10) I varchar(100)
I N0 I I ND I
l NULL I I NULL I
I |
I Codigoüficina I CodigoJefe
I varchar(10) I int(11)
I N0 I I YES
II
I NULL I I NULL
I I #autore1ación
I Puesto
I varchar(50)
I YES
II
--------------
+
-+ ------------
-+ ----
PRI I
-+
I
-+----+ -------
SELECT concat(emp.Nombre, ,emp.Ape11ido1) as concat(jefe.Nombre,,jefe.Ape11ido1)
I NULL
|
I NULL
I -+
-+
Empleado, as jefe 169
Bases de
Datos
FROM Empleados emp INNER JOIN Empleados ON emp.CodigoEmp1eado=jeÍe.CodigoJefe; +
-+ -----------------------
I Empleado
I Jefe
+ -----------------
-+ -----------------------
jefe
-+ -+
I
I Marcos Magaña I I Ruben López I
Ruben López Alberto Soria
I I
I Alberto Soria I I Kevin Fallmer I
Kevin Fallmer
I I
l Kevin Fallmer I -----------------
Julian Bellinelli Mariko Kishi -+ -----------------------
+
I -+
Analizando la query anterior, primero se observa el uso de la tabla empleados dos veces, una con un alias emp que representa los empleados como subordinados y otra con alias jefe que representa los empleados como jefes. Ambas tablas (aunque en realidad son la misma) se unen en una JOIN a través de la relación CodigoEmpleado y CodigoJefe. Por otro lado, el primer campo que se selecciona esla concatenación del nombre y apellido del empleado (concat(emp.Nombre,' ,emp.Apellido1) al que a su vez le damos un alias (empleado) y el segundo campo que es la concatenación de los empleados jefes, al que le se le da el alias jefe. Se puede observar que en esta query no aparecen los empleados sin jefe, puesto que se ha utilizado un INNER JOIN. Para mostrarlos, habría. que usar un LEFT o RIGHT OUTER
JOIN.
4.10. Consultas
con tablas
derivadas
Las consultas con tablas derivadas, o inline views, son aquellas que utilizan sentencias SELECT en la cláusula FROM en lugar de nombres de tablas, por ejemplo: SELECT *
FROM
(SELECT CodigoEmpleado, Nombre FROMEmpleados WHERE CodigoOficina=TAL-ES) as tabla_derivada;
En este caso se ha de distinguir, por un lado la tabla derivada, (SELECT Co-
digoEmpleado, NombreFROM Empleados) que tiene un alias tabla_derivada, es decir, una especie de tabla temporal cuyo contenido es el resultado de ejecutar la consulta, su nombre es tabla_derivada y tiene dos columnas, una CodigoEmpleado y otra Nombre. Este tipo de consultas ayudará a obtener información relacionada de forma 170
mucho más
avanzada.
Capítulo 4. Realización de Consultas Por ejemplo, en la base de datos jardineria, si se desea sacarel importe del pedido de menor coste de todos los pedidos. hay que pensar primero como sacar el total de todos los pedidos y de ahí, el pedido con menor coste con la función de columna MIN:
#1: Para calcular el total de cada pedido, hay que codificar esta SELECT SUM(Cantidad*PrecioUnidad) as total,CodigoPedido
query
FROM Deta11ePedidos
GROUP BY CodigoPedido;
#2: Para #derivada
calcular el de la
#obtener
menor pedido, consulta anterior
el menor
SELECT MIN(total)
se puede hacer una y con la función
tabla MIN
de ellos: FROM (
SELECT SUM(Cantidad*PrecioUnidad)
as total,CodigoPedido
FROM Deta11ePedidos
GROUP BYCodigoPedido ) AS
TotalPedidos;
+ ----------
--+
I MIN(tota1)
l
+
--+
| + ----------
4
I
--+
#Tota1Pedidos es
#por el
resultado de
la tabla
derivada formada
la consulta
entre paréntesis
Las tablas derivadas no tienen limitación, es decir, se pueden unir a otras tablas, ltrar, agrupar, etc.
171
Bases de
Datos
4.11. Prácticas
Resueltas
Práctica 4.1:
Consultas simplesen MS-Access
Con la BBDD Automóviles,
genera sentencias SQL para obtener:
1. El nombre de las marcas y modelos de los vehículos. 2. El nombre de los modelos cuyas emisiones estén entre 150 y 165. 3. El nombre de los modelos cuyas emisiones estén entre 150 y 165 o que su consumo esté entre 5y 6 ordenado por consumo descendentemente. 4. Un listado de todas las Marcas que hay (sin repeticiones). Para crear una consulta en modo SQL en Access, se pulsa en la pestaña. Crear, opción Diseño de Consulta, y a continuación, se pulsa en el botón SQL. Finalmente, se escribe la sentencia SELECT y, para ejecutarla, se pulsa en la admiración de la pestaña Diseño .
#1 SELECT Marca,Mode1o Automóviles; FROM #2 SELECT modelo Automóviles FROM WHERE Emisiones >=
150 AND
Emisiones <=165;
#3 SELECT mode1o,consumo,emisiones (Emisiones >= ORDER BY
150 AND
FROM Automóviles
Emisiones <=165)
WHERE
OR (Consumo>=5
AND Consumo<=6)
consumo DESC;
#4 SELECT DISTINCT FROM MarcaAutomóviles;
Práctica 4.2: Codica en
Consultas simplescon Ia BBDD jardinería
MySQL y Oracle sentencias para obtener la siguiente información:
1. Sacar el código de ocina y la ciudad donde hay ocinas. Sacar cuántos empleados hayen la compañía.
FP.
Sacar cuántos clientes tiene cada país.
Sacar cuálfue el pago medioen 2005 (pista: Usar la función YEAR de mysql
o la función to_char(fecha,yyyy)
de Oracle).
Capítulo 4. Realización de Consultas 5. Sacar cuántos pedidos están en cada estado ordenado descendentepor el número de pedidos. 6. Sacar el precio del producto más caro y del más barato.
#1
SELECT CodigoOficina,ciudad
FROM Oficinas;
#2
SELECT Count(*)
FROM Empleados;
#3
SELECT Count(*),Pais
FROM Clientes
GROUP BY
Pais;
#4
SELECT AVG(Cantidad) FROM Pagos
WHERE YEAR(FechaPago)=2005; #(mysql) ó
#4
SELECT AVG(Cantidad) FROM Pagos
WHERE TO_CHAR(FechaPago,YYYY)=2005;
#5
SELECT Count(*),Estado ORDER BY Count(*) DESC;
FROM Pedidos
GROUP BY Estado
#6
SELECT Max(PrecioVenta),Min(PrecioVenta)
Práctica 4.3: Codica en
FROM Productos;
Subconsultas conIa BBDD jardinería
SQL sentencias para obtener la siguiente información:
1. Obtener el nombre del cliente con mayor limite de crédito. 2. Obtener el nombre, apellidol ycargo ningún cliente.
de los empleados que no representen a
#1 SELECT Nombrecliente FROM Clientes WHERE LimiteCredito
= (SELECT
Max(LimiteCredito)
FROM Clientes);
#2
SELECT Nombre, Apellidol, Puesto FROM Empleados WHERE CodigoEmp1eado NOT IN (SELECT CodigoEmp1eadoRepVentas FROM Clientes );
173
Bases de
Datos
Práctica 4.4: Consultas multitabla con la BBDD jardinería Codica en SQL consultas para obtener: 1. Sacar un listado con el nombre de cada cliente yel nombre y apellido de su representante de ventas. 2. Mostrar el nombre de los clientes que no hayan realizado pagos junto con el nombre de sus representantes de ventas. 3. Listar las ventas totales de los productos que hayan facturado más de 3000 euros. Se mostrará el nombre. unidades vendidas, total facturado y total fac-
turado con impuestos (18(7o IVA). 4. Listar la dirección de las ocinas que tengan clientes en Fuenlabrada. #1
SELECT NombreC1iente, Nombre as NombreEmp, Apellidol as ApeEmp FROM Clientes INNER JOIN Empleados ON Clientes.CodigoEmpleadoRepVentas=Empleados.CodigoEmp1eado; #2
SELECT NombreC1iente,Nombre as NombreEmp, Apellidol as FROM Clientes INNER JOIN Empleados ON
ApeEmp
Clientes.CodigoEmp1eadoRepVentas=Emp1ea where Codigocliente in (SELECT notCodigoC1iente Pagos); FROM #3 SELECT Nombre,
SUM(Cantidad) As SUM(Cantidad*PrecioUnidad) as
Tota1Unidades, Tota1Facturado,
SUM(Cantidad*PrecioUnidad)*1.18 as FROM Deta11ePedidos GROUP BY Nombre
WHERE Oficinas.CodigoÜficina=Emp1eados.Codigo0ficina
AND Empleados.CodigoEmp1eado=C1ientes.CodigoEmp1eadoRepVentas AND Clientes.Ciudad=Fuenlabrada;
174
Capítulo 4. Realizaciónde Consultas
Práctica Sacar el
4.5: Consulta con tablas derivadas
hizo cliente que
el pedido de mayor cuantía:
Esta. consulta es mejor codicarla en un. amhivo de texto para no tener que escribirla múltiples veces si da errores. La estrategia para resolverlo es hacer pequeñasconsultas (querys A,B y C) para luego unirlas y generar la denitiva:
#query A: Sacar la cuantía de los pedidos: (select CodigoPedido, Codigocliente, sum(Cantidad*PrecioUnidad)
from Pedidos
natural
as
join
total
DetallePedidos
group by CodigoPedido,CodigoC1iente) #query
B:
select
max(tota1)
(select
Sacar
el
pedido
más caro:
from
CodigoPedido, Codigocliente,
sum(Cantidad*PrecioUnidad)
from Pedidos
group by
natural
as
join
total
Deta1lePedidos
CodigoPedido,CodigoC1iente)
#query al
Tota1Pedidos;
C:
Sacar
el
código
de cliente
Tota1Pedidos; correspondiente
pedido más caro (querydefinitiva.sq1)
querydefinitiva.sq1 Select
Tota1Pedidos.Codigocliente,NombreCliente
(select
CodigoPedido, Codigocliente,
sum(Cantidad*PrecioUnidad) from Pedidos natural join
group by inner
from
total Detal1ePedidos as
CodigoPedido,CodigoCliente) join
Clientes
Tota1Pedidos
on
Clientes.CodigoC1iente=Tota1Pedidos.CodigoC1iente where
tota1=
( select
(select
max(tota1)
from
CodigoPedido, CodigoC1iente,
sum(Cantidad*PrecioUnidad)
from Pedidos
natural
as
join
total
Deta11ePedidos
group by CodigoPedido,CodigoCliente)
TotalPedidos
);
175
Bases de
Datos
Prácticas Propuestas
4.12.
Práctica 4.6:
Consultas simplesen MS-Access
Con la BBDD Automóviles,
ción:
genera sentencias SELECT para obtener esta informa-
1. 2. Modelos de vehículos TDlf
3.
Modelos de la marca Audiy
de la marca "Seat ordenado por l\llarca y Modelo.
Alarcas de Vehículos que empiecen por T y terminen en a. .Vehículos .El
que tengan foto.
consumo de los vehículos está expresado en litros / IOOkm. Listar el consumo
de los vehículos Seaten MPG, l\Iillas por galón (10 MPG=23.49 1/100km). O
Práctica 4.7:
Consultas simplescon la BBDD jardinería
Codica en SQL (Oracle y MySQL) sentencias para obtener la siguiente información: 1.
Sacar la ciudad y el teléfono de las ocinas de Estados Unidos.
2.
Sacar el nombre, los apellidos y el email de los empleados a cargo de Alberto Soria.
Sacar el cargo, nombre, apellidos y email del jefe de la empresa. Sacar el nombre, apellidos y cargo de aquellos que no sean representantes de ventas.
Sacar el número de clientes que tiene la empresa. Sacar el nombre de los clientes españoles.
OWNQF-l Sacar cuántos clientes tiene cada país. Sacar cuántos
clientes tiene
la ciudad
de Madrid.
.Sacar cuántos clientes tienen las ciudades que empiezan por M.
4Hay quetener en cuenta queen Access,el comodín°7c es un *
10.
11. 12. 13. 14.
Bases de
Datos
3. Obtener los clientes cuya línea de crédito sea mayor que los pagos que haya realizado.
4. Sacar el producto que más unidades tiene en stock y el que menos unidades tiene en
stock.
Práctica 4.9: Consultas multitablacon Ia BBDD jardinería Codica en
SQL las siguientes consultas:
1. Sacar el nombre de los clientes y el nombre de sus representantes junto con la ciudad de 1a ocina a la que pertenece el representante. 2. Sacar la misma información que en la pregunta anterior pero solo los clientes que no hayan echo pagos. 3. Obtener un listado con el nombre de los empleados junto con el nombre de sus jefes. 4. Obtener el nombre de los clientes a los que no se les ha entregado a tiempo un
pedido (FechaEntrega>FechaEsperada).
Práctica 4.10: Codica en
Consultas variadascon la BBDD jardinería
SQL las siguientes consultas:
1. Sacar un listado de clientes indicando el nombre del cliente y cuántos pedidos ha realizado.
2. Sacar un listado con los nombres de los clientes y el total pagado por cada uno de ellos.
3. Sacar el nombre de los clientes que hayan hecho pedidos en 2008. 4. Listar el nombre del cliente y el nombre y apellido de sus representantes de aquellos clientes que no hayan realizado pagos. 178
10. Capítulo 4. Realización de Consultas
11.
Sacar un listado de clientes donde aparezca el nombre de su comercial y la ciudad donde
está su
ocina.
. Sacar el nombre, apellidos, ocina 12.
tantes de
y cargo de aquellos que no sean represen-
ventas.
. Sacar cuántos empleados tiene cada ocina, mostrando donde está
13.
el nombre de la ciudad
la ocina.
. Sacar un listado con el nombre de los empleados, y el nombre de sus respectivos jefes. . Sacar el nombre, apellido, ocina sente a ningún cliente.
14.
(ciudad) y cargo del empleado que no repre-
Sacar la media de unidades en stock de los productos agrupados por gama. Sacar los clientes que residan en la misma ciudad donde hay una ocina, indi-
15.
cando dónde
está la
ocina.
Sacar los clientes que residan en ciudades donde no hay ocinas ordenado por la ciudad
donde residen.
16.
Sacar el número de clientes que tiene asignado ca.da representantede ventas. Sacar cuál fue el cliente que hizo el pago con mayor cuantía y el que hizo el pago con menor cuantía.
17.
Sacar un listado con el precio total de cada pedido. Sacar los clientes que hayan hecho pedidos en el 2008 por una cuantía superior
a 2000
euros.
18.
Sacar cuántos pedidos tiene cada cliente en cada estado. Sacar los clientes que han pedido más de 200 unidades de cualquier producto.
Bases de
Datos
2. Equipos que comiencen por Hy
terminen en S.
3. Puntos por partido de Pau Gasolen toda su carrera. 4. Equipos que hay en la conferencia oeste (w'est).
5. Jugadores de Arizona que pesenmás de 100 kilos y midan más de 1.82m (6 pies). Puntos por partido de los jugadores de los c avaliers.
Número de jugadores que tiene cada equipo de la conferencia oeste West.
Número de jugadores Argentinos en la NBA.
.
10. Máxima media de puntos de Lebron James en su carrera.
11. Asistenciaspor partido de Jose Calderonen la temporada O 7/O8. 12. Puntos por partido de L ebron Jamesen las temporadasdel 03/04 al 05/06. 13. Número de jugadores que tiene cada equipo de la conferencia este East . 14. Tapones por partido de los jugadores de los B lazers. 15. Media de rebotes de los jugadores de la conferencia Este E ast. 16. Rebotes por partido de los jugadores de los equipos de Los Angeles. 17. Número de jugadores que tiene cada equipo de la división N orthWest. 18. Número de jugadores de España y Francia en la NBA. 19. Número de pivots Cque tiene cada equipo. 20. ¿Cuánto mide el pívot más alto de la nba? 21. ¿Cuánto pesa (en libras y en kilos) el pívot más alto de la NBA? 22. Número de jugadores que empiezan por "Y". 23. Jugadores que no metieron ningún punto en alguna temporada. 24. Número total de jugadores de cada división. 25. Peso medio en kilos y en libras de los jugadores de los Raptors. 180
Capítulo 4. Realización de Consultas 26.
Mostrar un listado de jugadores con el formato Nombre(Equipo) en una sola columna.
27.
Puntuación más baja de un partido de la NBA.
28.
Primeros 10 jugadores por orden alfabético.
29.
Temporada con más puntos por partido de Kobe Bryant.
30.
Número de bases "G que tiene cada equipo de la conferencia este E ast.
31.
Número de equipos que tiene cada conferencia.
32.
Nombre de
33.
Máximo reboteador
34.
Nláximo anotador de la toda base de datos en una temporada.
35.
Sacar cuántas letras tiene el nombre de cada jugador de los grizzlies función LENGTH).
36.
¿Cuántas letras tiene el equipo con nombre más largo de la NBA (Ciudad y Nombre)?
Práctica 4.12:
las divisiones
de la
Conferencia Este.
de los Suns.
Consultas con
(Usar
tablas derivadas
Realizar las siguientes consultas con tablas derivadas con las BBDD NBA y jardineria:
Sacar el importe medio de los pedidos de la BBDD jardineria. Sacar un listado con el número de partidos ganados por los equipos de la NBA. Sacar la media de partidos ganados por los equipos del oeste. ¿Cuál es el pedido más caro del empleado que más clientes tiene?
181
Bases de
4.13.
Datos
Resumen
Los conceptos clave de este capítulo son los siguientes: La sentencia SELECT devuelve un conjunto de resultados en forma de tabla
compuesto porlas (o registros) y columnas (ocampos). La cláusula FROM de la sentencia SELECT especica las tablas de las que se extrae la información, y permite. a través de operaciones como el producto cartesiano y las JOIN, construir conjuntos de datos de información relacionada. Cuando se especica más de una tabla en la cláusula FROM se denomina consulta multitabla. Pueden serescritas en dos tipos de sintaxis, SQLI y SQL2. SQLl solo permite composiciones internas (INNER JOIN), mientras que SQL2 permite, además, composiciones externas (OUTER JOIN). Las NATURAL JOIN, son un tipo de INNER JOIN que hace coincidir la información de dos campos con el mismo nombre. Los registros de una SELECT se pueden F ILTRAR mediante el uso de la cláusula WHERE. Los ltros se pueden construir mediante expresiones, el
operador de pertenencia a conjuntos (IN), operador de rango (BETWEEN), test de valor nulo (IS, IS NOT), test de patrón (LIKE), y limitación de registros
(LIMIT y numrows). Para ordenar un conjunto de resultados se utiliza la palabra clave ORDER BY. Se puede ordenar ascendentemente (ASC) o descendentemente (DESC). Las consultas de resumen se usanpara calcular información en base aconjuntos o grupos de datos. Los grupos se construyen mediante la cláusula GROUP BY. Los ltros
sobre grupos se generan mediante la cláusula HAVING.
Las subconsultas son SELECT usadas para ltrar información
mediante test
de comparación, Test de Existencia (EXISTS), Test cuanticados (ANY y ALL). Pueden ser anidadas. Las consultas reexivas son tabla dos
o más
las que forman en su cláusula FROM la misma
veces.
Las tablas derivadas son tablas virtuales generadas a través de consultas en tiempo de ejecución. Tienen un alias que las identica. 182
Capítulo 4. Realización de Consultas
4.14. Test 1. ¿Para
de repaso qué sirve
DISTINCT en
una
SELECT?
6. Filtrar
a) Para mostrar las las idénticas
d) Ninguna
número de
resultados
a) No se puede de ninguna manera en Oracle
b) Para no mostrar las idénticas c) Para mostrar, aparte, las las
por el
distintas
de las anteriores
b) Se puede mediante la cláusula LIMIT en Oracle
c) Se puede mediantela cláusulanumrows en Oracle
2. Un ltro WHERE expresiones con
puede incorporar
d) No se puede hacer de ninguna manera en MySQL
a) Operadores numéricos b) Operadores relacionales
7 .En
SQL se puede ordenar
c) Llamadas a funciones
a)El
d) Todas las anteriores
b) El nombre de la columna
número de columna (1,2,3.
c Una 3. El operador
no IN
se puede usar para
d
por .
expresión
)
a) Escribir en un ltro una lista de valores b) Escribir en un ltro una subconsulta c) Una ordenación
Todas ) anteriores las
d) Encadenar varios condicionesde tipo AND 4. El
test de
8. Si junto a una función selecciona un campo
valor nulo
a) Sirve para comprobarsi un conjunto deresultados es
vacío
b) Sirve para comprobarsi el valor deun campo es desconocido c) Sirve para comprobar si el valor de un campo es o no es desconocido
d) Todas las anterioresson correctas 5. El patrón %AX_
