SQL02 PDF

CURSO DE SQL
CAPTULO 21
ndice de contenido
INTRODUCCIN................................................................................................................................2
MANOS A LA OBRA.....................................................................................................................2
PRIMERA INCURSIN: CONSULTAS DE SELECCIN...............................................................2
UN INCISO SOBRE LA LLAMADA A LOS CAMPOS...............................................................2
SELECCIN DE TODOS LOS CAMPOS DE UNA TABLA.......................................................3
SELECCIN DE CAMPOS DE VARIAS TABLAS NO RELACIONADAS...............................3
ORDENANDO NUESTROS RESULTADOS................................................................................3
PRACTIQUEMOS CON UN EJEMPLO............................................................................................4
SQL SIMPLE..............................................................................................................................4
SQL COMPUESTA.................................................................................................................5
SQL ORDENADA......................................................................................................................5
PREDICADOS.....................................................................................................................................7
TOP..................................................................................................................................................7
DISTINCT.......................................................................................................................................8
OTRA MANERA DE CONSEGUIR EL MISMO RESULTADO...........................................10
DISTINCTROW............................................................................................................................10
UTILIZACIN DE LA CLUSULA WHERE.................................................................................11
CARACTERES COMODN.........................................................................................................11
OPERADORES.............................................................................................................................12
MARCO SEGN EL TIPO DE DATOS.......................................................................................12
CLUSULA WHERE, COMODINES Y OPERADORES...........................................................12
EJEMPLOS CON OPERADORES MATEMTICOS............................................................13
EJEMPLOS CON OPERADORES DE COMPARACIN......................................................14
BETWEEN... AND..............................................................................................................14
IN..........................................................................................................................................14
LIKE.....................................................................................................................................15
EJEMPLOS CON COMPARADORES LGICOS..................................................................17
AND.....................................................................................................................................17
OR........................................................................................................................................18
XOR......................................................................................................................................18
IMP / EQV............................................................................................................................19
NOT......................................................................................................................................20
ISNULL / NOT ISNULL.....................................................................................................21
PARA ACABAR ESTE CAPTULO.................................................................................................22
1
La BD donde estn los ejemplos de este captulo os la podis bajar aqu.
Vistame en http://siliconproject.com.ar/neckkito/
INTRODUCCIN
MANOS A LA OBRA
Empezaremos nuestra andadura prctica por SQL con el
aprendizaje de los comandos DML que comentbamos en el
primer captulo, creo yo que por ser los ms intuitivos
para quien no ha visto SQL (o ha visto muy poco) en su
construccin y significado.
La BD que utilizaremos de ejemplo para ir desarrollando este captulo fue la que construimos
(o nos bajamos) en el captulo 1. De todas maneras ya habris visto en la nota a pie de pgina
anterior que os podis bajar la BD con los ejemplos desarrollados de este captulo, por si
queris usarla como consulta o gua.
Y dicho lo anterior no perdamos ms tiempo con discursos y entremos de lleno ya en materia.
PRIMERA INCURSIN: CONSULTAS DE SELECCIN

Para realizar una consulta simple de seleccin debemos utilizar la siguiente estructura:
SELECT nomCampo FROM nomTabla
Es decir: selecciname el campo tal de esta tabla.
Esta consulta es extremadamente simple. Si queremos seleccionar ms campos debemos
indicarlo separndolos por una coma, de la siguiente manera:
SELECT nomCampo1, nomCampo2 FROM nomTabla
UN INCISO SOBRE LA LLAMADA A LOS CAMPOS

Si estamos trabajando sobre una sola tabla las estructuras anteriores nos funcionarn
perfectamente, pero si tenemos dos o ms tablas la cosa se complica un poco.
Personalmente soy de la opinin que, por facilidad de lectura de cdigo, es mejor indicar la
tabla de origen del campo, aunque la consulta sea del tipo ms simple. Con ello conseguimos,
adems, optimizar el rendimiento de la SQL. Evidentemente esto es una opinin personal y
no hay porque seguirla obligatoriamente.
Para indicar la tabla de origen debemos separar con un punto la tabla del campo. De esta
manera, nuestra estructura anterior quedara de la siguiente manera:
SELECT nomTabla.nomCampo FROM nomTabla
o, si necesitamos ms campos:
SELECT nomTabla.nomCampo1, nomTabla.nomCampo2 FROM nomTabla
SELECCIN DE TODOS LOS CAMPOS DE UNA TABLA

Para seleccionar todos los campos de una tabla tenemos
varias opciones:
Escribir los nombres de todos los campos

Utilizar el carcter asterisco (*) como comodn
Utilizar el predicado ALL *
Parece claro que lo ms prctico es utilizar el asterisco, por lo que

