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 spoken by the largest percentage of people in each country?</question>
[SQL]:

Output: <SQL_QUERY>SELECT LANGUAGE ,  CountryCode ,  max(Percentage) FROM countrylanguage GROUP BY CountryCode</SQL_QUERY>

Question: SELECT LANGUAGE ,  CountryCode ,  max(Percentage) FROM countrylanguage GROUP BY CountryCode

Question: What is the language spoken by the largest percentage of people in each country?


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 the different countries, and what are the languages spoken by the greatest percentage of people for each?</question>
[SQL]:

Output: <SQL_QUERY>SELECT LANGUAGE ,  CountryCode ,  max(Percentage) FROM countrylanguage GROUP BY CountryCode</SQL_QUERY>

Question: SELECT LANGUAGE ,  CountryCode ,  max(Percentage) FROM countrylanguage GROUP BY CountryCode

Question: What are the country codes of the different countries, and what are the languages spoken by the greatest percentage of people for each?


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 countries where Spanish is spoken by the largest percentage of people?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) ,   max(Percentage) FROM countrylanguage WHERE LANGUAGE  =  "Spanish" GROUP BY CountryCode</SQL_QUERY>

Question: SELECT count(*) ,   max(Percentage) FROM countrylanguage WHERE LANGUAGE  =  "Spanish" GROUP BY CountryCode

Question: What is the total number of countries where Spanish is spoken by the largest percentage of 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>Count the number of countries for which Spanish is the predominantly spoken language.</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) ,   max(Percentage) FROM countrylanguage WHERE LANGUAGE  =  "Spanish" GROUP BY CountryCode</SQL_QUERY>

Question: SELECT count(*) ,   max(Percentage) FROM countrylanguage WHERE LANGUAGE  =  "Spanish" GROUP BY CountryCode

Question: Count the number of countries for which Spanish is the predominantly spoken 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 codes of countries where Spanish is spoken by the largest percentage of people?</question>
[SQL]:

Output: <SQL_QUERY>SELECT CountryCode ,  max(Percentage) FROM countrylanguage WHERE LANGUAGE  =  "Spanish" GROUP BY CountryCode</SQL_QUERY>

Question: SELECT CountryCode ,  max(Percentage) FROM countrylanguage WHERE LANGUAGE  =  "Spanish" GROUP BY CountryCode

Question: What are the codes of countries where Spanish is spoken by the largest percentage of 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>Return the codes of countries for which Spanish is the predominantly spoken language.</question>
[SQL]:

Output: <SQL_QUERY>SELECT CountryCode ,  max(Percentage) FROM countrylanguage WHERE LANGUAGE  =  "Spanish" GROUP BY CountryCode</SQL_QUERY>

Question: SELECT CountryCode ,  max(Percentage) FROM countrylanguage WHERE LANGUAGE  =  "Spanish" GROUP BY CountryCode

Question: Return the codes of countries for which Spanish is the predominantly spoken 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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many conductors are there?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) FROM conductor</SQL_QUERY>

Question: SELECT count(*) FROM conductor

Question: How many conductors are there?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Count the number of conductors.</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) FROM conductor</SQL_QUERY>

Question: SELECT count(*) FROM conductor

Question: Count the number of conductors.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the names of conductors in ascending order of age.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM conductor ORDER BY Age ASC</SQL_QUERY>

Question: SELECT Name FROM conductor ORDER BY Age ASC

Question: List the names of conductors in ascending order of age.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of conductors, ordered by age?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM conductor ORDER BY Age ASC</SQL_QUERY>

Question: SELECT Name FROM conductor ORDER BY Age ASC

Question: What are the names of conductors, ordered by age?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of conductors whose nationalities are not "USA"?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM conductor WHERE Nationality != 'USA'</SQL_QUERY>

Question: SELECT Name FROM conductor WHERE Nationality != 'USA'

Question: What are the names of conductors whose nationalities are not "USA"?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the names of conductors that do not have the nationality "USA".</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM conductor WHERE Nationality != 'USA'</SQL_QUERY>

Question: SELECT Name FROM conductor WHERE Nationality != 'USA'

