QIAN-ME/bird_schema_data huggingface dataset:
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 movielens
【Schema】
# Table: movies2actors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(actorid:INTEGER, Primary Key, Examples: [88796, 88848, 121878]),
(cast_num:INTEGER, Examples: [0, 1, 2])
]
# Table: users
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(age:TEXT, Examples: [1, 56, 25]),
(u_gender:TEXT, Examples: [F, M]),
(occupation:TEXT, Examples: [2, 3, 4])
]
# Table: directors
[
(directorid:INTEGER, Primary Key, Examples: [7387, 12945, 15725]),
(d_quality:INTEGER, Examples: [0, 1, 2]),
(avg_revenue:INTEGER, Examples: [0, 1, 2])
]
# Table: movies
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(year:INTEGER, Examples: [3, 4, 1]),
(isEnglish:TEXT, Examples: [T, F]),
(country:TEXT, Examples: [other, USA, France]),
(runningtime:INTEGER, Examples: [2, 3, 0])
]
# Table: movies2directors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(directorid:INTEGER, Primary Key, Examples: [22397, 54934, 297253]),
(genre:TEXT, Examples: [Action, Adventure, Animation])
]
# Table: u2base
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(movieid:INTEGER, Primary Key, Examples: [1684486, 1685309, 1685493]),
(rating:TEXT, Examples: [1, 2, 3])
]
# Table: actors
[
(actorid:INTEGER, Primary Key, Examples: [4, 16, 28]),
(a_gender:TEXT, Examples: [M, F]),
(a_quality:INTEGER, Examples: [4, 0, 3])
]
【Foreign keys】
movies2actors.actorid=actors.actorid
movies2actors.movieid=movies.movieid
movies2directors.directorid=directors.directorid
movies2directors.movieid=movies.movieid
u2base.movieid=movies.movieid
u2base.userid=users.userid

    【Question】
    What is the difference of female and male audiences in number who viewed horror movies? The audience and users are the same meaning; Difference of female and male audiences = count(female users) - count(male users); Female users refers to u_gender = 'F'; Male users refers to u_gender = 'M'

    【Evidence】
    The audience and users are the same meaning; Difference of female and male audiences = count(female users) - count(male users); Female users refers to u_gender = 'F'; Male users refers to u_gender = 'M'

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT SUM(IIF(T2.u_gender = 'F', 1, 0)) - SUM(IIF(T2.u_gender = 'M', 1, 0)) FROM u2base AS T1 INNER JOIN users AS T2 ON T1.userid = T2.userid INNER JOIN movies2directors AS T3 ON T3.movieid = T1.movieid WHERE T3.genre = 'horror'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 movielens
【Schema】
# Table: movies2actors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(actorid:INTEGER, Primary Key, Examples: [88796, 88848, 121878]),
(cast_num:INTEGER, Examples: [0, 1, 2])
]
# Table: users
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(age:TEXT, Examples: [1, 56, 25]),
(u_gender:TEXT, Examples: [F, M]),
(occupation:TEXT, Examples: [2, 3, 4])
]
# Table: directors
[
(directorid:INTEGER, Primary Key, Examples: [7387, 12945, 15725]),
(d_quality:INTEGER, Examples: [0, 1, 2]),
(avg_revenue:INTEGER, Examples: [0, 1, 2])
]
# Table: movies
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(year:INTEGER, Examples: [3, 4, 1]),
(isEnglish:TEXT, Examples: [T, F]),
(country:TEXT, Examples: [other, USA, France]),
(runningtime:INTEGER, Examples: [2, 3, 0])
]
# Table: movies2directors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(directorid:INTEGER, Primary Key, Examples: [22397, 54934, 297253]),
(genre:TEXT, Examples: [Action, Adventure, Animation])
]
# Table: u2base
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(movieid:INTEGER, Primary Key, Examples: [1684486, 1685309, 1685493]),
(rating:TEXT, Examples: [1, 2, 3])
]
# Table: actors
[
(actorid:INTEGER, Primary Key, Examples: [4, 16, 28]),
(a_gender:TEXT, Examples: [M, F]),
(a_quality:INTEGER, Examples: [4, 0, 3])
]
【Foreign keys】
movies2actors.actorid=actors.actorid
movies2actors.movieid=movies.movieid
movies2directors.directorid=directors.directorid
movies2directors.movieid=movies.movieid
u2base.movieid=movies.movieid
u2base.userid=users.userid

    【Question】
    Please list the genre of the movies that are the newest and is in English. Year contains relative value, higher year value refers to newer date; Year = 4 refers to newest date, Year = 1 refer to oldest date; In English means isEnglish = T

    【Evidence】
    Year contains relative value, higher year value refers to newer date; Year = 4 refers to newest date, Year = 1 refer to oldest date; In English means isEnglish = T

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T2.genre FROM movies AS T1 INNER JOIN movies2directors AS T2 ON T1.movieid = T2.movieid WHERE T1.year = 4 AND T1.isEnglish = 'T'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 movielens
【Schema】
# Table: movies2actors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(actorid:INTEGER, Primary Key, Examples: [88796, 88848, 121878]),
(cast_num:INTEGER, Examples: [0, 1, 2])
]
# Table: users
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(age:TEXT, Examples: [1, 56, 25]),
(u_gender:TEXT, Examples: [F, M]),
(occupation:TEXT, Examples: [2, 3, 4])
]
# Table: directors
[
(directorid:INTEGER, Primary Key, Examples: [7387, 12945, 15725]),
(d_quality:INTEGER, Examples: [0, 1, 2]),
(avg_revenue:INTEGER, Examples: [0, 1, 2])
]
# Table: movies
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(year:INTEGER, Examples: [3, 4, 1]),
(isEnglish:TEXT, Examples: [T, F]),
(country:TEXT, Examples: [other, USA, France]),
(runningtime:INTEGER, Examples: [2, 3, 0])
]
# Table: movies2directors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(directorid:INTEGER, Primary Key, Examples: [22397, 54934, 297253]),
(genre:TEXT, Examples: [Action, Adventure, Animation])
]
# Table: u2base
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(movieid:INTEGER, Primary Key, Examples: [1684486, 1685309, 1685493]),
(rating:TEXT, Examples: [1, 2, 3])
]
# Table: actors
[
(actorid:INTEGER, Primary Key, Examples: [4, 16, 28]),
(a_gender:TEXT, Examples: [M, F]),
(a_quality:INTEGER, Examples: [4, 0, 3])
]
【Foreign keys】
movies2actors.actorid=actors.actorid
movies2actors.movieid=movies.movieid
movies2directors.directorid=directors.directorid
movies2directors.movieid=movies.movieid
u2base.movieid=movies.movieid
u2base.userid=users.userid

    【Question】
    Among the action movies from the USA, how many of them are not in English? USA is a country; not in English can be represented by isEnglish = 'F'

    【Evidence】
    USA is a country; not in English can be represented by isEnglish = 'F'

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT COUNT(T1.movieid) FROM movies AS T1 INNER JOIN movies2directors AS T2 ON T1.movieid = T2.movieid WHERE T1.country = 'USA' AND T1.isEnglish = 'F' AND T2.genre = 'Action'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 movielens
【Schema】
# Table: movies2actors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(actorid:INTEGER, Primary Key, Examples: [88796, 88848, 121878]),
(cast_num:INTEGER, Examples: [0, 1, 2])
]
# Table: users
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(age:TEXT, Examples: [1, 56, 25]),
(u_gender:TEXT, Examples: [F, M]),
(occupation:TEXT, Examples: [2, 3, 4])
]
# Table: directors
[
(directorid:INTEGER, Primary Key, Examples: [7387, 12945, 15725]),
(d_quality:INTEGER, Examples: [0, 1, 2]),
(avg_revenue:INTEGER, Examples: [0, 1, 2])
]
# Table: movies
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(year:INTEGER, Examples: [3, 4, 1]),
(isEnglish:TEXT, Examples: [T, F]),
(country:TEXT, Examples: [other, USA, France]),
(runningtime:INTEGER, Examples: [2, 3, 0])
]
# Table: movies2directors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(directorid:INTEGER, Primary Key, Examples: [22397, 54934, 297253]),
(genre:TEXT, Examples: [Action, Adventure, Animation])
]
# Table: u2base
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(movieid:INTEGER, Primary Key, Examples: [1684486, 1685309, 1685493]),
(rating:TEXT, Examples: [1, 2, 3])
]
# Table: actors
[
(actorid:INTEGER, Primary Key, Examples: [4, 16, 28]),
(a_gender:TEXT, Examples: [M, F]),
(a_quality:INTEGER, Examples: [4, 0, 3])
]
【Foreign keys】
movies2actors.actorid=actors.actorid
movies2actors.movieid=movies.movieid
movies2directors.directorid=directors.directorid
movies2directors.movieid=movies.movieid
u2base.movieid=movies.movieid
u2base.userid=users.userid

    【Question】
    For the male users no older than 18, how many times have they given the highest rating? Male users refers to u_gender = 'M'

    【Evidence】
    Male users refers to u_gender = 'M'

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT COUNT(T1.movieid) FROM u2base AS T1 INNER JOIN users AS T2 ON T1.userid = T2.userid WHERE T1.rating = 5 AND T2.age < 18 AND T2.u_gender = 'M'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 movielens
【Schema】
# Table: movies2actors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(actorid:INTEGER, Primary Key, Examples: [88796, 88848, 121878]),
(cast_num:INTEGER, Examples: [0, 1, 2])
]
# Table: users
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(age:TEXT, Examples: [1, 56, 25]),
(u_gender:TEXT, Examples: [F, M]),
(occupation:TEXT, Examples: [2, 3, 4])
]
# Table: directors
[
(directorid:INTEGER, Primary Key, Examples: [7387, 12945, 15725]),
(d_quality:INTEGER, Examples: [0, 1, 2]),
(avg_revenue:INTEGER, Examples: [0, 1, 2])
]
# Table: movies
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(year:INTEGER, Examples: [3, 4, 1]),
(isEnglish:TEXT, Examples: [T, F]),
(country:TEXT, Examples: [other, USA, France]),
(runningtime:INTEGER, Examples: [2, 3, 0])
]
# Table: movies2directors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(directorid:INTEGER, Primary Key, Examples: [22397, 54934, 297253]),
(genre:TEXT, Examples: [Action, Adventure, Animation])
]
# Table: u2base
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(movieid:INTEGER, Primary Key, Examples: [1684486, 1685309, 1685493]),
(rating:TEXT, Examples: [1, 2, 3])
]
# Table: actors
[
(actorid:INTEGER, Primary Key, Examples: [4, 16, 28]),
(a_gender:TEXT, Examples: [M, F]),
(a_quality:INTEGER, Examples: [4, 0, 3])
]
【Foreign keys】
movies2actors.actorid=actors.actorid
movies2actors.movieid=movies.movieid
movies2directors.directorid=directors.directorid
movies2directors.movieid=movies.movieid
u2base.movieid=movies.movieid
u2base.userid=users.userid

    【Question】
    Please list the ID of the movie that has been mostly rated by female users. Female users refers to u_gender = 'F'

    【Evidence】
    Female users refers to u_gender = 'F'

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T1.movieid FROM u2base AS T1 INNER JOIN users AS T2 ON T1.userid = T2.userid WHERE T2.u_gender = 'F' GROUP BY T1.movieid ORDER BY COUNT(T2.userid) DESC LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 movielens
【Schema】
# Table: movies2actors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(actorid:INTEGER, Primary Key, Examples: [88796, 88848, 121878]),
(cast_num:INTEGER, Examples: [0, 1, 2])
]
# Table: users
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(age:TEXT, Examples: [1, 56, 25]),
(u_gender:TEXT, Examples: [F, M]),
(occupation:TEXT, Examples: [2, 3, 4])
]
# Table: directors
[
(directorid:INTEGER, Primary Key, Examples: [7387, 12945, 15725]),
(d_quality:INTEGER, Examples: [0, 1, 2]),
(avg_revenue:INTEGER, Examples: [0, 1, 2])
]
# Table: movies
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(year:INTEGER, Examples: [3, 4, 1]),
(isEnglish:TEXT, Examples: [T, F]),
(country:TEXT, Examples: [other, USA, France]),
(runningtime:INTEGER, Examples: [2, 3, 0])
]
# Table: movies2directors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(directorid:INTEGER, Primary Key, Examples: [22397, 54934, 297253]),
(genre:TEXT, Examples: [Action, Adventure, Animation])
]
# Table: u2base
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(movieid:INTEGER, Primary Key, Examples: [1684486, 1685309, 1685493]),
(rating:TEXT, Examples: [1, 2, 3])
]
# Table: actors
[
(actorid:INTEGER, Primary Key, Examples: [4, 16, 28]),
(a_gender:TEXT, Examples: [M, F]),
(a_quality:INTEGER, Examples: [4, 0, 3])
]
【Foreign keys】
movies2actors.actorid=actors.actorid
movies2actors.movieid=movies.movieid
movies2directors.directorid=directors.directorid
movies2directors.movieid=movies.movieid
u2base.movieid=movies.movieid
u2base.userid=users.userid

    【Question】
    Among divergent movies that got the highest rating, how many of them are from the UK? UK is a country

    【Evidence】
    UK is a country

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT COUNT(DISTINCT T1.movieid) FROM u2base AS T1 INNER JOIN movies AS T2 ON T1.movieid = T2.movieid WHERE T2.country = 'UK' AND T1.rating = 5
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 movielens
【Schema】
# Table: movies2actors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(actorid:INTEGER, Primary Key, Examples: [88796, 88848, 121878]),
(cast_num:INTEGER, Examples: [0, 1, 2])
]
# Table: users
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(age:TEXT, Examples: [1, 56, 25]),
(u_gender:TEXT, Examples: [F, M]),
(occupation:TEXT, Examples: [2, 3, 4])
]
# Table: directors
[
(directorid:INTEGER, Primary Key, Examples: [7387, 12945, 15725]),
(d_quality:INTEGER, Examples: [0, 1, 2]),
(avg_revenue:INTEGER, Examples: [0, 1, 2])
]
# Table: movies
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(year:INTEGER, Examples: [3, 4, 1]),
(isEnglish:TEXT, Examples: [T, F]),
(country:TEXT, Examples: [other, USA, France]),
(runningtime:INTEGER, Examples: [2, 3, 0])
]
# Table: movies2directors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(directorid:INTEGER, Primary Key, Examples: [22397, 54934, 297253]),
(genre:TEXT, Examples: [Action, Adventure, Animation])
]
# Table: u2base
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(movieid:INTEGER, Primary Key, Examples: [1684486, 1685309, 1685493]),
(rating:TEXT, Examples: [1, 2, 3])
]
# Table: actors
[
(actorid:INTEGER, Primary Key, Examples: [4, 16, 28]),
(a_gender:TEXT, Examples: [M, F]),
(a_quality:INTEGER, Examples: [4, 0, 3])
]
【Foreign keys】
movies2actors.actorid=actors.actorid
movies2actors.movieid=movies.movieid
movies2directors.directorid=directors.directorid
movies2directors.movieid=movies.movieid
u2base.movieid=movies.movieid
u2base.userid=users.userid

    【Question】
    Please list different IDs of movies that are the newest and have gotten the lowest rating. Year contains relative value, higer year value refers to newer date; Year = 4 refers to newest date, Year = 1 refer to oldest date; Lowest rating = 1

    【Evidence】
    Year contains relative value, higer year value refers to newer date; Year = 4 refers to newest date, Year = 1 refer to oldest date; Lowest rating = 1

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT DISTINCT T1.movieid FROM u2base AS T1 INNER JOIN movies AS T2 ON T1.movieid = T2.movieid WHERE T2.year = 4 AND T1.rating = 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 movielens
【Schema】
# Table: movies2actors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(actorid:INTEGER, Primary Key, Examples: [88796, 88848, 121878]),
(cast_num:INTEGER, Examples: [0, 1, 2])
]
# Table: users
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(age:TEXT, Examples: [1, 56, 25]),
(u_gender:TEXT, Examples: [F, M]),
(occupation:TEXT, Examples: [2, 3, 4])
]
# Table: directors
[
(directorid:INTEGER, Primary Key, Examples: [7387, 12945, 15725]),
(d_quality:INTEGER, Examples: [0, 1, 2]),
(avg_revenue:INTEGER, Examples: [0, 1, 2])
]
# Table: movies
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(year:INTEGER, Examples: [3, 4, 1]),
(isEnglish:TEXT, Examples: [T, F]),
(country:TEXT, Examples: [other, USA, France]),
(runningtime:INTEGER, Examples: [2, 3, 0])
]
# Table: movies2directors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(directorid:INTEGER, Primary Key, Examples: [22397, 54934, 297253]),
(genre:TEXT, Examples: [Action, Adventure, Animation])
]
# Table: u2base
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(movieid:INTEGER, Primary Key, Examples: [1684486, 1685309, 1685493]),
(rating:TEXT, Examples: [1, 2, 3])
]
# Table: actors
[
(actorid:INTEGER, Primary Key, Examples: [4, 16, 28]),
(a_gender:TEXT, Examples: [M, F]),
(a_quality:INTEGER, Examples: [4, 0, 3])
]
【Foreign keys】
movies2actors.actorid=actors.actorid
movies2actors.movieid=movies.movieid
movies2directors.directorid=directors.directorid
movies2directors.movieid=movies.movieid
u2base.movieid=movies.movieid
u2base.userid=users.userid

    【Question】
    For the movies in English that are the oldest, how many of them have the lowest rating? Year contains relative value, higer year value refers to newer date; Year = 4 refers to newest date, Year = 1 refer to oldest date; Lowest rating = 1；isEnglish = 'T' means English movie

    【Evidence】
    Year contains relative value, higer year value refers to newer date; Year = 4 refers to newest date, Year = 1 refer to oldest date; Lowest rating = 1；isEnglish = 'T' means English movie

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT COUNT(DISTINCT T1.movieid) FROM movies AS T1 INNER JOIN u2base AS T2 ON T1.movieid = T2.movieid WHERE T1.year = 1 AND T2.rating = 1 AND T1.isEnglish = 'T'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 movielens
【Schema】
# Table: movies2actors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(actorid:INTEGER, Primary Key, Examples: [88796, 88848, 121878]),
(cast_num:INTEGER, Examples: [0, 1, 2])
]
# Table: users
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(age:TEXT, Examples: [1, 56, 25]),
(u_gender:TEXT, Examples: [F, M]),
(occupation:TEXT, Examples: [2, 3, 4])
]
# Table: directors
[
(directorid:INTEGER, Primary Key, Examples: [7387, 12945, 15725]),
(d_quality:INTEGER, Examples: [0, 1, 2]),
(avg_revenue:INTEGER, Examples: [0, 1, 2])
]
# Table: movies
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(year:INTEGER, Examples: [3, 4, 1]),
(isEnglish:TEXT, Examples: [T, F]),
(country:TEXT, Examples: [other, USA, France]),
(runningtime:INTEGER, Examples: [2, 3, 0])
]
# Table: movies2directors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(directorid:INTEGER, Primary Key, Examples: [22397, 54934, 297253]),
(genre:TEXT, Examples: [Action, Adventure, Animation])
]
# Table: u2base
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(movieid:INTEGER, Primary Key, Examples: [1684486, 1685309, 1685493]),
(rating:TEXT, Examples: [1, 2, 3])
]
# Table: actors
[
(actorid:INTEGER, Primary Key, Examples: [4, 16, 28]),
(a_gender:TEXT, Examples: [M, F]),
(a_quality:INTEGER, Examples: [4, 0, 3])
]
【Foreign keys】
movies2actors.actorid=actors.actorid
movies2actors.movieid=movies.movieid
movies2directors.directorid=directors.directorid
movies2directors.movieid=movies.movieid
u2base.movieid=movies.movieid
u2base.userid=users.userid

    【Question】
    How many different female users have rated movies from France? France is a country; Female users mean that u_gender = 'F'

    【Evidence】
    France is a country; Female users mean that u_gender = 'F'

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT COUNT(DISTINCT T2.userid) FROM users AS T1 INNER JOIN u2base AS T2 ON T1.userid = T2.userid INNER JOIN movies AS T3 ON T2.movieid = T3.movieid WHERE T1.u_gender = 'F' AND T3.country = 'France'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 movielens
【Schema】
# Table: movies2actors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(actorid:INTEGER, Primary Key, Examples: [88796, 88848, 121878]),
(cast_num:INTEGER, Examples: [0, 1, 2])
]
# Table: users
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(age:TEXT, Examples: [1, 56, 25]),
(u_gender:TEXT, Examples: [F, M]),
(occupation:TEXT, Examples: [2, 3, 4])
]
# Table: directors
[
(directorid:INTEGER, Primary Key, Examples: [7387, 12945, 15725]),
(d_quality:INTEGER, Examples: [0, 1, 2]),
(avg_revenue:INTEGER, Examples: [0, 1, 2])
]
# Table: movies
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(year:INTEGER, Examples: [3, 4, 1]),
(isEnglish:TEXT, Examples: [T, F]),
(country:TEXT, Examples: [other, USA, France]),
(runningtime:INTEGER, Examples: [2, 3, 0])
]
# Table: movies2directors
[
(movieid:INTEGER, Primary Key, Examples: [1672052, 1672111, 1672580]),
(directorid:INTEGER, Primary Key, Examples: [22397, 54934, 297253]),
(genre:TEXT, Examples: [Action, Adventure, Animation])
]
# Table: u2base
[
(userid:INTEGER, Primary Key, Examples: [1, 2, 3]),
(movieid:INTEGER, Primary Key, Examples: [1684486, 1685309, 1685493]),
(rating:TEXT, Examples: [1, 2, 3])
]
# Table: actors
[
(actorid:INTEGER, Primary Key, Examples: [4, 16, 28]),
(a_gender:TEXT, Examples: [M, F]),
(a_quality:INTEGER, Examples: [4, 0, 3])
]
【Foreign keys】
movies2actors.actorid=actors.actorid
movies2actors.movieid=movies.movieid
movies2directors.directorid=directors.directorid
movies2directors.movieid=movies.movieid
u2base.movieid=movies.movieid
u2base.userid=users.userid

    【Question】
    For different directors who direct well, how many of them have directed an action film? direct well means the quality of directing is good, which means d_quality = 4.

    【Evidence】
    direct well means the quality of directing is good, which means d_quality = 4.

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT COUNT(DISTINCT T2.directorid) FROM movies2directors AS T2 INNER JOIN directors AS T3 ON T2.directorid = T3.directorid WHERE T2.genre = 'Action' AND T3.d_quality = 4