brief_instruction stringlengths 16 224 | instruction stringlengths 687 8.77k | output stringlengths 18 577 |
|---|---|---|
What are the names and headquarters of all companies ordered by descending market value? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the names and headquarters of all companies ordered by descending market value?` to a syntactically-correct PostgreSQL query.
| SELECT company , headquarters FROM company ORDER BY market_value DESC |
Show minimum, maximum, and average market value for all companies. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show minimum, maximum, and average market value for all companies.` to a syntactically-correct PostgreSQL query.
| SELECT min(market_value) , max(market_value) , avg(market_value) FROM company |
What is the minimum, maximum, and average market value for every company? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the minimum, maximum, and average market value for every company?` to a syntactically-correct PostgreSQL query.
| SELECT min(market_value) , max(market_value) , avg(market_value) FROM company |
Show all main industry for all companies. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show all main industry for all companies.` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT main_industry FROM company |
What are the different main industries for all companies? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the different main industries for all companies?` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT main_industry FROM company |
List all headquarters and the number of companies in each headquarter. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List all headquarters and the number of companies in each headquarter.` to a syntactically-correct PostgreSQL query.
| SELECT headquarters , count(*) FROM company GROUP BY headquarters |
For each headquarter, what are the headquarter and how many companies are centered there? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `For each headquarter, what are the headquarter and how many companies are centered there?` to a syntactically-correct PostgreSQL query.
| SELECT headquarters , count(*) FROM company GROUP BY headquarters |
Show all main industry and total market value in each industry. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show all main industry and total market value in each industry.` to a syntactically-correct PostgreSQL query.
| SELECT main_industry , sum(market_value) FROM company GROUP BY main_industry |
What are the main indstries and total market value for each industry? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the main indstries and total market value for each industry?` to a syntactically-correct PostgreSQL query.
| SELECT main_industry , sum(market_value) FROM company GROUP BY main_industry |
List the main industry with highest total market value and its number of companies. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List the main industry with highest total market value and its number of companies.` to a syntactically-correct PostgreSQL query.
| SELECT main_industry , count(*) FROM company GROUP BY main_industry ORDER BY sum(market_value) DESC LIMIT 1 |
For each main industry, what is the total number of companies for the industry with the highest total market value? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `For each main industry, what is the total number of companies for the industry with the highest total market value?` to a syntactically-correct PostgreSQL query.
| SELECT main_industry , count(*) FROM company GROUP BY main_industry ORDER BY sum(market_value) DESC LIMIT 1 |
Show headquarters with at least two companies in the banking industry. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show headquarters with at least two companies in the banking industry.` to a syntactically-correct PostgreSQL query.
| SELECT headquarters FROM company WHERE main_industry = 'Banking' GROUP BY headquarters HAVING count(*) >= 2 |
What are the headquarters with at least two companies in the banking industry? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the headquarters with at least two companies in the banking industry?` to a syntactically-correct PostgreSQL query.
| SELECT headquarters FROM company WHERE main_industry = 'Banking' GROUP BY headquarters HAVING count(*) >= 2 |
Show gas station id, location, and manager_name for all gas stations ordered by open year. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show gas station id, location, and manager_name for all gas stations ordered by open year.` to a syntactically-correct PostgreSQL query.
| SELECT station_id , LOCATION , manager_name FROM gas_station ORDER BY open_year |
What are the gas station ids, locations, and manager names for the gas stations ordered by opening year? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the gas station ids, locations, and manager names for the gas stations ordered by opening year?` to a syntactically-correct PostgreSQL query.
| SELECT station_id , LOCATION , manager_name FROM gas_station ORDER BY open_year |
How many gas station are opened between 2000 and 2005? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many gas station are opened between 2000 and 2005?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM gas_station WHERE open_year BETWEEN 2000 AND 2005 |
What is the total number of gas stations that opened between 2000 and 2005? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the total number of gas stations that opened between 2000 and 2005?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM gas_station WHERE open_year BETWEEN 2000 AND 2005 |
Show all locations and the number of gas stations in each location ordered by the count. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show all locations and the number of gas stations in each location ordered by the count.` to a syntactically-correct PostgreSQL query.
| SELECT LOCATION , count(*) FROM gas_station GROUP BY LOCATION ORDER BY count(*) |
For each location, how many gas stations are there in order? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `For each location, how many gas stations are there in order?` to a syntactically-correct PostgreSQL query.
| SELECT LOCATION , count(*) FROM gas_station GROUP BY LOCATION ORDER BY count(*) |
Show all headquarters with both a company in banking industry and a company in Oil and gas. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show all headquarters with both a company in banking industry and a company in Oil and gas.` to a syntactically-correct PostgreSQL query.
| SELECT headquarters FROM company WHERE main_industry = 'Banking' INTERSECT SELECT headquarters FROM company WHERE main_industry = 'Oil and gas' |
What are the headquarters that have both a company in the banking and 'oil and gas' industries? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the headquarters that have both a company in the banking and 'oil and gas' industries?` to a syntactically-correct PostgreSQL query.
| SELECT headquarters FROM company WHERE main_industry = 'Banking' INTERSECT SELECT headquarters FROM company WHERE main_industry = 'Oil and gas' |
Show all headquarters without a company in banking industry. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show all headquarters without a company in banking industry.` to a syntactically-correct PostgreSQL query.
| SELECT headquarters FROM company EXCEPT SELECT headquarters FROM company WHERE main_industry = 'Banking' |
What are the headquarters without companies that are in the banking industry? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the headquarters without companies that are in the banking industry?` to a syntactically-correct PostgreSQL query.
| SELECT headquarters FROM company EXCEPT SELECT headquarters FROM company WHERE main_industry = 'Banking' |
Show the company name with the number of gas station. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the company name with the number of gas station.` to a syntactically-correct PostgreSQL query.
| SELECT T2.company , count(*) FROM station_company AS T1 JOIN company AS T2 ON T1.company_id = T2.company_id GROUP BY T1.company_id |
For each company id, what are the companies and how many gas stations does each one operate? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `For each company id, what are the companies and how many gas stations does each one operate?` to a syntactically-correct PostgreSQL query.
| SELECT T2.company , count(*) FROM station_company AS T1 JOIN company AS T2 ON T1.company_id = T2.company_id GROUP BY T1.company_id |
Show company name and main industry without a gas station. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show company name and main industry without a gas station.` to a syntactically-correct PostgreSQL query.
| SELECT company , main_industry FROM company WHERE company_id NOT IN (SELECT company_id FROM station_company) |
What are the main industries of the companies without gas stations and what are the companies? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the main industries of the companies without gas stations and what are the companies?` to a syntactically-correct PostgreSQL query.
| SELECT company , main_industry FROM company WHERE company_id NOT IN (SELECT company_id FROM station_company) |
Show the manager name for gas stations belonging to the ExxonMobil company. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the manager name for gas stations belonging to the ExxonMobil company.` to a syntactically-correct PostgreSQL query.
| SELECT T3.manager_name FROM station_company AS T1 JOIN company AS T2 ON T1.company_id = T2.company_id JOIN gas_station AS T3 ON T1.station_id = T3.station_id WHERE T2.company = 'ExxonMobil' |
What are the names of the managers for gas stations that are operated by the ExxonMobil company? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the names of the managers for gas stations that are operated by the ExxonMobil company?` to a syntactically-correct PostgreSQL query.
| SELECT T3.manager_name FROM station_company AS T1 JOIN company AS T2 ON T1.company_id = T2.company_id JOIN gas_station AS T3 ON T1.station_id = T3.station_id WHERE T2.company = 'ExxonMobil' |
Show all locations where a gas station for company with market value greater than 100 is located. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show all locations where a gas station for company with market value greater than 100 is located.` to a syntactically-correct PostgreSQL query.
| SELECT T3.location FROM station_company AS T1 JOIN company AS T2 ON T1.company_id = T2.company_id JOIN gas_station AS T3 ON T1.station_id = T3.station_id WHERE T2.market_value > 100 |
What are the locations that have gas stations owned by a company with a market value greater than 100? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the locations that have gas stations owned by a company with a market value greater than 100?` to a syntactically-correct PostgreSQL query.
| SELECT T3.location FROM station_company AS T1 JOIN company AS T2 ON T1.company_id = T2.company_id JOIN gas_station AS T3 ON T1.station_id = T3.station_id WHERE T2.market_value > 100 |
Show the manager name with most number of gas stations opened after 2000. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the manager name with most number of gas stations opened after 2000.` to a syntactically-correct PostgreSQL query.
| SELECT manager_name FROM gas_station WHERE open_year > 2000 GROUP BY manager_name ORDER BY count(*) DESC LIMIT 1 |
What is the name of the manager with the most gas stations that opened after 2000? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the name of the manager with the most gas stations that opened after 2000?` to a syntactically-correct PostgreSQL query.
| SELECT manager_name FROM gas_station WHERE open_year > 2000 GROUP BY manager_name ORDER BY count(*) DESC LIMIT 1 |
order all gas station locations by the opening year. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `order all gas station locations by the opening year.` to a syntactically-correct PostgreSQL query.
| SELECT LOCATION FROM gas_station ORDER BY open_year |
What are the locations of all the gas stations ordered by opening year? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the locations of all the gas stations ordered by opening year?` to a syntactically-correct PostgreSQL query.
| SELECT LOCATION FROM gas_station ORDER BY open_year |
find the rank, company names, market values of the companies in the banking industry order by their sales and profits in billion. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `find the rank, company names, market values of the companies in the banking industry order by their sales and profits in billion.` to a syntactically-correct PostgreSQL query.
| SELECT rank , company , market_value FROM company WHERE main_industry = 'Banking' ORDER BY sales_billion , profits_billion |
What is the rank, company, and market value of every comapny in the banking industry ordered by sales and profits? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the rank, company, and market value of every comapny in the banking industry ordered by sales and profits?` to a syntactically-correct PostgreSQL query.
| SELECT rank , company , market_value FROM company WHERE main_industry = 'Banking' ORDER BY sales_billion , profits_billion |
find the location and Representative name of the gas stations owned by the companies with top 3 Asset amounts. |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `find the location and Representative name of the gas stations owned by the companies with top 3 Asset amounts.` to a syntactically-correct PostgreSQL query.
| SELECT T3.location , T3.Representative_Name FROM station_company AS T1 JOIN company AS T2 ON T1.company_id = T2.company_id JOIN gas_station AS T3 ON T1.station_id = T3.station_id ORDER BY T2.Assets_billion DESC LIMIT 3 |
What are the locations and representatives' names of the gas stations owned by the companies with the 3 largest amounts of assets? |
-- Language PostgreSQL
-- Tables:
-- Table: company
columns : [['company id', 'number'], ['rank', 'number'], ['company', 'text'], ['headquarters', 'text'], ['main industry', 'text'], ['sales billion', 'number'], ['profits billion', 'number'], ['assets billion', 'number'], ['market value', 'number']]
-- Table: gas station
columns : [['station id', 'number'], ['open year', 'number'], ['location', 'text'], ['manager name', 'text'], ['vice manager name', 'text'], ['representative name', 'text']]
-- Table: station company
columns : [['station id', 'number'], ['company id', 'number'], ['rank of the year', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the locations and representatives' names of the gas stations owned by the companies with the 3 largest amounts of assets?` to a syntactically-correct PostgreSQL query.
| SELECT T3.location , T3.Representative_Name FROM station_company AS T1 JOIN company AS T2 ON T1.company_id = T2.company_id JOIN gas_station AS T3 ON T1.station_id = T3.station_id ORDER BY T2.Assets_billion DESC LIMIT 3 |
How many regions do we have? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many regions do we have?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM region |
Count the number of regions. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Count the number of regions.` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM region |
Show all distinct region names ordered by their labels. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show all distinct region names ordered by their labels.` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT region_name FROM region ORDER BY Label |
What are the different region names, ordered by labels? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the different region names, ordered by labels?` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT region_name FROM region ORDER BY Label |
How many parties do we have? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many parties do we have?` to a syntactically-correct PostgreSQL query.
| SELECT count(DISTINCT party_name) FROM party |
Count the number of different parties. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Count the number of different parties.` to a syntactically-correct PostgreSQL query.
| SELECT count(DISTINCT party_name) FROM party |
Show the ministers and the time they took and left office, listed by the time they left office. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the ministers and the time they took and left office, listed by the time they left office.` to a syntactically-correct PostgreSQL query.
| SELECT minister , took_office , left_office FROM party ORDER BY left_office |
Who are the ministers, when did they take office, and when did they leave office, ordered by when they left office? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Who are the ministers, when did they take office, and when did they leave office, ordered by when they left office?` to a syntactically-correct PostgreSQL query.
| SELECT minister , took_office , left_office FROM party ORDER BY left_office |
Show the minister who took office after 1961 or before 1959. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the minister who took office after 1961 or before 1959.` to a syntactically-correct PostgreSQL query.
| SELECT minister FROM party WHERE took_office > 1961 OR took_office < 1959 |
Who are the ministers who took office after 1961 or before 1959? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Who are the ministers who took office after 1961 or before 1959?` to a syntactically-correct PostgreSQL query.
| SELECT minister FROM party WHERE took_office > 1961 OR took_office < 1959 |
Show all ministers who do not belong to Progress Party. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show all ministers who do not belong to Progress Party.` to a syntactically-correct PostgreSQL query.
| SELECT minister FROM party WHERE party_name != 'Progress Party' |
Which ministers are not a part of the Progress Party? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Which ministers are not a part of the Progress Party?` to a syntactically-correct PostgreSQL query.
| SELECT minister FROM party WHERE party_name != 'Progress Party' |
Show all ministers and parties they belong to in descending order of the time they took office. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show all ministers and parties they belong to in descending order of the time they took office.` to a syntactically-correct PostgreSQL query.
| SELECT minister , party_name FROM party ORDER BY took_office DESC |
Who are the ministers and what parties do they belong to, listed descending by the times they took office? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Who are the ministers and what parties do they belong to, listed descending by the times they took office?` to a syntactically-correct PostgreSQL query.
| SELECT minister , party_name FROM party ORDER BY took_office DESC |
Return the minister who left office at the latest time. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Return the minister who left office at the latest time.` to a syntactically-correct PostgreSQL query.
| SELECT minister FROM party ORDER BY left_office DESC LIMIT 1 |
Which minister left office the latest? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Which minister left office the latest?` to a syntactically-correct PostgreSQL query.
| SELECT minister FROM party ORDER BY left_office DESC LIMIT 1 |
List member names and their party names. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List member names and their party names.` to a syntactically-correct PostgreSQL query.
| SELECT T1.member_name , T2.party_name FROM Member AS T1 JOIN party AS T2 ON T1.party_id = T2.party_id |
What are the names of members and their corresponding parties? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the names of members and their corresponding parties?` to a syntactically-correct PostgreSQL query.
| SELECT T1.member_name , T2.party_name FROM Member AS T1 JOIN party AS T2 ON T1.party_id = T2.party_id |
Show all party names and the number of members in each party. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show all party names and the number of members in each party.` to a syntactically-correct PostgreSQL query.
| SELECT T2.party_name , count(*) FROM Member AS T1 JOIN party AS T2 ON T1.party_id = T2.party_id GROUP BY T1.party_id |
How many members are in each party? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many members are in each party?` to a syntactically-correct PostgreSQL query.
| SELECT T2.party_name , count(*) FROM Member AS T1 JOIN party AS T2 ON T1.party_id = T2.party_id GROUP BY T1.party_id |
What is the name of party with most number of members? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the name of party with most number of members?` to a syntactically-correct PostgreSQL query.
| SELECT T2.party_name FROM Member AS T1 JOIN party AS T2 ON T1.party_id = T2.party_id GROUP BY T1.party_id ORDER BY count(*) DESC LIMIT 1 |
Return the name of the party with the most members. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Return the name of the party with the most members.` to a syntactically-correct PostgreSQL query.
| SELECT T2.party_name FROM Member AS T1 JOIN party AS T2 ON T1.party_id = T2.party_id GROUP BY T1.party_id ORDER BY count(*) DESC LIMIT 1 |
Show all party names and their region names. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show all party names and their region names.` to a syntactically-correct PostgreSQL query.
| SELECT T1.party_name , T2.region_name FROM party AS T1 JOIN region AS T2 ON T1.region_id = T2.region_id |
What are the names of parties and their respective regions? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the names of parties and their respective regions?` to a syntactically-correct PostgreSQL query.
| SELECT T1.party_name , T2.region_name FROM party AS T1 JOIN region AS T2 ON T1.region_id = T2.region_id |
Show names of parties that does not have any members. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show names of parties that does not have any members.` to a syntactically-correct PostgreSQL query.
| SELECT party_name FROM party WHERE party_id NOT IN (SELECT party_id FROM Member) |
What are the names of parties that have no members? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the names of parties that have no members?` to a syntactically-correct PostgreSQL query.
| SELECT party_name FROM party WHERE party_id NOT IN (SELECT party_id FROM Member) |
Show the member names which are in both the party with id 3 and the party with id 1. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the member names which are in both the party with id 3 and the party with id 1.` to a syntactically-correct PostgreSQL query.
| SELECT member_name FROM member WHERE party_id = 3 INTERSECT SELECT member_name FROM member WHERE party_id = 1 |
Which member names are shared among members in the party with the id 3 and the party with the id 1? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Which member names are shared among members in the party with the id 3 and the party with the id 1?` to a syntactically-correct PostgreSQL query.
| SELECT member_name FROM member WHERE party_id = 3 INTERSECT SELECT member_name FROM member WHERE party_id = 1 |
Show member names that are not in the Progress Party. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show member names that are not in the Progress Party.` to a syntactically-correct PostgreSQL query.
| SELECT T1.member_name FROM Member AS T1 JOIN party AS T2 ON T1.party_id = T2.party_id WHERE T2.Party_name != "Progress Party" |
Which member names corresponding to members who are not in the Progress Party? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Which member names corresponding to members who are not in the Progress Party?` to a syntactically-correct PostgreSQL query.
| SELECT T1.member_name FROM Member AS T1 JOIN party AS T2 ON T1.party_id = T2.party_id WHERE T2.Party_name != "Progress Party" |
How many party events do we have? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many party events do we have?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM party_events |
Count the number of party events. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Count the number of party events.` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM party_events |
Show party names and the number of events for each party. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show party names and the number of events for each party.` to a syntactically-correct PostgreSQL query.
| SELECT T2.party_name , count(*) FROM party_events AS T1 JOIN party AS T2 ON T1.party_id = T2.party_id GROUP BY T1.party_id |
How many events are there for each party? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many events are there for each party?` to a syntactically-correct PostgreSQL query.
| SELECT T2.party_name , count(*) FROM party_events AS T1 JOIN party AS T2 ON T1.party_id = T2.party_id GROUP BY T1.party_id |
Show all member names who are not in charge of any event. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show all member names who are not in charge of any event.` to a syntactically-correct PostgreSQL query.
| SELECT member_name FROM member EXCEPT SELECT T1.member_name FROM member AS T1 JOIN party_events AS T2 ON T1.member_id = T2.member_in_charge_id |
What are the names of members who are not in charge of any events? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the names of members who are not in charge of any events?` to a syntactically-correct PostgreSQL query.
| SELECT member_name FROM member EXCEPT SELECT T1.member_name FROM member AS T1 JOIN party_events AS T2 ON T1.member_id = T2.member_in_charge_id |
What are the names of parties with at least 2 events? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the names of parties with at least 2 events?` to a syntactically-correct PostgreSQL query.
| SELECT T2.party_name FROM party_events AS T1 JOIN party AS T2 ON T1.party_id = T2.party_id GROUP BY T1.party_id HAVING count(*) >= 2 |
Return the names of parties that have two or more events. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Return the names of parties that have two or more events.` to a syntactically-correct PostgreSQL query.
| SELECT T2.party_name FROM party_events AS T1 JOIN party AS T2 ON T1.party_id = T2.party_id GROUP BY T1.party_id HAVING count(*) >= 2 |
What is the name of member in charge of greatest number of events? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the name of member in charge of greatest number of events?` to a syntactically-correct PostgreSQL query.
| SELECT T1.member_name FROM member AS T1 JOIN party_events AS T2 ON T1.member_id = T2.member_in_charge_id GROUP BY T2.member_in_charge_id ORDER BY count(*) DESC LIMIT 1 |
Return the name of the member who is in charge of the most events. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Return the name of the member who is in charge of the most events.` to a syntactically-correct PostgreSQL query.
| SELECT T1.member_name FROM member AS T1 JOIN party_events AS T2 ON T1.member_id = T2.member_in_charge_id GROUP BY T2.member_in_charge_id ORDER BY count(*) DESC LIMIT 1 |
find the event names that have more than 2 records. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `find the event names that have more than 2 records.` to a syntactically-correct PostgreSQL query.
| SELECT event_name FROM party_events GROUP BY event_name HAVING count(*) > 2 |
Which event names were used more than twice for party events? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Which event names were used more than twice for party events?` to a syntactically-correct PostgreSQL query.
| SELECT event_name FROM party_events GROUP BY event_name HAVING count(*) > 2 |
How many Annual Meeting events happened in the United Kingdom region? |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many Annual Meeting events happened in the United Kingdom region?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM region AS t1 JOIN party AS t2 ON t1.region_id = t2.region_id JOIN party_events AS t3 ON t2.party_id = t3.party_id WHERE t1.region_name = "United Kingdom" AND t3.Event_Name = "Annaual Meeting" |
Count the number of Annual Meeting events that took place in the region of the United Kingdom. |
-- Language PostgreSQL
-- Tables:
-- Table: region
columns : [['region id', 'number'], ['region name', 'text'], ['date', 'text'], ['label', 'text'], ['format', 'text'], ['catalogue', 'text']]
-- Table: party
columns : [['party id', 'number'], ['minister', 'text'], ['took office', 'text'], ['left office', 'text'], ['region id', 'number'], ['party name', 'text']]
-- Table: member
columns : [['member id', 'number'], ['member name', 'text'], ['party id', 'text'], ['in office', 'text']]
-- Table: party events
columns : [['event id', 'number'], ['event name', 'text'], ['party id', 'number'], ['member in charge id', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Count the number of Annual Meeting events that took place in the region of the United Kingdom.` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM region AS t1 JOIN party AS t2 ON t1.region_id = t2.region_id JOIN party_events AS t3 ON t2.party_id = t3.party_id WHERE t1.region_name = "United Kingdom" AND t3.Event_Name = "Annaual Meeting" |
How many pilots are there? |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many pilots are there?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM pilot |
List the names of pilots in ascending order of rank. |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List the names of pilots in ascending order of rank.` to a syntactically-correct PostgreSQL query.
| SELECT Pilot_name FROM pilot ORDER BY Rank ASC |
What are the positions and teams of pilots? |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the positions and teams of pilots?` to a syntactically-correct PostgreSQL query.
| SELECT POSITION , Team FROM pilot |
List the distinct positions of pilots older than 30. |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List the distinct positions of pilots older than 30.` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT POSITION FROM pilot WHERE Age > 30 |
Show the names of pilots from team "Bradley" or "Fordham". |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the names of pilots from team "Bradley" or "Fordham".` to a syntactically-correct PostgreSQL query.
| SELECT Pilot_name FROM pilot WHERE Team = "Bradley" OR Team = "Fordham" |
What is the joined year of the pilot of the highest rank? |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the joined year of the pilot of the highest rank?` to a syntactically-correct PostgreSQL query.
| SELECT Join_Year FROM pilot ORDER BY Rank ASC LIMIT 1 |
What are the different nationalities of pilots? Show each nationality and the number of pilots of each nationality. |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the different nationalities of pilots? Show each nationality and the number of pilots of each nationality.` to a syntactically-correct PostgreSQL query.
| SELECT Nationality , COUNT(*) FROM pilot GROUP BY Nationality |
Show the most common nationality of pilots. |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the most common nationality of pilots.` to a syntactically-correct PostgreSQL query.
| SELECT Nationality FROM pilot GROUP BY Nationality ORDER BY COUNT(*) DESC LIMIT 1 |
Show the pilot positions that have both pilots joining after year 2005 and pilots joining before 2000. |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the pilot positions that have both pilots joining after year 2005 and pilots joining before 2000.` to a syntactically-correct PostgreSQL query.
| SELECT POSITION FROM pilot WHERE Join_Year < 2000 INTERSECT SELECT POSITION FROM pilot WHERE Join_Year > 2005 |
Show the names of pilots and models of aircrafts they have flied with. |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the names of pilots and models of aircrafts they have flied with.` to a syntactically-correct PostgreSQL query.
| SELECT T3.Pilot_name , T2.Model FROM pilot_record AS T1 JOIN aircraft AS T2 ON T1.Aircraft_ID = T2.Aircraft_ID JOIN pilot AS T3 ON T1.Pilot_ID = T3.Pilot_ID |
Show the names of pilots and fleet series of the aircrafts they have flied with in ascending order of the rank of the pilot. |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the names of pilots and fleet series of the aircrafts they have flied with in ascending order of the rank of the pilot.` to a syntactically-correct PostgreSQL query.
| SELECT T3.Pilot_name , T2.Fleet_Series FROM pilot_record AS T1 JOIN aircraft AS T2 ON T1.Aircraft_ID = T2.Aircraft_ID JOIN pilot AS T3 ON T1.Pilot_ID = T3.Pilot_ID ORDER BY T3.Rank |
Show the fleet series of the aircrafts flied by pilots younger than 34 |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the fleet series of the aircrafts flied by pilots younger than 34` to a syntactically-correct PostgreSQL query.
| SELECT T2.Fleet_Series FROM pilot_record AS T1 JOIN aircraft AS T2 ON T1.Aircraft_ID = T2.Aircraft_ID JOIN pilot AS T3 ON T1.Pilot_ID = T3.Pilot_ID WHERE T3.Age < 34 |
Show the names of pilots and the number of records they have. |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the names of pilots and the number of records they have.` to a syntactically-correct PostgreSQL query.
| SELECT T2.Pilot_name , COUNT(*) FROM pilot_record AS T1 JOIN pilot AS T2 ON T1.pilot_ID = T2.pilot_ID GROUP BY T2.Pilot_name |
Show names of pilots that have more than one record. |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show names of pilots that have more than one record.` to a syntactically-correct PostgreSQL query.
| SELECT T2.Pilot_name , COUNT(*) FROM pilot_record AS T1 JOIN pilot AS T2 ON T1.pilot_ID = T2.pilot_ID GROUP BY T2.Pilot_name HAVING COUNT(*) > 1 |
List the names of pilots that do not have any record. |
-- Language PostgreSQL
-- Tables:
-- Table: aircraft
columns : [['aircraft id', 'number'], ['order year', 'number'], ['manufacturer', 'text'], ['model', 'text'], ['fleet series', 'text'], ['powertrain', 'text'], ['fuel propulsion', 'text']]
-- Table: pilot
columns : [['pilot id', 'number'], ['pilot name', 'text'], ['rank', 'number'], ['age', 'number'], ['nationality', 'text'], ['position', 'text'], ['join year', 'number'], ['team', 'text']]
-- Table: pilot record
columns : [['record id', 'number'], ['pilot id', 'number'], ['aircraft id', 'number'], ['date', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List the names of pilots that do not have any record.` to a syntactically-correct PostgreSQL query.
| SELECT Pilot_name FROM pilot WHERE Pilot_ID NOT IN (SELECT Pilot_ID FROM pilot_record) |
What document status codes do we have? |
-- Language PostgreSQL
-- Tables:
-- Table: reference document types
columns : [['document type code', 'text'], ['document type description', 'text']]
-- Table: roles
columns : [['role code', 'text'], ['role description', 'text']]
-- Table: addresses
columns : [['address id', 'number'], ['address details', 'text']]
-- Table: reference document status
columns : [['document status code', 'text'], ['document status description', 'text']]
-- Table: reference shipping agents
columns : [['shipping agent code', 'text'], ['shipping agent name', 'text'], ['shipping agent description', 'text']]
-- Table: documents
columns : [['document id', 'number'], ['document status code', 'text'], ['document type code', 'text'], ['shipping agent code', 'text'], ['receipt date', 'time'], ['receipt number', 'text'], ['other details', 'text']]
-- Table: employees
columns : [['employee id', 'number'], ['role code', 'text'], ['employee name', 'text'], ['other details', 'text']]
-- Table: document drafts
columns : [['document id', 'number'], ['draft number', 'number'], ['draft details', 'text']]
-- Table: draft copies
columns : [['document id', 'number'], ['draft number', 'number'], ['copy number', 'number']]
-- Table: circulation history
columns : [['document id', 'number'], ['draft number', 'number'], ['copy number', 'number'], ['employee id', 'number']]
-- Table: documents mailed
columns : [['document id', 'number'], ['mailed to address id', 'number'], ['mailing date', 'time']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What document status codes do we have?` to a syntactically-correct PostgreSQL query.
| SELECT document_status_code FROM Ref_Document_Status; |
What is the description of document status code 'working'? |
-- Language PostgreSQL
-- Tables:
-- Table: reference document types
columns : [['document type code', 'text'], ['document type description', 'text']]
-- Table: roles
columns : [['role code', 'text'], ['role description', 'text']]
-- Table: addresses
columns : [['address id', 'number'], ['address details', 'text']]
-- Table: reference document status
columns : [['document status code', 'text'], ['document status description', 'text']]
-- Table: reference shipping agents
columns : [['shipping agent code', 'text'], ['shipping agent name', 'text'], ['shipping agent description', 'text']]
-- Table: documents
columns : [['document id', 'number'], ['document status code', 'text'], ['document type code', 'text'], ['shipping agent code', 'text'], ['receipt date', 'time'], ['receipt number', 'text'], ['other details', 'text']]
-- Table: employees
columns : [['employee id', 'number'], ['role code', 'text'], ['employee name', 'text'], ['other details', 'text']]
-- Table: document drafts
columns : [['document id', 'number'], ['draft number', 'number'], ['draft details', 'text']]
-- Table: draft copies
columns : [['document id', 'number'], ['draft number', 'number'], ['copy number', 'number']]
-- Table: circulation history
columns : [['document id', 'number'], ['draft number', 'number'], ['copy number', 'number'], ['employee id', 'number']]
-- Table: documents mailed
columns : [['document id', 'number'], ['mailed to address id', 'number'], ['mailing date', 'time']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the description of document status code 'working'?` to a syntactically-correct PostgreSQL query.
| SELECT document_status_description FROM Ref_Document_Status WHERE document_status_code = "working"; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.