1 Mysql ...............................................................................................................................

4
1.1 Creacin de una base de datos. ................................................................................ 5
1.1.1 Creacion de tablas. ............................................................................................ 5
1.1.2 Insertar registros en una tabla ........................................................................... 5
1.1.3 Tipos de datos de un campo de una tabla. ........................................................ 6
1.2 Consulta de campos. ................................................................................................ 6
1.2.1 Consultas de registros especficos. ................................................................... 6
1.2.2 Operadores relacionales. ................................................................................... 7
1.3 borrar registros de una tabla..................................................................................... 7
1.4 Modificacin de registros de una tabla. ................................................................... 7
1.5 Clave primaria y clave fornea. ............................................................................... 8
1.6 Campo autoincremento. ........................................................................................... 8
1.7 Modificar la estructura de una tabla......................................................................... 8
1.8 Comando truncate table. .......................................................................................... 9
1.9 Valores null. ............................................................................................................. 9
1.10 Columnas calculadas. ............................................................................................. 10
2 Funciones para el manejo de cadenas. .......................................................................... 11
2.1 Funciones matemticas. ......................................................................................... 13
3 Clusula order by del select. ......................................................................................... 20
4 Operadores Lgicos (and - or - not) .............................................................................. 21
5 Agrupando los resultados .............................................................................................. 23
5.1 Filtrando los datos agrupados ................................................................................ 24
5.2 Filtro distinct. ......................................................................................................... 24
6 Alias. ............................................................................................................................. 27
7 Qu es una subconsulta? .............................................................................................. 28
7.1 Subconsultas que devuelven conjuntos de datos. .................................................. 29
8 Join ................................................................................................................................ 29
8.1 Acercamiento a la necesidad de los JOIN.............................................................. 29
8.2 JOIN cruzados, internos y externos ....................................................................... 33
9 Union ............................................................................................................................. 36
 9.1Unin de dos consultas
36
9.2 Imitando un FULL OUTER JOIN ......................................................................... 38
Referencias ........................................................................................................................... 40
 INTRODUCCIN

Nos encontramos en un momento decisivo respecto del uso de la tecnologa para extender y
potenciar nuestra capacidad de comunicarnos. La globalizacin de Internet se ha producido
ms rpido de lo que cualquiera hubiera imaginado. El modo en que se producen las
interacciones sociales, comerciales, polticas y personales cambia en forma continua para
estar al da con la evolucin de esta red global. En la prxima etapa de nuestro desarrollo, los
innovadores usarn Internet como punto de inicio para sus esfuerzos, lo que generar nuevos
productos y servicios diseados especficamente para aprovechar las capacidades de la red.
A medida que los programadores impulsen los lmites de lo posible, las capacidades de las
redes interconectadas que crean la Internet jugarn un papel cada vez ms grande en el xito
de estos proyectos.
 1 Mysql
MySQL es un interpretador de SQL, es un servidor de base de datos.

MySQL permite crear base de datos y tablas, insertar datos, modificarlos, eliminarlos,
ordenarlos, hacer consultas y realizar muchas operaciones, etc., resumiendo: administrar
bases de datos.

Ingresando instrucciones en la lnea de comandos o embebidas en un lenguaje como PHP nos

comunicamos con el servidor. Cada sentencia debe acabar con punto y coma (;).

La sensibilidad a maysculas y minsculas, es decir, si hace diferencia entre ellas, depende

del sistema operativo, Windows no es sensible, pero Linux s. Por ejemplo, Windows
interpreta igualmente las siguientes sentencias:

create database administracion;

Create DataBase administracion;

Pero Linux interpretar como un error la segunda.

 1.1 Creacin de una base de datos.
Para la creacin de nuestras bases de datos utilizaremos la siguiente instruccin:
Create database NobreDeLaBaseDatos;
Para que el servidor nos muestre las bases de datos existentes, se lo solicitamos enviando la
instruccin:
show databases;
Para utilizar una BD especifica:
Use NombreDeLaBd;
1.1.1 Creacion de tablas.
Una tabla es una estructura de datos que organiza los datos en columnas y filas; cada columna
es un campo (o atributo) y cada fila, un registro. La interseccin de una columna con una fila,
contiene un dato especfico, un solo valor.
Creacin de tablas
create table NombreDeLaTabla (
atributos.
);
Para ver las tablas que existen dentro de nuestro BD:
show tables;
Para la eliminacin de una tabla:
drop table nombre de la tabla;
Visualizar la estructura de una tabla;
describe NombreDeLaTabla;

1.1.2 Insertar registros en una tabla

Un registro es una fila de la tabla que contiene los datos propiamente dichos. Cada registro
tiene un dato por cada columna.
Al ingresar los datos de cada registro debe tenerse en cuenta la cantidad y el orden de los
campos.
insert into NombreDelaTabla (atributos..) values ('ValorDelAtributo', 'ValorDelAtributo');
Es importante ingresar los valores en el mismo orden en que se nombran los campos, si
ingresamos los datos en otro orden, no aparece un mensaje de error y los datos se guardan de
modo incorrecto.
1.1.3 Tipos de datos de un campo de una tabla.
Cuando creamos una tabla es muy importante especificar la longitud y el tipo de cambo que
tendr nuestro atributo.
Alfanumrico (varchar): contiene cifras numricas y caracteres alfabticos.
Numrico (integer): existen de varios tipos principalmente como enteros y reales.
Nmeros decimales (float): valores numricos decimales. Se utiliza como separador el
punto (.). Definimos campos de este tipo para precios.
Fecha y hora (datetime): almacena fecha y hora, su formato es "YYYY-MM-DD
HH:MM:SS".
Hora (time): una hora. Su formato es "HH:MM:SS".

1.2 Consulta de campos.

Para visualizar todos los registros de una tabla utilizaremos:
select *form NombreDeLaTabla;
Podemos especificar los atributos que se desean ver:
Select nombreDelosAtributos from NombreDeLaTabla;
El comando "select" recupera los registros de una tabla. Con el asterisco (*) indicamos que
seleccione todos los campos de la tabla que nombramos.

