Mostrando entradas con la etiqueta mysql. Mostrar todas las entradas
Mostrando entradas con la etiqueta mysql. Mostrar todas las entradas

viernes, 8 de enero de 2010

Join con relaciones muchos a muchos

En la entrada anterior dejaba pendiente el tema de las relaciones muchos a muchos, aunque es probable que ya te hayas dado cuenta de como combinar tablas relacionadas de esta manera.

Este tipo de relaciones requiere una tabla intermedia (o join table) que nos permita asociar las parejas de registros. Las tablas izquierda y derecha se relacionan de uno a muchos con la join table. Por lo tanto tendremos que "unir" la tabla izquierda con la join table y ésta con la tabla derecha.

Etiquetar libros

Vamos a seguir con nuestro ejemplo y vamos a añadir una tabla tags a nuestro sistema para poder etiquetar cada libro con diversas palabras clave descriptoras. Por ejemplo, así:


CREATE TABLE `tags` (
  `id` int(11) NOT NULL auto_increment,
  `tag` varchar(200) default NULL,
  PRIMARY KEY  (`id`)
)

Y vamos a introducir algunos valores, para que la tabla quede así:


+----+-----------------------+
| id | tag                   |
+----+-----------------------+
|  1 | Novela                | 
|  2 | Lit. Castellana       | 
|  3 | Lit. Hispanoamericana | 
|  4 | Lit. Francesa         | 
|  5 | Poesia                | 
+----+-----------------------+
5 rows in set (0,00 sec)

Ahora creamos la join table:

create table books_tags (
books_id int(11) not null,
tags_id int(11) not null);

Y la poblamos para relacionar nuestros libros con sus tags correspondientes, nos quedaría algo así:

+----------+---------+
| books_id | tags_id |
+----------+---------+
|        1 |       1 | 
|        2 |       1 | 
|        3 |       1 | 
|        4 |       1 | 
|        1 |       2 | 
|        4 |       2 | 
|        2 |       3 | 
|        3 |       4 | 
+----------+---------+
8 rows in set (0,00 sec)

Ahora podemos empezar a trabajar combinando las tablas. En realidad es muy simple: definimos una cláusula JOIN con cada una de las tablas que queremos unir. Por ejemplo:

select * from books join books_tags join tags;

Esta query específicamente se puede abreviar usando ',' en vez de JOIN:

select * from books, books_tags, tags;

La petición anterior nos devolverá el producto cartesiano de las tres tablas (nada menos que 160 filas). Ya que las tablas están relacionadas podemos usar las sentencias ON sobre los campos de clave primaria y clave foránea:

select title, tag 
from books 
    join books_tags on books.id = books_tags.books_id 
    join tags on books_tags.tags_id = tags.id;

Es decir, unimos la tabla books con la books_tags cuando coinciden books.id y books_tags.books_id y ésta a su vez con la tabla tags, cuando coinciden books_tags.tags.id y tags.id.

El resultado (lo he restringido a los campos title y tag para que se vea más claro):

+---------------------+-----------------------+
| title               | tag                   |
+---------------------+-----------------------+
| El quijote          | Novela                | 
| El quijote          | Lit. Castellana       | 
| 100 a?os de soledad | Novela                | 
| 100 a?os de soledad | Lit. Hispanoamericana | 
| El Principito       | Novela                | 
| El Principito       | Lit. Francesa         | 
| Lazarillo de Tormes | Novela                | 
| Lazarillo de Tormes | Lit. Castellana       | 
+---------------------+-----------------------+
8 rows in set (0,00 sec)

¿Podríamos meter a los autores en esta petición? Vamos a verlo (añado también el campo author y una cláusula para ordenar los registros a fin de apreciar mejor los resultados):

select title, author, tag 
from books 
    join authors on books.author_id = authors.id 
    join books_tags on books.id = books_tags.books_id 
    join tags on books_tags.tags_id = tags.id 
order by title;

+---------------------+----------------+-----------------------+
| title               | author         | tag                   |
+---------------------+----------------+-----------------------+
| 100 a?os de soledad | Garc?a M?rquez | Lit. Hispanoamericana | 
| 100 a?os de soledad | Garc?a M?rquez | Novela                | 
| El Principito       | Saint_Exupery  | Novela                | 
| El Principito       | Saint_Exupery  | Lit. Francesa         | 
| El quijote          | Cervantes      | Novela                | 
| El quijote          | Cervantes      | Lit. Castellana       | 
+---------------------+----------------+-----------------------+
6 rows in set (0,00 sec)

