Normalization made my queries slower - mysql

Question

Before normalization I had a column called genreand it contained values like "Action, Thriller, Comedy"
Now I have normalized the genre column by creating genre and movie2genre tables.
The problem now is my queries are more complicated and are actually slower
These two queries basically search for movies that are action and thriller
Old query
select title, genre from movie where genre like '%action%' and genre like '%thriller%'
0.062 sec duration / 0.032 sec fetch
New Query
SELECT movie.title, movie.genre
FROM Movie
Where
EXISTS (
select *
from movie2genre
JOIN Genre on Genre.id = movie2genre.GenreId
where Movie.id = movie2genre.MovieId
and genre in ('action', 'thriller')
)
0.328 sec duration / 0.078 sec fetch
Am I doing something wrong?
More info:
Movie
+-------------+---------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------------+---------------+------+-----+---------+----------------+
| ID | int(11) | NO | PRI | NULL | auto_increment |
| Title | varchar(345) | YES | | NULL | |
ETC....
Genre
+---------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+---------+-------------+------+-----+---------+----------------+
| genreid | int(11) | NO | PRI | NULL | auto_increment |
| name | varchar(50) | YES | | NULL | |
+---------+-------------+------+-----+---------+----------------+.
movie2genre
+---------+---------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------+---------+------+-----+---------+-------+
| movieid | int(11) | YES | | NULL | |
| genreid | int(11) | YES | | NULL | |
+---------+---------+------+-----+---------+-------+

Answer 1

Try this without correlated Queries (Please check the execution plan of both queries if you are concerned about the performance) also Make sure you have proper indexes on your new table.
SELECT *
FROM movie2genre mg, Genre g, Movie m
WHERE m.id = mg.MovieId
AND g.id = mg.GenreId
AND g.genre in ('action', 'thriller')

Answer 2

First, your two queries are not the same. The newer version does an or rather than an and, so the difference in time could simply be returning a larger result set. In addition, your new query refers to movie.genre, a column that wouldn't exist in a normalized database.
You seem to be asking for:
select m.title
from Movie m
where exists (select 1
from movie2genre m2g JOIN
Genre g
on g.id = m2g.GenreId
where m.id = m2g.MovieId and g.genre = 'action'
) and
exists (select 1
from movie2genre m2g JOIN
Genre g
on g.id = m2g.GenreId
where m.id = m2g.MovieId and g.genre = 'thriller'
);
Admittedly, you probably will not think this solves the "complication" problem. Leaving that aside, you need to have indexes for this to work well. Do you have the "obvious" indexes of: movie2genre(MovieId, GenreId) and genre(GenreId)?
Second, your data is not particularly large (judging by the duration for the queries). So, a full table scan may be more efficient than the joining and filtering with these tables. As the database grows, the normalized approach will often be faster.
A more equivalent query is:
select m.title, group_concat(g.genre)
from movies m join
movie2genre m2g
on m.movieid = m2g.movieid join
genre g
on g.genreid = m2g.genreid
group by m.title
having sum(g.genre = 'action') > 0 and sum(g.genre = 'thriller') > 0;
Because of the nature of your particular query -- you need to fetch all genres on a movie so you cannot filter on them -- this particular query is probably going to perform less well than the unnormalized version.
By the way, normalization is more about keeping data consistent than about speeding queries. Normalized databases require more join operations. Indexes can help performance, but there is still work in doing the join. In some cases, the tables themselves are bigger than the unnormalized forms. And, normalized databases may require aggregation where none is required for non-normalized database. All of these can affect performance, which is why in many decision support architectures, the central database is normalized but the application-specific databases are not.

Answer 3

Indexes are vitally important when doing joins (and sub queries tend to lose the indexing).
There are 2 ways I would suggest trying.
Firstly you join movies to movie2genre, and then one join to genre for each one you are checking. Well indexed this should be fast.
SELECT movie.title,
movie.genre
FROM Movie
INNER JOIN movie2genre
ON Movie.id = movie2genre.MovieId
INNER JOIN Genre G1
ON G1.id = movie2genre.GenreId
AND G1.genre = 'action'
INNER JOIN Genre G2
ON G2.id = movie2genre.GenreId
AND G2.genre = 'thriller'
An alternative is to use IN, and use the aggregate COUNT function to check that the number of genres found is the same as the number expected.
SELECT movie.title,
movie.genre
FROM Movie
INNER JOIN movie2genre
ON Movie.id = movie2genre.MovieId
INNER JOIN Genre
ON Genre.id = movie2genre.GenreId
AND Genre.genre IN ('action', 'thriller')
GROUP BY movie.title, movie.genre
HAVING COUNT(DISTINCT genreid) = 2
I would prefer the 1st solution, but it is a bit more complicated to set up the SQL for in code (ie, the SQL varies greatly depending on the number of genres), and potentially is limited by the max number of table joins if you are checking for lots of genres.