База знаний

La forma más simple de SELECT
recupera todo lo que hay en la tabla:

mysql> SELECT * FROM pet;

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

| name     | owner  | species | sex  | birth      | death      |

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

| Fluffy   | Harold | cat     | f    | 1993-02-04 | NULL       |

| Claws    | Gwen   | cat     | m    | 1994-03-17 | NULL       |

| Buffy    | Harold | dog     | f    | 1989-05-13 | NULL       |

| Fang     | Benny  | dog     | m    | 1990-08-27 | NULL       |

| Bowser   | Diane  | dog     | m    | 1979-08-31 | 1995-07-29 |

| Chirpy   | Gwen   | bird    | f    | 1998-09-11 | NULL       |

| Whistler | Gwen   | bird    | NULL | 1997-12-09 | NULL       |

| Slim     | Benny  | snake   | m    | 1996-04-29 | NULL       |

| Puffball | Diane  | hamster | f    | 1999-03-30 | NULL       |

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

Esta forma de SELECT es útil si se
quiere revisar la tabla completa, por ejemplo, despues de haberla
cargado con un conjunto de datos inicial. Por ejemplo, puede ocurrir
que la fecha de nacimiento de Bowser no parezca correcta.
Consultando los papeles de pedigri, se descubre que el año correcto
de nacimiento es 1989, no 1979.

Existen al menos dos formas de solucionarlo:

Como se ha visto en la sección anterior, es fácil recuperar una
tabla en su totalidad. Sólo debe omitir la cláusula
WHERE en la sentencia
SELECT. Pero, generalmente, no se desea
ver la tabla completa, especialmente cuando alcanza un gran tamaño.
En cambio, usualmente, se tiene interés en obtener una respuesta
para una consulta en particular, en cuyo caso se especifican algunas
restricciones para la información que se traerá. A continuación se
verán algunas consultas que responden preguntas acerca de las
mascotas.

Se pueden seleccionar sólo algunos registros de la tabla. Por
ejemplo, si quisiera verificar los cambios realizados sobre la fecha
de nacimiento de Bowser, seleccione el registro de Bowser de esta
manera:

mysql> SELECT * FROM pet WHERE name = 'Bowser';

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

| name   | owner | species | sex  | birth      | death      |

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

| Bowser | Diane | dog     | m    | 1989-08-31 | 1995-07-29 |

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

La salida confirma que el año fue correctamente registrado como
1989, ya no es 1979.

Normalmente, las comparaciones de cadenas no son case sensitive,
por eso puede escribir el nombre como 'bowser',
'BOWSER', etc. El resultado de la
consulta será el mismo.

Se pueden indicar condiciones a cumplir por cualquier columna, no
solamente por name. Por ejemplo, si
quisiera saber qué animales han nacido luego de 1998, necesita
evaluar la columnabirth:

mysql> SELECT * FROM pet WHERE birth > '1998-1-1';

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

| name     | owner | species | sex  | birth      | death |

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

| Chirpy   | Gwen  | bird    | f    | 1998-09-11 | NULL  |

| Puffball | Diane | hamster | f    | 1999-03-30 | NULL  |

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

Se pueden combinar condiciones, por ejemplo para localizar perros
hembra:

mysql> SELECT * FROM pet WHERE species = 'dog' AND sex = 'f';

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

| name  | owner  | species | sex  | birth      | death |

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

| Buffy | Harold | dog     | f    | 1989-05-13 | NULL  |

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

La consulta anterior emplea el operador lógico
AND. También existe el operador
OR:

mysql> SELECT * FROM pet WHERE species = 'snake' OR species = 'bird';

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

| name     | owner | species | sex  | birth      | death |

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

| Chirpy   | Gwen  | bird    | f    | 1998-09-11 | NULL  |

| Whistler | Gwen  | bird    | NULL | 1997-12-09 | NULL  |