1.2.1 Consultas de registros especficos.

Podemos utilizar la clusula where para poder especificar un registro especifico que solo
cumplan con ciertas condiciones.
select atributo, atributo2 from NombreDelaTabla where atributo=marcos;
 1.2.2 Operadores relacionales.
Se emplean para comparar valores y proporcionar un valor lgico.
Los operadores relacionales son los siguientes:
= igual
<> distinto
> mayor
< menor
>= mayor o igual
<= menor o igual

Ejemplo:

select atributo, atributo2, atributo3 from NombreDelaTabla where atributo1 > 20;

1.3 borrar registros de una tabla.

Para eliminar el registro de una tabla utilizamos el comando delete.
Ejemplo:
delete from NombreDelaTabla where atributo1 = 20;

1.4 Modificacin de registros de una tabla.

Para la modificacin de una o varios registros utilizamos update.
update NombreDelaTabla set atributo = dato;
Si queremos modificar algunos registros utilizaremos where.
update NombreDelaTabla set atributo = dato where atributo ='Marco';
Para actualizar varios campos en una sola instruccin.
update NombreDelaTabla set atributo = dato, atributo = 3 where atributo ='Marco';
 1.5 Clave primaria y clave fornea.
Una clave primaria es un campo (o varios) que identifica 1 solo registro (fila) en una tabla y
es un valor que no se repite.
create table NombreTabla (atributo varchar (20), atributo1 varchar (10), primary key
(atributo));
Si la clave primaria existe nos mandara un error.
Para colocar una clave fornea utilizaremos la siguiente sintaxis:
FOREIGN KEY(campo_fk) REFERENCES nombre_tabla (nombre_campo)
Las claves forneas y las claves primarias deben ser del mismo tipo para poder enlazarse. Si
modificamos una, debemos modificar la otra para que los valores se correspondan.

1.6 Campo autoincremento.

Los campos de autoincremento se inician de 1 y se van incrementando de 1 automticamente.
Los campos deben de ser enteros y deben ser una clave primaria.
create table NombreTabla (atributo int auto_increment, atributo1 varchar (10), primary key
(atributo));

1.7 Modificar la estructura de una tabla

Modificar la estructura de una tabla es algo ms complicado: aadir campos, eliminarlos,

cambiar su nombre o el tipo de datos. En general, para todo ello se usar la orden "ALTER
TABLE". Vamos a ver las posibilidades ms habituales.

Para aadir un campo usaramos "ADD":

ALTER TABLE ciudades ADD habitantes decimal(7);

Si no se indica otra cosa, el nuevo campo se aade al final de la tabla. Si queremos que sea
el primer campo, lo indicaramos aadiendo "first" al final de la orden. Tambin podemos
hacer que se aada despus de un cierto campo, con "AFTER nombreCampo".

Podemos modificar el tipo de datos de un campo con "MODIFY". Por ejemplo, podramos
hacer que el campo "habitantes" no fuera un "decimal" sino un entero largo ("bigint") con:
ALTER TABLE ciudades MODIFY habitantes bigint;
Si queremos cambiar el nombre de un campo, debemos usar "CHANGE" (se debe indicar el
nombre antiguo, el nombre nuevo y el tipo de datos). Por ejemplo, podramos cambiar el
nombre "habitantes" por "numhabitantes":

ALTER TABLE ciudades CHANGE habitantes numhabitantes bigint;

Si queremos borrar algn campo, usaremos "drop column":

ALTER TABLE ciudades DROP COLUMN numhabitantes;

Muchas de estas rdenes se pueden encadenar, separadas por comas. Por ejemplo, podramos
borrar dos campos con "alter table ciudades drop column num habitantes, drop column
provincia;"

Tambin podramos cambiar el nombre de una tabla con "RENAME":

ALTER TABLE ciudades RENAME ciudad;

Y si hemos olvidado indicar la clave primaria en una tabla, tambin podemos usar ALTER
TABLE para detallarla a posteriori:

ALTER TABLE ciudades ADD PRIMARY KEY(codigo);

1.8 Comando truncate table.

La sentencia "truncate table" vaca la tabla (elimina todos los registros) y vuelve a crear la
tabla con la misma estructura.
La diferencia con "drop table" es que esta sentencia borra la tabla, "truncate table" la vaca.
truncate table NombreTabla;

1.9 Valores null.

Null significa "dato desconocido" o "valor inexistente". No es lo mismo que un valor 0, una
cadena vaca o una cadena literal "null".
 A veces, puede desconocerse o no existir el dato correspondiente a algn campo de un
registro. En estos casos decimos que el campo puede contener valores nulos.
create table alumnos (
matricula int auto_increment,
nombre varchar (20) not null
edad varchar (30),
curp varchar (15),
colegiatura float,
primary key (matricula)
);

1.10 Columnas calculadas.

Es posible obtener salidas en las cuales una columna sea el resultado de un clculo y no un
campo de una tabla.
select atributo1, atributo2, atributo1 + atributo2 from nombreTabla;
2 Funciones para el manejo de cadenas.

Recuerda que no debe haber espacios entre un nombre de funcin y los parntesis porque
MySQL puede confundir una llamada a una funcin con una referencia a una tabla o campo
que tenga el mismo nombre de una funcin.
MySQL tiene algunas funciones para trabajar con cadenas de caracteres. estas son algunas:

Funciones de conversin a maysculas/minsculas

LOWER o LCASE convierte una cadena a minsculas: SELECT LOWER('Hola'); hola.
UPPER o UCASE convierte una cadena a maysculas: SELECT UPPER('Hola'); HOLA.

Funciones de extraccin de parte de la cadena