nuestra estructura SQL quedara de la siguiente manera:
SELECT * FROM nomTabla
o tambin
SELECT ALL * FROM nomTabla
SELECCIN DE CAMPOS DE VARIAS TABLAS NO RELACIONADAS

Si queremos seleccionar varios campos de varias tablas no relacionadas el sistema,
afortunadamente, no se nos complica demasiado. La estructura que deberamos utilizar sera:
SELECT nomTabla1.nomCampo1, nomTabla1.nomCampo2, nomTabla2.nomCampo1
FROM nomTabla1, nomTabla2
Como podemos observar, hemos separado utilizando comas (,) tanto los campos que
queremos como las tablas que queremos.
ORDENANDO NUESTROS RESULTADOS

Para ordenar nuestros registros debemos emplear la clusula ORDER BY
As, nuestra sentencia quedara de la siguiente manera:
SELECT nomTabla.nomCampo1, nomTabla.nomCampo2 FROM nomTabla ORDER BY nomTabla.nomCampoX
Evidentemente, si queremos ordenar por dos campos, nuestra sentencia quedara as:
SELECT nomTabla.nomCampo1, nomTabla.nomCampo2, nomTabla.nomCampo3
FROM nomTabla ORDER BY nomTabla.nomCampoX, nomTabla.nomCampoY
Lo anterior nos da una ordenacin ascendente (de la A a la Z). Qu ocurre si queremos una
ordenacin descendente?
Pues que debemos indicrselo a travs de la palabra DESC.
La estructura quedara, pues, as:
SELECT nomTabla.nomCampo1, nomTabla.nomCampo2
FROM nomTabla ORDER BY nomTabla.nomCampoX DESC
PRACTIQUEMOS CON UN EJEMPLO

Para que quede constancia de nuestros esfuerzos vamos a
creamos un formulario en blanco, al que llamaremos
FConsultasSQL, y que nos servir para meter los botones
para practicar los distintos tipos de SQL que hemos visto
hasta ahora. Recordad que los cdigos para las consultas de
seleccin, para que podamos ver los resultados, tendrn la
siguiente estructura:
Eliminamos la consulta, si existiera
Creamos la consulta SQL (marcado en negrita)

Creamos el objeto-consulta para poder ver los resultados.
Deberamos centrarnos en la fase 2, es decir, en la SQL propiamente dicha.
SQL SIMPLE
Insertamos un botn de comando, al que llamaremos cmdSimpleSobreClientes. Lo que vamos
a hacer es extraer toda la informacin de la tabla TClientes. El cdigo que debemos generar al
botn en el evento Al hacer click es el siguiente:
Private Sub cmdSimpleSobreClientes_Click()

'Definimos las variables
Dim miSql As String, nomQuery As String
'Indicamos qu nombre va a tener la consulta
nomQuery = "CClientes"
'La borramos si ya existe a travs del cdigo del mdulo mdlProcesos
Call eliminaConsulta(nomQuery)
'-----Definimos la consulta SQL-----------------------------------------miSql = "SELECT * FROM TClientes"
'------------------------------------------------------------------'Creamos la consulta a travs del cdigo del mdulo mdlProcesos
Call creaConsulta(nomQuery, miSql)
'Abrimos la consulta creada
DoCmd.OpenQuery nomQuery
End Sub
Si queremos podemos cambiar el asterisco por ALL *, y comprobaremos que los resultados
son los mismos.
Para abundar ms en el tema vamos a realizar una consulta que nos d el nombre del cliente y
su poblacin. Para ello creamos un nuevo botn de comando, lo llamamos cmdNomyPoblCli y
le generamos el siguiente cdigo (os recomiendo que intentis crearla vosotros antes de echar
un vistazo al cdigo):
Private Sub cmdNomyPoblCli_Click()

nomQuery = "CNombreYPoblacionClientes"
miSql = "SELECT TClientes.NomCli, TClientes.PoblCli FROM TClientes"

End Sub
SQL COMPUESTA
Vamos a imaginarnos que necesitamos crear una consulta
como la anterior, pero que necesitamos, en cada registro,
que nos aparezca el nombre del usuario activo.
Recordemos que no existe ninguna relacin entre TClientes y
TUsuarioAct (que es donde tenemos informado el nombre del
usuario activo).
Creamos el botn cmdClientesYUser y... cmo sera el cdigo? Pues as:
Private Sub cmdClientesYUser_Click()

nomQuery = "CClienteYUsuario"
miSql = "SELECT TClientes.NomCli, TClientes.PoblCli, TUsuarioAct.NomUser" _
& " FROM TClientes, TUsuarioAct"
End Sub
Fijaos que, en este caso, s es necesario utilizar la estructura nomTabla.nomCampoX, y que

