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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are all of the episodes ordered by ratings?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Episode FROM TV_series ORDER BY rating</SQL_QUERY>

Question: SELECT Episode FROM TV_series ORDER BY rating

Question: What are all of the episodes ordered by ratings?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>List top 3 highest Rating  TV series. List the TV series's Episode and Rating.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Episode ,  Rating FROM TV_series ORDER BY Rating DESC LIMIT 3;</SQL_QUERY>

Question: SELECT Episode ,  Rating FROM TV_series ORDER BY Rating DESC LIMIT 3;

Question: List top 3 highest Rating  TV series. List the TV series's Episode and Rating.


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are 3 most highly rated episodes in the TV series table and what were those ratings?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Episode ,  Rating FROM TV_series ORDER BY Rating DESC LIMIT 3;</SQL_QUERY>

Question: SELECT Episode ,  Rating FROM TV_series ORDER BY Rating DESC LIMIT 3;

Question: What are 3 most highly rated episodes in the TV series table and what were those ratings?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is minimum and maximum share of TV series?</question>
[SQL]:

Output: <SQL_QUERY>SELECT max(SHARE) , min(SHARE) FROM TV_series;</SQL_QUERY>

Question: SELECT max(SHARE) , min(SHARE) FROM TV_series;

Question: What is minimum and maximum share of TV series?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the maximum and minimum share for the TV series?</question>
[SQL]:

Output: <SQL_QUERY>SELECT max(SHARE) , min(SHARE) FROM TV_series;</SQL_QUERY>

Question: SELECT max(SHARE) , min(SHARE) FROM TV_series;

Question: What is the maximum and minimum share for the TV series?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the air date of TV series with Episode "A Love of a Lifetime"?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Air_Date FROM TV_series WHERE Episode = "A Love of a Lifetime";</SQL_QUERY>

Question: SELECT Air_Date FROM TV_series WHERE Episode = "A Love of a Lifetime";

Question: What is the air date of TV series with Episode "A Love of a Lifetime"?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>When did the episode "A Love of a Lifetime" air?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Air_Date FROM TV_series WHERE Episode = "A Love of a Lifetime";</SQL_QUERY>

Question: SELECT Air_Date FROM TV_series WHERE Episode = "A Love of a Lifetime";

Question: When did the episode "A Love of a Lifetime" air?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is Weekly Rank of TV series with Episode "A Love of a Lifetime"?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Weekly_Rank FROM TV_series WHERE Episode = "A Love of a Lifetime";</SQL_QUERY>

Question: SELECT Weekly_Rank FROM TV_series WHERE Episode = "A Love of a Lifetime";

Question: What is Weekly Rank of TV series with Episode "A Love of a Lifetime"?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the weekly rank for the episode "A Love of a Lifetime"?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Weekly_Rank FROM TV_series WHERE Episode = "A Love of a Lifetime";</SQL_QUERY>

Question: SELECT Weekly_Rank FROM TV_series WHERE Episode = "A Love of a Lifetime";

Question: What is the weekly rank for the episode "A Love of a Lifetime"?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the TV Channel of TV series with Episode "A Love of a Lifetime"? List the TV Channel's series name.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.series_name FROM TV_Channel AS T1 JOIN TV_series AS T2 ON T1.id = T2.Channel WHERE T2.Episode = "A Love of a Lifetime";</SQL_QUERY>

Question: SELECT T1.series_name FROM TV_Channel AS T1 JOIN TV_series AS T2 ON T1.id = T2.Channel WHERE T2.Episode = "A Love of a Lifetime";

Question: What is the TV Channel of TV series with Episode "A Love of a Lifetime"? List the TV Channel's series name.


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the name of the series that has the episode "A Love of a Lifetime"?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.series_name FROM TV_Channel AS T1 JOIN TV_series AS T2 ON T1.id = T2.Channel WHERE T2.Episode = "A Love of a Lifetime";</SQL_QUERY>

Question: SELECT T1.series_name FROM TV_Channel AS T1 JOIN TV_series AS T2 ON T1.id = T2.Channel WHERE T2.Episode = "A Love of a Lifetime";

Question: What is the name of the series that has the episode "A Love of a Lifetime"?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the Episode of all  TV series showed on TV Channel with series name "Sky Radio".</question>
[SQL]:

Output: <SQL_QUERY>SELECT T2.Episode FROM TV_Channel AS T1 JOIN TV_series AS T2 ON T1.id = T2.Channel WHERE T1.series_name = "Sky Radio";</SQL_QUERY>