LEFT(cadena, longitud) extrae varios caracteres del comienzo (la parte izquierda) de la
cadena: SELECT LEFT('Hola',2); Ho
RIGHT(cadena, longitud) extrae varios caracteres del final (la parte derecha) de la cadena:
SELECT RIGHT('Hola',2); la
MID(cadena, posicin, longitud), SUBSTR(cadena, posicin, longitud) o
SUBSTRING(cadena, posicin, longitud) extrae varios caracteres de cualquier posicin de
una cadena, tantos como se indique en "longitud": SELECT SUBSTRING('Hola',2,3); ola
(Nota: a partir MySQL 5 se permite un valor negativo en la posicin, y entonces se comienza
a contar desde la derecha -el final de la cadena-)
CONCAT une (concatena) varias cadenas para formar una nueva: SELECT CONCAT('Ho',
'la'); Hola
CONCAT_WS une (concatena) varias cadenas para formar una nueva, usando un separador
que se indique (With Separator): SELECT CONCAT_WS('-','Ho','la','Que','tal'); Ho-la-
Que-tal
LTRIM devuelve la cadena sin los espacios en blanco que pudiera contener al principio (en
su parte izquierda): SELECT LTRIM(' Hola'); Hola
RTRIM devuelve la cadena sin los espacios en blanco que pudiera contener al final (en su
parte derecha): SELECT RTRIM('Hola '); Hola
TRIM devuelve la cadena sin los espacios en blanco que pudiera contener al principio ni al
final: SELECT TRIM(' Hola '); Hola
 (Nota: realmente, TRIM puede eliminar cualquier prefijo, no slo espacios; mira el
manual de MySQL para ms detalles)

Funciones de conversin de base numrica

BIN convierte un nmero decimal a binario: SELECT BIN(10); 1010
HEX convierte un nmero decimal a hexadecimal: SELECT HEX(10); 'A'
(Nota: HEX tambin tiene un uso alternativo menos habitual: puede recibir una cadena, y
entonces mostrar el cdigo ASCII en hexadecimal de sus caracteres: SELECT HEX('Hola');
'486F6C61')
OCT convierte un nmero decimal a octal: SELECT OCT(10); 12
CONV(nmero,baseInicial,baseFinal) convierte de cualquier base a cualquier base:
SELECT CONV('F3',16,2); 11110011
UNHEX convierte una serie de nmeros hexadecimales a una cadena ASCII, al contrario de
lo que hace HEX: SELECT UNHEX('486F6C61'); 'Hola')

Otras funciones de modificacin de la cadena

INSERT(cadena,posicin,longitud,nuevaCadena) inserta en la cadena otra cadena:
SELECT INSERT('Hola', 2, 2, 'ADIOS'); HADIOSa
REPLACE(cadena,de,a) devuelve la cadena pero cambiando ciertas secuencias de
caracteres por otras: SELECT REPLACE('Hola', 'l', 'LLL'); HoLLLa
REPEAT(cadena,numero) devuelve la cadena repetida varias veces:
SELECT REPEAT(' Hola',3); HolaHolaHola
REVERSE(cadena) devuelve la cadena "del revs": SELECT REVERSE('Hola'); aloH
SPACE(longitud) devuelve una cadena formada por varios espacios en blanco: SELECT
SPACE(3); " "
Funciones de informacin sobre la cadena
CHAR_LENGTH o CHARACTER_LENGTH devuelve la longitud de la cadena en
caracteres
LENGTH devuelve la longitud de la cadena en bytes
BIT_LENGTH devuelve la longitud de la cadena en bits
INSTR(cadena,subcadena) o LOCATE(subcadena,cadena,posInicial) devuelve la
posicin de una subcadena dentro de la cadena: SELECT INSTR('Hola','ol'); 2

2.1 Funciones matemticas.

Los operadores aritmticos son "+","-","*" y "/". Todas las operaciones matemticas retornan
"null" en caso de error. Ejemplo:

select 5/0;

RECUERDE que NO debe haber espacios entre un nombre de funcin y los parntesis porque
MySQL puede confundir una llamada a una funcin con una referencia a una tabla o campo
que tenga el mismo nombre de una funcin.

Los operadores matemticos que podemos emplear son los habituales en cualquier lenguaje
de programacin, ligeramente ampliados: + (suma), - (resta y negacin), * (multiplicacin),
/ (divisin). La divisin calcula el resultado con decimales; si queremos trabajar con nmeros
enteros, tambin tenemos los operadores DIV (divisin entera) y MOD (resto de la divisin):

Dara como resultado:

 Para que resulte ms legible, se puede aadir un "alias" a cada "nuevo campo" que se
genera al plantear las operaciones matemticas:

Tambin podramos utilizar incluso operaciones a nivel de bits, como las del lenguaje C (>>
para desplazar los bits varias posiciones a la derecha, << para desplazar a la izquierda, para
una suma lgica bit a bit, & para un producto lgico bit a bit y ^ para una operacin XOR):

Que dara:

Funciones de agregacin
Tambin podemos aplicar ciertas funciones matemticas a todo un conjunto de
datos de una tabla. Por ejemplo, podemos saber cul es la edad ms baja de
entre las personas que tenemos en nuestra base de datos, haramos:

Las funciones de agregacin ms habituales son:

min = mnimo valor

max = mximo valor
sum = suma de los valores
avg = media de los valores
count = cantidad de valores
 La forma ms habitual de usar "count" es pidiendo con "count(*)" que se nos
muestren todos los datos que cumplen una condicin. Por ejemplo, podramos saber
cuntas personas tienen una direccin que comience por la letra "s", as:

Funciones para el uso de fecha y hora.

MySQL tiene algunas funciones para trabajar con fechas y horas. Estas son algunas:

adddate(fecha, interval expresion): retorna la fecha agregndole el intervalo especificado.

Ejemplos:

adddate('2006-10-10',interval 25 day) retorna "2006-11-04". adddate('2006-10-10',interval 5

month) retorna "2007-03-10".

adddate(fecha, dias): retorna la fecha agregndole a fecha "dias".

Ejemplo:

adddate('2006-10-10',25), retorna "2006-11-04".

addtime(expresion1,expresion2): agrega expresion2 a expresion1 y retorna el resultado.

