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】
    Who is the winner of the game happened on 2009/10/10, between "East Fife" and "Dumbarton"? 2009/10/10 is a date; the winner refers to FTR = 'A'; East Fife and Dumbarton are name of teams where HomeTeam = 'East Fife'; AwayTeam = 'Dumbarton';

    【Evidence】
    2009/10/10 is a date; the winner refers to FTR = 'A'; East Fife and Dumbarton are name of teams where HomeTeam = 'East Fife'; AwayTeam = 'Dumbarton';

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

SQL: SELECT CASE WHEN FTR = 'H' THEN 'East Fife' ELSE 'Dumbarton' END WINNER FROM matchs WHERE Date = '2009-10-10' AND HomeTeam = 'East Fife' AND AwayTeam = 'Dumbarton'
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 final score for the game Bursaspor vs Denizlispor on 2009/4/26? Bursaspor vs Denizlispor are names of teams where HomeTeam = 'Bursaspor' and AwayTeam = 'Denizlispor'; Date = '2009-04-26'; final score refers to FTHG, FTAG;

    【Evidence】
    Bursaspor vs Denizlispor are names of teams where HomeTeam = 'Bursaspor' and AwayTeam = 'Denizlispor'; Date = '2009-04-26'; final score refers to FTHG, FTAG;

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

SQL: SELECT FTHG, FTAG FROM matchs WHERE Date = '2009-04-26' AND HomeTeam = 'Bursaspor' AND AwayTeam = 'Denizlispor'
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】
    When did the first match that score more than 10 goals happen? score more than 10 goals refers to SUM(FTHG, FTAG)>10, which are short names for Final-time Home-team Goals and Final-time Away-team Goals; the first means the earliest and refers to MIN(Date);

    【Evidence】
    score more than 10 goals refers to SUM(FTHG, FTAG)>10, which are short names for Final-time Home-team Goals and Final-time Away-team Goals; the first means the earliest and refers to MIN(Date);

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

SQL: SELECT MIN(Date) FROM matchs WHERE FTHG + FTAG > 10
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】
    For the Ligue 2 game that made the most goals, who is the winner of that game? Ligue 2 is the name of division; the most goals refer to MAX(SUM(FTHG, FTAG)) which are short names for Final-time Home-team Goals and Final-time Away-team Goals; winner refers to FTR = 'A';

    【Evidence】
    Ligue 2 is the name of division; the most goals refer to MAX(SUM(FTHG, FTAG)) which are short names for Final-time Home-team Goals and Final-time Away-team Goals; winner refers to FTR = 'A';

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

SQL: SELECT CASE WHEN T1.FTR = 'H' THEN T1.HomeTeam ELSE T1.AwayTeam END WINNER FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T2.name = 'Ligue 2' ORDER BY T1.FTAG + T1.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】
    How many Away Victories happened on 2016/3/27 in the LaLiga 2 division? Away victories refer to FTR = 'A'; LaLiga 2 is the name of division; Date = '2016-03-27';

    【Evidence】
    Away victories refer to FTR = 'A'; LaLiga 2 is the name of division; Date = '2016-03-27';

    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 = 'LaLiga 2' AND T1.Date = '2016-03-27' AND T1.FTR = 'A'
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 draw games happened on 2018/8/7 for National League? National League is the name of division; Date = '2018-08-07'; draw refers to FTR = 'D'; games refer to Div;

    【Evidence】
    National League is the name of division; Date = '2018-08-07'; draw refers to FTR = 'D'; games refer to Div;

    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 = 'National League' AND T1.Date = '2018-08-07' 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】
    Which country had the game that Away team made the most goals? the most goals refer to MAX(FTAG), which is a short name for Final-time Away-team Goals;

    【Evidence】
    the most goals refer to MAX(FTAG), which is a short name for Final-time Away-team Goals;

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