tras el FROM debemos indicar las dos tablas de dnde queremos obtener los datos.
Es decir:
SQL ORDENADA
Vamos a ordenar nuestros resultados. Para ello insertaremos un nuevo botn de comando
(cmdOrdenadoAsc) y vamos a generarle el siguiente cdigo:
Private Sub cmdOrdenadoAsc_Click()

5
nomQuery = "CNombreYPoblacionClientesAscendente"
miSql
=
"SELECT
TClientes.NomCli,
TClientes.PoblCli FROM TClientes" _
& " ORDER BY TClientes.NomCli"
End Sub
Podemos realizar varias ordenaciones por diferentes campos en la misma consulta. El orden de
ordenacin lo estableceremos nosotros por el orden en que escribamos tras el ORDER BY. Por
ejemplo, si queremos ordenar por poblacin y, dentro de esta ordenacin, a su vez ordenar por
cliente deberamos escribir este cdigo en el botn cmdOrdenadoAsc2:
Private Sub cmdOrdenadoAsc2_Click()

nomQuery = "CNombreYPoblacionClientesAscendente2"
miSql = "SELECT TClientes.NomCli, TClientes.PoblCli FROM TClientes" _
& " ORDER BY TClientes.PoblCli,TClientes.NomCli"
End Sub
Como vemos, la estructura es igual a nuestra consulta simple; simplemente lo que hacemos es
aadir el ORDER BY identificando a continuacin el campo que nos dar la ordenacin.
En la ilustracin de la izquierda podemos ver los resultados de la primera ordenacin, y en la
de la derecha los resultados de la segunda.
Y si queremos el orden descendente? Pues ya deberamos saber hacerlo, pero por si las
moscas el cdigo asignado al botn cmdOrdenadoDesc sera:
Private Sub cmdOrdenadoDesc_Click()

nomQuery = "CNombreYPoblacionClientesAscendente"
6

& " ORDER BY TClientes.NomCli DESC"
End Sub
Fcil, no?
PREDICADOS
Aprovecharemos lo que hemos aprendido anteriormente para aplicar predicados a nuestras
SQL's.
De hecho, ya hemos utilizado un predicado, que ha sido ALL.
La estructura de las SQL, en general, con los predicados, sera:
SELECT <PREDICADO> ...
Echemos un vistazo a otros predicados:
TOP
Supongamos que queremos ver el importe ms alto de todas las ventas que hemos realizado.
Para ello necesitaramos utilizar el predicado TOP. Como queremos ver una (1) sola venta (la
mayor) necesitaremos indicrselo al TOP. Es decir:
SELECT TOP 1 ...
El cdigo que nos dara la consulta con dicho resultado sera:
Private Sub cmdTop_Click()

nomQuery = "VentaImporteMasAlto"
miSql = "SELECT TOP 1 TVentas.ImpVta FROM TVentas ORDER BY TVentas.ImpVta DESC"

7
End Sub
Fijaos en que debemos ordenar los resultados (ORDER BY)

porque, si no lo hacemos as, nos devolvera el primer
registro de la consulta. Adems, la ordenacin debe ser
descendente, para que los importes se nos siten de mayor
a menor.
Si cambisemos el 1 por un 5, por ejemplo, obtendramos las 5
ventas de importe ms alto
Sigamos con el TOP. Imaginemos que no queremos utilizar valores absolutos, sino que
queremos utilizar porcentajes. Es decir, que queremos saber el 10% de las ventas ms altas.
Para ello utilizaramos la estructura:
SELECT TOP XX PERCENT
Donde XX sera el porcentaje deseado.
Nuestro cdigo debera quedar de esta manera:
Private Sub cmdTop10_Click()

nomQuery = "VentaImporteMasAlto10xCiento"
miSql = "SELECT TOP 10 PERCENT TVentas.ImpVta FROM TVentas ORDER BY TVentas.ImpVta DESC"

End Sub
Y el resultado sera:
DISTINCT
Si realizramos una seleccin de los clientes a los cuales hemos vendido gnero podramos
utilizar la siguiente SQL:
Private Sub cmdDistinct_Click()

nomQuery = "CClientesConVenta"
8
miSql = "SELECT TVentas.IdCliVta FROM TVentas"
End Sub
Nos arrojara un resultado as:
Como podemos ver, este listado no nos es demasiado prctico, porque se producen
repeticiones del nombre de cliente.
Para obtener valores nicos podemos utilizar el predicado DISTINCT, de acuerdo a la siguiente
estructura:
SELECT DISTINCT
De manera que modificando ligeramente el cdigo anterior por:
Private Sub cmdDistinct_Click()