Question: Return the names of conductors that do not have the nationality "USA".


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the record companies of orchestras in descending order of years in which they were founded?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Record_Company FROM orchestra ORDER BY Year_of_Founded DESC</SQL_QUERY>

Question: SELECT Record_Company FROM orchestra ORDER BY Year_of_Founded DESC

Question: What are the record companies of orchestras in descending order of years in which they were founded?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the record companies of orchestras, sorted descending by the years in which they were founded.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Record_Company FROM orchestra ORDER BY Year_of_Founded DESC</SQL_QUERY>

Question: SELECT Record_Company FROM orchestra ORDER BY Year_of_Founded DESC

Question: Return the record companies of orchestras, sorted descending by the years in which they were founded.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the average attendance of shows?</question>
[SQL]:

Output: <SQL_QUERY>SELECT avg(Attendance) FROM SHOW</SQL_QUERY>

Question: SELECT avg(Attendance) FROM SHOW

Question: What is the average attendance of shows?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the average attendance across all shows.</question>
[SQL]:

Output: <SQL_QUERY>SELECT avg(Attendance) FROM SHOW</SQL_QUERY>

Question: SELECT avg(Attendance) FROM SHOW

Question: Return the average attendance across all shows.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the maximum and minimum share of performances whose type is not "Live final".</question>
[SQL]:

Output: <SQL_QUERY>SELECT max(SHARE) ,  min(SHARE) FROM performance WHERE TYPE != "Live final"</SQL_QUERY>

Question: SELECT max(SHARE) ,  min(SHARE) FROM performance WHERE TYPE != "Live final"

Question: What are the maximum and minimum share of performances whose type is not "Live final".


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the maximum and minimum shares for performances that do not have the type "Live final".</question>
[SQL]:

Output: <SQL_QUERY>SELECT max(SHARE) ,  min(SHARE) FROM performance WHERE TYPE != "Live final"</SQL_QUERY>

Question: SELECT max(SHARE) ,  min(SHARE) FROM performance WHERE TYPE != "Live final"

Question: Return the maximum and minimum shares for performances that do not have the type "Live final".


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many different nationalities do conductors have?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(DISTINCT Nationality) FROM conductor</SQL_QUERY>

Question: SELECT count(DISTINCT Nationality) FROM conductor

Question: How many different nationalities do conductors have?