current_date: retorna la fecha de hoy con formato "YYYY-MM-DD" o "YYYYMMDD".

current_time: retorna la hora actual con formato "HH:MM:SS" o "HHMMSS".

date_add(fecha,interval expresion tipo) y date_sub(fecha,interval expresion tipo): el

argumento "fecha" es un valor "date" o "datetime", "expresion" especifica el valor de
intervalo a ser aadido o substrado de la fecha indicada (puede empezar con "-", para
intervalos negativos), "tipo" indica la medida de adicin o substraccin.

Ejemplo:

date_add('2006-08-10', interval 1 month) retorna "2006-09-10";

date_add('2006-08-10', interval -1 day) retorna "2006-09-09";

date_sub('2006-08-10 18:55:44', interval 2 minute) retorna "2006-08-10 18:53:44";

date_sub('2006-08-10 18:55:44', interval '2:3' minute_second) retorna "2006-08-10

18:52:41";
 Los valores para "tipo" pueden ser: second, minute, hour, day, month, year,
minute_second (minutos y segundos), hour_minute (horas y minutos), day_hour (das y
horas), year_month (ao y mes), hour_second (hora, minuto y segundo), day_minute (das,
horas y minutos), day_second(das a segundos).

datediff(fecha1,fecha2): retorna la cantidad de das entre fecha1 y fecha2.

dayname(fecha): retorna el nombre del da de la semana de la fecha.

Ejemplo:

dayname('2006-08-10') retorna "thursday".

dayofmonth(fecha): retorna el da del mes para la fecha dada, dentro del rango 1 a 31.

Ejemplo:

dayofmonth('2006-08-10') retorna 10.

dayofweek(fecha): retorna el ndice del da de semana para la fecha pasada como

argumento. Los valores de los ndices son: 1=domingo, 2=lunes,... 7=sbado).

Ejemplo:

dayofweek('2006-08-10') retorna 5, o sea jueves.

dayofyear(fecha): retorna el da del ao para la fecha dada, dentro del rango 1 a 366.

Ejemplo:

dayofmonth('2006-08-10') retorna 222.

extract(tipo from fecha): extrae partes de una fecha.

Ejemplos:

extract(year from '2006-10-10'), retorna "2006".

extract(year_month from '2006-10-10 10:15:25') retorna "200610".

extract(day_minute from '2006-10-10 10:15:25') retorna "101015";

Los valores para tipo pueden ser: second, minute, hour, day, month, year, minute_second,
hour_minute, day_hour, year_month, hour_second (horas, minutos y segundos),
day_minute (das, horas y minutos), day_second (das a segundos).
 hour(hora): retorna la hora para el dato dado, en el rango de 0 a 23.

Ejemplo:

hour('18:25:09') retorna "18";

minute(hora): retorna los minutos de la hora dada, en el rango de 0 a 59.

monthname(fecha): retorna el nombre del mes de la fecha dada.

Ejemplo:

monthname('2006-08-10') retorna "August".

month(fecha): retorna el mes de la fecha dada, en el rango de 1 a 12.

now() y sysdate(): retornan la fecha y hora actuales.

period_add(p,n): agrega "n" meses al periodo "p", en el formato "YYMM" o

"YYYYMM"; retorna un valor en el formato "YYYYMM". El argumento "p" no es una
fecha, sino un ao y un mes.

Ejemplo:

period_add('200608',2) retorna "200610".

period_diff(p1, p2): retorna el nmero de meses entre los perodos "p1" y "p2", en el
formato "YYMM" o "YYYYMM". Los argumentos de perodo no son fechas sino un ao y
un mes.

Ejemplo:

period_diff('200608','200602') retorna 6.

second(hora): retorna los segundos para la hora dada, en el rango de 0 a 59.

sec_to_time(segundos): retorna el argumento "segundos" convertido a horas, minutos y

segundos.

Ejemplo:

sec_to_time(90) retorna "1:30".

timediff(hora1,hora2): retorna la cantidad de horas, minutos y segundos entre hora1 y

hora2.
 time_to_sec(hora): retorna el argumento "hora" convertido en segundos.

to_days(fecha): retorna el nmero de da (el nmero de da desde el ao 0).

weekday(fecha): retorna el ndice del da de la semana para la fecha pasada como

argumento. Los ndices son: 0=lunes, 1=martes, 6=domingo).

Ejemplo:

weekday('2006-08-10') retorna 3, o sea jueves.

year(fecha): retorna el ao de la fecha dada, en el rango de 1000 a 9999.

Ejemplo:

year('06-08-10') retorna "2006".

 3 Clusula order by del select.

Podemos ordenar el resultado de un "select" para que los registros se muestren ordenados
por algn campo, para ello usamos la clusula "order by".

Por ejemplo, recuperamos los registros de la tabla "libros" ordenados por el ttulo:

select codigo,titulo,autor,editorial,precio from libros order by titulo;

Aparecen los registros ordenados alfabticamente por el campo especificado.

Tambin podemos colocar el nmero de orden del campo por el que queremos que se ordene
en lugar de su nombre. Por ejemplo, queremos el resultado del "select" ordenado por
"precio":

select codigo,titulo,autor,editorial,precio from libros order by 5;

Por defecto, si no aclaramos en la sentencia, los ordena de manera ascendente (de menor a
mayor). Podemos ordenarlos de mayor a menor, para ello agregamos la palabra clave "desc":

select codigo,titulo,autor,editorial,precio from libros order by editorial desc;

Tambin podemos ordenar por varios campos, por ejemplo, por "titulo" y "editorial":

select codigo,titulo,autor,editorial,precio from libros order by titulo, editorial;

Incluso, podemos ordenar en distintos sentidos, por ejemplo, por "titulo" en sentido
ascendente y "editorial" en sentido descendente:

select codigo,titulo,autor,editorial,precio from libros order by titulo asc, editorial desc;