Question: SELECT T2.Episode FROM TV_Channel AS T1 JOIN TV_series AS T2 ON T1.id = T2.Channel WHERE T1.series_name = "Sky Radio";

Question: List the Episode of all  TV series showed on TV Channel with series name "Sky Radio".


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the episode for the TV series named "Sky Radio"?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T2.Episode FROM TV_Channel AS T1 JOIN TV_series AS T2 ON T1.id = T2.Channel WHERE T1.series_name = "Sky Radio";</SQL_QUERY>

Question: SELECT T2.Episode FROM TV_Channel AS T1 JOIN TV_series AS T2 ON T1.id = T2.Channel WHERE T1.series_name = "Sky Radio";

Question: What is the episode for the TV series named "Sky Radio"?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the number of cartoons directed by each of the listed directors.</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) ,  Directed_by FROM cartoon GROUP BY Directed_by</SQL_QUERY>

Question: SELECT count(*) ,  Directed_by FROM cartoon GROUP BY Directed_by

Question: Find the number of cartoons directed by each of the listed directors.


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many cartoons did each director create?</question>
[SQL]:

Output: <SQL_QUERY>SELECT count(*) ,  Directed_by FROM cartoon GROUP BY Directed_by</SQL_QUERY>

Question: SELECT count(*) ,  Directed_by FROM cartoon GROUP BY Directed_by

Question: How many cartoons did each director create?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the production code and channel of the most recently aired cartoon .</question>
[SQL]:

Output: <SQL_QUERY>select production_code ,  channel from cartoon order by original_air_date desc limit 1</SQL_QUERY>

Question: select production_code ,  channel from cartoon order by original_air_date desc limit 1

Question: Find the production code and channel of the most recently aired cartoon .


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the produdction code and channel of the most recent cartoon ?</question>
[SQL]:

Output: <SQL_QUERY>select production_code ,  channel from cartoon order by original_air_date desc limit 1</SQL_QUERY>

Question: select production_code ,  channel from cartoon order by original_air_date desc limit 1

Question: What is the produdction code and channel of the most recent cartoon ?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the package choice and series name of the TV channel that has high definition TV.</question>
[SQL]:

Output: <SQL_QUERY>SELECT package_option ,  series_name FROM TV_Channel WHERE hight_definition_TV  =  "yes"</SQL_QUERY>

Question: SELECT package_option ,  series_name FROM TV_Channel WHERE hight_definition_TV  =  "yes"

Question: Find the package choice and series name of the TV channel that has high definition TV.


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the package options and the name of the series for the TV Channel that supports high definition TV?</question>
[SQL]:

Output: <SQL_QUERY>SELECT package_option ,  series_name FROM TV_Channel WHERE hight_definition_TV  =  "yes"</SQL_QUERY>

Question: SELECT package_option ,  series_name FROM TV_Channel WHERE hight_definition_TV  =  "yes"

Question: What are the package options and the name of the series for the TV Channel that supports high definition TV?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>which countries' tv channels are playing some cartoon written by Todd Casey?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.written_by  =  'Todd Casey'</SQL_QUERY>

Question: SELECT T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.written_by  =  'Todd Casey'

Question: which countries' tv channels are playing some cartoon written by Todd Casey?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the countries that have cartoons on TV that were written by Todd Casey?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.written_by  =  'Todd Casey'</SQL_QUERY>

Question: SELECT T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.written_by  =  'Todd Casey'

Question: What are the countries that have cartoons on TV that were written by Todd Casey?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>which countries' tv channels are not playing any cartoon written by Todd Casey?</question>
[SQL]:

Output: <SQL_QUERY>SELECT country FROM TV_Channel EXCEPT SELECT T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.written_by  =  'Todd Casey'</SQL_QUERY>

Question: SELECT country FROM TV_Channel EXCEPT SELECT T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.written_by  =  'Todd Casey'

Question: which countries' tv channels are not playing any cartoon written by Todd Casey?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the countries that are not playing cartoons written by Todd Casey?</question>
[SQL]:

Output: <SQL_QUERY>SELECT country FROM TV_Channel EXCEPT SELECT T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.written_by  =  'Todd Casey'</SQL_QUERY>

Question: SELECT country FROM TV_Channel EXCEPT SELECT T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.written_by  =  'Todd Casey'