Input:
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
 <schema>[Schema (values) (types)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Count the number of different nationalities of conductors.</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(DISTINCT Nationality) FROM conductor</SQL_QUERY>

Question: SELECT count(DISTINCT Nationality) FROM conductor

Question: Count the number of different nationalities of conductors.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>List names of conductors in descending order of years of work.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM conductor ORDER BY Year_of_Work DESC</SQL_QUERY>

Question: SELECT Name FROM conductor ORDER BY Year_of_Work DESC

Question: List names of conductors in descending order of years of work.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of conductors, sorted descending by the number of years they have worked?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM conductor ORDER BY Year_of_Work DESC</SQL_QUERY>

Question: SELECT Name FROM conductor ORDER BY Year_of_Work DESC

Question: What are the names of conductors, sorted descending by the number of years they have worked?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the name of the conductor with the most years of work.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM conductor ORDER BY Year_of_Work DESC LIMIT 1</SQL_QUERY>

Question: SELECT Name FROM conductor ORDER BY Year_of_Work DESC LIMIT 1

Question: List the name of the conductor with the most years of work.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the name of the conductor who has worked the greatest number of years?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM conductor ORDER BY Year_of_Work DESC LIMIT 1</SQL_QUERY>

Question: SELECT Name FROM conductor ORDER BY Year_of_Work DESC LIMIT 1

Question: What is the name of the conductor who has worked the greatest number of years?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the names of conductors and the orchestras they have conducted.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name ,  T2.Orchestra FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID</SQL_QUERY>

Question: SELECT T1.Name ,  T2.Orchestra FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID

Question: Show the names of conductors and the orchestras they have conducted.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of conductors as well as the corresonding orchestras that they have conducted?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name ,  T2.Orchestra FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID</SQL_QUERY>

Question: SELECT T1.Name ,  T2.Orchestra FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID

Question: What are the names of conductors as well as the corresonding orchestras that they have conducted?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the names of conductors that have conducted more than one orchestras.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID GROUP BY T2.Conductor_ID HAVING COUNT(*)  >  1</SQL_QUERY>

Question: SELECT T1.Name FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID GROUP BY T2.Conductor_ID HAVING COUNT(*)  >  1

Question: Show the names of conductors that have conducted more than one orchestras.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of conductors who have conducted at more than one orchestra?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID GROUP BY T2.Conductor_ID HAVING COUNT(*)  >  1</SQL_QUERY>

Question: SELECT T1.Name FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID GROUP BY T2.Conductor_ID HAVING COUNT(*)  >  1

Question: What are the names of conductors who have conducted at more than one orchestra?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the name of the conductor that has conducted the most number of orchestras.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID GROUP BY T2.Conductor_ID ORDER BY COUNT(*) DESC LIMIT 1</SQL_QUERY>

Question: SELECT T1.Name FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID GROUP BY T2.Conductor_ID ORDER BY COUNT(*) DESC LIMIT 1

Question: Show the name of the conductor that has conducted the most number of orchestras.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the name of the conductor who has conducted the most orchestras?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID GROUP BY T2.Conductor_ID ORDER BY COUNT(*) DESC LIMIT 1</SQL_QUERY>

Question: SELECT T1.Name FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID GROUP BY T2.Conductor_ID ORDER BY COUNT(*) DESC LIMIT 1

Question: What is the name of the conductor who has conducted the most orchestras?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Please show the name of the conductor that has conducted orchestras founded after 2008.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID WHERE Year_of_Founded  >  2008</SQL_QUERY>

Question: SELECT T1.Name FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID WHERE Year_of_Founded  >  2008

Question: Please show the name of the conductor that has conducted orchestras founded after 2008.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of conductors who have conducted orchestras founded after the year 2008?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID WHERE Year_of_Founded  >  2008</SQL_QUERY>

Question: SELECT T1.Name FROM conductor AS T1 JOIN orchestra AS T2 ON T1.Conductor_ID  =  T2.Conductor_ID WHERE Year_of_Founded  >  2008

Question: What are the names of conductors who have conducted orchestras founded after the year 2008?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Please show the different record companies and the corresponding number of orchestras.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Record_Company ,  COUNT(*) FROM orchestra GROUP BY Record_Company</SQL_QUERY>

Question: SELECT Record_Company ,  COUNT(*) FROM orchestra GROUP BY Record_Company

Question: Please show the different record companies and the corresponding number of orchestras.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many orchestras does each record company manage?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Record_Company ,  COUNT(*) FROM orchestra GROUP BY Record_Company</SQL_QUERY>

Question: SELECT Record_Company ,  COUNT(*) FROM orchestra GROUP BY Record_Company

Question: How many orchestras does each record company manage?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Please show the record formats of orchestras in ascending order of count.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Major_Record_Format FROM orchestra GROUP BY Major_Record_Format ORDER BY COUNT(*) ASC</SQL_QUERY>

Question: SELECT Major_Record_Format FROM orchestra GROUP BY Major_Record_Format ORDER BY COUNT(*) ASC

Question: Please show the record formats of orchestras in ascending order of count.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the major record formats of orchestras, sorted by their frequency?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Major_Record_Format FROM orchestra GROUP BY Major_Record_Format ORDER BY COUNT(*) ASC</SQL_QUERY>

Question: SELECT Major_Record_Format FROM orchestra GROUP BY Major_Record_Format ORDER BY COUNT(*) ASC

Question: What are the major record formats of orchestras, sorted by their frequency?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the record company shared by the most number of orchestras.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Record_Company FROM orchestra GROUP BY Record_Company ORDER BY COUNT(*) DESC LIMIT 1</SQL_QUERY>

Question: SELECT Record_Company FROM orchestra GROUP BY Record_Company ORDER BY COUNT(*) DESC LIMIT 1

Question: List the record company shared by the most number of orchestras.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the record company used by the greatest number of orchestras?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Record_Company FROM orchestra GROUP BY Record_Company ORDER BY COUNT(*) DESC LIMIT 1</SQL_QUERY>

Question: SELECT Record_Company FROM orchestra GROUP BY Record_Company ORDER BY COUNT(*) DESC LIMIT 1

Question: What is the record company used by the greatest number of orchestras?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the names of orchestras that have no performance.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Orchestra FROM orchestra WHERE Orchestra_ID NOT IN (SELECT Orchestra_ID FROM performance)</SQL_QUERY>

Question: SELECT Orchestra FROM orchestra WHERE Orchestra_ID NOT IN (SELECT Orchestra_ID FROM performance)

Question: List the names of orchestras that have no performance.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the orchestras that do not have any performances?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Orchestra FROM orchestra WHERE Orchestra_ID NOT IN (SELECT Orchestra_ID FROM performance)</SQL_QUERY>

Question: SELECT Orchestra FROM orchestra WHERE Orchestra_ID NOT IN (SELECT Orchestra_ID FROM performance)

Question: What are the orchestras that do not have any performances?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the record companies shared by orchestras founded before 2003 and after 2003.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Record_Company FROM orchestra WHERE Year_of_Founded  <  2003 INTERSECT SELECT Record_Company FROM orchestra WHERE Year_of_Founded  >  2003</SQL_QUERY>

Question: SELECT Record_Company FROM orchestra WHERE Year_of_Founded  <  2003 INTERSECT SELECT Record_Company FROM orchestra WHERE Year_of_Founded  >  2003

Question: Show the record companies shared by orchestras founded before 2003 and after 2003.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the record companies that are used by both orchestras founded before 2003 and those founded after 2003?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Record_Company FROM orchestra WHERE Year_of_Founded  <  2003 INTERSECT SELECT Record_Company FROM orchestra WHERE Year_of_Founded  >  2003</SQL_QUERY>

Question: SELECT Record_Company FROM orchestra WHERE Year_of_Founded  <  2003 INTERSECT SELECT Record_Company FROM orchestra WHERE Year_of_Founded  >  2003

Question: What are the record companies that are used by both orchestras founded before 2003 and those founded after 2003?


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the number of orchestras whose record format is "CD" or "DVD".</question>
[SQL]:

Output: <SQL_QUERY>SELECT COUNT(*) FROM orchestra WHERE Major_Record_Format  =  "CD" OR Major_Record_Format  =  "DVD"</SQL_QUERY>

Question: SELECT COUNT(*) FROM orchestra WHERE Major_Record_Format  =  "CD" OR Major_Record_Format  =  "DVD"

Question: Find the number of orchestras whose record format is "CD" or "DVD".


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Count the number of orchestras that have CD or DVD as their record format.</question>
[SQL]:

Output: <SQL_QUERY>SELECT COUNT(*) FROM orchestra WHERE Major_Record_Format  =  "CD" OR Major_Record_Format  =  "DVD"</SQL_QUERY>

Question: SELECT COUNT(*) FROM orchestra WHERE Major_Record_Format  =  "CD" OR Major_Record_Format  =  "DVD"

Question: Count the number of orchestras that have CD or DVD as their record format.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the years in which orchestras that have given more than one performance are founded.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Year_of_Founded FROM orchestra AS T1 JOIN performance AS T2 ON T1.Orchestra_ID  =  T2.Orchestra_ID GROUP BY T2.Orchestra_ID HAVING COUNT(*)  >  1</SQL_QUERY>

Question: SELECT Year_of_Founded FROM orchestra AS T1 JOIN performance AS T2 ON T1.Orchestra_ID  =  T2.Orchestra_ID GROUP BY T2.Orchestra_ID HAVING COUNT(*)  >  1

Question: Show the years in which orchestras that have given more than one performance are founded.


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)]: | orchestra |  conductor : conductor_id (text) , name (number) , age (text) , nationality (number) , year_of_work (text) | orchestra : orchestra_id (text) , orchestra (number) , conductor_id (text) , record_company (number) , year_of_founded (text) , major_record_format (number) | performance : performance_id (text) , orchestra_id (number) , type (text) , date (number) , official_ratings_(millions) (text) , weekly_rank (number) , share (number) | show : show_id (text) , performance_id (number) , if_first_show (text) , result (number) , attendance (text);</schema>"
<primary_keys>[Primary Keys]: conductor : conductor_id, orchestra : orchestra_id, performance : performance_id</primary_keys>"
<foreign_keys>[Foreign Keys]: orchestra : conductor_id = conductor : conductor_id | performance : orchestra_id = orchestra : orchestra_id | show : performance_id = performance : performance_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are years of founding for orchestras that have had more than a single performance?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Year_of_Founded FROM orchestra AS T1 JOIN performance AS T2 ON T1.Orchestra_ID  =  T2.Orchestra_ID GROUP BY T2.Orchestra_ID HAVING COUNT(*)  >  1</SQL_QUERY>