Debe aclararse al lado de cada campo, pues estas palabras claves afectan al campo
inmediatamente anterior.
4 Operadores Lgicos (and - or - not)
Podemos establecer ms de una condicin con la clusula "where", para ello aprenderemos
los operadores lgicos.
Son los siguientes:
And: significa "y",
Or: significa "y/o",
Xor: significa "o",
Not: significa "no", invierte el resultado
(): parntesis
Los operadores lgicos se usan para combinar condiciones.
Queremos recuperar todos los registros cuyo autor sea igual a "Borges" y cuyo precio no
supere los 20 pesos, para ello necesitamos 2 condiciones:
select * from libros
where (autor='Borges') and
(precio<=20);
Los registros recuperados en una sentencia que une 2 condiciones con el operador "and",
cumplen con las 2 condiciones.
Queremos ver los libros cuyo autor sea "Borges" y/o cuya editorial sea "Planeta":
select * from libros
where autor='Borges' or
editorial='Planeta';
En la sentencia anterior usamos el operador "or", indicamos que recupere los libros en los
cuales el valor del campo "autor" sea "Borges" y/o el valor del campo "editorial" sea
"Planeta", es decir, seleccionar los registros que cumplan con la primera condicin, con la
segunda condicin o con ambas condiciones.
Los registros recuperados con una sentencia que une 2 condiciones con el operador "or",
cumplen 1 de las condiciones o ambas.
Queremos ver los libros cuyo autor sea "Borges" o cuya editorial sea "Planeta":
select * from libros
where (autor='Borges') xor
(editorial='Planeta');
En la sentencia anterior usamos el operador "xor", indicamos que recupere los libros en los
cuales el valor del campo "autor" sea "Borges" o el valor del campo "editorial" sea "Planeta",
es decir, seleccionar los registros que cumplan con la primera condicin o con la segunda
condicin, pero no los que cumplan con ambas condiciones. Los registros recuperados con
una sentencia que une 2 condiciones con el operador "xor", cumplen 1 de las condiciones, no
ambas.
Queremos recuperar los libros que no cumplan la condicin dada, por ejemplo, aquellos cuya
editorial NO sea "Planeta":
select * from libros
where not (editorial='Planeta');
El operador "not" invierte el resultado de la condicin a la cual antecede.
Los registros recuperados en una sentencia en la cual aparece el operador "not", no cumplen
con la condicin a la cual afecta el "NO".
Los parntesis se usan para encerrar condiciones, para que se evalen como una sola
expresin.
Cuando explicitamos varias condiciones con diferentes operadores lgicos (combinamos
"and", "or") permite establecer el orden de prioridad de la evaluacin; adems permite
diferenciar las expresiones ms claramente.
Por ejemplo, las siguientes expresiones devuelven un resultado diferente:
select * from libros
where (autor='Borges') or
(editorial='Paidos' and precio<20);
select*from libros
where (autor='Borges' or editorial='Paidos') and
(precio<20);
Si bien los parntesis no son obligatorios en todos los casos, se recomienda utilizarlos para
evitar confusiones.
El orden de prioridad de los operadores lgicos es el siguiente: "not" se aplica antes que "and"
y "and" antes que "or", si no se especifica un orden de evaluacin mediante el uso de
parntesis.
El orden en el que se evalan los operadores con igual nivel de precedencia es indefinido,
por ello se recomienda usar los parntesis.

5 Agrupando los resultados

Puede ocurrir que no nos interese un nico valor agrupado para todos los datos (el total, la
media, la cantidad de datos), sino el resultado para un grupo especfico de datos. Por ejemplo:
podemos desear saber no slo la cantidad de clientes que hay registrados en nuestra base de
datos, sino tambin la cantidad de clientes que viven en cada ciudad.

La forma de obtener subtotales es creando grupos con la orden "GROUP BY", y entonces
pidiendo un valor agrupado (count, sum, avg, ...) para cada uno de esos grupos. Como
limitacin, slo se podrn pedir como resultados los valores agrupados (como la cantidad o
la media) y el criterio de agrupamiento.
Por ejemplo, en nuestra tabla "personas", podramos saber cuntas personas aparecen de cada
edad, con:
SELECT count(*), edad FROM personas GROUP BY edad;
que dara como resultado
+----------+------+
| count(*) | edad |
+----------+------+
| 1 | 22 |
| 1 | 23 |
| 1 | 25 |
+----------+------+
5.1 Filtrando los datos agrupados
Pero podemos llegar ms all: podemos no trabajar con todos los grupos posibles, sino slo
con los que cumplen alguna condicin.
La condicin que se aplica a los grupos no se indica con "where", sino con "having" (que se
podra traducir como "los que tengan..."). Un ejemplo:
SELECT count(*), edad FROM personas GROUP BY edad HAVING edad > 24;
que mostrara
+----------+------+
| count(*) | edad |
+----------+------+
| 1 | 25 |
+----------+------+

5.2 Filtro distinct.

Con la clusula "distinct" se especifica que los registros con ciertos datos duplicados sean
omitidos en el resultado. Por ejemplo, queremos conocer todos los autores de los cuales
tenemos libros, si utilizamos esta sentencia:
select autor from libros;
Aparecen repetidos. Para obtener la lista de autores sin repeticin usamos:
select distinct autor from libros;
Tambin podemos teclear:
select autor from libros group by autor;
Nota que en los tres casos anteriores aparece "null" como un valor para "autor" Si slo
queremos la lista de autores conocidos, es decir, no queremos incluir "null" en la lista,
podemos utilizar la sentencia siguiente:
select distinct autor from libros where autor is not null;
Para contar los distintos autores, sin considerar el valor "null" usamos:
select count(distinct autor) from libros;
Nota que, si contamos los autores sin "distinct", no incluir los valores "null" pero si los
repetidos:
select count(autor) from libros;
Esta sentencia cuenta los registros que tienen autor.
Para obtener los nombres de las editoriales usamos:
select editoriales from libros;
Para una consulta en la cual los nombres no se repitan tecleamos:
select distinct editorial from libros;
Podemos saber la cantidad de editoriales distintas usamos:
select count(distinct editoriales) from libros;
Podemos combinarla con "where". Por ejemplo, queremos conocer los distintos autores de la
editorial "Planeta":
select distinct autor from libros where editorial='Planeta';
Tambin puede utilizarse con "group by":
select editorial, count(distinct autor) from libros group by editorial;
Para mostrar los ttulos de los libros sin repetir ttulos, usamos:
select distinct titulo from libros order by titulo;
La clusula "distinct" afecta a todos los campos presentados. Para mostrar los ttulos y
editoriales de los libros sin repetir ttulos ni editoriales, usamos:
select distinct titulo,editorial from libros order by titulo;
Nota que los registros no estn duplicados, aparecen ttulos iguales pero con editorial
diferente, cada registro es diferente.