nomQuery = "CClientesConVenta"
miSql = "SELECT DISTINCT TVentas.IdCliVta FROM TVentas"
End Sub
El resultado que obtendramos ya sera ms manejable:
OTRA MANERA DE CONSEGUIR EL MISMO RESULTADO

Para este tipo de seleccin podemos utilizar la clusula GROUP BY
para obtener el mismo resultado.
La estructura para hacer lo anterior sera:
SELECT nomTabla.nomCampo FROM nomTabla GROUP
BY nomTabla.nomCampo
As, nuestro cdigo quedara de la siguiente manera:
Private Sub cmdGBy_Click()

nomQuery = "CClientesConVenta2"
miSql = "SELECT TVentas.IdCliVta FROM TVentas GROUP BY TVentas.IdCliVta"
End Sub
DISTINCTROW
Con DISTINCTROW, a diferencia de DISTINC (que slo examina el contenido de los campos
seleccionados), se examina el contenido del registro completo independientemente de los
campos indicados en el SELECT.
Para poder realizar un ejemplo vamos, en nuestra tabla TTrabPersonal, a insertar un nuevo
trabajador, con la caracterstica que va a compartir apellido con uno de los trabajadores ya
existentes. Por ejemplo, yo he aadido el siguiente registro:
Si utilizramos el DISTINC se nos devolveran 10 registros, seleccionando por

apellido, porque eliminara uno (Lugosi) por estar repetido
Es decir, la SQL sera:
miSql = "SELECT DISTINCT TTrabPersonal.ApellTrab FROM TTrabPersonal"
Sin embargo, si utilizamos DISTINCTROW nos devolvera 11 registros, puesto que

aunque en la SQL examinamos el campo [ApellTrab] se examinan tambin el resto
de campos.
Nuestro cdigo sera:
Private Sub cmdDistincRow_Click()

10
nomQuery = "CTrabDistinctRow"
miSql
=
"SELECT
DISTINCTROW
TTrabPersonal.ApellTrab FROM TTrabPersonal"
End Sub
Con el resultado:
UTILIZACIN DE LA CLUSULA WHERE

Hasta ahora hemos visto cmo seleccionar los datos, pero puede ocurrirnos que necesitemos
filtrar los datos existentes para depurar nuestra bsqueda de informacin. Un manera de
hacerlo es a travs de la clusula WHERE.
Sin embargo, antes de entrar de lleno con esta clusula vamos a ver un par de curiosidades
sobre cmo maximizar la eficacia de los filtros.
CARACTERES COMODN
Podemos utilizar, en combinacin con la clusula WHERE, los operadores que vimos en el
primer captulo (operadores matemticos y operadores lgicos), y podemos tambin utilizar lo
que se denominan caracteres comodn.
Tenemos los siguientes caracteres comodn:
* (asterisco): representa cero o ms caracteres
? (interrogacin de cierre): representa cualquier carcter, pero slo uno.
# (almohadilla): representa cualquier nmero, pero un slo dgito
[] (corchetes): si en el interior de los corchetes escribimos un smbolo especial,

estamos indicando que lo que queremos es la coincidencia con ese smbolo especial.
[listaDeCaracteres]: representa que queremos coincidencia con cualquier carcter que

est dentro de esa lista.
! (exclamacin de cierre): representa la negacin de lo que el signo antecede.

Bueno... Dicho as quiz no acabe de entenderse del todo. Vamos a ver...
Si yo escribo ENE* podr obtener resultados como ENE (letra n), ENERO o ENERGIA, porque
* representa cero (letra n) o ms caracteres.
Si yo escribo LO?O podr obtener resultados como LOBO, o LORO, pero no LOBEZNO, porque
? representa cualquier carcter, pero slo uno. Para que me devolviera LOBEZNO debera
buscar LO????O.
Si yo escribo A#B podr obtener resultados como A1B, o A9B, pero no A11B, porque slo he
utilizado una almohadilla (un dgito), y A11B contiene dos dgitos numricos.
11
Si yo escribo [a-c]* podr obtener resultados como azul, barco, casa, pero no dedo, porque
estoy buscando palabras que empiecen por a, b o c.
Si yo escribo [a-c, f-g]* podr obtener todas las palabras
que empiecen por a, b, c, f y g.
Si yo escribo [!w-z]* podr obtener todas las palabras
que empiecen por cualquier letra del abecedario,
exceptuando las que comiencen por w, x, y, z.
Si yo escribo A[*]A slo podr obtener el valor A*A, porque al
encerrar el asterisco entre corchetes estoy indicando que no quiero
el asterisco como comodn, sino como literal.
Veremos un par de ejemplos de utilizacin de estos caracteres comodn un poco ms adelante.
OPERADORES
Como comentbamos en el captulo primero, tenemos dos tipos de operadores: los operadores
matemticos y los operadores lgicos.
Su combinacin con la clusula WHERE nos permite una gran versatilidad de filtros y de
bsquedas para extraer los datos que nos interesan.
Como ya los comentamos en el captulo anterior los veremos a travs de diversos ejemplos.
MARCO SEGN EL TIPO DE DATOS