Question: SELECT Year_of_Founded FROM orchestra AS T1 JOIN performance AS T2 ON T1.Orchestra_ID  =  T2.Orchestra_ID GROUP BY T2.Orchestra_ID HAVING COUNT(*)  >  1

Question: What are years of founding for orchestras that have had more than a single performance?


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many high schoolers are there?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) FROM Highschooler</SQL_QUERY>

Question: SELECT count(*) FROM Highschooler

Question: How many high schoolers are there?


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Count the number of high schoolers.</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) FROM Highschooler</SQL_QUERY>

Question: SELECT count(*) FROM Highschooler

Question: Count the number of high schoolers.


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the names and grades of each high schooler.</question>
[SQL]:

Output: <SQL_QUERY>SELECT name ,  grade FROM Highschooler</SQL_QUERY>

Question: SELECT name ,  grade FROM Highschooler

Question: Show the names and grades of each high schooler.


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names and grades for each high schooler?</question>
[SQL]:

Output: <SQL_QUERY>SELECT name ,  grade FROM Highschooler</SQL_QUERY>

Question: SELECT name ,  grade FROM Highschooler

Question: What are the names and grades for each high schooler?


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show all the grades of the high schoolers.</question>
[SQL]:

Output: <SQL_QUERY>SELECT grade FROM Highschooler</SQL_QUERY>