Por supuesto, puedes usar los LEFT JOIN y RIGHT JOIN según tus necesidades, por ejemplo, para obtener el listado completo de libros y sus etiquetas:

select title, author, tag 
from books 
    left join authors on books.author_id = authors.id 
    join books_tags on books.id = books_tags.books_id 
    join tags on books_tags.tags_id = tags.id 
order by title;

En qué medida debes usar left o right join depende de si necesitas obtener todos los registros posibles de las tablas izquierda o derecha, o sólo aquellos que tienen datos en ambas tablas.

Ahora veamos cómo podemos buscar libros que correspondan a una etiqueta. Empezamos por la combinación de tablas y luego no tenemos más que indicar en WHERE qué etiquetas queremos seleccionar:

select title, author, tag 
from books 
    left join authors on books.author_id = authors.id 
    join books_tags on books.id = books_tags.books_id 
    join tags on books_tags.tags_id = tags.id 
where tags.tag = 'Novela'
order by title;

+---------------------+----------------+--------+
| title               | author         | tag    |
+---------------------+----------------+--------+
| 100 a?os de soledad | Garc?a M?rquez | Novela | 
| El Principito       | Saint_Exupery  | Novela | 
| El quijote          | Cervantes      | Novela | 
| Lazarillo de Tormes | NULL           | Novela | 
+---------------------+----------------+--------+
4 rows in set (0,00 sec)

También puede ser otra etiqueta, claro. Por ejemplo, qué libros tenemos de literatura castellana:

select title, author, tag 
from books 
    left join authors on books.author_id = authors.id 
    join books_tags on books.id = books_tags.books_id 
    join tags on books_tags.tags_id = tags.id 
where tags.tag = 'Lit. Castellana'
order by title;

Que nos dará este resultado:

+---------------------+-----------+-----------------+
| title               | author    | tag             |
+---------------------+-----------+-----------------+
| El quijote          | Cervantes | Lit. Castellana | 
| Lazarillo de Tormes | NULL      | Lit. Castellana | 
+---------------------+-----------+-----------------+
2 rows in set (0,00 sec)

Como puedes ver, aparte del pequeño lío que supone especificar las combinaciones de tablas a través de múltiples join el trabajo es bastante sencillo.

jueves, 7 de enero de 2010

Uniendo tablas con Join

En la entrada anterior dejé caer que explicaría un poco más a fondo los tipos de JOIN que se pueden hacer y qué diferencias hay entre ellos.

Una buena manera de entenderlo es practicando, por lo que es recomendable que crees algunas tablas sencillas y lances las querys como forma de ver en vivo los resultados de cada tipo de JOIN y así entender para qué casos te pueden servir. No hace falta que tengan muchos campos, ni muchos registros.

Un buen ejemplo puede ser una tabla de libros y una de autores, como las que siguen (en este ejemplo estoy usando MySQL):


CREATE TABLE `books` (
`id` int(11) NOT NULL auto_increment,
`title` varchar(200) default NULL,
`author_id` int(11) default NULL,
PRIMARY KEY (`id`)
)

CREATE TABLE `authors` (
`id` int(11) NOT NULL auto_increment,
`author` varchar(200) default NULL,
PRIMARY KEY (`id`)
)


Los datos para las tablas:




# Dump of table authors


# ------------------------------------------------------------

INSERT INTO `authors` (`id`,`author`) VALUES ('1','Cervantes');
INSERT INTO `authors` (`id`,`author`) VALUES ('2','García Márquez');
INSERT INTO `authors` (`id`,`author`) VALUES ('3','Saint_Exupery');


# Dump of table books
# ------------------------------------------------------------

INSERT INTO `books` (`id`,`title`,`author_id`) VALUES ('1','El quijote','1');
INSERT INTO `books` (`id`,`title`,`author_id`) VALUES ('2','100 años de soledad','2');

INSERT INTO `books` (`id`,`title`,`author_id`) VALUES ('3','El Principito','3');

Producto cartesiano

Para entender cómo funcionan los JOIN tenemos que empezar repasando un concepto que muchos aprendimos en la Primaria: el producto cartesiano. Ya sabes: dados dos conjuntos A y B, su producto cartesiano es otro conjunto C (A × B) formado por todos los pares ordenados en los que el primer elemento del par pertenece a A y el segundo elemento del par pertenece a B.

Así, JOIN es básicamente el producto cartesiano de las tablas, es decir, una nueva tabla en que cada registro combina un registro de la primera tabla con cada uno de los registros de la segunda tabla.

La query

SELECT * FROM books JOIN authors

