Input:
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)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the vote ids, phone numbers and states of all votes.</question>
[SQL]:

Output: <SQL_QUERY>SELECT vote_id ,  phone_number ,  state FROM votes</SQL_QUERY>

Question: SELECT vote_id ,  phone_number ,  state FROM votes

Question: List the vote ids, phone numbers and states of all votes.


Input:
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)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the maximum and minimum values of area codes?</question>
[SQL]:

Output: <SQL_QUERY>SELECT max(area_code) ,  min(area_code) FROM area_code_state</SQL_QUERY>

Question: SELECT max(area_code) ,  min(area_code) FROM area_code_state

Question: What are the maximum and minimum values of area codes?


Input:
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)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is last date created of votes from the state 'CA'?</question>
[SQL]:

Output: <SQL_QUERY>SELECT max(created) FROM votes WHERE state  =  'CA'</SQL_QUERY>

Question: SELECT max(created) FROM votes WHERE state  =  'CA'

Question: What is last date created of votes from the state 'CA'?


Input:
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)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of the contestants whose names are not 'Jessie Alloway'</question>
[SQL]:

Output: <SQL_QUERY>SELECT contestant_name FROM contestants WHERE contestant_name != 'Jessie Alloway'</SQL_QUERY>

Question: SELECT contestant_name FROM contestants WHERE contestant_name != 'Jessie Alloway'

Question: What are the names of the contestants whose names are not 'Jessie Alloway'


Input:
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)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the distinct states and create time of all votes?</question>
[SQL]:

Output: <SQL_QUERY>SELECT DISTINCT state ,  created FROM votes</SQL_QUERY>

Question: SELECT DISTINCT state ,  created FROM votes

Question: What are the distinct states and create time of all votes?


Input:
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)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the contestant numbers and names of the contestants who had at least two votes?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.contestant_number , T1.contestant_name FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number  =  T2.contestant_number GROUP BY T1.contestant_number HAVING count(*)  >=  2</SQL_QUERY>

Question: SELECT T1.contestant_number , T1.contestant_name FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number  =  T2.contestant_number GROUP BY T1.contestant_number HAVING count(*)  >=  2

Question: What are the contestant numbers and names of the contestants who had at least two votes?


Input:
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)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>Of all the contestants who got voted, what is the contestant number and name of the contestant who got least votes?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.contestant_number , T1.contestant_name FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number  =  T2.contestant_number GROUP BY T1.contestant_number ORDER BY count(*) ASC LIMIT 1</SQL_QUERY>

Question: SELECT T1.contestant_number , T1.contestant_name FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number  =  T2.contestant_number GROUP BY T1.contestant_number ORDER BY count(*) ASC LIMIT 1

Question: Of all the contestants who got voted, what is the contestant number and name of the contestant who got least votes?


Input:
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)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the number of votes from state 'NY' or 'CA'?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) FROM votes WHERE state  =  'NY' OR state  =  'CA'</SQL_QUERY>

Question: SELECT count(*) FROM votes WHERE state  =  'NY' OR state  =  'CA'

Question: What are the number of votes from state 'NY' or 'CA'?


Input:
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)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many contestants did not get voted?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) FROM contestants WHERE contestant_number NOT IN ( SELECT contestant_number FROM votes )</SQL_QUERY>

Question: SELECT count(*) FROM contestants WHERE contestant_number NOT IN ( SELECT contestant_number FROM votes )

Question: How many contestants did not get voted?


Input:
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)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the area code in which the most voters voted?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.area_code FROM area_code_state AS T1 JOIN votes AS T2 ON T1.state  =  T2.state GROUP BY T1.area_code ORDER BY count(*) DESC LIMIT 1</SQL_QUERY>

Question: SELECT T1.area_code FROM area_code_state AS T1 JOIN votes AS T2 ON T1.state  =  T2.state GROUP BY T1.area_code ORDER BY count(*) DESC LIMIT 1

Question: What is the area code in which the most voters voted?


Input:
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)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the create dates, states, and phone numbers of the votes that were for the contestant named 'Tabatha Gehling'?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T2.created ,  T2.state ,  T2.phone_number FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number  =  T2.contestant_number WHERE T1.contestant_name  =  'Tabatha Gehling'</SQL_QUERY>