| Slim     | Benny | snake   | m    | 1996-04-29 | NULL  |

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

AND and OR
pueden ser combinadas, si bien AND
tiene mayor precedencia que OR. Si
utiliza ambos operadores, es buena idea emplear paréntesis para
indicar explicitamente la forma en que las condiciones deben
agruparse:

mysql> SELECT * FROM pet WHERE (species = 'cat' AND sex = 'm')

    -> OR (species = 'dog' AND sex = 'f');

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

| name  | owner  | species | sex  | birth      | death |

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

| Claws | Gwen   | cat     | m    | 1994-03-17 | NULL  |

| Buffy | Harold | dog     | f    | 1989-05-13 | NULL  |

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

Si no se quieren ver filas completas, solo hace falta indicar las
columnas en las que se está interesado, separadas por comas. Por
ejemplo, si desea saber cuándo nació cada animal, seleccione las
columnas name y
birth:

mysql> SELECT name, birth FROM pet;

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

| name     | birth      |

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

| Fluffy   | 1993-02-04 |

| Claws    | 1994-03-17 |

| Buffy    | 1989-05-13 |

| Fang     | 1990-08-27 |

| Bowser   | 1989-08-31 |

| Chirpy   | 1998-09-11 |

| Whistler | 1997-12-09 |

| Slim     | 1996-04-29 |

| Puffball | 1999-03-30 |

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

Para saber quien posee mascotas, utilice esta consulta:

mysql> SELECT owner FROM pet;

+--------+

| owner  |

+--------+

| Harold |

| Gwen   |

| Harold |

| Benny  |

| Diane  |

| Gwen   |

| Gwen   |

| Benny  |

| Diane  |

+--------+

Observe que esta sentencia retorna el campo
owner de cada registro, y algunos de ellos aparecen más de
una vez. Para reducir la salida, recupere solamente una vez cada
registro repetido, agregando la palabra clave
DISTINCT:

mysql> SELECT DISTINCT owner FROM pet;

+--------+

| owner  |

+--------+

| Benny  |

| Diane  |

| Gwen   |

| Harold |

+--------+

Puede emplearse una clásula WHERE
para combinar la selección de ciertas filas y de ciertas columnas.
Por ejemplo, para obtener únicamente la fecha de nacimiento de
perros y gatos, ejecute esta consulta:

mysql> SELECT name, species, birth FROM pet

    -> WHERE species = 'dog' OR species = 'cat';

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

| name   | species | birth      |

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

| Fluffy | cat     | 1993-02-04 |

| Claws  | cat     | 1994-03-17 |

| Buffy  | dog     | 1989-05-13 |

| Fang   | dog     | 1990-08-27 |

| Bowser | dog     | 1989-08-31 |

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

Quizá advirtió, en los ejemplos anteriores, que las filas
resultantes se mostraron sin ningún orden en particular. A menudo es
más fácil examinar la salida de una consulta cuando las filas se
ordenan de algún modo significativo. Para ordenar un resultado, se
usa la clásula ORDER BY.

Aqui tiene las fechas de cumpleaños de los animales, ordenadas
por fecha:

mysql> SELECT name, birth FROM pet ORDER BY birth;

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

| name     | birth      |

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

| Buffy    | 1989-05-13 |

| Bowser   | 1989-08-31 |

| Fang     | 1990-08-27 |

| Fluffy   | 1993-02-04 |

| Claws    | 1994-03-17 |

| Slim     | 1996-04-29 |

| Whistler | 1997-12-09 |

| Chirpy   | 1998-09-11 |

| Puffball | 1999-03-30 |

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

Por lo general, cuando se trata de columnas de tipo carácter, la
ordenación, ? al igual que otras operaciones de comparación ? no es
case-sensitive. Significa que el orden permanece indefinido para las
columnas que son idénticas excepto por sus mayúsculas y minúsculas.
Puede no obstante forzar a que una columna se ordene en forma
sensible a mayúsculas empleando el modificador
BINARY: ORDER BY BINARY columna.