Un "alias" se usa como nombre de un campo o de una expresin o para referenciar una tabla
cuando se utilizan ms de una tabla (tema que veremos ms adelante).

Cuando usamos una funcin de agrupamiento, por ejemplo:

select count(*)
from libros
where autor like '%Borges%';
 la columna en la salida tiene como encabezado "count(*)", para que el resultado sea
ms claro podemos utilizar un alias:

select count(*) as librosdeborges

from libros
where autor like '%Borges%';
La columna de la salida ahora tiene como encabezado el alias, lo que hace ms comprensible
el resultado.
6 Alias.
Un alias puede tener hasta 255 caracteres, acepta todos los caracteres. La palabra clave "as"
es opcional en algunos casos, pero es conveniente usarla. Si el alias consta de una sola cadena
las comillas no son necesarias, pero si contiene ms de una palabra, es necesario colocarla
entre comillas.
Se pueden utilizar alias en las clsulas "group by", "order by", "having". Por ejemplo:
select editorial as 'Nombre de editorial' from libros group by 'Nombre de editorial';
select editorial, count(*) as cantidad from libros group by editorial order by cantidad;
select editorial, count(*) as cantidad from libros group by editorial having cantidad>2;
No est permitido utilizar alias de campos en las clusulas "where".
Los alias sern de suma importancia cuando rescate datos desde el lenguaje PHP
7 Qu es una subconsulta?

A veces tenemos que realizar operaciones ms complejas con los datos, operaciones en las
que nos interesara ayudarnos de una primera consulta auxiliar que extrajera la informacin
en la que nos queremos basar. Esta consulta auxiliar recibe el nombre de "subconsulta" o
"subquery".
Por ejemplo, si queremos saber qu clientes tenemos en la ciudad que ms habitantes tenga,
la forma "razonable" de conseguirlo sera saber en primer lugar cual es la ciudad que ms
habitantes tenga, y entonces lanzar una segunda consulta para ver qu clientes hay en esa
ciudad.
Como la estructura de nuestra base de datos de ejemplo es muy sencilla, no podemos hacer
grandes cosas, pero un caso parecido al anterior (aunque claramente ms intil) podra ser
saber qu personas tenemos almacenadas que vivan en la ltima ciudad de nuestra lista.
Para ello, la primera consulta (la "subconsulta") sera saber cul es la ltima ciudad de nuestra
lista. Si suponemos que los cdigos numricos son creciente, y lo hacemos tomando la ciudad
que tenga el ltimo cdigo (el mayor de ellos), la consulta podra ser:
SELECT MAX(codigo) FROM ciudades;
Vamos a imaginar que pudiramos hacerlo en dos pasos. Si llamamos "maxCodigo" a ese
cdigo obtenido, la "segunda" consulta podra ser:
SELECT * FROM personas WHERE codciudad= maxCodigo;
Pero estos dos pasos se pueden dar en uno: al final de la "segunda" consulta (la "grande")
incluimos la primera consulta (la "subconsulta"), entre parntesis, as:
SELECT * FROM personas WHERE codciudad= ( SELECT MAX(codigo) FROM
ciudades);
7.1 Subconsultas que devuelven conjuntos de datos.

Si la subconsulta no devuelve un nico dato, sino un conjunto de datos, la forma de trabajar

ser bsicamente la misma, pero para comprobar si el valor coincide con alguno de la lista,
no usaremos el smbolo "=", sino la palabra "in".
Por ejemplo, vamos a hacer una consulta que nos muestre las personas que viven en ciudades
cuyo nombre tiene una "a" en segundo lugar (por ejemplo, seran ciudades vlidas Madrid o
Barcelona, pero no Alicante).
Para consultar qu letras hay en ciertas posiciones de una cadena, podemos usar
SUBSTRING (en el prximo apartado veremos las funciones ms importantes de
manipulacin de cadenas, pero podemos anticipar ya que recibe tres datos: el nombre del
campo, la posicin inicial y la longitud). As, una forma de saber qu ciudades tienen una
letra A en su segunda posicin sera:
SELECT codigo FROM ciudades WHERE SUBSTRING(nombre,2,1)='a';
Como esta subconsulta puede devolver ms de un resultado, deberemos usar IN para incluirla
en la consulta principal, que quedara de esta forma:
SELECT * FROM personas WHERE codciudad IN (SELECT codigo FROM ciudades
WHERE SUBSTRING(nombre,2,1)='a');

8 Join
8.1 Acercamiento a la necesidad de los JOIN
Sabemos enlazar varias tablas para mostrar datos que estn relacionados, empleando
"WHERE". Por ejemplo, podramos mostrar nombres de deportistas, junto con los nombres
de los deportes que practican. Pero todava hay un detalle que se nos escapa: cmo hacemos
si queremos mostrar todos los deportes que hay en nuestra base de datos, incluso aunque no
haya deportistas que los practiquen?

Vamos a crear una base de datos sencilla para ver un ejemplo de cual es este problema y de
cmo solucionarlo.

Nuestra base de datos se llamar "ejemploJoins":