Question: SELECT T2.created ,  T2.state ,  T2.phone_number FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number  =  T2.contestant_number WHERE T1.contestant_name  =  'Tabatha Gehling'

Question: What are the create dates, states, and phone numbers of the votes that were for the contestant named 'Tabatha Gehling'?


Input:
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)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the area codes in which voters voted both for the contestant 'Tabatha Gehling' and the contestant 'Kelly Clauss'.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T3.area_code FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number  =  T2.contestant_number JOIN area_code_state AS T3 ON T2.state  =  T3.state WHERE T1.contestant_name  =  'Tabatha Gehling' INTERSECT SELECT T3.area_code FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number  =  T2.contestant_number JOIN area_code_state AS T3 ON T2.state  =  T3.state WHERE T1.contestant_name  =  'Kelly Clauss'</SQL_QUERY>

Question: SELECT T3.area_code FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number  =  T2.contestant_number JOIN area_code_state AS T3 ON T2.state  =  T3.state WHERE T1.contestant_name  =  'Tabatha Gehling' INTERSECT SELECT T3.area_code FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number  =  T2.contestant_number JOIN area_code_state AS T3 ON T2.state  =  T3.state WHERE T1.contestant_name  =  'Kelly Clauss'

Question: List the area codes in which voters voted both for the contestant 'Tabatha Gehling' and the contestant 'Kelly Clauss'.


Input:
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)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the names of the contestants whose names contain the substring 'Al' .</question>
[SQL]:

Output: <SQL_QUERY>select contestant_name from contestants where contestant_name like "%al%"</SQL_QUERY>

Question: select contestant_name from contestants where contestant_name like "%al%"

Question: Return the names of the contestants whose names contain the substring 'Al' .


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of all the countries that became independent after 1950?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country WHERE IndepYear  >  1950</SQL_QUERY>

Question: SELECT Name FROM country WHERE IndepYear  >  1950

Question: What are the names of all the countries that became independent after 1950?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Give the names of the nations that were founded after 1950.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country WHERE IndepYear  >  1950</SQL_QUERY>

Question: SELECT Name FROM country WHERE IndepYear  >  1950

Question: Give the names of the nations that were founded after 1950.


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many countries have a republic as their form of government?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) FROM country WHERE GovernmentForm  =  "Republic"</SQL_QUERY>

Question: SELECT count(*) FROM country WHERE GovernmentForm  =  "Republic"

Question: How many countries have a republic as their form of government?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many countries have governments that are republics?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) FROM country WHERE GovernmentForm  =  "Republic"</SQL_QUERY>

Question: SELECT count(*) FROM country WHERE GovernmentForm  =  "Republic"

Question: How many countries have governments that are republics?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the total surface area of the countries in the Caribbean region?</question>
[SQL]:

Output: <SQL_QUERY>SELECT sum(SurfaceArea) FROM country WHERE Region  =  "Caribbean"</SQL_QUERY>

Question: SELECT sum(SurfaceArea) FROM country WHERE Region  =  "Caribbean"

Question: What is the total surface area of the countries in the Caribbean region?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>How much surface area do the countires in the Carribean cover together?</question>
[SQL]:

Output: <SQL_QUERY>SELECT sum(SurfaceArea) FROM country WHERE Region  =  "Caribbean"</SQL_QUERY>

Question: SELECT sum(SurfaceArea) FROM country WHERE Region  =  "Caribbean"

Question: How much surface area do the countires in the Carribean cover together?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Which continent is Anguilla in?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Continent FROM country WHERE Name  =  "Anguilla"</SQL_QUERY>

Question: SELECT Continent FROM country WHERE Name  =  "Anguilla"

Question: Which continent is Anguilla in?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the continent name which Anguilla belongs to?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Continent FROM country WHERE Name  =  "Anguilla"</SQL_QUERY>

Question: SELECT Continent FROM country WHERE Name  =  "Anguilla"