nos dará como resultado todas las posibles combinaciones de books y authors (en nuestro caso 9 registros). Algo así:


+----+---------------------+-----------+----+----------------+
| id | title               | author_id | id | author         |
+----+---------------------+-----------+----+----------------+
|  1 | El quijote          |         1 |  1 | Cervantes      | 
|  2 | 100 a?os de soledad |         2 |  1 | Cervantes      | 
|  3 | El Principito       |         3 |  1 | Cervantes      | 
|  1 | El quijote          |         1 |  2 | Garc?a M?rquez | 
|  2 | 100 a?os de soledad |         2 |  2 | Garc?a M?rquez | 
|  3 | El Principito       |         3 |  2 | Garc?a M?rquez | 
|  1 | El quijote          |         1 |  3 | Saint_Exupery  | 
|  2 | 100 a?os de soledad |         2 |  3 | Saint_Exupery  | 
|  3 | El Principito       |         3 |  3 | Saint_Exupery  | 
+----+---------------------+-----------+----+----------------+
9 rows in set (0,03 sec)

Como puedes suponer, hacer este resultado no es muy útil para este tipo de datos, aunque hay muchos casos en que si que lo puede ser.

Por ejemplo, en un campeonato deportivo como una liga de fútbol tendremos una tabla equipos, que recoge el nombre de todos los equipos participantes.


+----+------------+
| id | equipo     |
+----+------------+
|  1 | Barcelona  | 
|  2 | Madrid     | 
|  3 | Celta      | 
|  4 | Villarreal | 
+----+------------+
4 rows in set (0,02 sec)


Pues bien, un JOIN de la tabla consigo misma, nos permitirá obtener todos los partidos del campeonato. Eso sí, tendremos que recurrir a los alias para evitar un error de MySQL.

SELECT * FROM equipos AS Local JOIN equipos as Visitante


+----+------------+----+------------+
| id | equipo     | id | equipo     |
+----+------------+----+------------+
|  1 | Barcelona  |  1 | Barcelona  | 
|  2 | Madrid     |  1 | Barcelona  | 
|  3 | Celta      |  1 | Barcelona  | 
|  4 | Villarreal |  1 | Barcelona  | 
|  1 | Barcelona  |  2 | Madrid     | 
|  2 | Madrid     |  2 | Madrid     | 
|  3 | Celta      |  2 | Madrid     | 
|  4 | Villarreal |  2 | Madrid     | 
|  1 | Barcelona  |  3 | Celta      | 
|  2 | Madrid     |  3 | Celta      | 
|  3 | Celta      |  3 | Celta      | 
|  4 | Villarreal |  3 | Celta      | 
|  1 | Barcelona  |  4 | Villarreal | 
|  2 | Madrid     |  4 | Villarreal | 
|  3 | Celta      |  4 | Villarreal | 
|  4 | Villarreal |  4 | Villarreal | 
+----+------------+----+------------+
16 rows in set (0,03 sec)


Con todo, esta query necesita alguna restricción para se perfecta, pues nos empareja cada equipo consigo misma, así que podemos añadir condiciones para eliminar esas parejas del resultado.

SELECT * FROM equipos AS Local JOIN equipos AS Visitante WHERE Local.id != Visitante.id


+----+------------+----+------------+
| id | equipo     | id | equipo     |
+----+------------+----+------------+
|  2 | Madrid     |  1 | Barcelona  | 
|  3 | Celta      |  1 | Barcelona  | 
|  4 | Villarreal |  1 | Barcelona  | 
|  1 | Barcelona  |  2 | Madrid     | 
|  3 | Celta      |  2 | Madrid     | 
|  4 | Villarreal |  2 | Madrid     | 
|  1 | Barcelona  |  3 | Celta      | 
|  2 | Madrid     |  3 | Celta      | 
|  4 | Villarreal |  3 | Celta      | 
|  1 | Barcelona  |  4 | Villarreal | 
|  2 | Madrid     |  4 | Villarreal | 
|  3 | Celta      |  4 | Villarreal | 
+----+------------+----+------------+
12 rows in set (0,00 sec)


INNER JOIN

Este tipo de JOINS que nos dan el producto cartesiano son del tipo INNER y los resultados que podemos obtener de ellas estan siempre dentro de ese producto cartesiano.

Como deciamos antes, este tipo de resultados no es muy útil en algunos casos. Volviendo a nuestro ejemplo de ibros y autores, la query nos empareja obras y autores de todas las maneras posibles, lo que no se corresponde con la realidad. Nuestro sistema tiene que tener más conocimiento del mundo y poder utilizarlo al hacer la combinacion de tablas.