SQL: SELECT T2.country FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division GROUP BY T2.country ORDER BY SUM(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】
    For a game had a score of 1-8 in the year of 2011, what division was that game in? Give the full name of the division. 2011 refers to season; a score of 1-8 refers to FTHG = '1' and FTAG = '8';

    【Evidence】
    2011 refers to season; a score of 1-8 refers to FTHG = '1' and FTAG = '8';

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

SQL: SELECT T2.division, T2.name FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T1.season = 2011 AND T1.FTHG = 1 AND T1.FTAG = 8
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 games with more than 5 total field goals on 2020/2/22? Give the full name of the division? more than 5 total field goals refers to SUM(FTHG, FTAG)>5, which are short names for Final-time Home-team Goals and Final-time Away-team Goals; 2020/2/22 is a date;

    【Evidence】
    more than 5 total field goals refers to SUM(FTHG, FTAG)>5, which are short names for Final-time Home-team Goals and Final-time Away-team Goals; 2020/2/22 is a date;

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

SQL: SELECT T2.division, T2.name FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T1.Date = '2020-02-22' AND T1.FTAG + T1.FTHG > 5 ORDER BY T1.FTAG + T1.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】
    Give the full name of the divison that had the most 0-0 games. the most 0-0 games means a no-score draw and refers to MAX(COUNT(Div where FTHG = '0' and FTAG = '0'));

    【Evidence】
    the most 0-0 games means a no-score draw and refers to MAX(COUNT(Div where FTHG = '0' and FTAG = '0'));

    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.FTAG = 0 AND T1.FTHG = 0 GROUP BY T2.division ORDER BY COUNT(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】
    How many Scottish League One games took place on the day that "Pro Vercelli" and "Pescara"had a 5-2 game? Pro Vercelli and Pescara are names of teams; HomeTeam = 'Pro Vercelli'; AwayTeam = 'Pescara'; 5-2 is a score where FTHG = '5' and FTAG = '2'; Scottish League One is a name of division; games refer to Div;

    【Evidence】
    Pro Vercelli and Pescara are names of teams; HomeTeam = 'Pro Vercelli'; AwayTeam = 'Pescara'; 5-2 is a score where FTHG = '5' and FTAG = '2'; Scottish League One is a name of division; games refer to Div;

    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.Date) FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T2.name = 'Scottish League One' AND T1.Date = ( SELECT Date FROM matchs WHERE FTHG = 5 AND FTAG = 2 AND HomeTeam = 'Pro Vercelli' AND AwayTeam = 'Pescara' )
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】
    List the number of games that ended up with 5-0 in Greece. 5-0 is a score where FTHG = '5' and FTAG = '0'; Greece is a name of country; games refer to Div;

    【Evidence】
    5-0 is a score where FTHG = '5' and FTAG = '0'; Greece is a name of country; games refer to Div;

    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.country = 'Greece' AND T1.FTHG = 5 AND T1.FTAG = 0
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 country did Bradford Team belongs to? Bradford team refers to HomeTeam = 'Bradford' or AwayTeam = 'Bradford';

    【Evidence】
    Bradford team refers to HomeTeam = 'Bradford' or AwayTeam = 'Bradford';

    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.country FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T1.HomeTeam = 'Bradford' OR T1.AwayTeam = 'Bradford'
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 Eredivisie teams have played in 2008? Eredivisie is the name of division; 2008 refers to season; teams refer to HomeTeam;

    【Evidence】
    Eredivisie is the name of division; 2008 refers to season; teams refer to HomeTeam;

    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.HomeTeam) FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T2.name = 'Eredivisie' AND T1.season = 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】
    What's the home win ratio of the Bundesliga division in 2021? home win refers to FTR = 'H', where H stands for home victory; season = '2021'; Bundesliga is a name of division; DIVIDE(COUNT(Div where FTR = 'H, season = '2021' and name = 'Bundesliga'), COUNT(Div where season = '2021' and name = 'Bundesliga')) as percentage;

    【Evidence】
    home win refers to FTR = 'H', where H stands for home victory; season = '2021'; Bundesliga is a name of division; DIVIDE(COUNT(Div where FTR = 'H, season = '2021' and name = 'Bundesliga'), COUNT(Div where season = '2021' and name = 'Bundesliga')) 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 T1.FTR = 'H' THEN 1 ELSE NULL END) AS REAL) * 100 / COUNT(T1.FTR) FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T1.season = 2021 AND T2.name = 'Bundesliga'
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】
    For all the games ended up with 1-1, what percentage of them are from Liga NOS division? 1-1 is a score where FTHG = '1' and FTAG = '1'; Liga NOS is the name of division; DIVIDE(COUNT(Div where FTHG = '1', FTAG = '1', name = 'Liga NOS'), COUNT(Div where FTHG = '1' and FTAG = '1')) as percentage;

    【Evidence】
    1-1 is a score where FTHG = '1' and FTAG = '1'; Liga NOS is the name of division; DIVIDE(COUNT(Div where FTHG = '1', FTAG = '1', name = 'Liga NOS'), COUNT(Div where FTHG = '1' and FTAG = '1')) 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 T2.name = 'Liga NOS' THEN T1.Div ELSE NULL END) AS REAL) * 100 / COUNT(T1.Div) FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T1.FTHG = 1 AND FTAG = 1