input
stringlengths 667
7.62k
| output
stringlengths 41
600
| db_id
stringlengths 3
31
| query
stringlengths 18
577
| question
stringlengths 3
224
| schema
stringlengths 177
6.14k
| primary_keys
stringlengths 16
545
| foreign_keys
stringlengths 16
1.48k
|
|---|---|---|---|---|---|---|---|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the total and minimum enrollments across all schools.</question>
[SQL]:
|
<SQL_QUERY>SELECT sum(enrollment) , min(enrollment) FROM university</SQL_QUERY>
|
university_basketball
|
SELECT sum(enrollment) , min(enrollment) FROM university
|
Return the total and minimum enrollments across all schools.
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the total student enrollment for different affiliation type schools.</question>
[SQL]:
|
<SQL_QUERY>SELECT sum(enrollment) , affiliation FROM university GROUP BY affiliation</SQL_QUERY>
|
university_basketball
|
SELECT sum(enrollment) , affiliation FROM university GROUP BY affiliation
|
Find the total student enrollment for different affiliation type schools.
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the total enrollments of universities of each affiliation type?</question>
[SQL]:
|
<SQL_QUERY>SELECT sum(enrollment) , affiliation FROM university GROUP BY affiliation</SQL_QUERY>
|
university_basketball
|
SELECT sum(enrollment) , affiliation FROM university GROUP BY affiliation
|
What are the total enrollments of universities of each affiliation type?
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many schools do not participate in the basketball match?</question>
[SQL]:
|
<SQL_QUERY>SELECT count(*) FROM university WHERE school_id NOT IN (SELECT school_id FROM basketball_match)</SQL_QUERY>
|
university_basketball
|
SELECT count(*) FROM university WHERE school_id NOT IN (SELECT school_id FROM basketball_match)
|
How many schools do not participate in the basketball match?
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Count the number of universities that do not participate in the baketball match.</question>
[SQL]:
|
<SQL_QUERY>SELECT count(*) FROM university WHERE school_id NOT IN (SELECT school_id FROM basketball_match)</SQL_QUERY>
|
university_basketball
|
SELECT count(*) FROM university WHERE school_id NOT IN (SELECT school_id FROM basketball_match)
|
Count the number of universities that do not participate in the baketball match.
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the schools that were either founded after 1850 or public.</question>
[SQL]:
|
<SQL_QUERY>SELECT school FROM university WHERE founded > 1850 OR affiliation = 'Public'</SQL_QUERY>
|
university_basketball
|
SELECT school FROM university WHERE founded > 1850 OR affiliation = 'Public'
|
Find the schools that were either founded after 1850 or public.
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the schools that were either founded before 1850 or are public?</question>
[SQL]:
|
<SQL_QUERY>SELECT school FROM university WHERE founded > 1850 OR affiliation = 'Public'</SQL_QUERY>
|
university_basketball
|
SELECT school FROM university WHERE founded > 1850 OR affiliation = 'Public'
|
What are the schools that were either founded before 1850 or are public?
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find how many different affiliation types there are.</question>
[SQL]:
|
<SQL_QUERY>SELECT count(DISTINCT affiliation) FROM university</SQL_QUERY>
|
university_basketball
|
SELECT count(DISTINCT affiliation) FROM university
|
Find how many different affiliation types there are.
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Count the number of different affiliation types.</question>
[SQL]:
|
<SQL_QUERY>SELECT count(DISTINCT affiliation) FROM university</SQL_QUERY>
|
university_basketball
|
SELECT count(DISTINCT affiliation) FROM university
|
Count the number of different affiliation types.
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find how many school locations have the word 'NY'.</question>
[SQL]:
|
<SQL_QUERY>SELECT count(*) FROM university WHERE LOCATION LIKE "%NY%"</SQL_QUERY>
|
university_basketball
|
SELECT count(*) FROM university WHERE LOCATION LIKE "%NY%"
|
Find how many school locations have the word 'NY'.
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many universities have a location that contains NY?</question>
[SQL]:
|
<SQL_QUERY>SELECT count(*) FROM university WHERE LOCATION LIKE "%NY%"</SQL_QUERY>
|
university_basketball
|
SELECT count(*) FROM university WHERE LOCATION LIKE "%NY%"
|
How many universities have a location that contains NY?
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the team names of the universities whose enrollments are smaller than the average enrollment size.</question>
[SQL]:
|
<SQL_QUERY>SELECT t2.team_name FROM university AS t1 JOIN basketball_match AS t2 ON t1.school_id = t2.school_id WHERE enrollment < (SELECT avg(enrollment) FROM university)</SQL_QUERY>
|
university_basketball
|
SELECT t2.team_name FROM university AS t1 JOIN basketball_match AS t2 ON t1.school_id = t2.school_id WHERE enrollment < (SELECT avg(enrollment) FROM university)
|
Find the team names of the universities whose enrollments are smaller than the average enrollment size.
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of teams from universities that have a below average enrollment?</question>
[SQL]:
|
<SQL_QUERY>SELECT t2.team_name FROM university AS t1 JOIN basketball_match AS t2 ON t1.school_id = t2.school_id WHERE enrollment < (SELECT avg(enrollment) FROM university)</SQL_QUERY>
|
university_basketball
|
SELECT t2.team_name FROM university AS t1 JOIN basketball_match AS t2 ON t1.school_id = t2.school_id WHERE enrollment < (SELECT avg(enrollment) FROM university)
|
What are the names of teams from universities that have a below average enrollment?
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the number of universities that have over a 20000 enrollment size for each affiliation type.</question>
[SQL]:
|
<SQL_QUERY>SELECT count(*) , affiliation FROM university WHERE enrollment > 20000 GROUP BY affiliation</SQL_QUERY>
|
university_basketball
|
SELECT count(*) , affiliation FROM university WHERE enrollment > 20000 GROUP BY affiliation
|
Find the number of universities that have over a 20000 enrollment size for each affiliation type.
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the different affiliations, and how many schools with each have an enrollment size of above 20000?</question>
[SQL]:
|
<SQL_QUERY>SELECT count(*) , affiliation FROM university WHERE enrollment > 20000 GROUP BY affiliation</SQL_QUERY>
|
university_basketball
|
SELECT count(*) , affiliation FROM university WHERE enrollment > 20000 GROUP BY affiliation
|
What are the different affiliations, and how many schools with each have an enrollment size of above 20000?
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the total number of students enrolled in the colleges that were founded after the year of 1850 for each affiliation type.</question>
[SQL]:
|
<SQL_QUERY>SELECT sum(Enrollment) , affiliation FROM university WHERE founded > 1850 GROUP BY affiliation</SQL_QUERY>
|
university_basketball
|
SELECT sum(Enrollment) , affiliation FROM university WHERE founded > 1850 GROUP BY affiliation
|
Find the total number of students enrolled in the colleges that were founded after the year of 1850 for each affiliation type.
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the different affiliations, and what is the total enrollment of schools founded after 1850 for each enrollment type?</question>
[SQL]:
|
<SQL_QUERY>SELECT sum(Enrollment) , affiliation FROM university WHERE founded > 1850 GROUP BY affiliation</SQL_QUERY>
|
university_basketball
|
SELECT sum(Enrollment) , affiliation FROM university WHERE founded > 1850 GROUP BY affiliation
|
What are the different affiliations, and what is the total enrollment of schools founded after 1850 for each enrollment type?
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the maximum enrollment across all schools?</question>
[SQL]:
|
<SQL_QUERY>SELECT max(Enrollment) FROM university</SQL_QUERY>
|
university_basketball
|
SELECT max(Enrollment) FROM university
|
What is the maximum enrollment across all schools?
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the maximum enrollment across all schools.</question>
[SQL]:
|
<SQL_QUERY>SELECT max(Enrollment) FROM university</SQL_QUERY>
|
university_basketball
|
SELECT max(Enrollment) FROM university
|
Return the maximum enrollment across all schools.
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>List all information regarding the basketball match.</question>
[SQL]:
|
<SQL_QUERY>SELECT * FROM basketball_match</SQL_QUERY>
|
university_basketball
|
SELECT * FROM basketball_match
|
List all information regarding the basketball match.
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is all the information about the basketball match?</question>
[SQL]:
|
<SQL_QUERY>SELECT * FROM basketball_match</SQL_QUERY>
|
university_basketball
|
SELECT * FROM basketball_match
|
What is all the information about the basketball match?
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>List names of all teams in the basketball competition, ordered by all home scores in descending order.</question>
[SQL]:
|
<SQL_QUERY>SELECT team_name FROM basketball_match ORDER BY All_Home DESC</SQL_QUERY>
|
university_basketball
|
SELECT team_name FROM basketball_match ORDER BY All_Home DESC
|
List names of all teams in the basketball competition, ordered by all home scores in descending order.
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);</schema>"
<primary_keys>[Primary Keys]: basketball_match : team_id, university : school_id</primary_keys>"
<foreign_keys>[Foreign Keys]: basketball_match : school_id = university : school_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of all the teams in the basketball competition, sorted by all home scores in descending order?</question>
[SQL]:
|
<SQL_QUERY>SELECT team_name FROM basketball_match ORDER BY All_Home DESC</SQL_QUERY>
|
university_basketball
|
SELECT team_name FROM basketball_match ORDER BY All_Home DESC
|
What are the names of all the teams in the basketball competition, sorted by all home scores in descending order?
|
[Schema (values) (types)]: | university_basketball | basketball_match : team_id (text) , school_id (number) , team_name (number) , acc_regular_season (text) , acc_percent (text) , acc_home (text) , acc_road (text) , all_games (text) , all_games_percent (text) , all_home (number) , all_road (text) , all_neutral (text) | university : school_id (text) , school (number) , location (number) , founded (text) , affiliation (text) , enrollment (text) , nickname (text) , primary_conference (text);
|
[Primary Keys]: basketball_match : team_id, university : school_id
|
[Foreign Keys]: basketball_match : school_id = university : school_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>the names of models that launched between 2002 and 2004.</question>
[SQL]:
|
<SQL_QUERY>SELECT Model_name FROM chip_model WHERE Launch_year BETWEEN 2002 AND 2004;</SQL_QUERY>
|
phone_1
|
SELECT Model_name FROM chip_model WHERE Launch_year BETWEEN 2002 AND 2004;
|
the names of models that launched between 2002 and 2004.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>Which model has the least amount of RAM? List the model name and the amount of RAM.</question>
[SQL]:
|
<SQL_QUERY>SELECT Model_name , RAM_MiB FROM chip_model ORDER BY RAM_MiB ASC LIMIT 1;</SQL_QUERY>
|
phone_1
|
SELECT Model_name , RAM_MiB FROM chip_model ORDER BY RAM_MiB ASC LIMIT 1;
|
Which model has the least amount of RAM? List the model name and the amount of RAM.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the chip model and screen mode of the phone with hardware model name "LG-P760"?</question>
[SQL]:
|
<SQL_QUERY>SELECT chip_model , screen_mode FROM phone WHERE Hardware_Model_name = "LG-P760";</SQL_QUERY>
|
phone_1
|
SELECT chip_model , screen_mode FROM phone WHERE Hardware_Model_name = "LG-P760";
|
What are the chip model and screen mode of the phone with hardware model name "LG-P760"?
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many phone hardware models are produced by the company named "Nokia Corporation"?</question>
[SQL]:
|
<SQL_QUERY>SELECT count(*) FROM phone WHERE Company_name = "Nokia Corporation";</SQL_QUERY>
|
phone_1
|
SELECT count(*) FROM phone WHERE Company_name = "Nokia Corporation";
|
How many phone hardware models are produced by the company named "Nokia Corporation"?
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is maximum and minimum RAM size of phone produced by company named "Nokia Corporation"?</question>
[SQL]:
|
<SQL_QUERY>SELECT max(T1.RAM_MiB) , min(T1.RAM_MiB) FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model WHERE T2.Company_name = "Nokia Corporation";</SQL_QUERY>
|
phone_1
|
SELECT max(T1.RAM_MiB) , min(T1.RAM_MiB) FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model WHERE T2.Company_name = "Nokia Corporation";
|
What is maximum and minimum RAM size of phone produced by company named "Nokia Corporation"?
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the average ROM size of phones produced by the company named "Nokia Corporation"?</question>
[SQL]:
|
<SQL_QUERY>SELECT avg(T1.ROM_MiB) FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model WHERE T2.Company_name = "Nokia Corporation";</SQL_QUERY>
|
phone_1
|
SELECT avg(T1.ROM_MiB) FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model WHERE T2.Company_name = "Nokia Corporation";
|
What is the average ROM size of phones produced by the company named "Nokia Corporation"?
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the hardware model name and company name for all the phones that were launched in year 2002 or have RAM size greater than 32.</question>
[SQL]:
|
<SQL_QUERY>SELECT T2.Hardware_Model_name , T2.Company_name FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model WHERE T1.Launch_year = 2002 OR T1.RAM_MiB > 32;</SQL_QUERY>
|
phone_1
|
SELECT T2.Hardware_Model_name , T2.Company_name FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model WHERE T1.Launch_year = 2002 OR T1.RAM_MiB > 32;
|
List the hardware model name and company name for all the phones that were launched in year 2002 or have RAM size greater than 32.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find all phones that have word 'Full' in their accreditation types. List the Hardware Model name and Company name.</question>
[SQL]:
|
<SQL_QUERY>SELECT Hardware_Model_name , Company_name FROM phone WHERE Accreditation_type LIKE 'Full';</SQL_QUERY>
|
phone_1
|
SELECT Hardware_Model_name , Company_name FROM phone WHERE Accreditation_type LIKE 'Full';
|
Find all phones that have word 'Full' in their accreditation types. List the Hardware Model name and Company name.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the Char cells, Pixels and Hardware colours for the screen of the phone whose hardware model name is "LG-P760".</question>
[SQL]:
|
<SQL_QUERY>SELECT T1.Char_cells , T1.Pixels , T1.Hardware_colours FROM screen_mode AS T1 JOIN phone AS T2 ON T1.Graphics_mode = T2.screen_mode WHERE T2.Hardware_Model_name = "LG-P760";</SQL_QUERY>
|
phone_1
|
SELECT T1.Char_cells , T1.Pixels , T1.Hardware_colours FROM screen_mode AS T1 JOIN phone AS T2 ON T1.Graphics_mode = T2.screen_mode WHERE T2.Hardware_Model_name = "LG-P760";
|
Find the Char cells, Pixels and Hardware colours for the screen of the phone whose hardware model name is "LG-P760".
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the hardware model name and company name for the phone whose screen mode type is "Graphics."</question>
[SQL]:
|
<SQL_QUERY>SELECT T2.Hardware_Model_name , T2.Company_name FROM screen_mode AS T1 JOIN phone AS T2 ON T1.Graphics_mode = T2.screen_mode WHERE T1.Type = "Graphics";</SQL_QUERY>
|
phone_1
|
SELECT T2.Hardware_Model_name , T2.Company_name FROM screen_mode AS T1 JOIN phone AS T2 ON T1.Graphics_mode = T2.screen_mode WHERE T1.Type = "Graphics";
|
List the hardware model name and company name for the phone whose screen mode type is "Graphics."
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the name of the company that has the least number of phone models. List the company name and the number of phone model produced by that company.</question>
[SQL]:
|
<SQL_QUERY>SELECT Company_name , count(*) FROM phone GROUP BY Company_name ORDER BY count(*) ASC LIMIT 1;</SQL_QUERY>
|
phone_1
|
SELECT Company_name , count(*) FROM phone GROUP BY Company_name ORDER BY count(*) ASC LIMIT 1;
|
Find the name of the company that has the least number of phone models. List the company name and the number of phone model produced by that company.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the name of the company that produced more than one phone model.</question>
[SQL]:
|
<SQL_QUERY>SELECT Company_name FROM phone GROUP BY Company_name HAVING count(*) > 1;</SQL_QUERY>
|
phone_1
|
SELECT Company_name FROM phone GROUP BY Company_name HAVING count(*) > 1;
|
List the name of the company that produced more than one phone model.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the maximum, minimum and average number of used kb in screen mode.</question>
[SQL]:
|
<SQL_QUERY>SELECT max(used_kb) , min(used_kb) , avg(used_kb) FROM screen_mode;</SQL_QUERY>
|
phone_1
|
SELECT max(used_kb) , min(used_kb) , avg(used_kb) FROM screen_mode;
|
List the maximum, minimum and average number of used kb in screen mode.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the name of the phone model launched in year 2002 and with the highest RAM size.</question>
[SQL]:
|
<SQL_QUERY>SELECT T2.Hardware_Model_name FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model WHERE T1.Launch_year = 2002 ORDER BY T1.RAM_MiB DESC LIMIT 1;</SQL_QUERY>
|
phone_1
|
SELECT T2.Hardware_Model_name FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model WHERE T1.Launch_year = 2002 ORDER BY T1.RAM_MiB DESC LIMIT 1;
|
List the name of the phone model launched in year 2002 and with the highest RAM size.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the wifi and screen mode type of the hardware model named "LG-P760"?</question>
[SQL]:
|
<SQL_QUERY>SELECT T1.WiFi , T3.Type FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model JOIN screen_mode AS T3 ON T2.screen_mode = T3.Graphics_mode WHERE T2.Hardware_Model_name = "LG-P760";</SQL_QUERY>
|
phone_1
|
SELECT T1.WiFi , T3.Type FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model JOIN screen_mode AS T3 ON T2.screen_mode = T3.Graphics_mode WHERE T2.Hardware_Model_name = "LG-P760";
|
What are the wifi and screen mode type of the hardware model named "LG-P760"?
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the hardware model name for the phones that have screen mode type "Text" or RAM size greater than 32.</question>
[SQL]:
|
<SQL_QUERY>SELECT T2.Hardware_Model_name FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model JOIN screen_mode AS T3 ON T2.screen_mode = T3.Graphics_mode WHERE T3.Type = "Text" OR T1.RAM_MiB > 32;</SQL_QUERY>
|
phone_1
|
SELECT T2.Hardware_Model_name FROM chip_model AS T1 JOIN phone AS T2 ON T1.Model_name = T2.chip_model JOIN screen_mode AS T3 ON T2.screen_mode = T3.Graphics_mode WHERE T3.Type = "Text" OR T1.RAM_MiB > 32;
|
List the hardware model name for the phones that have screen mode type "Text" or RAM size greater than 32.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the hardware model name for the phones that were produced by "Nokia Corporation" or whose screen mode type is "Graphics."</question>
[SQL]:
|
<SQL_QUERY>SELECT DISTINCT T2.Hardware_Model_name FROM screen_mode AS T1 JOIN phone AS T2 ON T1.Graphics_mode = T2.screen_mode WHERE T1.Type = "Graphics" OR t2.Company_name = "Nokia Corporation"</SQL_QUERY>
|
phone_1
|
SELECT DISTINCT T2.Hardware_Model_name FROM screen_mode AS T1 JOIN phone AS T2 ON T1.Graphics_mode = T2.screen_mode WHERE T1.Type = "Graphics" OR t2.Company_name = "Nokia Corporation"
|
List the hardware model name for the phones that were produced by "Nokia Corporation" or whose screen mode type is "Graphics."
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the hardware model name for the phons that were produced by "Nokia Corporation" but whose screen mode type is not Text.</question>
[SQL]:
|
<SQL_QUERY>SELECT DISTINCT T2.Hardware_Model_name FROM screen_mode AS T1 JOIN phone AS T2 ON T1.Graphics_mode = T2.screen_mode WHERE t2.Company_name = "Nokia Corporation" AND T1.Type != "Text";</SQL_QUERY>
|
phone_1
|
SELECT DISTINCT T2.Hardware_Model_name FROM screen_mode AS T1 JOIN phone AS T2 ON T1.Graphics_mode = T2.screen_mode WHERE t2.Company_name = "Nokia Corporation" AND T1.Type != "Text";
|
List the hardware model name for the phons that were produced by "Nokia Corporation" but whose screen mode type is not Text.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the phone hardware model and company name for the phones whose screen usage in kb is between 10 and 15.</question>
[SQL]:
|
<SQL_QUERY>SELECT DISTINCT T2.Hardware_Model_name , T2.Company_name FROM screen_mode AS T1 JOIN phone AS T2 ON T1.Graphics_mode = T2.screen_mode WHERE T1.used_kb BETWEEN 10 AND 15;</SQL_QUERY>
|
phone_1
|
SELECT DISTINCT T2.Hardware_Model_name , T2.Company_name FROM screen_mode AS T1 JOIN phone AS T2 ON T1.Graphics_mode = T2.screen_mode WHERE T1.used_kb BETWEEN 10 AND 15;
|
List the phone hardware model and company name for the phones whose screen usage in kb is between 10 and 15.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the number of phones for each accreditation type.</question>
[SQL]:
|
<SQL_QUERY>SELECT Accreditation_type , count(*) FROM phone GROUP BY Accreditation_type</SQL_QUERY>
|
phone_1
|
SELECT Accreditation_type , count(*) FROM phone GROUP BY Accreditation_type
|
Find the number of phones for each accreditation type.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many phones belongs to each accreditation type?</question>
[SQL]:
|
<SQL_QUERY>SELECT Accreditation_type , count(*) FROM phone GROUP BY Accreditation_type</SQL_QUERY>
|
phone_1
|
SELECT Accreditation_type , count(*) FROM phone GROUP BY Accreditation_type
|
How many phones belongs to each accreditation type?
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the accreditation level that more than 3 phones use.</question>
[SQL]:
|
<SQL_QUERY>SELECT Accreditation_level FROM phone GROUP BY Accreditation_level HAVING count(*) > 3</SQL_QUERY>
|
phone_1
|
SELECT Accreditation_level FROM phone GROUP BY Accreditation_level HAVING count(*) > 3
|
Find the accreditation level that more than 3 phones use.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the details for all chip models.</question>
[SQL]:
|
<SQL_QUERY>SELECT * FROM chip_model</SQL_QUERY>
|
phone_1
|
SELECT * FROM chip_model
|
Find the details for all chip models.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many models do not have the wifi function?</question>
[SQL]:
|
<SQL_QUERY>SELECT count(*) FROM chip_model WHERE wifi = 'No'</SQL_QUERY>
|
phone_1
|
SELECT count(*) FROM chip_model WHERE wifi = 'No'
|
How many models do not have the wifi function?
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>Count the number of chip model that do not have wifi.</question>
[SQL]:
|
<SQL_QUERY>SELECT count(*) FROM chip_model WHERE wifi = 'No'</SQL_QUERY>
|
phone_1
|
SELECT count(*) FROM chip_model WHERE wifi = 'No'
|
Count the number of chip model that do not have wifi.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>List all the model names sorted by their launch year.</question>
[SQL]:
|
<SQL_QUERY>SELECT model_name FROM chip_model ORDER BY launch_year</SQL_QUERY>
|
phone_1
|
SELECT model_name FROM chip_model ORDER BY launch_year
|
List all the model names sorted by their launch year.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the average ram mib size of the chip models that are never used by any phone.</question>
[SQL]:
|
<SQL_QUERY>SELECT avg(RAM_MiB) FROM chip_model WHERE model_name NOT IN (SELECT chip_model FROM phone)</SQL_QUERY>
|
phone_1
|
SELECT avg(RAM_MiB) FROM chip_model WHERE model_name NOT IN (SELECT chip_model FROM phone)
|
Find the average ram mib size of the chip models that are never used by any phone.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the names of the chip models that are not used by any phone with full accreditation type.</question>
[SQL]:
|
<SQL_QUERY>SELECT model_name FROM chip_model EXCEPT SELECT chip_model FROM phone WHERE Accreditation_type = 'Full'</SQL_QUERY>
|
phone_1
|
SELECT model_name FROM chip_model EXCEPT SELECT chip_model FROM phone WHERE Accreditation_type = 'Full'
|
Find the names of the chip models that are not used by any phone with full accreditation type.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);</schema>"
<primary_keys>[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name</primary_keys>"
<foreign_keys>[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the pixels of the screen modes that are used by both phones with full accreditation types and phones with Provisional accreditation types.</question>
[SQL]:
|
<SQL_QUERY>SELECT t1.pixels FROM screen_mode AS t1 JOIN phone AS t2 ON t1.Graphics_mode = t2.screen_mode WHERE t2.Accreditation_type = 'Provisional' INTERSECT SELECT t1.pixels FROM screen_mode AS t1 JOIN phone AS t2 ON t1.Graphics_mode = t2.screen_mode WHERE t2.Accreditation_type = 'Full'</SQL_QUERY>
|
phone_1
|
SELECT t1.pixels FROM screen_mode AS t1 JOIN phone AS t2 ON t1.Graphics_mode = t2.screen_mode WHERE t2.Accreditation_type = 'Provisional' INTERSECT SELECT t1.pixels FROM screen_mode AS t1 JOIN phone AS t2 ON t1.Graphics_mode = t2.screen_mode WHERE t2.Accreditation_type = 'Full'
|
Find the pixels of the screen modes that are used by both phones with full accreditation types and phones with Provisional accreditation types.
|
[Schema (values) (types)]: | phone_1 | chip_model : model_name (text) , launch_year (text) , ram_mib (number) , rom_mib (number) , slots (number) , wifi (text) , bluetooth (text) | screen_mode : graphics_mode (text) , char_cells (text) , pixels (number) , hardware_colours (number) , used_kb (number) , map (text) , type (text) | phone : company_name (text) , hardware_model_name (text) , accreditation_type (number) , accreditation_level (number) , date (number) , chip_model (text) , screen_mode (text);
|
[Primary Keys]: chip_model : model_name, screen_mode : graphics_mode, phone : hardware_model_name
|
[Foreign Keys]: phone : chip_model = chip_model : model_name | phone : screen_mode = screen_mode : graphics_mode
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many countries are there in total?</question>
[SQL]:
|
<SQL_QUERY>SELECT count(*) FROM country</SQL_QUERY>
|
match_season
|
SELECT count(*) FROM country
|
How many countries are there in total?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Count the number of countries.</question>
[SQL]:
|
<SQL_QUERY>SELECT count(*) FROM country</SQL_QUERY>
|
match_season
|
SELECT count(*) FROM country
|
Count the number of countries.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the country name and capital of all countries.</question>
[SQL]:
|
<SQL_QUERY>SELECT Country_name , Capital FROM country</SQL_QUERY>
|
match_season
|
SELECT Country_name , Capital FROM country
|
Show the country name and capital of all countries.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names and capitals of each country?</question>
[SQL]:
|
<SQL_QUERY>SELECT Country_name , Capital FROM country</SQL_QUERY>
|
match_season
|
SELECT Country_name , Capital FROM country
|
What are the names and capitals of each country?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show all official native languages that contain the word "English".</question>
[SQL]:
|
<SQL_QUERY>SELECT Official_native_language FROM country WHERE Official_native_language LIKE "%English%"</SQL_QUERY>
|
match_season
|
SELECT Official_native_language FROM country WHERE Official_native_language LIKE "%English%"
|
Show all official native languages that contain the word "English".
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the official native languages that contain the string "English".</question>
[SQL]:
|
<SQL_QUERY>SELECT Official_native_language FROM country WHERE Official_native_language LIKE "%English%"</SQL_QUERY>
|
match_season
|
SELECT Official_native_language FROM country WHERE Official_native_language LIKE "%English%"
|
What are the official native languages that contain the string "English".
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show all distinct positions of matches.</question>
[SQL]:
|
<SQL_QUERY>SELECT DISTINCT POSITION FROM match_season</SQL_QUERY>
|
match_season
|
SELECT DISTINCT POSITION FROM match_season
|
Show all distinct positions of matches.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the different positions for match season?</question>
[SQL]:
|
<SQL_QUERY>SELECT DISTINCT POSITION FROM match_season</SQL_QUERY>
|
match_season
|
SELECT DISTINCT POSITION FROM match_season
|
What are the different positions for match season?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the players from college UCLA.</question>
[SQL]:
|
<SQL_QUERY>SELECT Player FROM match_season WHERE College = "UCLA"</SQL_QUERY>
|
match_season
|
SELECT Player FROM match_season WHERE College = "UCLA"
|
Show the players from college UCLA.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Who are the players from UCLA?</question>
[SQL]:
|
<SQL_QUERY>SELECT Player FROM match_season WHERE College = "UCLA"</SQL_QUERY>
|
match_season
|
SELECT Player FROM match_season WHERE College = "UCLA"
|
Who are the players from UCLA?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the distinct position of players from college UCLA or Duke.</question>
[SQL]:
|
<SQL_QUERY>SELECT DISTINCT POSITION FROM match_season WHERE College = "UCLA" OR College = "Duke"</SQL_QUERY>
|
match_season
|
SELECT DISTINCT POSITION FROM match_season WHERE College = "UCLA" OR College = "Duke"
|
Show the distinct position of players from college UCLA or Duke.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the different positions of players from UCLA or Duke colleges?</question>
[SQL]:
|
<SQL_QUERY>SELECT DISTINCT POSITION FROM match_season WHERE College = "UCLA" OR College = "Duke"</SQL_QUERY>
|
match_season
|
SELECT DISTINCT POSITION FROM match_season WHERE College = "UCLA" OR College = "Duke"
|
What are the different positions of players from UCLA or Duke colleges?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the draft pick numbers and draft classes of players whose positions are defenders.</question>
[SQL]:
|
<SQL_QUERY>SELECT Draft_Pick_Number , Draft_Class FROM match_season WHERE POSITION = "Defender"</SQL_QUERY>
|
match_season
|
SELECT Draft_Pick_Number , Draft_Class FROM match_season WHERE POSITION = "Defender"
|
Show the draft pick numbers and draft classes of players whose positions are defenders.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the draft pick numbers and draft classes for players who play the Defender position?</question>
[SQL]:
|
<SQL_QUERY>SELECT Draft_Pick_Number , Draft_Class FROM match_season WHERE POSITION = "Defender"</SQL_QUERY>
|
match_season
|
SELECT Draft_Pick_Number , Draft_Class FROM match_season WHERE POSITION = "Defender"
|
What are the draft pick numbers and draft classes for players who play the Defender position?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many distinct teams are involved in match seasons?</question>
[SQL]:
|
<SQL_QUERY>SELECT count(DISTINCT Team) FROM match_season</SQL_QUERY>
|
match_season
|
SELECT count(DISTINCT Team) FROM match_season
|
How many distinct teams are involved in match seasons?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Count the number of different teams involved in match season.</question>
[SQL]:
|
<SQL_QUERY>SELECT count(DISTINCT Team) FROM match_season</SQL_QUERY>
|
match_season
|
SELECT count(DISTINCT Team) FROM match_season
|
Count the number of different teams involved in match season.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the players and the years played.</question>
[SQL]:
|
<SQL_QUERY>SELECT Player , Years_Played FROM player</SQL_QUERY>
|
match_season
|
SELECT Player , Years_Played FROM player
|
Show the players and the years played.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Who are the different players and how many years has each played?</question>
[SQL]:
|
<SQL_QUERY>SELECT Player , Years_Played FROM player</SQL_QUERY>
|
match_season
|
SELECT Player , Years_Played FROM player
|
Who are the different players and how many years has each played?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show all team names.</question>
[SQL]:
|
<SQL_QUERY>SELECT Name FROM Team</SQL_QUERY>
|
match_season
|
SELECT Name FROM Team
|
Show all team names.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of all teams?</question>
[SQL]:
|
<SQL_QUERY>SELECT Name FROM Team</SQL_QUERY>
|
match_season
|
SELECT Name FROM Team
|
What are the names of all teams?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the season, the player, and the name of the country that player belongs to.</question>
[SQL]:
|
<SQL_QUERY>SELECT T2.Season , T2.Player , T1.Country_name FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country</SQL_QUERY>
|
match_season
|
SELECT T2.Season , T2.Player , T1.Country_name FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country
|
Show the season, the player, and the name of the country that player belongs to.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>For each player, what are their name, season, and country that they belong to?</question>
[SQL]:
|
<SQL_QUERY>SELECT T2.Season , T2.Player , T1.Country_name FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country</SQL_QUERY>
|
match_season
|
SELECT T2.Season , T2.Player , T1.Country_name FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country
|
For each player, what are their name, season, and country that they belong to?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Which players are from Indonesia?</question>
[SQL]:
|
<SQL_QUERY>SELECT T2.Player FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T1.Country_name = "Indonesia"</SQL_QUERY>
|
match_season
|
SELECT T2.Player FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T1.Country_name = "Indonesia"
|
Which players are from Indonesia?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Who are the players from Indonesia?</question>
[SQL]:
|
<SQL_QUERY>SELECT T2.Player FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T1.Country_name = "Indonesia"</SQL_QUERY>
|
match_season
|
SELECT T2.Player FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T1.Country_name = "Indonesia"
|
Who are the players from Indonesia?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the distinct positions of the players from a country whose capital is Dublin?</question>
[SQL]:
|
<SQL_QUERY>SELECT DISTINCT T2.Position FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T1.Capital = "Dublin"</SQL_QUERY>
|
match_season
|
SELECT DISTINCT T2.Position FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T1.Capital = "Dublin"
|
What are the distinct positions of the players from a country whose capital is Dublin?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Give the different positions of players who play for the country with the capital Dublin.</question>
[SQL]:
|
<SQL_QUERY>SELECT DISTINCT T2.Position FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T1.Capital = "Dublin"</SQL_QUERY>
|
match_season
|
SELECT DISTINCT T2.Position FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T1.Capital = "Dublin"
|
Give the different positions of players who play for the country with the capital Dublin.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the official languages of the countries of players from Maryland or Duke college?</question>
[SQL]:
|
<SQL_QUERY>SELECT T1.Official_native_language FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T2.College = "Maryland" OR T2.College = "Duke"</SQL_QUERY>
|
match_season
|
SELECT T1.Official_native_language FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T2.College = "Maryland" OR T2.College = "Duke"
|
What are the official languages of the countries of players from Maryland or Duke college?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the official native languages of countries who have players from Maryland or Duke colleges.</question>
[SQL]:
|
<SQL_QUERY>SELECT T1.Official_native_language FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T2.College = "Maryland" OR T2.College = "Duke"</SQL_QUERY>
|
match_season
|
SELECT T1.Official_native_language FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T2.College = "Maryland" OR T2.College = "Duke"
|
Return the official native languages of countries who have players from Maryland or Duke colleges.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many distinct official languages are there among countries of players whose positions are defenders.</question>
[SQL]:
|
<SQL_QUERY>SELECT count(DISTINCT T1.Official_native_language) FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T2.Position = "Defender"</SQL_QUERY>
|
match_season
|
SELECT count(DISTINCT T1.Official_native_language) FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T2.Position = "Defender"
|
How many distinct official languages are there among countries of players whose positions are defenders.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Count the number of different official languages corresponding to countries that players who play Defender are from.</question>
[SQL]:
|
<SQL_QUERY>SELECT count(DISTINCT T1.Official_native_language) FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T2.Position = "Defender"</SQL_QUERY>
|
match_season
|
SELECT count(DISTINCT T1.Official_native_language) FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country WHERE T2.Position = "Defender"
|
Count the number of different official languages corresponding to countries that players who play Defender are from.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the season, the player, and the name of the team that players belong to.</question>
[SQL]:
|
<SQL_QUERY>SELECT T1.Season , T1.Player , T2.Name FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id</SQL_QUERY>
|
match_season
|
SELECT T1.Season , T1.Player , T2.Name FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id
|
Show the season, the player, and the name of the team that players belong to.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Who are the different players, what season do they play in, and what is the name of the team they are on?</question>
[SQL]:
|
<SQL_QUERY>SELECT T1.Season , T1.Player , T2.Name FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id</SQL_QUERY>
|
match_season
|
SELECT T1.Season , T1.Player , T2.Name FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id
|
Who are the different players, what season do they play in, and what is the name of the team they are on?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the positions of the players from the team with name "Ryley Goldner".</question>
[SQL]:
|
<SQL_QUERY>SELECT T1.Position FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = "Ryley Goldner"</SQL_QUERY>
|
match_season
|
SELECT T1.Position FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = "Ryley Goldner"
|
Show the positions of the players from the team with name "Ryley Goldner".
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the positions of players on the team Ryley Goldner.</question>
[SQL]:
|
<SQL_QUERY>SELECT T1.Position FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = "Ryley Goldner"</SQL_QUERY>
|
match_season
|
SELECT T1.Position FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = "Ryley Goldner"
|
Return the positions of players on the team Ryley Goldner.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many distinct colleges are associated with players from the team with name "Columbus Crew".</question>
[SQL]:
|
<SQL_QUERY>SELECT count(DISTINCT T1.College) FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = "Columbus Crew"</SQL_QUERY>
|
match_season
|
SELECT count(DISTINCT T1.College) FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = "Columbus Crew"
|
How many distinct colleges are associated with players from the team with name "Columbus Crew".
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Count the number of different colleges that players who play for Columbus Crew are from.</question>
[SQL]:
|
<SQL_QUERY>SELECT count(DISTINCT T1.College) FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = "Columbus Crew"</SQL_QUERY>
|
match_season
|
SELECT count(DISTINCT T1.College) FROM match_season AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = "Columbus Crew"
|
Count the number of different colleges that players who play for Columbus Crew are from.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the players and years played for players from team "Columbus Crew".</question>
[SQL]:
|
<SQL_QUERY>SELECT T1.Player , T1.Years_Played FROM player AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = "Columbus Crew"</SQL_QUERY>
|
match_season
|
SELECT T1.Player , T1.Years_Played FROM player AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = "Columbus Crew"
|
Show the players and years played for players from team "Columbus Crew".
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the players who played for Columbus Crew, and how many years did each play for?</question>
[SQL]:
|
<SQL_QUERY>SELECT T1.Player , T1.Years_Played FROM player AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = "Columbus Crew"</SQL_QUERY>
|
match_season
|
SELECT T1.Player , T1.Years_Played FROM player AS T1 JOIN team AS T2 ON T1.Team = T2.Team_id WHERE T2.Name = "Columbus Crew"
|
What are the players who played for Columbus Crew, and how many years did each play for?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the position of players and the corresponding number of players.</question>
[SQL]:
|
<SQL_QUERY>SELECT POSITION , COUNT(*) FROM match_season GROUP BY POSITION</SQL_QUERY>
|
match_season
|
SELECT POSITION , COUNT(*) FROM match_season GROUP BY POSITION
|
Show the position of players and the corresponding number of players.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many players played each position?</question>
[SQL]:
|
<SQL_QUERY>SELECT POSITION , COUNT(*) FROM match_season GROUP BY POSITION</SQL_QUERY>
|
match_season
|
SELECT POSITION , COUNT(*) FROM match_season GROUP BY POSITION
|
How many players played each position?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the country names and the corresponding number of players.</question>
[SQL]:
|
<SQL_QUERY>SELECT Country_name , COUNT(*) FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country GROUP BY T1.Country_name</SQL_QUERY>
|
match_season
|
SELECT Country_name , COUNT(*) FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country GROUP BY T1.Country_name
|
Show the country names and the corresponding number of players.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many players are from each country?</question>
[SQL]:
|
<SQL_QUERY>SELECT Country_name , COUNT(*) FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country GROUP BY T1.Country_name</SQL_QUERY>
|
match_season
|
SELECT Country_name , COUNT(*) FROM country AS T1 JOIN match_season AS T2 ON T1.Country_id = T2.Country GROUP BY T1.Country_name
|
How many players are from each country?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return all players sorted by college in ascending alphabetical order.</question>
[SQL]:
|
<SQL_QUERY>SELECT player FROM match_season ORDER BY College ASC</SQL_QUERY>
|
match_season
|
SELECT player FROM match_season ORDER BY College ASC
|
Return all players sorted by college in ascending alphabetical order.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are all the players who played in match season, sorted by college in ascending alphabetical order?</question>
[SQL]:
|
<SQL_QUERY>SELECT player FROM match_season ORDER BY College ASC</SQL_QUERY>
|
match_season
|
SELECT player FROM match_season ORDER BY College ASC
|
What are all the players who played in match season, sorted by college in ascending alphabetical order?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the most common position of players in match seasons.</question>
[SQL]:
|
<SQL_QUERY>SELECT POSITION FROM match_season GROUP BY POSITION ORDER BY count(*) DESC LIMIT 1</SQL_QUERY>
|
match_season
|
SELECT POSITION FROM match_season GROUP BY POSITION ORDER BY count(*) DESC LIMIT 1
|
Show the most common position of players in match seasons.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the position that is most common among players in match seasons?</question>
[SQL]:
|
<SQL_QUERY>SELECT POSITION FROM match_season GROUP BY POSITION ORDER BY count(*) DESC LIMIT 1</SQL_QUERY>
|
match_season
|
SELECT POSITION FROM match_season GROUP BY POSITION ORDER BY count(*) DESC LIMIT 1
|
What is the position that is most common among players in match seasons?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the top 3 most common colleges of players in match seasons.</question>
[SQL]:
|
<SQL_QUERY>SELECT College FROM match_season GROUP BY College ORDER BY count(*) DESC LIMIT 3</SQL_QUERY>
|
match_season
|
SELECT College FROM match_season GROUP BY College ORDER BY count(*) DESC LIMIT 3
|
Show the top 3 most common colleges of players in match seasons.
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
<schema>[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);</schema>"
<primary_keys>[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id</primary_keys>"
<foreign_keys>[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the three colleges from which the most players are from?</question>
[SQL]:
|
<SQL_QUERY>SELECT College FROM match_season GROUP BY College ORDER BY count(*) DESC LIMIT 3</SQL_QUERY>
|
match_season
|
SELECT College FROM match_season GROUP BY College ORDER BY count(*) DESC LIMIT 3
|
What are the three colleges from which the most players are from?
|
[Schema (values) (types)]: | match_season | country : country_id (text) , country_name (number) , capital (text) , official_native_language (text) | team : team_id (text) , name (number) | match_season : season (text) , player (number) , position (text) , country (text) , team (text) , draft_pick_number (number) , draft_class (text) , college (number) | player : player_id (text) , player (number) , years_played (text) , total_wl (text) , singles_wl (text) , doubles_wl (number) , team (text);
|
[Primary Keys]: country : country_id, team : team_id, match_season : season, player : player_id
|
[Foreign Keys]: match_season : team = team : team_id | match_season : country = country : country_id | player : team = team : team_id
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.