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】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    From the Spanish LaLiga division in the 2017 season, which team won the most times as a local team and by what percentage? local team refers to HomeTeam; Spanish means belong to the country = 'Spain'; LaLiga is a name of division; won as a local team refers to FTR = 'H', where H stands for home victory; DIVIDE(COUNT(Div where name = 'LaLiga', country = 'Spain', season = 2017, FRT = 'H'), COUNT(Div where name = 'LaLiga', country = 'Spain', season = 2017)) as percentage;

    【Evidence】
    local team refers to HomeTeam; Spanish means belong to the country = 'Spain'; LaLiga is a name of division; won as a local team refers to FTR = 'H', where H stands for home victory; DIVIDE(COUNT(Div where name = 'LaLiga', country = 'Spain', season = 2017, FRT = 'H'), COUNT(Div where name = 'LaLiga', country = 'Spain', season = 2017)) as percentage;

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

SQL: SELECT T1.HomeTeam HWHT , CAST(COUNT(CASE WHEN T1.FTR = 'H' THEN 1 ELSE NULL END) AS REAL) * 100 / COUNT(HomeTeam) FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T2.name = 'LaLiga' AND T2.country = 'Spain' AND T1.season = 2017
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    How many teams that played in the 2012 season belong to any of the English divisions and what percentage play in each of the divisions? matches = Div

    【Evidence】
    matches = Div

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

SQL: SELECT ( SELECT COUNT(T1.Div) AS total FROM matchs T1 INNER JOIN divisions T2 ON T2.division = T1.Div WHERE T2.country = 'England' AND T1.season = 2012 ) AS num , CASE WHEN 1 THEN T.result END AS percentage FROM ( SELECT 100.0 * COUNT(T1.Div) / ( SELECT COUNT(T1.Div) FROM matchs T1 INNER JOIN divisions T2 ON T2.division = T1.Div WHERE T2.country = 'England' AND T1.season = 2012 ) AS result FROM matchs T1 INNER JOIN divisions T2 ON T2.division = T1.Div WHERE T2.country = 'England' AND T1.season = 2012 GROUP BY T2.division ) AS T
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    What is the highest final-time score across all divisions in the 2021 season? Which team was the team that made up that score? MAX(SUM where FTHG, FTAG, season = 2021);

    【Evidence】
    MAX(SUM where FTHG, FTAG, season = 2021);

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

SQL: SELECT ( SELECT MAX(MAX(FTAG), MAX(FTHG)) FROM matchs WHERE season = 2021 ) AS T1, AwayTeam FROM matchs WHERE season = 2021 AND FTHG = T1 OR FTAG = T1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    What is the name of the home team in division P1 with the highest final time goal in all seasons? the highest final time goal refers to MAX(FTHG); P1 = Div;

    【Evidence】
    the highest final time goal refers to MAX(FTHG); P1 = Div;

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

SQL: SELECT HomeTeam FROM matchs WHERE Div = 'P1' AND season = 2021 ORDER BY FTHG DESC LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    What was the difference in home team and away team win percentages across all divisions in 2010? 2010 refers to season = 2010; SUBTRACT(DIVIDE(COUNT(Div where FTR = 'H', season = 2010), COUNT(Div where season = 2010)), COUNT(Div where FTR = 'A', season = 2010), COUNT(Div where season = 2010)) as percentage;

    【Evidence】
    2010 refers to season = 2010; SUBTRACT(DIVIDE(COUNT(Div where FTR = 'H', season = 2010), COUNT(Div where season = 2010)), COUNT(Div where FTR = 'A', season = 2010), COUNT(Div where season = 2010)) as percentage;

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

SQL: SELECT CAST(COUNT(CASE WHEN FTR = 'H' THEN 1 ELSE NULL END) AS REAL) * 100 / COUNT(FTR) - CAST(COUNT(CASE WHEN FTR = 'A' THEN 1 ELSE NULL END) AS REAL) * 100 / COUNT(FTR) DIFFERENCE FROM matchs WHERE season = 2010
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    Which division had the most draft matches in the 2008 season? the most draft matches refer to MAX(COUNT(Div)) where FTR = 'D';

    【Evidence】
    the most draft matches refer to MAX(COUNT(Div)) where FTR = 'D';

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

SQL: SELECT Div FROM matchs WHERE season = 2008 AND FTR = 'D' GROUP BY Div ORDER BY COUNT(FTR) DESC LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    Which team won the match in the EC division on January 20, 2008 at home? won at home refers to FTR = 'H'; January 20, 2008 refers to Date = '2008-01-20'; EC division refers to Div = 'EC';

    【Evidence】
    won at home refers to FTR = 'H'; January 20, 2008 refers to Date = '2008-01-20'; EC division refers to Div = 'EC';

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