Question: SELECT grade FROM Highschooler

Question: Show all the grades of the high schoolers.


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the grade of each high schooler?</question>
[SQL]:

Output: <SQL_QUERY>SELECT grade FROM Highschooler</SQL_QUERY>

Question: SELECT grade FROM Highschooler

Question: What is the grade of each high schooler?


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What grade is Kyle in?</question>
[SQL]:

Output: <SQL_QUERY>SELECT grade FROM Highschooler WHERE name  =  "Kyle"</SQL_QUERY>

Question: SELECT grade FROM Highschooler WHERE name  =  "Kyle"

Question: What grade is Kyle in?


Input:
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
 <schema>[Schema (values) (types)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the grade for the high schooler named Kyle.</question>
[SQL]:

Output: <SQL_QUERY>SELECT grade FROM Highschooler WHERE name  =  "Kyle"</SQL_QUERY>

Question: SELECT grade FROM Highschooler WHERE name  =  "Kyle"

Question: Return the grade for the high schooler named Kyle.


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the names of all high schoolers in grade 10.</question>
[SQL]:

Output: <SQL_QUERY>SELECT name FROM Highschooler WHERE grade  =  10</SQL_QUERY>

Question: SELECT name FROM Highschooler WHERE grade  =  10

Question: Show the names of all high schoolers in grade 10.


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of all high schoolers in grade 10?</question>
[SQL]:

Output: <SQL_QUERY>SELECT name FROM Highschooler WHERE grade  =  10</SQL_QUERY>

Question: SELECT name FROM Highschooler WHERE grade  =  10

Question: What are the names of all high schoolers in grade 10?


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the ID of the high schooler named Kyle.</question>
[SQL]:

Output: <SQL_QUERY>SELECT ID FROM Highschooler WHERE name  =  "Kyle"</SQL_QUERY>

Question: SELECT ID FROM Highschooler WHERE name  =  "Kyle"

Question: Show the ID of the high schooler named Kyle.


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is Kyle's id?</question>
[SQL]:

Output: <SQL_QUERY>SELECT ID FROM Highschooler WHERE name  =  "Kyle"</SQL_QUERY>

Question: SELECT ID FROM Highschooler WHERE name  =  "Kyle"

Question: What is Kyle's id?


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many high schoolers are there in grade 9 or 10?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) FROM Highschooler WHERE grade  =  9 OR grade  =  10</SQL_QUERY>