Segn el tipo de dato debemos enmarcar la condicin de bsqueda o no entre unos caracteres
especiales.
La siguiente tabla muestra cmo debemos indicrselo a la SQL
TIPO DE CAMPO
LO ENCERRAREMOS ENTRE
Numrico / Moneda
No lo encerramos. El filtro es directo
Texto
Comillas simples (')
Fecha
Almohadillas (#)
Booleano
No lo encerramos. Lo igualamos a TRUE o a FALSE
CLUSULA WHERE, COMODINES Y OPERADORES

La estructura de una construccin SQL con WHERE sera
SELECT nomTabla.nomCampo FROM nomTabla WHERE nomTabla.nomCampo <condicin>
Vamos a empezar con una serie de ejemplos de cmo podemos utilizar los diferentes
elementos que hemos visto hasta ahora.
12
EJEMPLOS CON OPERADORES MATEMTICOS

Vamos a realizar una consulta sobre la tabla TVentas donde
obtengamos las ventas de importe mayor a 5000 euros.
Recordemos que, al ser un valor numrico, el filtro es
directo (no debemos enmarcarlo entre ningn carcter
especial).
El cdigo que nos hara lo anterior sera:
Private Sub cmdVtasMas5000_Click()

nomQuery = "VentasMas5000"
miSql = "SELECT TVentas.IdCliVta, TVentas.ImpVta FROM TVentas" _
& " WHERE TVentas.ImpVta>=5000"
End Sub
Imaginemos que queremos conocer las ventas realizadas a partir de abril 2012. En este caso
estamos trabajando con un dato de tipo fecha, por lo que debemos recordar enmarcarlo entre
almohadillas.
La SQL que nos devolvera esos valores sera:
Private Sub cmdVtasSupAbril12_Click()

nomQuery = "VentasSupAbril12"
miSql = "SELECT TVentas.IdCliVta, TVentas.ImpVta, TVentas.FechVta" _
& " FROM TVentas" _
& " WHERE TVentas.FechVta>=#04-01-12#"
End Sub
Importante: fijaos que he tenido que escribir la fecha en formato ingls (mm/dd/yy) para
conseguir devolver unos resultados correctos. Hay varios factores que influyen en cmo
examina Access el formato de fecha que tenemos en nuestra BD (aunque en la interfaz grfica
veamos las fechas en formato espaol -dd/mm/yy-). Es importante comprobar si los
resultados que nos devuelve la SQL para saber si, en nuestra BD, debemos emplear un
formato u otro.
Como podemos ver, la operativa con operadores matemticos es sencilla y no creo que
necesitemos ms ejemplos sobre el tema.
13
EJEMPLOS CON OPERADORES DE COMPARACIN

BETWEEN... AND...
La estructura, tras el WHERE, para utilizar este operador
sera:
WHERE nomTabla.nomCampo
AND <valor2>
BETWEEN
<valor1>
Supongamos que queremos saber qu ventas se han

realizado durante el primer trimestre de 2012.
Nuestra SQL sera la siguiente:
Private Sub cmdVtas1T12_Click()

nomQuery = "Ventas1T12"
miSql = "SELECT TVentas.ImpVta, TVentas.FechVta FROM TVentas" _
& " WHERE TVentas.FechVta BETWEEN #01-01-12# AND #03-31-12#" _
& " ORDER BY TVentas.FechVta"
End Sub
Fijaos que he enmarcado las fechas entre almohadillas y que he utilizado el formato de fecha
ingls de nuevo.
IN
El operador IN nos permite seleccionar registros con valores que coincidan con la condicin
marcada en el propio IN.
La estructura del WHERE con el operador IN sera:
WHERE nomTabla.nomCampo IN (<valor1>, <valor2>, , <valorN>)
Por ejemplo, queremos saber qu clientes tenemos en las poblaciones de Valencia y Badajoz.
Nuestra SQL sera:
Private Sub cmdClientesValenciaBadajoz_Click()

nomQuery = "CClientesValenciaYBadajoz"
& " WHERE TClientes.PoblCli IN ('Valencia', 'Badajoz')"
14
End Sub
Fijaos que al buscar cadenas de texto hemos enmarcado los

valores a buscar entre comillas simples.
Si operamos con nmeros, por ejemplo, podramos utilizar
los valores directos. Por ejemplo, vamos a ver los meses
impares utilizando IN:
Private Sub cmdMesesIN_Click()

nomQuery = "CMesesConIN"
miSql = "SELECT TMeses.NumMes, TMeses.NomMes FROM TMeses" _
& " WHERE TMeses.NumMes IN (1,3,5,7,9,11)"
End Sub
LIKE
El operador LIKE nos sirve para buscar por aproximacin, y lo utilizamos combinndolo con los
caracteres comodn que hemos visto unos apartados ms arriba.
La estructura del WHERE con LIKE sera:
WHERE nomTabla.nomCampo LIKE <condicin>
Supongamos que queremos saber qu trabajadores estn relacionados con el departamento de
ventas. Podramos pues filtrar por aquellos cuyo cargo contenga las palabras ven.
Nuestra SQL podra ser as:
Private Sub cmdTrabRelVtas_Click()

nomQuery = "CTrabRelacionadosVentas"
miSql = "SELECT TTrabLaboral.IdTrab, TTrabLaboral.Cargo FROM TTrabLaboral" _
& " WHERE TTrabLaboral.Cargo LIKE '*ven*'"
End Sub
Fijaos que, como estamos buscando una cadena de texto, debemos enmarcar la condicin
entre comillas simples.
15
Supongamos que queremos mostrar todos los trabajadores cuyo apellido empiece por las
letras de la F a la J.
Nuestra SQL sera:
Private Sub cmdTrabFJ_Click()

nomQuery = "CTrabFaJ"
miSql = "SELECT TTrabPersonal.ApellTrab FROM TTrabPersonal" _
& " WHERE TTrabPersonal.ApellTrab LIKE '[F-J]*'"
End Sub
Del mismo modo, si quisiramos aadir a la anterior bsqueda aquellos trabajadores cuyo
apellido empiece tambin por las letras que van de la V a la Z escribiramos:
Private Sub cmdTrabFJ_VZ_Click()

nomQuery = "CTrabFaJyVaZ"
& " WHERE TTrabPersonal.ApellTrab LIKE '[F-J, V-Z]*'"
End Sub
Si, por el contrario, lo que queremos es ver todos los trabajadores menos aquellos cuyo
apellido empiece por las letras de la F a la J escribiramos:
Private Sub cmdTrabNoFJ_Click()

nomQuery = "CTrabNoFaJ"
miSql = "SELECT DISTINCT TTrabPersonal.ApellTrab FROM TTrabPersonal" _
& " WHERE TTrabPersonal.ApellTrab LIKE '[!F-J]*'"
End Sub
Otro ejemplo con dgitos. Imaginemos que queremos conocer aquellos trabajadores cuyo
telfono acabe con un 2 seguido de cualquier dgito. Nuestra SQL sera:
16

Private Sub cmdTrabTfno2x_Click()
nomQuery = "CTrabTfno2x"
miSql
=
"SELECT
TTrabPersonal.ApellTrab,
TTrabPersonal.TfnoTrab FROM TTrabPersonal" _
& " WHERE TTrabPersonal.TfnoTrab LIKE '*2#'"

End Sub
Finalmente, imaginemos que queremos saber qu trabajadores tienen, en su apellido, la letra I

y la letra O, pero que slo haya un carcter en medio de ambas letras.
Si utilizramos el comodn asterisco obtendramos estos resultados, pero vemos
que no cumplen nuestra condicin
Utilizaremos pues el comodn ? para conseguir el resultado que queremos:
Private Sub cmdTrabIxO_Click()

nomQuery = "CTrabIxO"
& " WHERE TTrabPersonal.ApellTrab LIKE '*i?o*'"
End Sub
EJEMPLOS CON COMPARADORES LGICOS

Vamos a ver cmo podemos utilizar los comparadores lgicos. Ni que decir tiene que podemos
combinarlo con todos los anteriores comparadores.
AND
El operador AND obliga a que se cumplan todas las condiciones especificadas para devolver
registros.
Su estructura sera:
WHERE nomTabla.nomCampoX <operador><condicion> AND
nomTabla.nomCampoY <operador><condicion> AND
Por ejemplo, vamos a recuperar los clientes que sean de Valencia y en su nombre aparezcan
las letras Frut.
17
El cdigo sera:
Private Sub cmdCliFrutValencia_Click()

nomQuery = "CClientesFrutValencia"
miSql
=
"SELECT
TClientes.NomCli,
TClientes.PoblCli FROM TClientes" _
& " WHERE TClientes.NomCli LIKE '*Frut*' AND
TClientes.PoblCli='Valencia'"
End Sub
OR
Con el operador se nos devuelven registros siempre que se cumpla una de las dos condiciones,
o ambas (pueden ser ms de dos, ojo).
La estructura es idntica a la de AND:
WHERE nomTabla.nomCampoX <operador><condicion> OR
nomTabla.nomCampoY <operador><condicion> OR
Por ejemplo, si queremos saber qu clientes tenemos en Madrid o en Bilbao deberamos
escribir:
Private Sub cmdCliMadridBilbao_Click()

nomQuery = "CClientesMadridBilbao"
& " WHERE TClientes.PoblCli='Madrid' OR TClientes.PoblCli='Bilbao'"
End Sub
XOR
Con el operador XOR obtenemos el registro si slo se cumple una de las condiciones; si se
cumplen ambas o no se cumple ninguna no obtenemos ningn registro.
La estructura es la misma que la especificada para OR:
WHERE nomTabla.nomCampoX <operador><condicion> XOR
18
nomTabla.nomCampoY <operador><condicion> XOR

Imaginemos que queremos mostrar o bien los clientes que
estn en Barcelona o bien aquellos clientes cuyo CIF
empiece por A, pero no los que sean de Barcelona con NIF
empezando por A. Nuestra SQL sera:
Private Sub cmdXor_Click()

nomQuery = "CEjemploXOR"
miSql = "SELECT TClientes.NomCli, TClientes.NIFCli, TClientes.PoblCli" _
& " FROM TClientes" _
& " WHERE TClientes.NIFCli LIKE 'A*' XOR TClientes.PoblCli='Barcelona'"
End Sub
El resultado que obtendramos es:
Si miramos la tabla TClientes veremos que nos ha excluido el registro
Porque S es de Barcelona y su Nif S empieza por A

Y tambin nos ha excluido los registros:
porque NO son de Barcelona y su Nif NO empieza por A
IMP / EQV
A modo de informacin os comentar que existen los operadores IMP y EQV. No realizaremos
ningn ejemplo sobre los mismos, pero s os dejar indicadas sus tablas de verdad, por si en
alguna ocasin os pudieran ser de utilidad.
19
IMP
Expresin1
Expresin2
Devuelve
Verdadero
Verdadero
Verdadero
Verdadero
Falso
Falso
Verdadero
Null
Null
Falso
Verdadero
Verdadero
Falso
Falso
Verdadero
Falso
Null
Verdadero
Null
Verdadero
Verdadero
Null
Falso
Null
Null
Null
Null
EQV
Expresin1
Expresin2
Devuelve
Verdadero
Verdadero
Verdadero
Verdadero
Falso
Falso
Falso
Verdadero
Falso
Falso
Falso
Verdadero
NOT
El uso del NOT es de lo ms sencillo: se antepone a todos los operadores que hemos visto
anteriormente y convierte su significado en el contrario.
Es decir, que su estructura sera:
WHERE nomTabla.nomCampo NOT <expresin>
Por ejemplo, en un epgrafe anterior hemos visto cmo podamos sacar los meses impares. Si
quisiramos sacar los meses pares aprovechando el cdigo que ya tenemos escrito podramos
utilizar el operador NOT, con lo que obtendramos:
Private Sub cmdNot_Click()

20
nomQuery = "CMesesConNOTIN"
miSql = "SELECT TMeses.NumMes, TMeses.NomMes
FROM TMeses" _
& " WHERE TMeses.NumMes NOT IN (1,3,5,7,9,11)"
End Sub
ISNULL / NOT ISNULL

Finalmente, si queremos filtrar por campos vacos (o no vacos, utilizando el NOT que
acabamos de ver) podemos emplear el operar ISNULL.
La estructura de este operador sera:
WHERE ISNULL(nomTabla.nomCampo)
o utilizando el NOT
WHERE NOT ISNULL(nomTabla.nomCampo)
Vamos, en nuestra tabla TClientes, a aadir un nuevo cliente, pero no le asignaremos ninguna
poblacin. El registro nos quedara una cosa as:
Entonces, para saber qu clientes no tienen poblacin asignada, escribiramos:
Private Sub cmdIsNull_Click()

nomQuery = "CClientesSinPoblacion"
& " WHERE ISNULL(TClientes.PoblCli)"
End Sub
Lo que nos devolvera el registro que acabamos dar de alta.

Para devolver todos los registros menos el que acabamos de dar de alta simplemente
construiramos la SQL as:
& " WHERE NOT ISNULL(TClientes.PoblCli)"
21
PARA ACABAR ESTE CAPTULO...

Hemos hecho una primera incursin en el lenguaje SQL
con sentencias muy simples. El objetivo del mismo era que
os familiarizarais con las estructuras y con las palabras
clave que generalmente veris en una sentencia SQL
(hablando muy en general). As, si en un cdigo os
encontris con SELECT, FROM, ORDER BY... ya sabris
inmediatamente que estamos hablando de este lenguaje.
Hemos aprendido a utilizar predicados para depurar
nuestras bsquedas.
Finalmente, hemos aprendido tambin cmo filtrar los datos mediante consultas de seleccin,
aplicando la clusula WHERE y muchos operadores que tenemos a nuestra disposicin.
En prximos captulos iremos viendo otras posibilidades para manejar datos a travs del
Structured Query Language
Un saludo, y
suerte!
22

SQL02 PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

SQL02 PDF

Uploaded by

Copyright:

Available Formats

CURSO DE SQL

La BD donde estn los ejemplos de este captulo os la podis bajar aqu.

PRIMERA INCURSIN: CONSULTAS DE SELECCIN

UN INCISO SOBRE LA LLAMADA A LOS CAMPOS

SELECCIN DE TODOS LOS CAMPOS DE UNA TABLA

Escribir los nombres de todos los campos

Parece claro que lo ms prctico es utilizar el asterisco, por lo que

SELECCIN DE CAMPOS DE VARIAS TABLAS NO RELACIONADAS

ORDENANDO NUESTROS RESULTADOS

PRACTIQUEMOS CON UN EJEMPLO

Eliminamos la consulta, si existiera

Creamos la consulta SQL (marcado en negrita)

Deberamos centrarnos en la fase 2, es decir, en la SQL propiamente dicha.

Private Sub cmdSimpleSobreClientes_Click()

Private Sub cmdNomyPoblCli_Click()

Call creaConsulta(nomQuery, miSql)

Private Sub cmdClientesYUser_Click()

Fijaos que, en este caso, s es necesario utilizar la estructura nomTabla.nomCampoX, y que

Private Sub cmdOrdenadoAsc_Click()

Private Sub cmdOrdenadoAsc2_Click()

Private Sub cmdOrdenadoDesc_Click()

miSql = "SELECT TClientes.NomCli, TClientes.PoblCli FROM TClientes" _

Private Sub cmdTop_Click()

Call creaConsulta(nomQuery, miSql)

Fijaos en que debemos ordenar los resultados (ORDER BY)

Private Sub cmdTop10_Click()

Call creaConsulta(nomQuery, miSql)

Private Sub cmdDistinct_Click()

Nos arrojara un resultado as:

Private Sub cmdDistinct_Click()

El resultado que obtendramos ya sera ms manejable:

OTRA MANERA DE CONSEGUIR EL MISMO RESULTADO

Private Sub cmdGBy_Click()

Si utilizramos el DISTINC se nos devolveran 10 registros, seleccionando por

Sin embargo, si utilizamos DISTINCTROW nos devolvera 11 registros, puesto que

Private Sub cmdDistincRow_Click()

UTILIZACIN DE LA CLUSULA WHERE

* (asterisco): representa cero o ms caracteres

? (interrogacin de cierre): representa cualquier carcter, pero slo uno.

# (almohadilla): representa cualquier nmero, pero un slo dgito

[] (corchetes): si en el interior de los corchetes escribimos un smbolo especial,

[listaDeCaracteres]: representa que queremos coincidencia con cualquier carcter que

! (exclamacin de cierre): representa la negacin de lo que el signo antecede.

MARCO SEGN EL TIPO DE DATOS

No lo encerramos. El filtro es directo

Comillas simples (')

No lo encerramos. Lo igualamos a TRUE o a FALSE

CLUSULA WHERE, COMODINES Y OPERADORES

EJEMPLOS CON OPERADORES MATEMTICOS

Private Sub cmdVtasMas5000_Click()

Private Sub cmdVtasSupAbril12_Click()

EJEMPLOS CON OPERADORES DE COMPARACIN

Supongamos que queremos saber qu ventas se han

Private Sub cmdVtas1T12_Click()

Private Sub cmdClientesValenciaBadajoz_Click()

Fijaos que al buscar cadenas de texto hemos enmarcado los

Private Sub cmdMesesIN_Click()

Private Sub cmdTrabRelVtas_Click()

Private Sub cmdTrabFJ_Click()

Private Sub cmdTrabFJ_VZ_Click()

Private Sub cmdTrabNoFJ_Click()

Call creaConsulta(nomQuery, miSql)

Finalmente, imaginemos que queremos saber qu trabajadores tienen, en su apellido, la letra I