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】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    Which education App has the worst rating and state the translated review if available. education App refers to Category = 'EDUCATION'; worst rated app refers to Rating = 1;

    【Evidence】
    education App refers to Category = 'EDUCATION'; worst rated app refers to 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 T1.App, T2.Translated_Review FROM playstore AS T1 INNER JOIN user_reviews AS T2 ON T1.App = T2.App WHERE T1.Category = 'EDUCATION' GROUP BY T1.App, T2.Translated_Review ORDER BY T1.Rating ASC LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    List all free sports Apps and their translated review. paid sports Apps refers to type = 'Paid' and Category = 'SPORTS';

    【Evidence】
    paid sports Apps refers to type = 'Paid' and Category = 'SPORTS';

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

SQL: SELECT T1.App, T2.Translated_Review FROM playstore AS T1 INNER JOIN user_reviews AS T2 ON T1.App = T2.App WHERE T1.Type = 'Free' AND T1.Category = 'SPORTS'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    Among the role playing game genre, how many are targeted to teens and what is their average sentiment polarity score? targeted to teen refers to Content Rating = 'Teen'; average = AVG(Sentiment_Polarity);

    【Evidence】
    targeted to teen refers to Content Rating = 'Teen'; average = AVG(Sentiment_Polarity);

    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.App), AVG(T2.Sentiment_Polarity) FROM playstore AS T1 INNER JOIN user_reviews AS T2 ON T1.App = T2.App WHERE T1."Content Rating" = 'Teen' AND T1.Genres = 'Role Playing'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 app_store
【Schema】
# Table: user_reviews
[
(App:TEXT, Examples: [10 Best Foods for You]),
(Translated_Review:TEXT),
(Sentiment:TEXT, Examples: [Positive, nan, Neutral]),
(Sentiment_Polarity:TEXT, Examples: [1.0, 0.25, nan]),
(Sentiment_Subjectivity:TEXT, Examples: [0.5333333333333333, 0.28846153846153844, nan])
]
# Table: playstore
[
(App:TEXT, Examples: [Photo Editor & Candy Camera & Grid & ScrapBook]),
(Category:TEXT, Examples: [ART_AND_DESIGN, AUTO_AND_VEHICLES, BEAUTY]),
(Rating:REAL, Examples: [4.1, 3.9, 4.7]),
(Reviews:INTEGER, Examples: [159, 967, 87510]),
(Size:TEXT, Examples: [19M, 14M, 8.7M]),
(Installs:TEXT, Examples: [10,000+, 500,000+, 5,000,000+]),
(Type:TEXT, Examples: [Free, Paid, NaN]),
(Price:TEXT, Examples: [0, $4.99, $3.99]),
(Content Rating:TEXT, Examples: [Everyone, Teen, Everyone 10+]),
(Genres:TEXT, Examples: [Art & Design])
]
【Foreign keys】
user_reviews.App=playstore.App

    【Question】
    What is the average rating of Apps falling under the racing genre and what is the percentage ratio of positive sentiment reviews? average rating = AVG(Rating); percentage = MULTIPLY(DIVIDE((SUM(Sentiment = 'Positive')), (COUNT(*)), 100));

    【Evidence】
    average rating = AVG(Rating); percentage = MULTIPLY(DIVIDE((SUM(Sentiment = 'Positive')), (COUNT(*)), 100));

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