Question: SELECT count(*) FROM Highschooler WHERE grade  =  9 OR grade  =  10

Question: How many high schoolers are there in grade 9 or 10?


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Count the number of high schoolers in grades 9 or 10.</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) FROM Highschooler WHERE grade  =  9 OR grade  =  10</SQL_QUERY>

Question: SELECT count(*) FROM Highschooler WHERE grade  =  9 OR grade  =  10

Question: Count the number of high schoolers in grades 9 or 10.


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the number of high schoolers for each grade.</question>
[SQL]:

Output: <SQL_QUERY>SELECT grade ,  count(*) FROM Highschooler GROUP BY grade</SQL_QUERY>

Question: SELECT grade ,  count(*) FROM Highschooler GROUP BY grade

Question: Show the number of high schoolers for each grade.


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many high schoolers are in each grade?</question>
[SQL]:

Output: <SQL_QUERY>SELECT grade ,  count(*) FROM Highschooler GROUP BY grade</SQL_QUERY>

Question: SELECT grade ,  count(*) FROM Highschooler GROUP BY grade

Question: How many high schoolers are in each grade?


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Which grade has the most high schoolers?</question>
[SQL]:

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

Question: SELECT grade FROM Highschooler GROUP BY grade ORDER BY count(*) DESC LIMIT 1

Question: Which grade has the most high schoolers?


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the grade that has the greatest number of high schoolers.</question>
[SQL]:

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

Question: SELECT grade FROM Highschooler GROUP BY grade ORDER BY count(*) DESC LIMIT 1

Question: Return the grade that has the greatest number of high schoolers.


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show me all grades that have at least 4 students.</question>
[SQL]:

Output: <SQL_QUERY>SELECT grade FROM Highschooler GROUP BY grade HAVING count(*)  >=  4</SQL_QUERY>

Question: SELECT grade FROM Highschooler GROUP BY grade HAVING count(*)  >=  4

Question: Show me all grades that have at least 4 students.


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Which grades have 4 or more high schoolers?</question>
[SQL]:

Output: <SQL_QUERY>SELECT grade FROM Highschooler GROUP BY grade HAVING count(*)  >=  4</SQL_QUERY>

Question: SELECT grade FROM Highschooler GROUP BY grade HAVING count(*)  >=  4

Question: Which grades have 4 or more high schoolers?


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the student IDs and numbers of friends corresponding to each.</question>
[SQL]:

Output: <SQL_QUERY>SELECT student_id ,  count(*) FROM Friend GROUP BY student_id</SQL_QUERY>

Question: SELECT student_id ,  count(*) FROM Friend GROUP BY student_id

Question: Show the student IDs and numbers of friends corresponding to each.


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)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many friends does each student have?</question>
[SQL]:

Output: <SQL_QUERY>SELECT student_id ,  count(*) FROM Friend GROUP BY student_id</SQL_QUERY>

Question: SELECT student_id ,  count(*) FROM Friend GROUP BY student_id

Question: How many friends does each student have?


Input:
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
 <schema>[Schema (values) (types)]: | network_1 |  Highschooler : id (text) , name (number) , grade (text) | Friend : student_id (text) , friend_id (number) | Likes : student_id (text) , liked_id (number);</schema>"
<primary_keys>[Primary Keys]: highschooler : id, friend : student_id, likes : student_id</primary_keys>"
<foreign_keys>[Foreign Keys]: friend : friend_id = highschooler : id | friend : student_id = highschooler : id | likes : student_id = highschooler : id | likes : liked_id = highschooler : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show the names of high school students and their corresponding number of friends.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T2.name ,  count(*) FROM Friend AS T1 JOIN Highschooler AS T2 ON T1.student_id  =  T2.id GROUP BY T1.student_id</SQL_QUERY>

Question: SELECT T2.name ,  count(*) FROM Friend AS T1 JOIN Highschooler AS T2 ON T1.student_id  =  T2.id GROUP BY T1.student_id

Question: Show the names of high school students and their corresponding number of friends.