Question: What are the countries that are not playing cartoons written by Todd Casey?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Find the series name and country of the tv channel that is playing some cartoons directed by Ben Jones and Michael Chang?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.series_name ,  T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.directed_by  =  'Michael Chang' INTERSECT SELECT T1.series_name ,  T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.directed_by  =  'Ben Jones'</SQL_QUERY>

Question: SELECT T1.series_name ,  T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.directed_by  =  'Michael Chang' INTERSECT SELECT T1.series_name ,  T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.directed_by  =  'Ben Jones'

Question: Find the series name and country of the tv channel that is playing some cartoons directed by Ben Jones and Michael Chang?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the series name and country of all TV channels that are playing cartoons directed by Ben Jones and cartoons directed by Michael Chang?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.series_name ,  T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.directed_by  =  'Michael Chang' INTERSECT SELECT T1.series_name ,  T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.directed_by  =  'Ben Jones'</SQL_QUERY>

Question: SELECT T1.series_name ,  T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.directed_by  =  'Michael Chang' INTERSECT SELECT T1.series_name ,  T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.directed_by  =  'Ben Jones'

Question: What is the series name and country of all TV channels that are playing cartoons directed by Ben Jones and cartoons directed by Michael Chang?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>find the pixel aspect ratio and nation of the tv channels that do not use English.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Pixel_aspect_ratio_PAR ,  country FROM tv_channel WHERE LANGUAGE != 'English'</SQL_QUERY>

Question: SELECT Pixel_aspect_ratio_PAR ,  country FROM tv_channel WHERE LANGUAGE != 'English'

Question: find the pixel aspect ratio and nation of the tv channels that do not use English.


Input:
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
 <schema>[Schema (values) (types)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the pixel aspect ratio and country of origin for all TV channels that do not use English?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Pixel_aspect_ratio_PAR ,  country FROM tv_channel WHERE LANGUAGE != 'English'</SQL_QUERY>

Question: SELECT Pixel_aspect_ratio_PAR ,  country FROM tv_channel WHERE LANGUAGE != 'English'

Question: What is the pixel aspect ratio and country of origin for all TV channels that do not use English?


Input:
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
 <schema>[Schema (values) (types)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>find id of the tv channels that from the countries where have more than two tv channels.</question>
[SQL]:

Output: <SQL_QUERY>SELECT id FROM tv_channel GROUP BY country HAVING count(*)  >  2</SQL_QUERY>

Question: SELECT id FROM tv_channel GROUP BY country HAVING count(*)  >  2

Question: find id of the tv channels that from the countries where have more than two tv channels.


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the ids of all tv channels that have more than 2 TV channels?</question>
[SQL]:

Output: <SQL_QUERY>SELECT id FROM tv_channel GROUP BY country HAVING count(*)  >  2</SQL_QUERY>

Question: SELECT id FROM tv_channel GROUP BY country HAVING count(*)  >  2

Question: What are the ids of all tv channels that have more than 2 TV channels?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>find the id of tv channels that do not play any cartoon directed by Ben Jones.</question>
[SQL]:

Output: <SQL_QUERY>SELECT id FROM TV_Channel EXCEPT SELECT channel FROM cartoon WHERE directed_by  =  'Ben Jones'</SQL_QUERY>

Question: SELECT id FROM TV_Channel EXCEPT SELECT channel FROM cartoon WHERE directed_by  =  'Ben Jones'

Question: find the id of tv channels that do not play any cartoon directed by Ben Jones.


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the ids of the TV channels that do not have any cartoons directed by Ben Jones?</question>
[SQL]:

Output: <SQL_QUERY>SELECT id FROM TV_Channel EXCEPT SELECT channel FROM cartoon WHERE directed_by  =  'Ben Jones'</SQL_QUERY>

Question: SELECT id FROM TV_Channel EXCEPT SELECT channel FROM cartoon WHERE directed_by  =  'Ben Jones'

Question: What are the ids of the TV channels that do not have any cartoons directed by Ben Jones?


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>find the package option of the tv channel that do not have any cartoon directed by Ben Jones.</question>
[SQL]:

Output: <SQL_QUERY>SELECT package_option FROM TV_Channel WHERE id NOT IN (SELECT channel FROM cartoon WHERE directed_by  =  'Ben Jones')</SQL_QUERY>

Question: SELECT package_option FROM TV_Channel WHERE id NOT IN (SELECT channel FROM cartoon WHERE directed_by  =  'Ben Jones')

Question: find the package option of the tv channel that do not have any cartoon directed by Ben Jones.


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)]: | tvshow |  TV_Channel : id (text) , series_name (text) , country (text) , language (text) , content (text) , pixel_aspect_ratio_par (text) , hight_definition_tv (text) , pay_per_view_ppv (text) , package_option (text) | TV_series : id (text) , episode (text) , air_date (text) , rating (text) , share (text) , 18_49_rating_share (text) , viewers_m (text) , weekly_rank (text) , channel (text) | Cartoon : id (text) , title (text) , directed_by (text) , written_by (text) , original_air_date (text) , production_code (text) , channel (text);</schema>"
<primary_keys>[Primary Keys]: tv_channel : id, tv_series : id, cartoon : id</primary_keys>"
<foreign_keys>[Foreign Keys]: tv_series : channel = tv_channel : id | cartoon : channel = tv_channel : id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the package options of all tv channels that are not playing any cartoons directed by Ben Jones?</question>
[SQL]:

Output: <SQL_QUERY>SELECT package_option FROM TV_Channel WHERE id NOT IN (SELECT channel FROM cartoon WHERE directed_by  =  'Ben Jones')</SQL_QUERY>

Question: SELECT package_option FROM TV_Channel WHERE id NOT IN (SELECT channel FROM cartoon WHERE directed_by  =  'Ben Jones')

Question: What are the package options of all tv channels that are not playing any cartoons directed by Ben Jones?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many poker players are there?</question>
[SQL]:

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

Question: SELECT count(*) FROM poker_player

Question: How many poker players 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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Count the number of poker players.</question>
[SQL]:

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

Question: SELECT count(*) FROM poker_player

Question: Count the number of poker players.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the earnings of poker players in descending order.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Earnings FROM poker_player ORDER BY Earnings DESC</SQL_QUERY>

Question: SELECT Earnings FROM poker_player ORDER BY Earnings DESC

Question: List the earnings of poker players in descending order.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the earnings of poker players, ordered descending by value?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Earnings FROM poker_player ORDER BY Earnings DESC</SQL_QUERY>

Question: SELECT Earnings FROM poker_player ORDER BY Earnings DESC

Question: What are the earnings of poker players, ordered descending by value?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the final tables made and the best finishes of poker players.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Final_Table_Made ,  Best_Finish FROM poker_player</SQL_QUERY>

Question: SELECT Final_Table_Made ,  Best_Finish FROM poker_player

Question: List the final tables made and the best finishes of poker players.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the final tables made and best finishes for all poker players?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Final_Table_Made ,  Best_Finish FROM poker_player</SQL_QUERY>

Question: SELECT Final_Table_Made ,  Best_Finish FROM poker_player

Question: What are the final tables made and best finishes for all poker players?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the average earnings of poker players?</question>
[SQL]:

Output: <SQL_QUERY>SELECT avg(Earnings) FROM poker_player</SQL_QUERY>

Question: SELECT avg(Earnings) FROM poker_player

Question: What is the average earnings of poker players?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the average earnings across all poker players.</question>
[SQL]:

Output: <SQL_QUERY>SELECT avg(Earnings) FROM poker_player</SQL_QUERY>

Question: SELECT avg(Earnings) FROM poker_player

Question: Return the average earnings across all poker players.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the money rank of the poker player with the highest earnings?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Money_Rank FROM poker_player ORDER BY Earnings DESC LIMIT 1</SQL_QUERY>

Question: SELECT Money_Rank FROM poker_player ORDER BY Earnings DESC LIMIT 1

Question: What is the money rank of the poker player with the highest earnings?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the money rank of the player with the greatest earnings.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Money_Rank FROM poker_player ORDER BY Earnings DESC LIMIT 1</SQL_QUERY>

Question: SELECT Money_Rank FROM poker_player ORDER BY Earnings DESC LIMIT 1

Question: Return the money rank of the player with the greatest earnings.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the maximum number of final tables made among poker players with earnings less than 200000?</question>
[SQL]:

Output: <SQL_QUERY>SELECT max(Final_Table_Made) FROM poker_player WHERE Earnings  <  200000</SQL_QUERY>

Question: SELECT max(Final_Table_Made) FROM poker_player WHERE Earnings  <  200000

Question: What is the maximum number of final tables made among poker players with earnings less than 200000?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the maximum final tables made across all poker players who have earnings below 200000.</question>
[SQL]:

Output: <SQL_QUERY>SELECT max(Final_Table_Made) FROM poker_player WHERE Earnings  <  200000</SQL_QUERY>

Question: SELECT max(Final_Table_Made) FROM poker_player WHERE Earnings  <  200000