CREATE DATABASE ejemploJoins;
USE ejemploJoins;
En ella vamos a crear una primera tabla en la que guardaremos "capacidades" de personas
(cosas que saben hacer):
CREATE TABLE capacidad(
codigo varchar(4),
nombre varchar(20),
PRIMARY KEY(codigo)
);
Tambin crearemos una segunda tabla con datos bsicos de personas:
CREATE TABLE persona(
codigo varchar(4),
nombre varchar(20),
codcapac varchar(4),
PRIMARY KEY(codigo)
);
Vamos a introducir datos de ejemplo:
INSERT INTO capacidad VALUE ('c','Progr.C'), ('pas','Progr.Pascal'), ('j','Progr.Java'),
('sql','Bases datos SQL');
INSERT INTO persona VALUES ('ju','Juan','c'), ('ja','Javier','pas'), ('jo','Jose','perl'),
('je','Jesus','html');
Antes de seguir, comprobamos que todo est bien:
SELECT * FROM capacidad;
+--------+-----------------+
| codigo | nombre |
+--------+-----------------+
|c | Progr.C |
|j | Progr.Java |
| pas | Progr.Pascal |
| sql | Bases datos SQL |
+--------+-----------------+
SELECT * FROM persona;
+--------+--------+----------+
| codigo | nombre | codcapac |
+--------+--------+----------+
| ja | Javier | pas |
| je | Jesus | html |
| jo | Jose | perl |
| ju | Juan | c |
+--------+--------+----------+

Como se puede observar, hay dos capacidades en nuestra base de datos para las que no
conocemos a ninguna persona; de igual modo, existen dos personas que tienen capacidades
sobre las que no tenemos ningn detalle.
Por eso, si mostramos las personas con sus capacidades de la forma que sabemos, slo
aparecern las parejas de persona y capacidad para las que todo est claro (existe persona y
existe capacidad), es decir:
SELECT * FROM capacidad, persona WHERE persona.codcapac = capacidad.codigo;
+--------+--------------+--------+--------+----------+
| codigo | nombre | codigo | nombre | codcapac |
+--------+--------------+--------+--------+----------+
|c | Progr.C | ju | Juan | c |
| pas | Progr.Pascal | ja | Javier | pas |
+--------+--------------+--------+--------+----------+

Podemos resumir un poco esta consulta, para mostrar slo los nombres, que son los datos que
ms nos interesan:
SELECT persona.nombre, capacidad.nombre FROM persona, capacidad WHERE
persona.codcapac = capacidad.codigo;
 +--------+--------------+
| nombre | nombre |
+--------+--------------+
| Juan | Progr.C |
| Javier | Progr.Pascal |
+--------+--------------+

Hay que recordar que la orden "where" es obligatoria: si no indicamos esa condicin, se
mostrara el "producto cartesiano" de las dos tablas: todos los pares (persona, capacidad),
aunque no estn relacionados en nuestra base de datos:
SELECT persona.nombre, capacidad.nombre FROM persona, capacidad;
+--------+-----------------+

| nombre | nombre |

+--------+-----------------+

| Javier | Progr.C |

| Jesus | Progr.C |

| Jose | Progr.C |

| Juan | Progr.C |

| Javier | Progr.Java |

| Jesus | Progr.Java |

| Jose | Progr.Java |

| Juan | Progr.Java |

| Javier | Progr.Pascal |

| Jesus | Progr.Pascal |

| Jose | Progr.Pascal |

| Juan | Progr.Pascal |

| Javier | Bases datos SQL |

| Jesus | Bases datos SQL |

| Jose | Bases datos SQL |

| Juan | Bases datos SQL |

+--------+-----------------+
8.2 JOIN cruzados, internos y externos
Pues bien, con rdenes "join" podemos afinar cmo queremos enlazar (en ingls, "join", unir)
las tablas. Por ejemplo, si queremos ver todas las personas y todas las capacidades, aunque
no estn relacionadas, como en el ejemplo anterior, algo que no suele tener sentido en la
prctica, lo podramos hacer con un "cross join" (unir de forma cruzada):
SELECT persona.nombre, capacidad.nombre FROM persona CROSS JOIN capacidad;
+--------+-----------------+
| nombre | nombre |
+--------+-----------------+
| Javier | Progr.C |
| Jesus | Progr.C |
| Jose | Progr.C |
| Juan | Progr.C |
| Javier | Progr.Java |
| Jesus | Progr.Java |
| Jose | Progr.Java |
| Juan | Progr.Java |
| Javier | Progr.Pascal |
| Jesus | Progr.Pascal |
| Jose | Progr.Pascal |
| Juan | Progr.Pascal |
| Javier | Bases datos SQL |
| Jesus | Bases datos SQL |
| Jose | Bases datos SQL |
| Juan | Bases datos SQL |
+--------+-----------------+

Si slo queremos ver los datos que coinciden en ambas tablas, lo que antes conseguamos
comparando los cdigos con un "where", tambin podemos usar un "inner join" (unin
interior; se puede abreviar simplemente "join"):
SELECT persona.nombre, capacidad.nombre FROM persona INNER JOIN capacidad ON
persona.codcapac = capacidad.codigo;
+--------+--------------+
| nombre | nombre |
+--------+--------------+
| Juan | Progr.C |
| Javier | Progr.Pascal |
+--------+--------------+

Pero aqu llega la novedad: si queremos ver todas las personas y sus capacidades (si existen),
mostrando incluso aquellas personas para las cuales no tenemos constancia de ninguna
capacidad, usaramos un "left join" (unin por la izquierda, tambin se puede escribir "left
outer join", unin exterior por la izquierda, para dejar claro que se van a incluir datos que
estn slo en una de las dos tablas):
SELECT persona.nombre, capacidad.nombre FROM persona LEFT OUTER JOIN
capacidad ON persona.codcapac = capacidad.codigo;
+--------+--------------+
| nombre | nombre |
+--------+--------------+
| Juan | Progr.C |
| Javier | Progr.Pascal |
| Jesus | NULL |
| Jose | NULL |
+--------+--------------+