Question: What is the continent name which Anguilla belongs to?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Which region is the city Kabul located in?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Region FROM country AS T1 JOIN city AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Name  =  "Kabul"</SQL_QUERY>

Question: SELECT Region FROM country AS T1 JOIN city AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Name  =  "Kabul"

Question: Which region is the city Kabul located in?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What region is Kabul in?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Region FROM country AS T1 JOIN city AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Name  =  "Kabul"</SQL_QUERY>

Question: SELECT Region FROM country AS T1 JOIN city AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Name  =  "Kabul"

Question: What region is Kabul in?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Which language is the most popular in Aruba?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T2.Language FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.Name  =  "Aruba" ORDER BY Percentage DESC LIMIT 1</SQL_QUERY>

Question: SELECT T2.Language FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.Name  =  "Aruba" ORDER BY Percentage DESC LIMIT 1

Question: Which language is the most popular in Aruba?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What language is predominantly spoken in Aruba?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T2.Language FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.Name  =  "Aruba" ORDER BY Percentage DESC LIMIT 1</SQL_QUERY>

Question: SELECT T2.Language FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.Name  =  "Aruba" ORDER BY Percentage DESC LIMIT 1

Question: What language is predominantly spoken in Aruba?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the population and life expectancies in Brazil?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Population ,  LifeExpectancy FROM country WHERE Name  =  "Brazil"</SQL_QUERY>

Question: SELECT Population ,  LifeExpectancy FROM country WHERE Name  =  "Brazil"

Question: What are the population and life expectancies in Brazil?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Give me Brazil’s population and life expectancies.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Population ,  LifeExpectancy FROM country WHERE Name  =  "Brazil"</SQL_QUERY>

Question: SELECT Population ,  LifeExpectancy FROM country WHERE Name  =  "Brazil"

Question: Give me Brazil’s population and life expectancies.


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the region and population of Angola?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Population ,  Region FROM country WHERE Name  =  "Angola"</SQL_QUERY>

Question: SELECT Population ,  Region FROM country WHERE Name  =  "Angola"

Question: What are the region and population of Angola?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What region does Angola belong to and what is its population?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Population ,  Region FROM country WHERE Name  =  "Angola"</SQL_QUERY>

Question: SELECT Population ,  Region FROM country WHERE Name  =  "Angola"

Question: What region does Angola belong to and what is its population?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the average expected life expectancy for countries in the region of Central Africa?</question>
[SQL]:

Output: <SQL_QUERY>SELECT avg(LifeExpectancy) FROM country WHERE Region  =  "Central Africa"</SQL_QUERY>

Question: SELECT avg(LifeExpectancy) FROM country WHERE Region  =  "Central Africa"

Question: What is the average expected life expectancy for countries in the region of Central Africa?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>How long is the people’s average life expectancy in Central Africa?</question>
[SQL]:

Output: <SQL_QUERY>SELECT avg(LifeExpectancy) FROM country WHERE Region  =  "Central Africa"</SQL_QUERY>

Question: SELECT avg(LifeExpectancy) FROM country WHERE Region  =  "Central Africa"

Question: How long is the people’s average life expectancy in Central Africa?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the name of country that has the shortest life expectancy in Asia?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country WHERE Continent  =  "Asia" ORDER BY LifeExpectancy LIMIT 1</SQL_QUERY>

Question: SELECT Name FROM country WHERE Continent  =  "Asia" ORDER BY LifeExpectancy LIMIT 1

Question: What is the name of country that has the shortest life expectancy in Asia?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Give the name of the country in Asia with the lowest life expectancy.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country WHERE Continent  =  "Asia" ORDER BY LifeExpectancy LIMIT 1</SQL_QUERY>

Question: SELECT Name FROM country WHERE Continent  =  "Asia" ORDER BY LifeExpectancy LIMIT 1

Question: Give the name of the country in Asia with the lowest life expectancy.


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the total population and maximum GNP in Asia?</question>
[SQL]:

Output: <SQL_QUERY>SELECT sum(Population) ,  max(GNP) FROM country WHERE Continent  =  "Asia"</SQL_QUERY>

Question: SELECT sum(Population) ,  max(GNP) FROM country WHERE Continent  =  "Asia"