Question: Return the maximum final tables made across all poker players who have earnings below 200000.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of poker players?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID</SQL_QUERY>

Question: SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID

Question: What are the names of poker players?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the names of all the poker players.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID</SQL_QUERY>

Question: SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID

Question: Return the names of all the poker players.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of poker players whose earnings is higher than 300000?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID WHERE T2.Earnings  >  300000</SQL_QUERY>

Question: SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID WHERE T2.Earnings  >  300000

Question: What are the names of poker players whose earnings is higher than 300000?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Give the names of poker players who have earnings above 300000.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID WHERE T2.Earnings  >  300000</SQL_QUERY>

Question: SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID WHERE T2.Earnings  >  300000

Question: Give the names of poker players who have earnings above 300000.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the names of poker players ordered by the final tables made in ascending order.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Final_Table_Made</SQL_QUERY>

Question: SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Final_Table_Made

Question: List the names of poker players ordered by the final tables made in ascending order.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of poker players, ordered ascending by the number of final tables they have made?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Final_Table_Made</SQL_QUERY>

Question: SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Final_Table_Made

Question: What are the names of poker players, ordered ascending by the number of final tables they have made?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the birth date of the poker player with the lowest earnings?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Birth_Date FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Earnings ASC LIMIT 1</SQL_QUERY>

Question: SELECT T1.Birth_Date FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Earnings ASC LIMIT 1

Question: What is the birth date of the poker player with the lowest earnings?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the birth date of the poker player with the lowest earnings.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Birth_Date FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Earnings ASC LIMIT 1</SQL_QUERY>

Question: SELECT T1.Birth_Date FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Earnings ASC LIMIT 1

Question: Return the birth date of the poker player with the lowest earnings.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the money rank of the tallest poker player?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T2.Money_Rank FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T1.Height DESC LIMIT 1</SQL_QUERY>

Question: SELECT T2.Money_Rank FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T1.Height DESC LIMIT 1

Question: What is the money rank of the tallest poker player?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the money rank of the poker player with the greatest height.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T2.Money_Rank FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T1.Height DESC LIMIT 1</SQL_QUERY>

Question: SELECT T2.Money_Rank FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T1.Height DESC LIMIT 1

Question: Return the money rank of the poker player with the greatest height.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the average earnings of poker players with height higher than 200?</question>
[SQL]:

Output: <SQL_QUERY>SELECT avg(T2.Earnings) FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID WHERE T1.Height  >  200</SQL_QUERY>

Question: SELECT avg(T2.Earnings) FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID WHERE T1.Height  >  200

Question: What is the average earnings of poker players with height higher than 200?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Give average earnings of poker players who are taller than 200.</question>
[SQL]:

Output: <SQL_QUERY>SELECT avg(T2.Earnings) FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID WHERE T1.Height  >  200</SQL_QUERY>

Question: SELECT avg(T2.Earnings) FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID WHERE T1.Height  >  200

Question: Give average earnings of poker players who are taller than 200.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of poker players in descending order of earnings?</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Earnings DESC</SQL_QUERY>

Question: SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Earnings DESC

Question: What are the names of poker players in descending order of earnings?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the names of poker players sorted by their earnings descending.</question>
[SQL]:

Output: <SQL_QUERY>SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Earnings DESC</SQL_QUERY>

Question: SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Earnings DESC

Question: Return the names of poker players sorted by their earnings descending.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are different nationalities of people and the corresponding number of people from each nation?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Nationality ,  COUNT(*) FROM people GROUP BY Nationality</SQL_QUERY>

Question: SELECT Nationality ,  COUNT(*) FROM people GROUP BY Nationality

Question: What are different nationalities of people and the corresponding number of people from each nation?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many people are there of each nationality?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Nationality ,  COUNT(*) FROM people GROUP BY Nationality</SQL_QUERY>

Question: SELECT Nationality ,  COUNT(*) FROM people GROUP BY Nationality

Question: How many people are there of each nationality?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What is the most common nationality of people?</question>
[SQL]:

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

Question: SELECT Nationality FROM people GROUP BY Nationality ORDER BY COUNT(*) DESC LIMIT 1

Question: What is the most common nationality 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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Give the nationality that is most common across all people.</question>
[SQL]:

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

Question: SELECT Nationality FROM people GROUP BY Nationality ORDER BY COUNT(*) DESC LIMIT 1

Question: Give the nationality that is most common across all 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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the nationalities that are shared by at least two people?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Nationality FROM people GROUP BY Nationality HAVING COUNT(*)  >=  2</SQL_QUERY>

