具有多个条件的 SQL WHERE 语句

Question

I have a movies, credits, people and roles table (below) I would like to find the names of the people who are both actors and directors.

movies(TABLE)

id int
title

credits(TABLE)

id int
movie_id int
person_id int
role_id int

people(TABLE)

id int
name

roles(TABLE)

id int
role    (Actor, Director)

This is what I have did:

SELECT p.name, r.role, m.role_id
FROM mtm_credits m
JOIN people p ON p.id = m.person_id
JOIN roles r ON r.id = m.role_id
WHERE role = 'Director' AND role = 'Actor';

However, I am getting 0 results. Any suggestion is appreciated.

Answer 1

The problem is that there's no single row in the resulting table whose 'role' is both 'Director' and 'Actor', because 'role' can only be one value.

It's useful to first think of what your table looks like after your joins. In this case, you have:

credits.id, credits.movie_id, credits.person_id, credits.role_id, person.id, person.name, role.id, role.name

Now a person who is both director and actor will have two rows in this table, like this:

| credits.id | credits.movie_id | credits.person_id | credits.role_id | person.id | person.name | role.id | role.name |
| 111 | 222 | 333 | 444 | 555 | 333 | N. Cage | 555 | Actor |
| 111 | 222 | 333 | 444 | 555 | 333 | N. Cage | 555 | Director |

As others have said, you need to either perform an aggregation so one row can have multiple role values, or you can get the result and filter externally

Answer 2

I think you want aggregation:

SELECT p.name
FROM mtm_credits m JOIN
     people p
     ON p.id = m.person_id JOIN
     roles r
     ON r.id = m.role_id
WHERE r.role IN ('Director', 'Actor')
HAVING COUNT(DISTINCT r.role) = 2;

Answer 3

The problem with your query is that you are searching for a single role that is both Director and Actor: both conditions cannot be true at the same time, so the query comes up empty.

Whenever you need to look across multiple rows, aggregation comes to mind:

SELECT p.*
FROM mtm_credits m
JOIN people p ON p.id = m.person_id
JOIN roles r ON r.id = m.role_id
WHERE r.role IN ('Director', 'Actor')
GROUP BY p.id
HAVING COUNT(DISTINCT r.role) = 2

This searches for persons that are Director or Actor, then groups rows by person; finally, the having clause allows only persons that have both roles.

Answer 4

There are two answers that use the same method, but both are wrong. If this hypothetical database contains only a single movie per person, then it will work out. If there are multiple movies where a people record is referenced, or if a single people record is referenced by credits joined to roles records of roles . role = 'Director' or roles . role = 'Actor`, this query returns a record for that invalid result. This breaks the specified behavior.

Note that @Jason-Chen explains the issue you're experiencing with your query, while I'm specifically contradicting the two answers with solutions given as of the posting-time.

Instead of simply counting the results to guarantee more than one role per people.id, which is the only guarantee the above two examples give, the admin should instead query for a connection that exists both in the list of all roles records where 'Director' is the roles.role value and all records where 'Actor' is the roles.role value.

Note that I use different names below, because I generally find the practice of single-letter aliases to be awful, and I wish instructors would instill better practices in new students. Further, I find that table names in singular form yield the most readable code.

select `person`.*
from `people` `person`
where `person`.`id` in (
    select `credit`.`person_id`
    from `roles` `role`
    join`credits` `credit`
        on `role`.`id` = `credit`.`role_id`
    where `role` like "Director" 
) and `person`.`id` in (
    select `credit`.`person_id`
    from `roles` `role`
    join`credits` `credit`
        on `role`.`id` = `credit`.`role_id`
    where `role` like "Actor"
);

I'm selecting a single value from both of the sub-queries on the roles table, which does not require an alias and instead behaves as a set. This results in very quick lookups, even for rather large tables, provided the keys used are indexed on both sides of the join.

Further, this is better than a join, because given real life examples like "Keanu Reaves", "Mel Gibson," "Tom Cruise," or other celebrities that have many Director/Actor movies under their belt, each such record would result in resultset magnification, where a single added record in data causes more than one resulting record.