Nuestra tabla books cuenta con el campo author_id, la clave foránea que nos indica qué autor corresponde a cada libro. ¿Qué papel puede jugar en la combinacion de tablas?

JOIN admite una cláusula ON para definir qué condiciones deben usarse para que dos registros se combinen. En nuestro ejemplo, el cambo books.author_id debe coincidir con el campo author.id y lo expresamos así:

SELECT * FROM books INNER JOIN authors ON books.author_id = authors.id


+----+---------------------+-----------+----+----------------+
| id | title               | author_id | id | author         |
+----+---------------------+-----------+----+----------------+
|  1 | El quijote          |         1 |  1 | Cervantes      | 
|  2 | 100 a?os de soledad |         2 |  2 | Garc?a M?rquez | 
|  3 | El Principito       |         3 |  3 | Saint_Exupery  | 
+----+---------------------+-----------+----+----------------+
3 rows in set (0,05 sec)


De este modo, la query nos devuelve los libros correctamente emparejados con sus autores.

Podemos añadir la cláusula WHERE para especificar condiciones que restrinjan la busqueda de datos y esta puede usar campos de las tablas combinadas. Así, podemos buscar un libro por el nombre de su autor, a pesar de que este dato no está en la tabla books.

SELECT * FROM books INNER JOIN authors ON books.author_id = authors.id WHERE authors.author = 'Cervantes'


+----+------------+-----------+----+-----------+
| id | title      | author_id | id | author    |
+----+------------+-----------+----+-----------+
|  1 | El quijote |         1 |  1 | Cervantes | 
+----+------------+-----------+----+-----------+
1 row in set (0,00 sec)


Cuando combinamos ON y WHERE nos puede surgir la duda de si sería mejor poner las condiciones en ON o en WHERE.

La regla práctica sería poner en ON las condiciones para decidir que registros deben emparejarse y en WHERE las condiciones para filtrar o restringir el resultado. La base de datos primero genera la tabla temporal y luego hace el filtrado.

LEFT JOIN

Puede ocurrir que tengamos datos en una tabla que no tengan un registro asociado en la otra. Por ejemplo, añadimos un nuevo libro a nuestra tabla books pero no sabemos su autor (o es anónimo).

Ahora si pedimos una lista de todos los libros registrados con sus autores con la query anterior veremos que no aparecen los libros que no tengan autor. ¡Vaya! En muchos casos este comportamiento no nos interesa, querríamos tener toda la lista de libros aunque no sepamos el autor.

Para eso utilizamos LEFT JOIN.

Este tipo de combinación toma todos los registros válidos de la primera tabla (o tabla izquierda/left) y los combina con los registros de la otra tabla (derecha). Si no hay ningún registro que se pueda combinar lo hace con uno nuevo cuyos campos están todos en NULL.

En nuestros datos actuales tenemos tres libros y conocemos a sus autores correspondientes, así que al pedir la información a la base de datos nos devolverá este resultado:

SELECT * FROM books LEFT JOIN authors ON books.author_id = authors.id


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

| id | title               | author_id | id   | author         |
+----+---------------------+-----------+------+----------------+
|  1 | El quijote          |         1 |    1 | Cervantes      | 
|  2 | 100 a?os de soledad |         2 |    2 | Garc?a M?rquez | 
|  3 | El Principito       |         3 |    3 | Saint_Exupery  | 
+----+---------------------+-----------+------+----------------+
3 rows in set (0,00 sec)

Ahora introduciremos un nuevo libro del cual no conocemos el autor

INSERT INTO books (title) values ('Lazarillo de Tormes');

y repetimos la misma petición anterior. Este es el resultado:

+----+---------------------+-----------+------+----------------+
| id | title               | author_id | id   | author         |
+----+---------------------+-----------+------+----------------+
|  1 | El quijote          |         1 |    1 | Cervantes      | 
|  2 | 100 a?os de soledad |         2 |    2 | Garc?a M?rquez | 
|  3 | El Principito       |         3 |    3 | Saint_Exupery  | 
|  4 | Lazarillo de Tormes |      NULL | NULL | NULL           | 
+----+---------------------+-----------+------+----------------+
4 rows in set (0,00 sec)

La base de datos no encuentra un registro en authors que pueda emparejar con "Lazarillo de Tormes", pero al utilizar un LEFT JOIN también nos devuelve este libro, aunque deja los campos de authors sin definir. Para nosotros es útil porque de este modo podemos saber qué libros tenemos con independencia de si tenemos los datos de autor o no. La misma petición con un INNER JOIN nos dará el siguiente resultado:

SELECT * FROM books INNER JOIN authors ON books.author_id = authors.id;

+----+---------------------+-----------+----+----------------+
| id | title               | author_id | id | author         |
+----+---------------------+-----------+----+----------------+
|  1 | El quijote          |         1 |  1 | Cervantes      | 
|  2 | 100 a?os de soledad |         2 |  2 | Garc?a M?rquez | 
|  3 | El Principito       |         3 |  3 | Saint_Exupery  | 
+----+---------------------+-----------+----+----------------+
3 rows in set (0,00 sec)

Ves la diferencia, ¿verdad? Con el INNER JOIN sólo se devuelven resultados "dentro" del producto cartesiano (o dicho de otro modo, se devuelven pares de registros de ambas tablas). Es decir, se toman los registros de la tabla "izquierda" y se combinan con el registro correspondiente de la tabla "derecha" que cumpla las condiciones del ON y si no existe se ignora esa fila.

Con LEFT JOIN se podría decir que se toman todos los registros de la tabla izquierda relevantes (que cumplan las condiciones de WHERE si está presente) y se combinan con el registro correspondiente de la tabla "derecha" tanto si existe o no un registro en ella que cumpla las condiciones de ON.

RIGHT JOIN

Si entendiste bien el significado de LEFT JOIN seguro que eres capaz de deducir lo que significa RIGHT JOIN. Exacto: en este caso se parte de los registros de la tabla "derecha" y se busca si hay algún registro en la tabla "izquierda" que cumpla las condiciones en ON. En caso de no encontrarlo se ponen sus campos a NULL.

Para poder verlo en acción necesitamos añadir un author a nuestra tabla, que no tenga libros.

INSERT authors (author) values ('Quevedo')

A continuación ejecutamos una petición con RIGHT JOIN

SELECT * FROM books RIGHT JOIN authors ON books.author_id = authors.id;

El resultado es:

+------+---------------------+-----------+----+----------------+
| id   | title               | author_id | id | author         |
+------+---------------------+-----------+----+----------------+
|    1 | El quijote          |         1 |  1 | Cervantes      | 
|    2 | 100 a?os de soledad |         2 |  2 | Garc?a M?rquez | 
|    3 | El Principito       |         3 |  3 | Saint_Exupery  | 
| NULL | NULL                |      NULL |  4 | Quevedo        | 
+------+---------------------+-----------+----+----------------+
4 rows in set (0,00 sec)

Como era de esperar, el registro correspondiente al author "Quevedo" aparece recogido con los campos de la tabla books en null.

Y esto es todo de momento. En próximas entregas me dedicaré a las relaciones "muchos a muchos" y a hacer algunas consideraciones sobre la utilidad de los JOIN en CakePHP:






viernes, 11 de diciembre de 2009

Querys CakePHP con operaciones bitwise

Otro de esos títulos "sólo para iniciados"...

Hoy me he encontrado con un problemilla curioso. Necesitaba definir una condición para un find en la que hay una operación bitwise en la base de datos. En concreto, un & de una máscara binaria contra un campo del modelo.

Bueno, pues la forma en que he conseguido que funcione es algo así:

...
array('conditions' => array('12 & Rule.precedence'):
...

Que debe dar un WHERE más o menos así:

WHERE 12 & `Rule`.`precedence`

Es decir, primero pongo el valor de la máscara, luego la operación binaria y luego el campo.

Si pongo primero el campo, CakePHP se empeña en hacer no sé qué y no aparece la comparación en el WHERE.

lunes, 28 de enero de 2008

tinyint(1) es un Bit

Pues eso. Que tinyint(1) es un Bit.

¿Y qué significa? Significa que si defines un campo de una tabla de Mysql como Tinyint con un tamaño de 1, CakePHP lo considerará como un bit y cualquier valor que le intentes poner que no sea 1 ó 0 será convertido a 1.

En Mysql 5 ocurre exactamente eso (en versiones anteriores creo que no).

Es un poco "contraintuitivo" ya que la definición de tinyint es básicamente un byte (de 0 a 255).

En fin, yendo a lo práctico, si necesitas tener un campo tinyint para almacenar valores numéricos pequeños, algo normal para flags de estado e indicadores de tipos con pocas opciones, asígnale tamaño 2.

Esto lo he aprendido hoy, tras una hora y pico de desconcierto con un modelo que tiene un campo de "estado" que puede tomar valores 0, 1 y 2, y que siempre se guardaba como 1.