La tabla pet mantiene el registro de las
          mascotas que se poseen. Si quisiera registrar otros datos
          acerca de ellas, como eventos de su vida tales como visitas al
          veterinario o nacimiento de crías, necesitaría otra tabla.
          ¿Cómo debería ser esta tabla? Se necesita:
        
Un campo con el nombre de la mascota para saber a quien pertenece cada evento registrado.
La fecha en que ocurrió el evento.
Un campo con la descripción del evento.
Un campo con el tipo de evento, a fin de poder clasificarlo.
          Teniendo en cuenta estas consideraciones, la sentencia
          CREATE TABLE para la tabla
          event ("eventos", en inglés) podría ser
          así:
        
mysql> CREATE TABLE event (name VARCHAR(20), date DATE,
    -> type VARCHAR(15), remark VARCHAR(255));
          Como se hizo con la tabla pet, es más
          fácil realizar la carga inicial de datos si se crea un
          archivo de texto delimitado con tabulaciones que contenga la
          información a agregar:
        
| name | date | type | remark | 
| Fluffy | 1995-05-15 | litter | 4 kittens, 3 female, 1 male | 
| Buffy | 1993-06-23 | litter | 5 puppies, 2 female, 3 male | 
| Buffy | 1994-06-19 | litter | 3 puppies, 3 female | 
| Chirpy | 1999-03-21 | vet | needed beak straightened | 
| Slim | 1997-08-03 | vet | broken rib | 
| Bowser | 1991-10-12 | kennel | |
| Fang | 1991-10-12 | kennel | |
| Fang | 1998-08-28 | birthday | Gave him a new chew toy | 
| Claws | 1998-03-17 | birthday | Gave him a new flea collar | 
| Whistler | 1998-12-09 | birthday | First birthday | 
Los registros se cargan así:
mysql> LOAD DATA LOCAL INFILE 'event.txt' INTO TABLE event;
          Con base en lo que se ha aprendido a partir de las consultas
          efectuadas sobre la tabla pet, se debería
          poder recuperar registros de la tabla
          event; los principios son los mismos. Pero
          en un momento dado la tabla event por sí
          sola es insuficiente para responder las preguntas que pueden
          formularse.
        
          Suponga que se desea saber a qué edad tuvo sus crías cada
          mascota. Anteriormente se aprendió a calcular edades a partir
          de dos fechas. La fecha en que la mascota tuvo sus crias está
          en la tabla event, pero para calcular su
          edad, se necesita su fecha de nacimiento, la cual está
          localizada en la tabla pet. Esto significa
          que la consulta requiere ambas tablas:
        
mysql> SELECT pet.name,
    -> (YEAR(date)-YEAR(birth)) - (RIGHT(date,5)<RIGHT(birth,5)) AS age,
    -> remark
    -> FROM pet, event
    -> WHERE pet.name = event.name AND event.type = 'litter';
+--------+------+-----------------------------+
| name   | age  | remark                      |
+--------+------+-----------------------------+
| Fluffy |    2 | 4 kittens, 3 female, 1 male |
| Buffy  |    4 | 5 puppies, 2 female, 3 male |
| Buffy  |    5 | 3 puppies, 3 female         |
+--------+------+-----------------------------+
Hay varias cosas para observar en esta consulta:
              La cláusula FROM menciona dos tablas
              porque la consulta necesita traer datos de ambas
            
              Cuando se combina (también se denomina join -unión, en
              inglés-) información desde múltiples tablas, se
              necesita indicar qué registro de una tabla se combinará
              con qué registro de la otra. Esto es sencillo porque
              ambas tablas tienen una columna name.
              La consulta emplea la cláusula WHERE
              para hacer coincidir registros de las dos tablas
              basándose en el valor de name.
            
              Dado que la columna name aparece en
              ambas tablas, se debe especificar a cuál tabla pertenece
              la columna al hacer referencia a ella. Esto se hace
              anteponiendo el nombre de la tabla al nombre de la
              columna.
            
          No es necesario tener dos tablas diferentes para establecer
          una unión. A veces es útil combinar una tabla consigo misma,
          si se desea comparar entre sí registros de una misma tabla.
          Por ejemplo, para formar parejas de mascotas para
          reproducción, podría unir la tabla pet
          consigo misma para generar pares de animales macho y hembra de
          la misma especie:
        
mysql> SELECT p1.name, p1.sex, p2.name, p2.sex, p1.species
    -> FROM pet AS p1, pet AS p2
    -> WHERE p1.species = p2.species AND p1.sex = 'f' AND p2.sex = 'm';
+--------+------+--------+------+---------+
| name   | sex  | name   | sex  | species |
+--------+------+--------+------+---------+
| Fluffy | f    | Claws  | m    | cat     |
| Buffy  | f    | Fang   | m    | dog     |
| Buffy  | f    | Bowser | m    | dog     |
+--------+------+--------+------+---------+
En la consulta anterior se especificaron alias para la tabla con el fin de indicar a qué instancia de la tabla pertenece cada columna referenciada.
Ésta es una traducción del manual de referencia de MySQL, que puede encontrarse en dev.mysql.com. El manual de referencia original de MySQL está escrito en inglés, y esta traducción no necesariamente está tan actualizada como la versión original. Para cualquier sugerencia sobre la traducción y para señalar errores de cualquier tipo, no dude en dirigirse a mysql-es@vespito.com.