El sentido de ordenación, por defecto, es ascendente, con los
valores más pequeños primero. Para ordenar en sentido inverso
(descendente), agregue la palabra clave DESC
luego del nombre de la columna por la que ordena:

mysql> SELECT name, birth FROM pet ORDER BY birth DESC;

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

| name     | birth      |

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

| Puffball | 1999-03-30 |

| Chirpy   | 1998-09-11 |

| Whistler | 1997-12-09 |

| Slim     | 1996-04-29 |

| Claws    | 1994-03-17 |

| Fluffy   | 1993-02-04 |

| Fang     | 1990-08-27 |

| Bowser   | 1989-08-31 |

| Buffy    | 1989-05-13 |

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

Puede ordenar basándose en varias columnas, y cada columna en un
sentido diferente. Por ejemplo, para ordenar por tipo de animal en
sentido ascendente y, dentro de cada tipo, ordenar por nacimiento en
sentido descendente (los animales más jóvenes primero) utilice la
siguiente consulta:

mysql> SELECT name, species, birth FROM pet

    -> ORDER BY species, birth DESC;

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

| name     | species | birth      |

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

| Chirpy   | bird    | 1998-09-11 |

| Whistler | bird    | 1997-12-09 |

| Claws    | cat     | 1994-03-17 |

| Fluffy   | cat     | 1993-02-04 |

| Fang     | dog     | 1990-08-27 |

| Bowser   | dog     | 1989-08-31 |

| Buffy    | dog     | 1989-05-13 |

| Puffball | hamster | 1999-03-30 |

| Slim     | snake   | 1996-04-29 |

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

Advierta que la palabra clave DESC
se aplica sobre la columna inmediatamente anterior (birth);
no afecta el sentido de ordenación de la columna
species.

MySQL provee varias funciones que se aplican a cálculos entre
fechas, por ejemplo, para calcular edades u obtener partes de una
fecha.

Para determinar cuántos años de edad tiene cada mascota, hay que
calcular la diferencia entre el año de la fecha actual y el de la
fecha de nacimiento, y luego restar 1 al resultado si el dia y mes
actuales son anteriores al día y mes indicados por la fecha de
nacimiento. La siguiente consulta devuelve, para cada mascota, el
nombre, la fecha de nacimiento, la fecha actual, y la edad en años.

mysql> SELECT name, birth, CURDATE(),

    -> (YEAR(CURDATE())-YEAR(birth))

    -> - (RIGHT(CURDATE(),5)<RIGHT(birth,5))

    -> AS age

    -> FROM pet;

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

| name     | birth      | CURDATE()  | age  |

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

| Fluffy   | 1993-02-04 | 2003-08-19 |   10 |

| Claws    | 1994-03-17 | 2003-08-19 |    9 |

| Buffy    | 1989-05-13 | 2003-08-19 |   14 |

| Fang     | 1990-08-27 | 2003-08-19 |   12 |

| Bowser   | 1989-08-31 | 2003-08-19 |   13 |

| Chirpy   | 1998-09-11 | 2003-08-19 |    4 |

| Whistler | 1997-12-09 | 2003-08-19 |    5 |

| Slim     | 1996-04-29 | 2003-08-19 |    7 |

| Puffball | 1999-03-30 | 2003-08-19 |    4 |

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

En el ejemplo anterior, YEAR() trae
la parte correspondiente al año de una fecha, y
RIGHT() trae los 5 primeros caracteres
contando desde la derecha, que representan la parte
MM-DD de la fecha. La porción de la
expresión que compara los valores MM-DD
devuelve 1 o 0, lo cual se corresponde con la diferencia de 1 año a
restar de la edad si el dia de la fecha devuelto por
CURDATE() ocurre antes que la fecha de
nacimiento birth. La expresión completa
es un tanto confusa para usar como encabezado, por lo que se emplea
un alias (age)
para que el encabezado sea más comprensible.