Question: What is the total population and maximum GNP in Asia?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many people live in Asia, and what is the largest GNP among them?</question>
[SQL]:

Output: <SQL_QUERY>SELECT sum(Population) ,  max(GNP) FROM country WHERE Continent  =  "Asia"</SQL_QUERY>

Question: SELECT sum(Population) ,  max(GNP) FROM country WHERE Continent  =  "Asia"

Question: How many people live in Asia, and what is the largest GNP among them?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the average life expectancy in African countries that are republics?</question>
[SQL]:

Output: <SQL_QUERY>SELECT avg(LifeExpectancy) FROM country WHERE Continent  =  "Africa" AND GovernmentForm  =  "Republic"</SQL_QUERY>

Question: SELECT avg(LifeExpectancy) FROM country WHERE Continent  =  "Africa" AND GovernmentForm  =  "Republic"

Question: What is the average life expectancy in African countries that are republics?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Give the average life expectancy for countries in Africa which are republics?</question>
[SQL]:

Output: <SQL_QUERY>SELECT avg(LifeExpectancy) FROM country WHERE Continent  =  "Africa" AND GovernmentForm  =  "Republic"</SQL_QUERY>

Question: SELECT avg(LifeExpectancy) FROM country WHERE Continent  =  "Africa" AND GovernmentForm  =  "Republic"

Question: Give the average life expectancy for countries in Africa which are republics?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the total surface area of the continents Asia and Europe?</question>
[SQL]:

Output: <SQL_QUERY>SELECT sum(SurfaceArea) FROM country WHERE Continent  =  "Asia" OR Continent  =  "Europe"</SQL_QUERY>

Question: SELECT sum(SurfaceArea) FROM country WHERE Continent  =  "Asia" OR Continent  =  "Europe"

Question: What is the total surface area of the continents Asia and Europe?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Give the total surface area covered by countries in Asia or Europe.</question>
[SQL]:

Output: <SQL_QUERY>SELECT sum(SurfaceArea) FROM country WHERE Continent  =  "Asia" OR Continent  =  "Europe"</SQL_QUERY>

Question: SELECT sum(SurfaceArea) FROM country WHERE Continent  =  "Asia" OR Continent  =  "Europe"

Question: Give the total surface area covered by countries in Asia or Europe.


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many people live in Gelderland district?</question>
[SQL]:

Output: <SQL_QUERY>SELECT sum(Population) FROM city WHERE District  =  "Gelderland"</SQL_QUERY>

Question: SELECT sum(Population) FROM city WHERE District  =  "Gelderland"

Question: How many people live in Gelderland district?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the total population of Gelderland district?</question>
[SQL]:

Output: <SQL_QUERY>SELECT sum(Population) FROM city WHERE District  =  "Gelderland"</SQL_QUERY>

Question: SELECT sum(Population) FROM city WHERE District  =  "Gelderland"

Question: What is the total population of Gelderland district?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the average GNP and total population in all nations whose government is US territory?</question>
[SQL]:

Output: <SQL_QUERY>SELECT avg(GNP) ,  sum(population) FROM country WHERE GovernmentForm  =  "US Territory"</SQL_QUERY>

Question: SELECT avg(GNP) ,  sum(population) FROM country WHERE GovernmentForm  =  "US Territory"

Question: What is the average GNP and total population in all nations whose government is US territory?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Give the mean GNP and total population of nations which are considered US territory.</question>
[SQL]:

Output: <SQL_QUERY>SELECT avg(GNP) ,  sum(population) FROM country WHERE GovernmentForm  =  "US Territory"</SQL_QUERY>

Question: SELECT avg(GNP) ,  sum(population) FROM country WHERE GovernmentForm  =  "US Territory"

Question: Give the mean GNP and total population of nations which are considered US territory.


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many unique languages are spoken in the world?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(DISTINCT LANGUAGE) FROM countrylanguage</SQL_QUERY>

Question: SELECT count(DISTINCT LANGUAGE) FROM countrylanguage

Question: How many unique languages are spoken in the world?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the number of distinct languages used around the world?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(DISTINCT LANGUAGE) FROM countrylanguage</SQL_QUERY>