Question: SELECT Nationality FROM people GROUP BY Nationality HAVING COUNT(*)  >=  2

Question: What are the nationalities that are shared by at least two 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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Return the nationalities for which there are two or more people.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Nationality FROM people GROUP BY Nationality HAVING COUNT(*)  >=  2</SQL_QUERY>

Question: SELECT Nationality FROM people GROUP BY Nationality HAVING COUNT(*)  >=  2

Question: Return the nationalities for which there are two or more 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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the names and birth dates of people in ascending alphabetical order of name.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name ,  Birth_Date FROM people ORDER BY Name ASC</SQL_QUERY>

Question: SELECT Name ,  Birth_Date FROM people ORDER BY Name ASC

Question: List the names and birth dates of people in ascending alphabetical order of name.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names and birth dates of people, ordered by their names in alphabetical order?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name ,  Birth_Date FROM people ORDER BY Name ASC</SQL_QUERY>

Question: SELECT Name ,  Birth_Date FROM people ORDER BY Name ASC

Question: What are the names and birth dates of people, ordered by their names in alphabetical order?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Show names of people whose nationality is not "Russia".</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM people WHERE Nationality != "Russia"</SQL_QUERY>

Question: SELECT Name FROM people WHERE Nationality != "Russia"

Question: Show names of people whose nationality is not "Russia".


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of people who are not from Russia?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM people WHERE Nationality != "Russia"</SQL_QUERY>

Question: SELECT Name FROM people WHERE Nationality != "Russia"

Question: What are the names of people who are not from Russia?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the names of people that are not poker players.</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM people WHERE People_ID NOT IN (SELECT People_ID FROM poker_player)</SQL_QUERY>

Question: SELECT Name FROM people WHERE People_ID NOT IN (SELECT People_ID FROM poker_player)

Question: List the names of people that are not poker players.


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>What are the names of people who do not play poker?</question>
[SQL]:

Output: <SQL_QUERY>SELECT Name FROM people WHERE People_ID NOT IN (SELECT People_ID FROM poker_player)</SQL_QUERY>

Question: SELECT Name FROM people WHERE People_ID NOT IN (SELECT People_ID FROM poker_player)

Question: What are the names of people who do not play poker?


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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many distinct nationalities are there?</question>
[SQL]:

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

Question: SELECT count(DISTINCT Nationality) FROM people

Question: How many distinct nationalities 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)]: | poker_player |  poker_player : poker_player_id (text) , people_id (number) , final_table_made (number) , best_finish (number) , money_rank (number) , earnings (number) | people : people_id (text) , nationality (number) , name (number) , birth_date (number) , height (number);</schema>"
<primary_keys>[Primary Keys]: poker_player : poker_player_id, people : people_id</primary_keys>"
<foreign_keys>[Foreign Keys]: poker_player : people_id = people : people_id</foreign_keys>"
Answer the following question with a SQL Statement:<question>Count the number of different nationalities.</question>
[SQL]:

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

Question: SELECT count(DISTINCT Nationality) FROM people

Question: Count the number of different nationalities.


Input:
This is a task converting text into SQL statements. We will first give the dataset schema and column types, primary keys and foreign keys and then ask a question in text. You are asked to generate SQL statement in SQLite.
 <schema>[Schema (values) (types)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>How many states are there?</question>
[SQL]:

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

Question: SELECT count(*) FROM area_code_state

Question: How many states 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)]: | voter_1 |  AREA_CODE_STATE : area_code (text) , state (number) | CONTESTANTS : contestant_number (text) , contestant_name (number) | VOTES : vote_id (text) , phone_number (number) , state (text) , contestant_number (number) , created (text);</schema>"
<primary_keys>[Primary Keys]: area_code_state : area_code, contestants : contestant_number, votes : vote_id</primary_keys>"
<foreign_keys>[Foreign Keys]: votes : contestant_number = contestants : contestant_number | votes : state = area_code_state : state</foreign_keys>"
Answer the following question with a SQL Statement:<question>List the contestant numbers and names, ordered by contestant name descending.</question>
[SQL]:

Output: <SQL_QUERY>SELECT contestant_number ,  contestant_name FROM contestants ORDER BY contestant_name DESC</SQL_QUERY>

Question: SELECT contestant_number ,  contestant_name FROM contestants ORDER BY contestant_name DESC

Question: List the contestant numbers and names, ordered by contestant name descending.