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 countries have either English or Dutch as an official language?</question>
[SQL]:

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

Question: SELECT * FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" AND IsOfficial  =  "T" UNION SELECT * FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "Dutch" AND IsOfficial  =  "T"

Question: Which countries have either English or Dutch as an official language?


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 on the Asian continent?</question>
[SQL]:

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

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

Question: Which language is the most popular on the Asian continent?


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 language that is used by the largest number of Asian nations?</question>
[SQL]:

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

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

Question: What is the language that is used by the largest number of Asian nations?


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 languages are spoken by only one country in republic governments?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T2.Language FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.GovernmentForm  =  "Republic" GROUP BY T2.Language HAVING COUNT(*)  =  1</SQL_QUERY>

Question: SELECT T2.Language FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.GovernmentForm  =  "Republic" GROUP BY T2.Language HAVING COUNT(*)  =  1

Question: Which languages are spoken by only one country in republic governments?


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 languages are only used by a single country with a republic government?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T2.Language FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.GovernmentForm  =  "Republic" GROUP BY T2.Language HAVING COUNT(*)  =  1</SQL_QUERY>

Question: SELECT T2.Language FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.GovernmentForm  =  "Republic" GROUP BY T2.Language HAVING COUNT(*)  =  1

Question: What languages are only used by a single country with a republic 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>Find the city with the largest population that uses English.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name ,  T1.Population FROM city AS T1 JOIN countrylanguage AS T2 ON T1.CountryCode  =  T2.CountryCode WHERE T2.Language  =  "English" ORDER BY T1.Population DESC LIMIT 1</SQL_QUERY>

Question: SELECT T1.Name ,  T1.Population FROM city AS T1 JOIN countrylanguage AS T2 ON T1.CountryCode  =  T2.CountryCode WHERE T2.Language  =  "English" ORDER BY T1.Population DESC LIMIT 1

Question: Find the city with the largest population that uses 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 is the most populace city that speaks English?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name ,  T1.Population FROM city AS T1 JOIN countrylanguage AS T2 ON T1.CountryCode  =  T2.CountryCode WHERE T2.Language  =  "English" ORDER BY T1.Population DESC LIMIT 1</SQL_QUERY>

Question: SELECT T1.Name ,  T1.Population FROM city AS T1 JOIN countrylanguage AS T2 ON T1.CountryCode  =  T2.CountryCode WHERE T2.Language  =  "English" ORDER BY T1.Population DESC LIMIT 1

Question: What is the most populace city that speaks 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>Find the name, population and expected life length of asian country with the largest area?</question>
[SQL]:

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

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

Question: Find the name, population and expected life length of asian country with the largest area?


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 name, population, and life expectancy of the largest Asian country by land?</question>
[SQL]:

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

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

Question: What are the name, population, and life expectancy of the largest Asian country by land?


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 average life expectancy in the countries where English is not the official language?</question>
[SQL]:

Output: <SQL_QUERY>SELECT avg(LifeExpectancy) FROM country WHERE Name NOT IN (SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" AND T2.IsOfficial  =  "T")</SQL_QUERY>

Question: SELECT avg(LifeExpectancy) FROM country WHERE Name NOT IN (SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" AND T2.IsOfficial  =  "T")

Question: What is average life expectancy in the countries where English is not the official language?


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 life expectancy of countries in which English is not the official language.</question>
[SQL]:

Output: <SQL_QUERY>SELECT avg(LifeExpectancy) FROM country WHERE Name NOT IN (SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" AND T2.IsOfficial  =  "T")</SQL_QUERY>

Question: SELECT avg(LifeExpectancy) FROM country WHERE Name NOT IN (SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English" AND T2.IsOfficial  =  "T")

Question: Give the mean life expectancy of countries in which English is not the official language.


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 people living in the nations that do not use English?</question>
[SQL]:

Output: <SQL_QUERY>SELECT sum(Population) FROM country WHERE Name NOT IN (SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English")</SQL_QUERY>

Question: SELECT sum(Population) FROM country WHERE Name NOT IN (SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English")

Question: What is the total number of people living in the nations that do not use 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>How many people live in countries that do not speak English?</question>
[SQL]:

Output: <SQL_QUERY>SELECT sum(Population) FROM country WHERE Name NOT IN (SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English")</SQL_QUERY>

Question: SELECT sum(Population) FROM country WHERE Name NOT IN (SELECT T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T2.Language  =  "English")

Question: How many people live in countries that do not speak 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 is the official language spoken in the country whose head of state is Beatrix?</question>
[SQL]:

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

Question: SELECT T2.Language FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.HeadOfState  =  "Beatrix" AND T2.IsOfficial  =  "T"

Question: What is the official language spoken in the country whose head of state is Beatrix?


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 official language used in the country the name of whose head of state is Beatrix.</question>
[SQL]:

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

Question: SELECT T2.Language FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE T1.HeadOfState  =  "Beatrix" AND T2.IsOfficial  =  "T"

Question: What is the official language used in the country the name of whose head of state is Beatrix.


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 unique official languages spoken in the countries that are founded before 1930?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(DISTINCT T2.Language) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE  IndepYear  <  1930 AND T2.IsOfficial  =  "T"</SQL_QUERY>

Question: SELECT count(DISTINCT T2.Language) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE  IndepYear  <  1930 AND T2.IsOfficial  =  "T"

Question: What is the total number of unique official languages spoken in the countries that are founded before 1930?


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>For the countries founded before 1930, what is the total number of distinct official languages?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(DISTINCT T2.Language) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE  IndepYear  <  1930 AND T2.IsOfficial  =  "T"</SQL_QUERY>

Question: SELECT count(DISTINCT T2.Language) FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode WHERE  IndepYear  <  1930 AND T2.IsOfficial  =  "T"

Question: For the countries founded before 1930, what is the total number of distinct 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 are the countries that have greater surface area than any country in Europe?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country WHERE SurfaceArea  >  (SELECT min(SurfaceArea) FROM country WHERE Continent  =  "Europe")</SQL_QUERY>

Question: SELECT Name FROM country WHERE SurfaceArea  >  (SELECT min(SurfaceArea) FROM country WHERE Continent  =  "Europe")

Question: What are the countries that have greater surface area than any country in 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>Which countries have greater area than that of any country in Europe?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country WHERE SurfaceArea  >  (SELECT min(SurfaceArea) FROM country WHERE Continent  =  "Europe")</SQL_QUERY>

Question: SELECT Name FROM country WHERE SurfaceArea  >  (SELECT min(SurfaceArea) FROM country WHERE Continent  =  "Europe")

Question: Which countries have greater area than that of any country in 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>What are the African countries that have a  population less than any country in Asia?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country WHERE Continent  =  "Africa"  AND population  <  (SELECT max(population) FROM country WHERE Continent  =  "Asia")</SQL_QUERY>

Question: SELECT Name FROM country WHERE Continent  =  "Africa"  AND population  <  (SELECT max(population) FROM country WHERE Continent  =  "Asia")

Question: What are the African countries that have a  population less than any country 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>Which African countries have a smaller population than that of any country in Asia?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country WHERE Continent  =  "Africa"  AND population  <  (SELECT min(population) FROM country WHERE Continent  =  "Asia")</SQL_QUERY>

Question: SELECT Name FROM country WHERE Continent  =  "Africa"  AND population  <  (SELECT min(population) FROM country WHERE Continent  =  "Asia")

Question: Which African countries have a smaller population than that of any country 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>Which Asian countries have a population that is larger than any country in Africa?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country WHERE Continent  =  "Asia"  AND population  >  (SELECT max(population) FROM country WHERE Continent  =  "Africa")</SQL_QUERY>

Question: SELECT Name FROM country WHERE Continent  =  "Asia"  AND population  >  (SELECT max(population) FROM country WHERE Continent  =  "Africa")

Question: Which Asian countries have a population that is larger than any country 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 are the Asian countries which have a population larger than that of any country in Africa?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country WHERE Continent  =  "Asia"  AND population  >  (SELECT min(population) FROM country WHERE Continent  =  "Africa")</SQL_QUERY>

Question: SELECT Name FROM country WHERE Continent  =  "Asia"  AND population  >  (SELECT min(population) FROM country WHERE Continent  =  "Africa")

Question: What are the Asian countries which have a population larger than that of any country 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 are the country codes for countries that do not speak English?</question>
[SQL]:

Output: <SQL_QUERY>SELECT CountryCode FROM countrylanguage EXCEPT SELECT CountryCode FROM countrylanguage WHERE LANGUAGE  =  "English"</SQL_QUERY>

Question: SELECT CountryCode FROM countrylanguage EXCEPT SELECT CountryCode FROM countrylanguage WHERE LANGUAGE  =  "English"

Question: What are the country codes for countries that do not speak 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>Return the country codes for countries that do not speak English.</question>
[SQL]:

Output: <SQL_QUERY>SELECT CountryCode FROM countrylanguage EXCEPT SELECT CountryCode FROM countrylanguage WHERE LANGUAGE  =  "English"</SQL_QUERY>

Question: SELECT CountryCode FROM countrylanguage EXCEPT SELECT CountryCode FROM countrylanguage WHERE LANGUAGE  =  "English"

Question: Return the country codes for countries that do not speak 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 country codes of countries where people use languages other than English?</question>
[SQL]:

Output: <SQL_QUERY>SELECT DISTINCT CountryCode FROM countrylanguage WHERE LANGUAGE != "English"</SQL_QUERY>

Question: SELECT DISTINCT CountryCode FROM countrylanguage WHERE LANGUAGE != "English"

Question: What are the country codes of countries where people use languages other than 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>Give the country codes for countries in which people speak langauges that are not English.</question>
[SQL]:

Output: <SQL_QUERY>SELECT DISTINCT CountryCode FROM countrylanguage WHERE LANGUAGE != "English"</SQL_QUERY>

Question: SELECT DISTINCT CountryCode FROM countrylanguage WHERE LANGUAGE != "English"

Question: Give the country codes for countries in which people speak langauges that are not 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 codes of the countries that do not speak English and whose government forms are not Republic?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Code FROM country WHERE GovernmentForm != "Republic" EXCEPT SELECT CountryCode FROM countrylanguage WHERE LANGUAGE  =  "English"</SQL_QUERY>

Question: SELECT Code FROM country WHERE GovernmentForm != "Republic" EXCEPT SELECT CountryCode FROM countrylanguage WHERE LANGUAGE  =  "English"

Question: What are the codes of the countries that do not speak English and whose government forms are not Republic?


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>Return the codes of countries that do not speak English and do not have Republics for governments.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Code FROM country WHERE GovernmentForm != "Republic" EXCEPT SELECT CountryCode FROM countrylanguage WHERE LANGUAGE  =  "English"</SQL_QUERY>

Question: SELECT Code FROM country WHERE GovernmentForm != "Republic" EXCEPT SELECT CountryCode FROM countrylanguage WHERE LANGUAGE  =  "English"

Question: Return the codes of countries that do not speak English and do not have Republics for governments.


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 cities are in European countries where English is not the official language?</question>
[SQL]:

Output: <SQL_QUERY>SELECT DISTINCT T2.Name FROM country AS T1 JOIN city AS T2 ON T2.CountryCode  =  T1.Code WHERE T1.Continent  =  'Europe' AND T1.Name NOT IN (SELECT T3.Name FROM country AS T3 JOIN countrylanguage AS T4 ON T3.Code  =  T4.CountryCode WHERE T4.IsOfficial  =  'T' AND T4.Language  =  'English')</SQL_QUERY>

Question: SELECT DISTINCT T2.Name FROM country AS T1 JOIN city AS T2 ON T2.CountryCode  =  T1.Code WHERE T1.Continent  =  'Europe' AND T1.Name NOT IN (SELECT T3.Name FROM country AS T3 JOIN countrylanguage AS T4 ON T3.Code  =  T4.CountryCode WHERE T4.IsOfficial  =  'T' AND T4.Language  =  'English')

Question: Which cities are in European countries where English is not the official language?


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 cities in Europe for which English is not the official language?</question>
[SQL]:

Output: <SQL_QUERY>SELECT DISTINCT T2.Name FROM country AS T1 JOIN city AS T2 ON T2.CountryCode  =  T1.Code WHERE T1.Continent  =  'Europe' AND T1.Name NOT IN (SELECT T3.Name FROM country AS T3 JOIN countrylanguage AS T4 ON T3.Code  =  T4.CountryCode WHERE T4.IsOfficial  =  'T' AND T4.Language  =  'English')</SQL_QUERY>

Question: SELECT DISTINCT T2.Name FROM country AS T1 JOIN city AS T2 ON T2.CountryCode  =  T1.Code WHERE T1.Continent  =  'Europe' AND T1.Name NOT IN (SELECT T3.Name FROM country AS T3 JOIN countrylanguage AS T4 ON T3.Code  =  T4.CountryCode WHERE T4.IsOfficial  =  'T' AND T4.Language  =  'English')

Question: What are the names of cities in Europe for which English is not the official language?


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 unique cities are in Asian countries where Chinese is the official language ?</question>
[SQL]:

Output: <SQL_QUERY>select distinct t3.name from country as t1 join countrylanguage as t2 on t1.code  =  t2.countrycode join city as t3 on t1.code  =  t3.countrycode where t2.isofficial  =  't' and t2.language  =  'chinese' and t1.continent  =  "asia"</SQL_QUERY>

Question: select distinct t3.name from country as t1 join countrylanguage as t2 on t1.code  =  t2.countrycode join city as t3 on t1.code  =  t3.countrycode where t2.isofficial  =  't' and t2.language  =  'chinese' and t1.continent  =  "asia"

Question: Which unique cities are in Asian countries where Chinese is the official language ?


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>Return the different names of cities that are in Asia and for which Chinese is the official language.</question>
[SQL]:

Output: <SQL_QUERY>SELECT DISTINCT T3.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode JOIN city AS T3 ON T1.Code  =  T3.CountryCode WHERE T2.IsOfficial  =  'T' AND T2.Language  =  'Chinese' AND T1.Continent  =  "Asia"</SQL_QUERY>

Question: SELECT DISTINCT T3.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode JOIN city AS T3 ON T1.Code  =  T3.CountryCode WHERE T2.IsOfficial  =  'T' AND T2.Language  =  'Chinese' AND T1.Continent  =  "Asia"

Question: Return the different names of cities that are in Asia and for which Chinese is the official language.


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 name, independence year, and surface area of the country with the smallest population?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name ,  SurfaceArea ,  IndepYear FROM country ORDER BY Population LIMIT 1</SQL_QUERY>

Question: SELECT Name ,  SurfaceArea ,  IndepYear FROM country ORDER BY Population LIMIT 1

Question: What are the name, independence year, and surface area of the country with the smallest 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>Give the name, year of independence, and surface area of the country that has the lowest population.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name ,  SurfaceArea ,  IndepYear FROM country ORDER BY Population LIMIT 1</SQL_QUERY>

Question: SELECT Name ,  SurfaceArea ,  IndepYear FROM country ORDER BY Population LIMIT 1

Question: Give the name, year of independence, and surface area of the country that has the lowest 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 are the population, name and leader of the country with the largest area?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name ,  population ,  HeadOfState FROM country ORDER BY SurfaceArea DESC LIMIT 1</SQL_QUERY>

Question: SELECT Name ,  population ,  HeadOfState FROM country ORDER BY SurfaceArea DESC LIMIT 1

Question: What are the population, name and leader of the country with the largest area?


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, population, and head of state for the country that has the largest area.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name ,  population ,  HeadOfState FROM country ORDER BY SurfaceArea DESC LIMIT 1</SQL_QUERY>

Question: SELECT Name ,  population ,  HeadOfState FROM country ORDER BY SurfaceArea DESC LIMIT 1

Question: Give the name, population, and head of state for the country that has the largest area.


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>Return the country name and the numbers of languages spoken for each country that speaks at least 3 languages.</question>
[SQL]:

Output: <SQL_QUERY>SELECT COUNT(T2.Language) ,  T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode GROUP BY T1.Name HAVING COUNT(*)  >  2</SQL_QUERY>

Question: SELECT COUNT(T2.Language) ,  T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode GROUP BY T1.Name HAVING COUNT(*)  >  2

Question: Return the country name and the numbers of languages spoken for each country that speaks at least 3 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 are the names of countries that speak more than 2 languages, as well as how many languages they speak?</question>
[SQL]:

Output: <SQL_QUERY>SELECT COUNT(T2.Language) ,  T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode GROUP BY T1.Name HAVING COUNT(*)  >  2</SQL_QUERY>

Question: SELECT COUNT(T2.Language) ,  T1.Name FROM country AS T1 JOIN countrylanguage AS T2 ON T1.Code  =  T2.CountryCode GROUP BY T1.Name HAVING COUNT(*)  >  2

Question: What are the names of countries that speak more than 2 languages, as well as how many languages they speak?


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>Find the number of cities in each district whose population is greater than the average population of cities?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) ,  District FROM city WHERE Population  >  (SELECT avg(Population) FROM city) GROUP BY District</SQL_QUERY>

Question: SELECT count(*) ,  District FROM city WHERE Population  >  (SELECT avg(Population) FROM city) GROUP BY District

Question: Find the number of cities in each district whose population is greater than the average population of cities?


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 cities in each district have a population that is above the average population across all cities?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) ,  District FROM city WHERE Population  >  (SELECT avg(Population) FROM city) GROUP BY District</SQL_QUERY>

Question: SELECT count(*) ,  District FROM city WHERE Population  >  (SELECT avg(Population) FROM city) GROUP BY District

Question: How many cities in each district have a population that is above the average population across all cities?


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>Find the government form name and total population for each government form whose average life expectancy is longer than 72.</question>
[SQL]:

Output: <SQL_QUERY>SELECT sum(Population) ,  GovernmentForm FROM country GROUP BY GovernmentForm HAVING avg(LifeExpectancy)  >  72</SQL_QUERY>

Question: SELECT sum(Population) ,  GovernmentForm FROM country GROUP BY GovernmentForm HAVING avg(LifeExpectancy)  >  72

Question: Find the government form name and total population for each government form whose average life expectancy is longer than 72.


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 different government forms and what is the total population of each for government forms that have an average life expectancy greater than 72?</question>
[SQL]:

Output: <SQL_QUERY>SELECT sum(Population) ,  GovernmentForm FROM country GROUP BY GovernmentForm HAVING avg(LifeExpectancy)  >  72</SQL_QUERY>

Question: SELECT sum(Population) ,  GovernmentForm FROM country GROUP BY GovernmentForm HAVING avg(LifeExpectancy)  >  72

Question: What are the different government forms and what is the total population of each for government forms that have an average life expectancy greater than 72?


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>Find the average life expectancy and total population for each continent where the average life expectancy is shorter than 72?</question>
[SQL]:

Output: <SQL_QUERY>SELECT sum(Population) ,  avg(LifeExpectancy) ,  Continent FROM country GROUP BY Continent HAVING avg(LifeExpectancy)  <  72</SQL_QUERY>

Question: SELECT sum(Population) ,  avg(LifeExpectancy) ,  Continent FROM country GROUP BY Continent HAVING avg(LifeExpectancy)  <  72

Question: Find the average life expectancy and total population for each continent where the average life expectancy is shorter than 72?


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 different continents and the total popuation and average life expectancy corresponding to each, for continents that have an average life expectancy less than 72?</question>
[SQL]:

Output: <SQL_QUERY>SELECT sum(Population) ,  avg(LifeExpectancy) ,  Continent FROM country GROUP BY Continent HAVING avg(LifeExpectancy)  <  72</SQL_QUERY>

Question: SELECT sum(Population) ,  avg(LifeExpectancy) ,  Continent FROM country GROUP BY Continent HAVING avg(LifeExpectancy)  <  72

Question: What are the different continents and the total popuation and average life expectancy corresponding to each, for continents that have an average life expectancy less than 72?


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 and areas of countries with the top 5 largest area?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name ,  SurfaceArea FROM country ORDER BY SurfaceArea DESC LIMIT 5</SQL_QUERY>

Question: SELECT Name ,  SurfaceArea FROM country ORDER BY SurfaceArea DESC LIMIT 5

Question: What are the names and areas of countries with the top 5 largest area?


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>Return the names and surface areas of the 5 largest countries.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name ,  SurfaceArea FROM country ORDER BY SurfaceArea DESC LIMIT 5</SQL_QUERY>

Question: SELECT Name ,  SurfaceArea FROM country ORDER BY SurfaceArea DESC LIMIT 5

Question: Return the names and surface areas of the 5 largest countries.


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 names of countries with the top 3 largest population?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country ORDER BY Population DESC LIMIT 3</SQL_QUERY>

Question: SELECT Name FROM country ORDER BY Population DESC LIMIT 3

Question: What are names of countries with the top 3 largest 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>Return the names of the 3 most populated countries.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country ORDER BY Population DESC LIMIT 3</SQL_QUERY>

Question: SELECT Name FROM country ORDER BY Population DESC LIMIT 3

Question: Return the names of the 3 most populated countries.


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 the nations with the 3 lowest populations?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country ORDER BY Population ASC LIMIT 3</SQL_QUERY>

Question: SELECT Name FROM country ORDER BY Population ASC LIMIT 3

Question: What are the names of the nations with the 3 lowest populations?


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>Return the names of the 3 countries with the fewest people.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country ORDER BY Population ASC LIMIT 3</SQL_QUERY>

Question: SELECT Name FROM country ORDER BY Population ASC LIMIT 3

Question: Return the names of the 3 countries with the fewest people.


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 are in Asia?</question>
[SQL]:

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

Question: SELECT count(*) FROM country WHERE continent  =  "Asia"

Question: how many countries are 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>Count the number of countries in Asia.</question>
[SQL]:

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

Question: SELECT count(*) FROM country WHERE continent  =  "Asia"

Question: Count the number of countries 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>What are the names of the countries that are in the continent of Europe and have a population of 80000?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country WHERE continent  =  "Europe" AND Population  =  "80000"</SQL_QUERY>

Question: SELECT Name FROM country WHERE continent  =  "Europe" AND Population  =  "80000"

Question: What are the names of the countries that are in the continent of Europe and have a population of 80000?


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 that are in Europe and have a population equal to 80000.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM country WHERE continent  =  "Europe" AND Population  =  "80000"</SQL_QUERY>

Question: SELECT Name FROM country WHERE continent  =  "Europe" AND Population  =  "80000"

Question: Give the names of countries that are in Europe and have a population equal to 80000.


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 average area of countries in the continent of North America whose area is bigger than 3000 ?</question>
[SQL]:

Output: <SQL_QUERY>select sum(population) ,  avg(surfacearea) from country where continent  =  "north america" and surfacearea  >  3000</SQL_QUERY>

Question: select sum(population) ,  avg(surfacearea) from country where continent  =  "north america" and surfacearea  >  3000

Question: What is the total population and average area of countries in the continent of North America whose area is bigger than 3000 ?


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 population and average surface area corresponding to countries in North America that have a surface area greater than 3000 .</question>
[SQL]:

Output: <SQL_QUERY>select sum(population) ,  avg(surfacearea) from country where continent  =  "north america" and surfacearea  >  3000</SQL_QUERY>

Question: select sum(population) ,  avg(surfacearea) from country where continent  =  "north america" and surfacearea  >  3000

Question: Give the total population and average surface area corresponding to countries in North America that have a surface area greater than 3000 .


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 cities whose population is between 160000 and 900000?</question>
[SQL]:

Output: <SQL_QUERY>SELECT name FROM city WHERE Population BETWEEN 160000 AND 900000</SQL_QUERY>

Question: SELECT name FROM city WHERE Population BETWEEN 160000 AND 900000

Question: What are the cities whose population is between 160000 and 900000?


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>Return the names of cities that have a population between 160000 and 900000 .</question>
[SQL]:

Output: <SQL_QUERY>select name from city where population between 160000 and 900000</SQL_QUERY>

Question: select name from city where population between 160000 and 900000

Question: Return the names of cities that have a population between 160000 and 900000 .


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 spoken by the largest number of countries?</question>
[SQL]:

Output: <SQL_QUERY>SELECT LANGUAGE FROM countrylanguage GROUP BY LANGUAGE ORDER BY count(*) DESC LIMIT 1</SQL_QUERY>

Question: SELECT LANGUAGE FROM countrylanguage GROUP BY LANGUAGE ORDER BY count(*) DESC LIMIT 1

Question: Which language is spoken by the largest number of countries?


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 language that is spoken in the most countries.</question>
[SQL]:

Output: <SQL_QUERY>SELECT LANGUAGE FROM countrylanguage GROUP BY LANGUAGE ORDER BY count(*) DESC LIMIT 1</SQL_QUERY>

Question: SELECT LANGUAGE FROM countrylanguage GROUP BY LANGUAGE ORDER BY count(*) DESC LIMIT 1

Question: Give the language that is spoken in the most countries.