De igual modo, si queremos ver todas las capacidades, incluso aquellas para las que no hay
detalles sobre personas, podemos escribir el orden de las tablas al revs en la consulta
anterior, o bien usar "right join" (o "right outer join"):
SELECT persona.nombre, capacidad.nombre FROM persona RIGHT OUTER JOIN
capacidad ON persona.codcapac = capacidad.codigo;
 +--------+-----------------+
| nombre | nombre |
+--------+-----------------+
| Javier | Progr.Pascal |
| Juan | Progr.C |
| NULL | Progr.Java |
| NULL | Bases datos SQL |
+--------+-----------------+

El significado de "LEFT" y de "RIGHT" hay que buscarlo en la posicin en la que se

enumeran las tablas en el bloque "FROM". As, la ltima consulta se puede escribir tambin
como un LEFT JOIN si se indica la capacidad en segundo lugar (en la parte izquierda), as:
SELECT persona.nombre, capacidad.nombre FROM capacidad LEFT OUTER JOIN
persona ON persona.codcapac = capacidad.codigo;
+--------+-----------------+
| nombre | nombre |
+--------+-----------------+
| Javier | Progr.Pascal |
| Juan | Progr.C |
| NULL | Progr.Java |
| NULL | Bases datos SQL |
+--------+-----------------+
9 Union
9.1 Unin de dos consultas
Se puede unir dos consultas en una, empleando la palabra "UNION". El requisito es que
ambas consultas deben devolver campos "similares" (mismo nombre y tipo de datos). Como
primer ejemplo (un tanto innecesario), podramos crear una consulta que muestre las personas
cuyo nombre contiene una "o" y aquellas cuyo nombre tiene una "e":
SELECT nombre FROM persona WHERE nombre LIKE '%o%' unin SELECT nombre
FROM persona WHERE nombre LIKE '%e%';
que mostrara como resultado:
+--------+
| nombre |
+--------+
| Jose |
| Javier |
| Jesus |
+--------+

(Como has podido observar, "Jose" no aparece repetido, porque el operador "UNION"
elimina duplicados).
En este caso, el uso de "UNION" es poco razonable porque se trata de dos consultas casi
idnticas, que se podan haber realizado simplemente con un "OR" y se obtendr el mismo
resultado (quiz en distinto orden, ya que no hemos utilizado "ORDER BY"):
SELECT nombre FROM persona WHERE nombre LIKE '%o%' OR nombre LIKE '%e%';
+--------+
| nombre |
+--------+
| Javier |
| Jesus |
| Jose |
+--------+
La verdadera utilidad de "UNION" aparece cuando se trabaja sobre conjuntos de datos
diferentes, incluso distintas tablas. Por ejemplo, podramos obtener los nombres de todas las
personas y los de todas las capacidades en una misma consulta:
SELECT nombre FROM persona unin SELECT nombre FROM capacidad;
que mostrara:
+-----------------+
| nombre |
+-----------------+
| Javier |
| Jesus |
| Jose |
| Juan |
| Progr.C |
| Progr.Java |
| Progr.Pascal |
| Bases datos SQL |
+-----------------+

E incluso se podran mostrar datos originalmente muy distintos, si se renombran empleando

un alias:
SELECT concat('Persona: ', nombre) AS detalle FROM persona unin SELECT
concat('Habilidad: ', upper(nombre)) AS detalle FROM capacidad;
+----------------------------+
| detalle |
+----------------------------+
| Persona: Javier |
| Persona: Jesus |
| Persona: Jose |
| Persona: Juan |
| Habilidad: PROGR.C |
| Habilidad: PROGR.JAVA |
9.2 Imitando un FULL OUTER JOIN
En el apartado anterior comentbamos que la versin actual de MySQL no permite usar "full
outer join" para mostrar todos los datos que hay en dos tablas enlazadas, aunque alguno de
esos datos no tenga equivalencia en la otra tabla.
Tambin decamos que se podra imitar haciendo a la vez un "right join" y un "left join".
En general, tenemos la posibilidad de unir dos consultas en una usando "union", as:
SELECT persona.nombre, capacidad.nombre FROM persona RIGHT OUTER JOIN
capacidad ON persona.codcapac = capacidad.codigo unin SELECT persona.nombre,
capacidad.nombre FROM persona LEFT OUTER JOIN capacidad ON persona.codcapac =
capacidad.codigo;
+--------+-----------------+
| nombre | nombre |
+--------+-----------------+
| Javier | Progr.Pascal |
| Juan | Progr.C |
| NULL | Progr.Java |
| NULL | Bases datos SQL |
| Jesus | NULL |
| Jose | NULL |
+--------+-----------------+
Los datos no aparecen ordenados. Si se desea que lo estn, se puede incluir la "UNION"
dentro de una subconsulta (ser necesario usar un "alias" para la subconsulta), as:
SELECT * FROM ( SELECT persona.nombre , capacidad.nombre habilidad FROM persona
RIGHT OUTER JOIN capacidad ON persona.codcapac = capacidad.codigo unin SELECT
persona.nombre, capacidad.nombre FROM persona LEFT OUTER JOIN capacidad ON
persona.codcapac = capacidad.codigo ) resultado ORDER BY nombre;
 | nombre | habilidad |
+--------+-----------------+
| NULL | Progr.Java |
| NULL | Bases datos SQL |
| Javier | Progr.Pascal |
| Jesus | NULL |
| Jose | NULL |
| Juan | Progr.C |
+--------+-----------------+

(Como puedes ver, al ordenar resultados, los datos nulos aparecen antes de los que s tienen
valor).
 Referencias
Atkinson, L. (2002). Core MySQL.
Gallardo, J. D. (2006). MySQL 5.1. ANAYA.
Gilfillan, I. (2003). La Biblia de MySQL / MySQL 4. ANAYA.
Moisset., D. (s.f.). Programacin ya . Obtenido de http://www.programacionya.com
MySQL. (s.f.). MySQL. Obtenido de https://dev.mysql.com/doc/