SQL: SELECT HomeTeam FROM matchs WHERE Div = 'EC' AND Date = '2008-01-20' AND FTR = 'H'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    What is the name of the division in which Club Brugge and Genk competed on September 13, 2009? September 13, 2009 refers to Date = '2009-09-13'; Club Brugge refers to HomeTeam; Genk refers to AwayTeam;

    【Evidence】
    September 13, 2009 refers to Date = '2009-09-13'; Club Brugge refers to HomeTeam; Genk refers to AwayTeam;

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

SQL: SELECT T2.name FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T1.Date = '2009-09-13' and T1.HomeTeam = 'Club Brugge' AND T1.AwayTeam = 'Genk'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    How many matches were played in the Scottish Premiership division from 2006 to 2008? Scottish Premiership is a name of division; from 2006 to 2008 means seasons between 2006 and 2008;

    【Evidence】
    Scottish Premiership is a name of division; from 2006 to 2008 means seasons between 2006 and 2008;

    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.Div) FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T2.name = 'Scottish Premiership' AND (T1.season BETWEEN 2006 AND 2008)
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    In which division was the match between Hibernian, the away team, and Hearts, the home team, played? To which country does this division belong? FALSE;

    【Evidence】
    FALSE;

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

SQL: SELECT DISTINCT T2.division,T2.country FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T1.HomeTeam = 'Hearts' AND T1.AwayTeam = 'Hibernian'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    Which away team in the division of Bundesliga has the highest final time goals? Bundesliga is a name of division; the highest final time goals refers to MAX(FTAG);

    【Evidence】
    Bundesliga is a name of division; the highest final time goals refers to MAX(FTAG);

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

SQL: SELECT T1.AwayTeam FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div=T2.division WHERE T2.name = 'Bundesliga' ORDER BY T1.FTAG DESC LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    Please provide the names of any three away teams that competed in the Italian divisions. Italian means belong to country = 'Italy";

    【Evidence】
    Italian means belong to country = 'Italy";

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

SQL: SELECT T1.AwayTeam FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div=T2.division WHERE T2.country = 'Italy' LIMIT 3
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    What is the name of the division that has had the lowest number of draft matches in the 2019 season? the lowest number of draft matches refers to MIN(COUNT(FTR = 'D'));

    【Evidence】
    the lowest number of draft matches refers to MIN(COUNT(FTR = 'D'));

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

SQL: SELECT T2.name FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T1.season = 2019 AND T1.FTR = 'D' GROUP BY T2.division ORDER BY COUNT(FTR) LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    How many times did Valencia's home team win in the LaLiga division? LaLiga is a name of the division; Valencia's home team refers to HomeTeam = 'Valencia'; win refers to FTR = 'H';

    【Evidence】
    LaLiga is a name of the division; Valencia's home team refers to HomeTeam = 'Valencia'; win refers to FTR = 'H';

    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.HomeTeam) FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T2.name = 'LaLiga' AND T1.HomeTeam = 'Valencia' AND T1.FTR = 'H'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    In how many matches in the Seria A division did both teams have equal goals? Seria A is a name of division; equal goals refers to FTR = 'D', where D stands for draft;

    【Evidence】
    Seria A is a name of division; equal goals refers to FTR = 'D', where D stands for draft;

    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.FTR) FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T2.name = 'Seria A' AND T1.FTR = 'D'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    How many football divisions does England have? England is the name of country;

    【Evidence】
    England is the name of 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(division) FROM divisions WHERE country = 'England'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 european_football_1
【Schema】
# Table: divisions
[
(division:TEXT, Primary Key, Examples: [B1, D1, D2]),
(name:TEXT, Examples: [Division 1A, Bundesliga, 2. Bundesliga]),
(country:TEXT, Examples: [Belgium, Deutschland, England])
]
# Table: matchs
[
(Div:TEXT, Examples: [B1, D1, D2]),
(Date:DATE, Examples: [2020-08-08]),
(HomeTeam:TEXT, Examples: [Club Brugge, Antwerp, Standard]),
(AwayTeam:TEXT, Examples: [Charleroi, Mouscron, Cercle Brugge]),
(FTHG:INTEGER, Examples: [0, 1, 2]),
(FTAG:INTEGER, Examples: [1, 0, 2]),
(FTR:TEXT, Examples: [A, D, H]),
(season:INTEGER, Examples: [2021, 2020, 2019])
]
【Foreign keys】
matchs.Div=divisions.division

    【Question】
    What's the name of the football division in the Netherlands? Netherlands is the name of country;

    【Evidence】
    Netherlands is the name of country;

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

SQL: SELECT name FROM divisions WHERE country = 'Netherlands'