La consulta funciona bien, pero los resultados podrían revisarse
más fácilmente si las filas se presentaran en algún orden. Esto
puede hacerse agregando la cláusula ORDER BY
name para ordenar por nombre la salida:

mysql> SELECT name, birth, CURDATE(),

    -> (YEAR(CURDATE())-YEAR(birth))

    -> - (RIGHT(CURDATE(),5)<RIGHT(birth,5))

    -> AS age

    -> FROM pet ORDER BY name;

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

| name     | birth      | CURDATE()  | age  |

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

| Bowser   | 1989-08-31 | 2003-08-19 |   13 |

| Buffy    | 1989-05-13 | 2003-08-19 |   14 |

| Chirpy   | 1998-09-11 | 2003-08-19 |    4 |

| Claws    | 1994-03-17 | 2003-08-19 |    9 |

| Fang     | 1990-08-27 | 2003-08-19 |   12 |

| Fluffy   | 1993-02-04 | 2003-08-19 |   10 |

| Puffball | 1999-03-30 | 2003-08-19 |    4 |

| Slim     | 1996-04-29 | 2003-08-19 |    7 |

| Whistler | 1997-12-09 | 2003-08-19 |    5 |

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

Para ordenar la salida por edad (age)
en lugar de por nombre (name), solo hay
que utilizar una cláusula ORDER BY
diferente:

mysql> SELECT name, birth, CURDATE(),

    -> (YEAR(CURDATE())-YEAR(birth))

    -> - (RIGHT(CURDATE(),5)<RIGHT(birth,5))

    -> AS age

    -> FROM pet ORDER BY age;

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

| name     | birth      | CURDATE()  | age  |

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

| Chirpy   | 1998-09-11 | 2003-08-19 |    4 |

| Puffball | 1999-03-30 | 2003-08-19 |    4 |

| Whistler | 1997-12-09 | 2003-08-19 |    5 |

| Slim     | 1996-04-29 | 2003-08-19 |    7 |

| Claws    | 1994-03-17 | 2003-08-19 |    9 |

| Fluffy   | 1993-02-04 | 2003-08-19 |   10 |

| Fang     | 1990-08-27 | 2003-08-19 |   12 |

| Bowser   | 1989-08-31 | 2003-08-19 |   13 |

| Buffy    | 1989-05-13 | 2003-08-19 |   14 |

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

Una consulta similar se utiliza para determinar la edad a la
fecha de muerte de los animales. Se determinan los animales que han
muerto verificando si el valor de la columna
death es NULL. Entonces, para
todos los valores no NULL calcula la
diferencia entre las fechas de muerte (death)
y nacimiento (birth):

mysql> SELECT name, birth, death,

    -> (YEAR(death)-YEAR(birth)) - (RIGHT(death,5)<RIGHT(birth,5))

    -> AS age

    -> FROM pet WHERE death IS NOT NULL ORDER BY age;

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

| name   | birth      | death      | age  |

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

| Bowser | 1989-08-31 | 1995-07-29 |    5 |

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

La consulta utiliza la expresión death IS
NOT NULL en lugar de death <> NULL
porque NULL es un valor especial, que
no puede ser comparado mediante los operadores lógicos habituales.
Este tema se trata más extensamente más adelante. Consultar

Sección 3.3.4.6, ?Trabajar con valores NULL?.

¿Qué tal si se quisiera saber qué animales cumplen años el
próximo mes? Para esta clase de cálculos, el año y el día son
irrelevantes; simplemente se desea extraer de la columna
birth la parte correspondiente al mes.
MySQL cuenta con varias funciones para extraer partes de fechas,
como YEAR(),
MONTH(), y DAYOFMONTH().
MONTH() es la función apropiada para
este caso. Para verla en funcionamiento, ejecute una consulta que
muestra tanto el valor de birth como el