Question: SELECT count(DISTINCT LANGUAGE) FROM countrylanguage

Question: What is the number of distinct languages used around the world?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many type of governments are in Africa?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(DISTINCT GovernmentForm) FROM country WHERE Continent  =  "Africa"</SQL_QUERY>

Question: SELECT count(DISTINCT GovernmentForm) FROM country WHERE Continent  =  "Africa"

Question: How many type of governments are in Africa?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many different forms of governments are there in Africa?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(DISTINCT GovernmentForm) FROM country WHERE Continent  =  "Africa"</SQL_QUERY>

Question: SELECT count(DISTINCT GovernmentForm) FROM country WHERE Continent  =  "Africa"

Question: How many different forms of governments are there in Africa?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the total number of languages used in Aruba?</question>
[SQL]:

Output: <SQL_QUERY>SELECT COUNT(T2.Language) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.Name  =  "Aruba"</SQL_QUERY>

Question: SELECT COUNT(T2.Language) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.Name  =  "Aruba"

Question: What is the total number of languages used in Aruba?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many languages are spoken in Aruba?</question>
[SQL]:

Output: <SQL_QUERY>SELECT COUNT(T2.Language) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.Name  =  "Aruba"</SQL_QUERY>

Question: SELECT COUNT(T2.Language) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.Name  =  "Aruba"

Question: How many languages are spoken in Aruba?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many official languages does Afghanistan have?</question>
[SQL]:

Output: <SQL_QUERY>SELECT COUNT(*) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.Name  =  "Afghanistan" AND IsOfficial  =  "T"</SQL_QUERY>

Question: SELECT COUNT(*) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.Name  =  "Afghanistan" AND IsOfficial  =  "T"

Question: How many official languages does Afghanistan have?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many official languages are spoken in Afghanistan?</question>
[SQL]:

Output: <SQL_QUERY>SELECT COUNT(*) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.Name  =  "Afghanistan" AND IsOfficial  =  "T"</SQL_QUERY>

Question: SELECT COUNT(*) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.Name  =  "Afghanistan" AND IsOfficial  =  "T"

Question: How many official languages are spoken in Afghanistan?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is name of the country that speaks the largest number of languages?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode GROUP BY T1.Name ORDER BY COUNT(*) DESC LIMIT 1</SQL_QUERY>

Question: SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode GROUP BY T1.Name ORDER BY COUNT(*) DESC LIMIT 1

Question: What is name of the country that speaks the largest number of languages?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Give the name of the nation that uses the greatest amount of languages.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode GROUP BY T1.Name ORDER BY COUNT(*) DESC LIMIT 1</SQL_QUERY>

Question: SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode GROUP BY T1.Name ORDER BY COUNT(*) DESC LIMIT 1

Question: Give the name of the nation that uses the greatest amount of languages.


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Which continent has the most diverse languages?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Continent FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode GROUP BY T1.Continent ORDER BY COUNT(*) DESC LIMIT 1</SQL_QUERY>

Question: SELECT T1.Continent FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode GROUP BY T1.Continent ORDER BY COUNT(*) DESC LIMIT 1

Question: Which continent has the most diverse languages?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Which continent speaks the most languages?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Continent FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode GROUP BY T1.Continent ORDER BY COUNT(*) DESC LIMIT 1</SQL_QUERY>

Question: SELECT T1.Continent FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode GROUP BY T1.Continent ORDER BY COUNT(*) DESC LIMIT 1

Question: Which continent speaks the most languages?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many countries speak both English and Dutch?</question>
[SQL]:

Output: <SQL_QUERY>SELECT COUNT(*) FROM (SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" INTERSECT SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "Dutch")</SQL_QUERY>

Question: SELECT COUNT(*) FROM (SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" INTERSECT SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "Dutch")

Question: How many countries speak both English and Dutch?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the number of nations that use English and Dutch?</question>
[SQL]:

Output: <SQL_QUERY>SELECT COUNT(*) FROM (SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" INTERSECT SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "Dutch")</SQL_QUERY>

Question: SELECT COUNT(*) FROM (SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" INTERSECT SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "Dutch")

Question: What is the number of nations that use English and Dutch?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of nations speak both English and French?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" INTERSECT SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "French"</SQL_QUERY>

Question: SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" INTERSECT SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "French"

Question: What are the names of nations speak both English and French?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Give the names of nations that speak both English and French.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" INTERSECT SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "French"</SQL_QUERY>

Question: SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" INTERSECT SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "French"

Question: Give the names of nations that speak both English and French.


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of nations where both English and French are official languages?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" AND T2.IsOfficial  =  "T" INTERSECT SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "French" AND T2.IsOfficial  =  "T"</SQL_QUERY>

Question: SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" AND T2.IsOfficial  =  "T" INTERSECT SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "French" AND T2.IsOfficial  =  "T"

Question: What are the names of nations where both English and French are official languages?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Give the names of countries with English and French as official languages.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" AND T2.IsOfficial  =  "T" INTERSECT SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "French" AND T2.IsOfficial  =  "T"</SQL_QUERY>

Question: SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" AND T2.IsOfficial  =  "T" INTERSECT SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "French" AND T2.IsOfficial  =  "T"

Question: Give the names of countries with English and French as official languages.


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the number of distinct continents where Chinese is spoken?</question>
[SQL]:

Output: <SQL_QUERY>SELECT COUNT( DISTINCT Continent) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "Chinese"</SQL_QUERY>

Question: SELECT COUNT( DISTINCT Continent) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "Chinese"

Question: What is the number of distinct continents where Chinese is spoken?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many continents speak Chinese?</question>
[SQL]:

Output: <SQL_QUERY>SELECT COUNT( DISTINCT Continent) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "Chinese"</SQL_QUERY>

Question: SELECT COUNT( DISTINCT Continent) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "Chinese"

Question: How many continents speak Chinese?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the regions that use English or Dutch?</question>
[SQL]:

Output: <SQL_QUERY>SELECT DISTINCT T1.Region FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" OR T2.Language  =  "Dutch"</SQL_QUERY>

Question: SELECT DISTINCT T1.Region FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" OR T2.Language  =  "Dutch"

Question: What are the regions that use English or Dutch?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>Which regions speak Dutch or English?</question>
[SQL]:

Output: <SQL_QUERY>SELECT DISTINCT T1.Region FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" OR T2.Language  =  "Dutch"</SQL_QUERY>

Question: SELECT DISTINCT T1.Region FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" OR T2.Language  =  "Dutch"

Question: Which regions speak Dutch or English?


Input:
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)]: | world_1 |  city : id (text) , name (number) , countrycode (text) , district (text) , population (text) | sqlite_sequence : name (text) , seq (number) | country : code (text) , name (number) , continent (text) , region (text) , surfacearea (text) , indepyear (number) , population (text) , lifeexpectancy (text) , gnp (text) , gnpold (text) , localname (text) , governmentform (text) , headofstate (number) , capital (number) , code2 (number) | countrylanguage : countrycode (text) , language (number) , isofficial (text) , percentage (text);</schema>"
<primary_keys>[Primary Keys]: city : id, sqlite_sequence : code, country : countrycode</primary_keys>"
<foreign_keys>[Foreign Keys]: city : countrycode = country : code | countrylanguage : countrycode = country : code</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the countries where either English or Dutch is the official language ?</question>
[SQL]:

Output: <SQL_QUERY>select t1.name from country as t1 join countrylanguage as t2 on t1.code  =  t2.countrycode where t2.language  =  "english" and isofficial  =  "t" union select t1.name from country as t1 join countrylanguage as t2 on t1.code  =  t2.countrycode where t2.language  =  "dutch" and isofficial  =  "t"</SQL_QUERY>

Question: select t1.name from country as t1 join countrylanguage as t2 on t1.code  =  t2.countrycode where t2.language  =  "english" and isofficial  =  "t" union select t1.name from country as t1 join countrylanguage as t2 on t1.code  =  t2.countrycode where t2.language  =  "dutch" and isofficial  =  "t"

Question: What are the countries where either English or Dutch is the official language ?