SQL: SELECT AVG(T1.Rating), CAST(COUNT(CASE WHEN T2.Sentiment = 'Positive' THEN 1 ELSE NULL END) AS REAL) * 100 / COUNT(T2.Sentiment) FROM playstore AS T1 INNER JOIN user_reviews AS T2 ON T1.App = T2.App WHERE T1.Genres = 'Racing'
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 most consecutive games tied by Ebbsfleet as an away team in the 2008 season? consecutive games mean happen one after the other without interruption and refer to Date; tied refers to FTR = 'D';

    【Evidence】
    consecutive games mean happen one after the other without interruption and refer to Date; tied refers to 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 COUNT(*) FROM matchs WHERE season = 2008 AND AwayTeam = 'Ebbsfleet' AND 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】
    Of all the divisions in the world, what percentage of them belong to England? DIVIDE(COUNT(division where country = 'England'), COUNT(division)) as percentage;

    【Evidence】
    DIVIDE(COUNT(division where country = 'England'), COUNT(division)) 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 country = 'England' THEN division ELSE NULL END) AS REAL) * 100 / COUNT(division) FROM divisions
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 percentage of games won, games lost and games drawn does Cittadella have as a home team in total? Percentage of games won = DIVIDE(COUNT(FTR = 'H' where HomeTeam = 'Cittadella'), COUNT(Div where HomeTeam = 'Cittadella')) as percentage; Percentage of games lost = DIVIDE(COUNT(FTR = 'A' where HomeTeam = 'Cittadella')), COUNT(Div where HomeTeam = 'Cittadella') as percentage; percentage of games drawn = DIVIDE(SUM(FTR = 'D'where HomeTeam = 'Cittadella'), COUNT(Div where HomeTeam = 'Cittadella')) as percentage;

    【Evidence】
    Percentage of games won = DIVIDE(COUNT(FTR = 'H' where HomeTeam = 'Cittadella'), COUNT(Div where HomeTeam = 'Cittadella')) as percentage; Percentage of games lost = DIVIDE(COUNT(FTR = 'A' where HomeTeam = 'Cittadella')), COUNT(Div where HomeTeam = 'Cittadella') as percentage; percentage of games drawn = DIVIDE(SUM(FTR = 'D'where HomeTeam = 'Cittadella'), COUNT(Div where HomeTeam = 'Cittadella')) 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) / COUNT(HomeTeam) AS REAL) * 100, CAST(COUNT(CASE WHEN FTR = 'A' THEN 1 ELSE NULL END) AS REAL) / COUNT(HomeTeam), CAST(COUNT(CASE WHEN FTR = 'D' THEN 1 ELSE NULL END) AS REAL) / COUNT(HomeTeam) FROM matchs WHERE HomeTeam = 'Cittadella'
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】
    Of all the teams that played as a team away against Caen in the 2010 season, which one has the highest winning percentage? Caen refers to HomeTeam; which one refers to AwayTeam; the highest winning percentage = MAX(DIVIDE(COUNT(FTR = 'A' where HomeTeam = 'Caen', season = '2010')), COUNT(Div where HomeTeam = 'Caen', season = '2010')) as percentage;

    【Evidence】
    Caen refers to HomeTeam; which one refers to AwayTeam; the highest winning percentage = MAX(DIVIDE(COUNT(FTR = 'A' where HomeTeam = 'Caen', season = '2010')), COUNT(Div where HomeTeam = 'Caen', 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 AwayTeam FROM matchs WHERE HomeTeam = 'Caen' AND season = 2010 AND FTR = 'A' GROUP BY AwayTeam ORDER BY COUNT(AwayTeam) 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 percentage of matches played on 2005/07/30 belong to the F1 division? Division refers to Div; DIVIDE(COUNT(Div = 'F1', Date = '2005/07/30'), COUNT(Div, Date = '2005/07/30')) as percentage;

    【Evidence】
    Division refers to Div; DIVIDE(COUNT(Div = 'F1', Date = '2005/07/30'), COUNT(Div, Date = '2005/07/30')) 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(SUM(CASE WHEN Div = 'F1' THEN 1 ELSE 0 END) AS REAL) * 100 / COUNT(Div) FROM matchs WHERE Date = '2005-07-30'
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 percentage of all tied games did the Sassuolo team play in? tied games refer FTR = 'D'; DIVIDE(COUNT(Div where FTR = 'D', HomeTeam = 'Sassuolo' or AwayTeam = 'Sassuolo'), COUNT(Div where HomeTeam = 'Sassuolo' or AwayTeam = 'Sassuolo')) as percentage;

    【Evidence】
    tied games refer FTR = 'D'; DIVIDE(COUNT(Div where FTR = 'D', HomeTeam = 'Sassuolo' or AwayTeam = 'Sassuolo'), COUNT(Div where HomeTeam = 'Sassuolo' or AwayTeam = 'Sassuolo')) 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(SUM(CASE WHEN HomeTeam = 'Sassuolo' OR AwayTeam = 'Sassuolo' THEN 1 ELSE 0 END) AS REAL) * 100 / COUNT(FTR) FROM matchs WHERE 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】
    What is the percentage whereby the away team scored 2 goals during the 2017 seasons? scored 2 goals refers to FTAG = 2, which is short name for Final-time Away-team Goals; DIVIDE(COUNT(Div where season = 2017, FTAG = '2'), COUNT(Div where season = 2017)) as percentage;

    【Evidence】
    scored 2 goals refers to FTAG = 2, which is short name for Final-time Away-team Goals; DIVIDE(COUNT(Div where season = 2017, FTAG = '2'), COUNT(Div where 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 CAST(SUM(CASE WHEN FTAG = 2 THEN 1 ELSE 0 END) / COUNT(FTAG) AS REAL) * 100 FROM matchs WHERE 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】
    What is the name of all the teams that played in the EFL League One division? all the teams include both HomeTeam and AwayTeam; name = 'EFL League One'; DIV = 'E2';

    【Evidence】
    all the teams include both HomeTeam and AwayTeam; name = 'EFL League One'; DIV = 'E2';

    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,T1.AwayTeam FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div=T2.division WHERE T2.name = 'EFL League One' and T1.Div = 'E2'
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 playing in divisions in Greece have ever scored 4 or more goals? teams include both HomeTeam and AwayTeam; country = 'Greece'; scored 4 or more goals refer to FTAG≥4, which is short name for Final-time Away-team Goals;

    【Evidence】
    teams include both HomeTeam and AwayTeam; country = 'Greece'; scored 4 or more goals refer to FTAG≥4, which is 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 COUNT(DISTINCT CASE WHEN T1.FTHG >= 4 THEN HomeTeam ELSE NULL end) + COUNT(DISTINCT CASE WHEN T1.FTAG >= 4 THEN AwayTeam ELSE NULL end) FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T2.country = 'Greece'
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 played in the 2019 season of Scottish Championship league were ended with an equal result of 2-2? matches refer to Div; Scottish Championship is a name of the league; equal result of 2-2 refers to FTAG = 2 AND FTHG = 2;

    【Evidence】
    matches refer to Div; Scottish Championship is a name of the league; equal result of 2-2 refers to FTAG = 2 AND FTHG = 2;

    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 T1.season = 2019 AND T2.name = 'Scottish Championship' AND T1.FTAG = 2 AND T1.FTHG = 2
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 2 Scottish teams scored 10 goals playing as a local team and in which seasons? local team refers to HomeTeam; Scottish means belong to the country = 'Scotland'; scored 10 goals refer to FTHG = 10, which is short name for Final-time Away-team Goals;

    【Evidence】
    local team refers to HomeTeam; Scottish means belong to the country = 'Scotland'; scored 10 goals refer to FTHG = 10, which is 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 T1.HomeTeam FROM matchs AS T1 INNER JOIN divisions AS T2 ON T1.Div = T2.division WHERE T2.country = 'Scotland' AND T1.FTHG = 10