Datasets:

sert121

/

SpiderSQL

like 0

What are the dates that have an average sea level pressure between 30.3 and 31?

-- Language PostgreSQL -- Tables: -- Table: station columns : [['id', 'number'], ['name', 'text'], ['latitude', 'number'], ['longitude', 'number'], ['dock count', 'number'], ['city', 'text'], ['installation date', 'text']] -- Table: status columns : [['station id', 'number'], ['bikes available', 'number'], ['docks available', 'number'], ['time', 'text']] -- Table: trip columns : [['id', 'number'], ['duration', 'number'], ['start date', 'text'], ['start station name', 'text'], ['start station id', 'number'], ['end date', 'text'], ['end station name', 'text'], ['end station id', 'number'], ['bike id', 'number'], ['subscription type', 'text'], ['zip code', 'number']] -- Table: weather columns : [['date', 'text'], ['max temperature f', 'number'], ['mean temperature f', 'number'], ['min temperature f', 'number'], ['max dew point f', 'number'], ['mean dew point f', 'number'], ['min dew point f', 'number'], ['max humidity', 'number'], ['mean humidity', 'number'], ['min humidity', 'number'], ['max sea level pressure inches', 'number'], ['mean sea level pressure inches', 'number'], ['min sea level pressure inches', 'number'], ['max visibility miles', 'number'], ['mean visibility miles', 'number'], ['min visibility miles', 'number'], ['max wind speed mph', 'number'], ['mean wind speed mph', 'number'], ['max gust speed mph', 'number'], ['precipitation inches', 'number'], ['cloud cover', 'number'], ['events', 'text'], ['wind dir degrees', 'number'], ['zip code', '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 dates that have an average sea level pressure between 30.3 and 31?` to a syntactically-correct PostgreSQL query.

SELECT date FROM weather WHERE mean_sea_level_pressure_inches BETWEEN 30.3 AND 31

Find the day in which the difference between the max temperature and min temperature was the smallest. Also report the difference.

-- Language PostgreSQL -- Tables: -- Table: station columns : [['id', 'number'], ['name', 'text'], ['latitude', 'number'], ['longitude', 'number'], ['dock count', 'number'], ['city', 'text'], ['installation date', 'text']] -- Table: status columns : [['station id', 'number'], ['bikes available', 'number'], ['docks available', 'number'], ['time', 'text']] -- Table: trip columns : [['id', 'number'], ['duration', 'number'], ['start date', 'text'], ['start station name', 'text'], ['start station id', 'number'], ['end date', 'text'], ['end station name', 'text'], ['end station id', 'number'], ['bike id', 'number'], ['subscription type', 'text'], ['zip code', 'number']] -- Table: weather columns : [['date', 'text'], ['max temperature f', 'number'], ['mean temperature f', 'number'], ['min temperature f', 'number'], ['max dew point f', 'number'], ['mean dew point f', 'number'], ['min dew point f', 'number'], ['max humidity', 'number'], ['mean humidity', 'number'], ['min humidity', 'number'], ['max sea level pressure inches', 'number'], ['mean sea level pressure inches', 'number'], ['min sea level pressure inches', 'number'], ['max visibility miles', 'number'], ['mean visibility miles', 'number'], ['min visibility miles', 'number'], ['max wind speed mph', 'number'], ['mean wind speed mph', 'number'], ['max gust speed mph', 'number'], ['precipitation inches', 'number'], ['cloud cover', 'number'], ['events', 'text'], ['wind dir degrees', 'number'], ['zip code', '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 day in which the difference between the max temperature and min temperature was the smallest. Also report the difference.` to a syntactically-correct PostgreSQL query.

SELECT date , max_temperature_f - min_temperature_f FROM weather ORDER BY max_temperature_f - min_temperature_f LIMIT 1

What are the days that had the smallest temperature range, and what was that range?

-- Language PostgreSQL -- Tables: -- Table: station columns : [['id', 'number'], ['name', 'text'], ['latitude', 'number'], ['longitude', 'number'], ['dock count', 'number'], ['city', 'text'], ['installation date', 'text']] -- Table: status columns : [['station id', 'number'], ['bikes available', 'number'], ['docks available', 'number'], ['time', 'text']] -- Table: trip columns : [['id', 'number'], ['duration', 'number'], ['start date', 'text'], ['start station name', 'text'], ['start station id', 'number'], ['end date', 'text'], ['end station name', 'text'], ['end station id', 'number'], ['bike id', 'number'], ['subscription type', 'text'], ['zip code', 'number']] -- Table: weather columns : [['date', 'text'], ['max temperature f', 'number'], ['mean temperature f', 'number'], ['min temperature f', 'number'], ['max dew point f', 'number'], ['mean dew point f', 'number'], ['min dew point f', 'number'], ['max humidity', 'number'], ['mean humidity', 'number'], ['min humidity', 'number'], ['max sea level pressure inches', 'number'], ['mean sea level pressure inches', 'number'], ['min sea level pressure inches', 'number'], ['max visibility miles', 'number'], ['mean visibility miles', 'number'], ['min visibility miles', 'number'], ['max wind speed mph', 'number'], ['mean wind speed mph', 'number'], ['max gust speed mph', 'number'], ['precipitation inches', 'number'], ['cloud cover', 'number'], ['events', 'text'], ['wind dir degrees', 'number'], ['zip code', '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 days that had the smallest temperature range, and what was that range?` to a syntactically-correct PostgreSQL query.

SELECT date , max_temperature_f - min_temperature_f FROM weather ORDER BY max_temperature_f - min_temperature_f LIMIT 1

What are the id and name of the stations that have ever had more than 12 bikes available?

-- Language PostgreSQL -- Tables: -- Table: station columns : [['id', 'number'], ['name', 'text'], ['latitude', 'number'], ['longitude', 'number'], ['dock count', 'number'], ['city', 'text'], ['installation date', 'text']] -- Table: status columns : [['station id', 'number'], ['bikes available', 'number'], ['docks available', 'number'], ['time', 'text']] -- Table: trip columns : [['id', 'number'], ['duration', 'number'], ['start date', 'text'], ['start station name', 'text'], ['start station id', 'number'], ['end date', 'text'], ['end station name', 'text'], ['end station id', 'number'], ['bike id', 'number'], ['subscription type', 'text'], ['zip code', 'number']] -- Table: weather columns : [['date', 'text'], ['max temperature f', 'number'], ['mean temperature f', 'number'], ['min temperature f', 'number'], ['max dew point f', 'number'], ['mean dew point f', 'number'], ['min dew point f', 'number'], ['max humidity', 'number'], ['mean humidity', 'number'], ['min humidity', 'number'], ['max sea level pressure inches', 'number'], ['mean sea level pressure inches', 'number'], ['min sea level pressure inches', 'number'], ['max visibility miles', 'number'], ['mean visibility miles', 'number'], ['min visibility miles', 'number'], ['max wind speed mph', 'number'], ['mean wind speed mph', 'number'], ['max gust speed mph', 'number'], ['precipitation inches', 'number'], ['cloud cover', 'number'], ['events', 'text'], ['wind dir degrees', 'number'], ['zip code', '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 id and name of the stations that have ever had more than 12 bikes available?` to a syntactically-correct PostgreSQL query.

SELECT DISTINCT T1.id , T1.name FROM station AS T1 JOIN status AS T2 ON T1.id = T2.station_id WHERE T2.bikes_available > 12

What are the different ids and names of the stations that have had more than 12 bikes available?

-- Language PostgreSQL -- Tables: -- Table: station columns : [['id', 'number'], ['name', 'text'], ['latitude', 'number'], ['longitude', 'number'], ['dock count', 'number'], ['city', 'text'], ['installation date', 'text']] -- Table: status columns : [['station id', 'number'], ['bikes available', 'number'], ['docks available', 'number'], ['time', 'text']] -- Table: trip columns : [['id', 'number'], ['duration', 'number'], ['start date', 'text'], ['start station name', 'text'], ['start station id', 'number'], ['end date', 'text'], ['end station name', 'text'], ['end station id', 'number'], ['bike id', 'number'], ['subscription type', 'text'], ['zip code', 'number']] -- Table: weather columns : [['date', 'text'], ['max temperature f', 'number'], ['mean temperature f', 'number'], ['min temperature f', 'number'], ['max dew point f', 'number'], ['mean dew point f', 'number'], ['min dew point f', 'number'], ['max humidity', 'number'], ['mean humidity', 'number'], ['min humidity', 'number'], ['max sea level pressure inches', 'number'], ['mean sea level pressure inches', 'number'], ['min sea level pressure inches', 'number'], ['max visibility miles', 'number'], ['mean visibility miles', 'number'], ['min visibility miles', 'number'], ['max wind speed mph', 'number'], ['mean wind speed mph', 'number'], ['max gust speed mph', 'number'], ['precipitation inches', 'number'], ['cloud cover', 'number'], ['events', 'text'], ['wind dir degrees', 'number'], ['zip code', '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 ids and names of the stations that have had more than 12 bikes available?` to a syntactically-correct PostgreSQL query.

SELECT DISTINCT T1.id , T1.name FROM station AS T1 JOIN status AS T2 ON T1.id = T2.station_id WHERE T2.bikes_available > 12

Give me the zip code where the average mean humidity is below 70 and at least 100 trips took place.

-- Language PostgreSQL -- Tables: -- Table: station columns : [['id', 'number'], ['name', 'text'], ['latitude', 'number'], ['longitude', 'number'], ['dock count', 'number'], ['city', 'text'], ['installation date', 'text']] -- Table: status columns : [['station id', 'number'], ['bikes available', 'number'], ['docks available', 'number'], ['time', 'text']] -- Table: trip columns : [['id', 'number'], ['duration', 'number'], ['start date', 'text'], ['start station name', 'text'], ['start station id', 'number'], ['end date', 'text'], ['end station name', 'text'], ['end station id', 'number'], ['bike id', 'number'], ['subscription type', 'text'], ['zip code', 'number']] -- Table: weather columns : [['date', 'text'], ['max temperature f', 'number'], ['mean temperature f', 'number'], ['min temperature f', 'number'], ['max dew point f', 'number'], ['mean dew point f', 'number'], ['min dew point f', 'number'], ['max humidity', 'number'], ['mean humidity', 'number'], ['min humidity', 'number'], ['max sea level pressure inches', 'number'], ['mean sea level pressure inches', 'number'], ['min sea level pressure inches', 'number'], ['max visibility miles', 'number'], ['mean visibility miles', 'number'], ['min visibility miles', 'number'], ['max wind speed mph', 'number'], ['mean wind speed mph', 'number'], ['max gust speed mph', 'number'], ['precipitation inches', 'number'], ['cloud cover', 'number'], ['events', 'text'], ['wind dir degrees', 'number'], ['zip code', '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 `Give me the zip code where the average mean humidity is below 70 and at least 100 trips took place.` to a syntactically-correct PostgreSQL query.

SELECT zip_code FROM weather GROUP BY zip_code HAVING avg(mean_humidity) < 70 INTERSECT SELECT zip_code FROM trip GROUP BY zip_code HAVING count(*) >= 100

What are the zip codes that have an average mean humidity below 70 and had at least 100 trips come through there?

-- Language PostgreSQL -- Tables: -- Table: station columns : [['id', 'number'], ['name', 'text'], ['latitude', 'number'], ['longitude', 'number'], ['dock count', 'number'], ['city', 'text'], ['installation date', 'text']] -- Table: status columns : [['station id', 'number'], ['bikes available', 'number'], ['docks available', 'number'], ['time', 'text']] -- Table: trip columns : [['id', 'number'], ['duration', 'number'], ['start date', 'text'], ['start station name', 'text'], ['start station id', 'number'], ['end date', 'text'], ['end station name', 'text'], ['end station id', 'number'], ['bike id', 'number'], ['subscription type', 'text'], ['zip code', 'number']] -- Table: weather columns : [['date', 'text'], ['max temperature f', 'number'], ['mean temperature f', 'number'], ['min temperature f', 'number'], ['max dew point f', 'number'], ['mean dew point f', 'number'], ['min dew point f', 'number'], ['max humidity', 'number'], ['mean humidity', 'number'], ['min humidity', 'number'], ['max sea level pressure inches', 'number'], ['mean sea level pressure inches', 'number'], ['min sea level pressure inches', 'number'], ['max visibility miles', 'number'], ['mean visibility miles', 'number'], ['min visibility miles', 'number'], ['max wind speed mph', 'number'], ['mean wind speed mph', 'number'], ['max gust speed mph', 'number'], ['precipitation inches', 'number'], ['cloud cover', 'number'], ['events', 'text'], ['wind dir degrees', 'number'], ['zip code', '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 zip codes that have an average mean humidity below 70 and had at least 100 trips come through there?` to a syntactically-correct PostgreSQL query.

SELECT zip_code FROM weather GROUP BY zip_code HAVING avg(mean_humidity) < 70 INTERSECT SELECT zip_code FROM trip GROUP BY zip_code HAVING count(*) >= 100

What are the names of stations that are located in Palo Alto city but have never been the ending point of trips more than 100 times?

-- Language PostgreSQL -- Tables: -- Table: station columns : [['id', 'number'], ['name', 'text'], ['latitude', 'number'], ['longitude', 'number'], ['dock count', 'number'], ['city', 'text'], ['installation date', 'text']] -- Table: status columns : [['station id', 'number'], ['bikes available', 'number'], ['docks available', 'number'], ['time', 'text']] -- Table: trip columns : [['id', 'number'], ['duration', 'number'], ['start date', 'text'], ['start station name', 'text'], ['start station id', 'number'], ['end date', 'text'], ['end station name', 'text'], ['end station id', 'number'], ['bike id', 'number'], ['subscription type', 'text'], ['zip code', 'number']] -- Table: weather columns : [['date', 'text'], ['max temperature f', 'number'], ['mean temperature f', 'number'], ['min temperature f', 'number'], ['max dew point f', 'number'], ['mean dew point f', 'number'], ['min dew point f', 'number'], ['max humidity', 'number'], ['mean humidity', 'number'], ['min humidity', 'number'], ['max sea level pressure inches', 'number'], ['mean sea level pressure inches', 'number'], ['min sea level pressure inches', 'number'], ['max visibility miles', 'number'], ['mean visibility miles', 'number'], ['min visibility miles', 'number'], ['max wind speed mph', 'number'], ['mean wind speed mph', 'number'], ['max gust speed mph', 'number'], ['precipitation inches', 'number'], ['cloud cover', 'number'], ['events', 'text'], ['wind dir degrees', 'number'], ['zip code', '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 stations that are located in Palo Alto city but have never been the ending point of trips more than 100 times?` to a syntactically-correct PostgreSQL query.

SELECT name FROM station WHERE city = "Palo Alto" EXCEPT SELECT end_station_name FROM trip GROUP BY end_station_name HAVING count(*) > 100

What are the names of the stations that are located in Palo Alto but have never been the ending point of the trips

-- Language PostgreSQL -- Tables: -- Table: station columns : [['id', 'number'], ['name', 'text'], ['latitude', 'number'], ['longitude', 'number'], ['dock count', 'number'], ['city', 'text'], ['installation date', 'text']] -- Table: status columns : [['station id', 'number'], ['bikes available', 'number'], ['docks available', 'number'], ['time', 'text']] -- Table: trip columns : [['id', 'number'], ['duration', 'number'], ['start date', 'text'], ['start station name', 'text'], ['start station id', 'number'], ['end date', 'text'], ['end station name', 'text'], ['end station id', 'number'], ['bike id', 'number'], ['subscription type', 'text'], ['zip code', 'number']] -- Table: weather columns : [['date', 'text'], ['max temperature f', 'number'], ['mean temperature f', 'number'], ['min temperature f', 'number'], ['max dew point f', 'number'], ['mean dew point f', 'number'], ['min dew point f', 'number'], ['max humidity', 'number'], ['mean humidity', 'number'], ['min humidity', 'number'], ['max sea level pressure inches', 'number'], ['mean sea level pressure inches', 'number'], ['min sea level pressure inches', 'number'], ['max visibility miles', 'number'], ['mean visibility miles', 'number'], ['min visibility miles', 'number'], ['max wind speed mph', 'number'], ['mean wind speed mph', 'number'], ['max gust speed mph', 'number'], ['precipitation inches', 'number'], ['cloud cover', 'number'], ['events', 'text'], ['wind dir degrees', 'number'], ['zip code', '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 stations that are located in Palo Alto but have never been the ending point of the trips` to a syntactically-correct PostgreSQL query.

SELECT name FROM station WHERE city = "Palo Alto" EXCEPT SELECT end_station_name FROM trip GROUP BY end_station_name HAVING count(*) > 100

How many trips started from Mountain View city and ended at Palo Alto city?

-- Language PostgreSQL -- Tables: -- Table: station columns : [['id', 'number'], ['name', 'text'], ['latitude', 'number'], ['longitude', 'number'], ['dock count', 'number'], ['city', 'text'], ['installation date', 'text']] -- Table: status columns : [['station id', 'number'], ['bikes available', 'number'], ['docks available', 'number'], ['time', 'text']] -- Table: trip columns : [['id', 'number'], ['duration', 'number'], ['start date', 'text'], ['start station name', 'text'], ['start station id', 'number'], ['end date', 'text'], ['end station name', 'text'], ['end station id', 'number'], ['bike id', 'number'], ['subscription type', 'text'], ['zip code', 'number']] -- Table: weather columns : [['date', 'text'], ['max temperature f', 'number'], ['mean temperature f', 'number'], ['min temperature f', 'number'], ['max dew point f', 'number'], ['mean dew point f', 'number'], ['min dew point f', 'number'], ['max humidity', 'number'], ['mean humidity', 'number'], ['min humidity', 'number'], ['max sea level pressure inches', 'number'], ['mean sea level pressure inches', 'number'], ['min sea level pressure inches', 'number'], ['max visibility miles', 'number'], ['mean visibility miles', 'number'], ['min visibility miles', 'number'], ['max wind speed mph', 'number'], ['mean wind speed mph', 'number'], ['max gust speed mph', 'number'], ['precipitation inches', 'number'], ['cloud cover', 'number'], ['events', 'text'], ['wind dir degrees', 'number'], ['zip code', '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 trips started from Mountain View city and ended at Palo Alto city?` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM station AS T1 JOIN trip AS T2 JOIN station AS T3 JOIN trip AS T4 ON T1.id = T2.start_station_id AND T2.id = T4.id AND T3.id = T4.end_station_id WHERE T1.city = "Mountain View" AND T3.city = "Palo Alto"

How many trips stated from a station in Mountain View and ended at one in Palo Alto?

-- Language PostgreSQL -- Tables: -- Table: station columns : [['id', 'number'], ['name', 'text'], ['latitude', 'number'], ['longitude', 'number'], ['dock count', 'number'], ['city', 'text'], ['installation date', 'text']] -- Table: status columns : [['station id', 'number'], ['bikes available', 'number'], ['docks available', 'number'], ['time', 'text']] -- Table: trip columns : [['id', 'number'], ['duration', 'number'], ['start date', 'text'], ['start station name', 'text'], ['start station id', 'number'], ['end date', 'text'], ['end station name', 'text'], ['end station id', 'number'], ['bike id', 'number'], ['subscription type', 'text'], ['zip code', 'number']] -- Table: weather columns : [['date', 'text'], ['max temperature f', 'number'], ['mean temperature f', 'number'], ['min temperature f', 'number'], ['max dew point f', 'number'], ['mean dew point f', 'number'], ['min dew point f', 'number'], ['max humidity', 'number'], ['mean humidity', 'number'], ['min humidity', 'number'], ['max sea level pressure inches', 'number'], ['mean sea level pressure inches', 'number'], ['min sea level pressure inches', 'number'], ['max visibility miles', 'number'], ['mean visibility miles', 'number'], ['min visibility miles', 'number'], ['max wind speed mph', 'number'], ['mean wind speed mph', 'number'], ['max gust speed mph', 'number'], ['precipitation inches', 'number'], ['cloud cover', 'number'], ['events', 'text'], ['wind dir degrees', 'number'], ['zip code', '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 trips stated from a station in Mountain View and ended at one in Palo Alto?` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM station AS T1 JOIN trip AS T2 JOIN station AS T3 JOIN trip AS T4 ON T1.id = T2.start_station_id AND T2.id = T4.id AND T3.id = T4.end_station_id WHERE T1.city = "Mountain View" AND T3.city = "Palo Alto"

What is the average latitude and longitude of the starting points of all trips?

-- Language PostgreSQL -- Tables: -- Table: station columns : [['id', 'number'], ['name', 'text'], ['latitude', 'number'], ['longitude', 'number'], ['dock count', 'number'], ['city', 'text'], ['installation date', 'text']] -- Table: status columns : [['station id', 'number'], ['bikes available', 'number'], ['docks available', 'number'], ['time', 'text']] -- Table: trip columns : [['id', 'number'], ['duration', 'number'], ['start date', 'text'], ['start station name', 'text'], ['start station id', 'number'], ['end date', 'text'], ['end station name', 'text'], ['end station id', 'number'], ['bike id', 'number'], ['subscription type', 'text'], ['zip code', 'number']] -- Table: weather columns : [['date', 'text'], ['max temperature f', 'number'], ['mean temperature f', 'number'], ['min temperature f', 'number'], ['max dew point f', 'number'], ['mean dew point f', 'number'], ['min dew point f', 'number'], ['max humidity', 'number'], ['mean humidity', 'number'], ['min humidity', 'number'], ['max sea level pressure inches', 'number'], ['mean sea level pressure inches', 'number'], ['min sea level pressure inches', 'number'], ['max visibility miles', 'number'], ['mean visibility miles', 'number'], ['min visibility miles', 'number'], ['max wind speed mph', 'number'], ['mean wind speed mph', 'number'], ['max gust speed mph', 'number'], ['precipitation inches', 'number'], ['cloud cover', 'number'], ['events', 'text'], ['wind dir degrees', 'number'], ['zip code', '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 average latitude and longitude of the starting points of all trips?` to a syntactically-correct PostgreSQL query.

SELECT avg(T1.lat) , avg(T1.long) FROM station AS T1 JOIN trip AS T2 ON T1.id = T2.start_station_id

What is the average latitude and longitude of all starting stations for the trips?

-- Language PostgreSQL -- Tables: -- Table: station columns : [['id', 'number'], ['name', 'text'], ['latitude', 'number'], ['longitude', 'number'], ['dock count', 'number'], ['city', 'text'], ['installation date', 'text']] -- Table: status columns : [['station id', 'number'], ['bikes available', 'number'], ['docks available', 'number'], ['time', 'text']] -- Table: trip columns : [['id', 'number'], ['duration', 'number'], ['start date', 'text'], ['start station name', 'text'], ['start station id', 'number'], ['end date', 'text'], ['end station name', 'text'], ['end station id', 'number'], ['bike id', 'number'], ['subscription type', 'text'], ['zip code', 'number']] -- Table: weather columns : [['date', 'text'], ['max temperature f', 'number'], ['mean temperature f', 'number'], ['min temperature f', 'number'], ['max dew point f', 'number'], ['mean dew point f', 'number'], ['min dew point f', 'number'], ['max humidity', 'number'], ['mean humidity', 'number'], ['min humidity', 'number'], ['max sea level pressure inches', 'number'], ['mean sea level pressure inches', 'number'], ['min sea level pressure inches', 'number'], ['max visibility miles', 'number'], ['mean visibility miles', 'number'], ['min visibility miles', 'number'], ['max wind speed mph', 'number'], ['mean wind speed mph', 'number'], ['max gust speed mph', 'number'], ['precipitation inches', 'number'], ['cloud cover', 'number'], ['events', 'text'], ['wind dir degrees', 'number'], ['zip code', '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 average latitude and longitude of all starting stations for the trips?` to a syntactically-correct PostgreSQL query.

SELECT avg(T1.lat) , avg(T1.long) FROM station AS T1 JOIN trip AS T2 ON T1.id = T2.start_station_id

How many books are there?

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 books are there?` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM book

List the writers of the books in ascending alphabetical order.

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 writers of the books in ascending alphabetical order.` to a syntactically-correct PostgreSQL query.

SELECT Writer FROM book ORDER BY Writer ASC

List the titles of the books in ascending order of issues.

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 titles of the books in ascending order of issues.` to a syntactically-correct PostgreSQL query.

SELECT Title FROM book ORDER BY Issues ASC

What are the titles of the books whose writer is not "Elaine Lee"?

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 titles of the books whose writer is not "Elaine Lee"?` to a syntactically-correct PostgreSQL query.

SELECT Title FROM book WHERE Writer != "Elaine Lee"

What are the title and issues of the books?

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 title and issues of the books?` to a syntactically-correct PostgreSQL query.

SELECT Title , Issues FROM book

What are the dates of publications in descending order of price?

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 dates of publications in descending order of price?` to a syntactically-correct PostgreSQL query.

SELECT Publication_Date FROM publication ORDER BY Price DESC

What are the distinct publishers of publications with price higher than 5000000?

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 distinct publishers of publications with price higher than 5000000?` to a syntactically-correct PostgreSQL query.

SELECT DISTINCT Publisher FROM publication WHERE Price > 5000000

List the publisher of the publication with the highest price.

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 publisher of the publication with the highest price.` to a syntactically-correct PostgreSQL query.

SELECT Publisher FROM publication ORDER BY Price DESC LIMIT 1

List the publication dates of publications with 3 lowest prices.

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 publication dates of publications with 3 lowest prices.` to a syntactically-correct PostgreSQL query.

SELECT Publication_Date FROM publication ORDER BY Price ASC LIMIT 3

Show the title and publication dates of books.

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 title and publication dates of books.` to a syntactically-correct PostgreSQL query.

SELECT T1.Title , T2.Publication_Date FROM book AS T1 JOIN publication AS T2 ON T1.Book_ID = T2.Book_ID

Show writers who have published a book with price more than 4000000.

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 writers who have published a book with price more than 4000000.` to a syntactically-correct PostgreSQL query.

SELECT T1.Writer FROM book AS T1 JOIN publication AS T2 ON T1.Book_ID = T2.Book_ID WHERE T2.Price > 4000000

Show the titles of books in descending order of publication price.

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 titles of books in descending order of publication price.` to a syntactically-correct PostgreSQL query.

SELECT T1.Title FROM book AS T1 JOIN publication AS T2 ON T1.Book_ID = T2.Book_ID ORDER BY T2.Price DESC

Show publishers that have more than one publication.

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 publishers that have more than one publication.` to a syntactically-correct PostgreSQL query.

SELECT Publisher FROM publication GROUP BY Publisher HAVING COUNT(*) > 1

Show different publishers together with the number of publications they have.

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 different publishers together with the number of publications they have.` to a syntactically-correct PostgreSQL query.

SELECT Publisher , COUNT(*) FROM publication GROUP BY Publisher

Please show the most common publication date.

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 `Please show the most common publication date.` to a syntactically-correct PostgreSQL query.

SELECT Publication_Date FROM publication GROUP BY Publication_Date ORDER BY COUNT(*) DESC LIMIT 1

List the writers who have written more than one book.

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 writers who have written more than one book.` to a syntactically-correct PostgreSQL query.

SELECT Writer FROM book GROUP BY Writer HAVING COUNT(*) > 1

List the titles of books that are not published.

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 titles of books that are not published.` to a syntactically-correct PostgreSQL query.

SELECT Title FROM book WHERE Book_ID NOT IN (SELECT Book_ID FROM publication)

Show the publishers that have publications with price higher than 10000000 and publications with price lower than 5000000.

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 publishers that have publications with price higher than 10000000 and publications with price lower than 5000000.` to a syntactically-correct PostgreSQL query.

SELECT Publisher FROM publication WHERE Price > 10000000 INTERSECT SELECT Publisher FROM publication WHERE Price < 5000000

What is the number of distinct publication dates?

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 number of distinct publication dates?` to a syntactically-correct PostgreSQL query.

SELECT COUNT (DISTINCT Publication_Date) FROM publication

How many distinct publication dates are there in our record?

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 distinct publication dates are there in our record?` to a syntactically-correct PostgreSQL query.

SELECT COUNT (DISTINCT Publication_Date) FROM publication

Show the prices of publications whose publisher is either "Person" or "Wiley"

-- Language PostgreSQL -- Tables: -- Table: publication columns : [['publication id', 'number'], ['book id', 'number'], ['publisher', 'text'], ['publication date', 'text'], ['price', 'number']] -- Table: book columns : [['book id', 'number'], ['title', 'text'], ['issues', 'number'], ['writer', '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 prices of publications whose publisher is either "Person" or "Wiley"` to a syntactically-correct PostgreSQL query.

SELECT Price FROM publication WHERE Publisher = "Person" OR Publisher = "Wiley"

How many actors are there?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 actors are there?` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM actor

Count the number of actors.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 actors.` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM actor

List the name of actors in ascending alphabetical order.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 name of actors in ascending alphabetical order.` to a syntactically-correct PostgreSQL query.

SELECT Name FROM actor ORDER BY Name ASC

What are the names of actors, ordered alphabetically?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 actors, ordered alphabetically?` to a syntactically-correct PostgreSQL query.

SELECT Name FROM actor ORDER BY Name ASC

What are the characters and duration of actors?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 characters and duration of actors?` to a syntactically-correct PostgreSQL query.

SELECT Character , Duration FROM actor

Return the characters and durations for each actor.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 characters and durations for each actor.` to a syntactically-correct PostgreSQL query.

SELECT Character , Duration FROM actor

List the name of actors whose age is not 20.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 name of actors whose age is not 20.` to a syntactically-correct PostgreSQL query.

SELECT Name FROM actor WHERE Age != 20

What are the names of actors who are not 20 years old?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 actors who are not 20 years old?` to a syntactically-correct PostgreSQL query.

SELECT Name FROM actor WHERE Age != 20

What are the characters of actors in descending order of age?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 characters of actors in descending order of age?` to a syntactically-correct PostgreSQL query.

SELECT Character FROM actor ORDER BY age DESC

Return the characters for actors, ordered by age descending.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 characters for actors, ordered by age descending.` to a syntactically-correct PostgreSQL query.

SELECT Character FROM actor ORDER BY age DESC

What is the duration of the oldest actor?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 duration of the oldest actor?` to a syntactically-correct PostgreSQL query.

SELECT Duration FROM actor ORDER BY Age DESC LIMIT 1

Return the duration of the actor with the greatest age.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 duration of the actor with the greatest age.` to a syntactically-correct PostgreSQL query.

SELECT Duration FROM actor ORDER BY Age DESC LIMIT 1

What are the names of musicals with nominee "Bob Fosse"?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 musicals with nominee "Bob Fosse"?` to a syntactically-correct PostgreSQL query.

SELECT Name FROM musical WHERE Nominee = "Bob Fosse"

Return the names of musicals who have the nominee Bob Fosse.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 musicals who have the nominee Bob Fosse.` to a syntactically-correct PostgreSQL query.

SELECT Name FROM musical WHERE Nominee = "Bob Fosse"

What are the distinct nominees of the musicals with the award that is not "Tony Award"?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 distinct nominees of the musicals with the award that is not "Tony Award"?` to a syntactically-correct PostgreSQL query.

SELECT DISTINCT Nominee FROM musical WHERE Award != "Tony Award"

Return the different nominees of musicals that have an award that is not the Tony Award.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 different nominees of musicals that have an award that is not the Tony Award.` to a syntactically-correct PostgreSQL query.

SELECT DISTINCT Nominee FROM musical WHERE Award != "Tony Award"

Show names of actors and names of musicals they are in.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 actors and names of musicals they are in.` to a syntactically-correct PostgreSQL query.

SELECT T1.Name , T2.Name FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID

What are the names of actors and the musicals that they are in?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 actors and the musicals that they are in?` to a syntactically-correct PostgreSQL query.

SELECT T1.Name , T2.Name FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID

Show names of actors that have appeared in musical with name "The Phantom of the Opera".

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 actors that have appeared in musical with name "The Phantom of the Opera".` to a syntactically-correct PostgreSQL query.

SELECT T1.Name FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID WHERE T2.Name = "The Phantom of the Opera"

What are the names of actors who have been in the musical titled The Phantom of the Opera?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 actors who have been in the musical titled The Phantom of the Opera?` to a syntactically-correct PostgreSQL query.

SELECT T1.Name FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID WHERE T2.Name = "The Phantom of the Opera"

Show names of actors in descending order of the year their musical is awarded.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 actors in descending order of the year their musical is awarded.` to a syntactically-correct PostgreSQL query.

SELECT T1.Name FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID ORDER BY T2.Year DESC

What are the names of actors ordered descending by the year in which their musical was awarded?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 actors ordered descending by the year in which their musical was awarded?` to a syntactically-correct PostgreSQL query.

SELECT T1.Name FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID ORDER BY T2.Year DESC

Show names of musicals and the number of actors who have appeared in the musicals.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 musicals and the number of actors who have appeared in the musicals.` to a syntactically-correct PostgreSQL query.

SELECT T2.Name , COUNT(*) FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID GROUP BY T1.Musical_ID

How many actors have appeared in each musical?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 actors have appeared in each musical?` to a syntactically-correct PostgreSQL query.

SELECT T2.Name , COUNT(*) FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID GROUP BY T1.Musical_ID

Show names of musicals which have at least three actors.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 musicals which have at least three actors.` to a syntactically-correct PostgreSQL query.

SELECT T2.Name FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID GROUP BY T1.Musical_ID HAVING COUNT(*) >= 3

What are the names of musicals who have at 3 or more actors?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 musicals who have at 3 or more actors?` to a syntactically-correct PostgreSQL query.

SELECT T2.Name FROM actor AS T1 JOIN musical AS T2 ON T1.Musical_ID = T2.Musical_ID GROUP BY T1.Musical_ID HAVING COUNT(*) >= 3

Show different nominees and the number of musicals they have been nominated.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 different nominees and the number of musicals they have been nominated.` to a syntactically-correct PostgreSQL query.

SELECT Nominee , COUNT(*) FROM musical GROUP BY Nominee

How many musicals has each nominee been nominated for?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 musicals has each nominee been nominated for?` to a syntactically-correct PostgreSQL query.

SELECT Nominee , COUNT(*) FROM musical GROUP BY Nominee

Please show the nominee who has been nominated the greatest number of times.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 `Please show the nominee who has been nominated the greatest number of times.` to a syntactically-correct PostgreSQL query.

SELECT Nominee FROM musical GROUP BY Nominee ORDER BY COUNT(*) DESC LIMIT 1

Who is the nominee who has been nominated for the most musicals?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 is the nominee who has been nominated for the most musicals?` to a syntactically-correct PostgreSQL query.

SELECT Nominee FROM musical GROUP BY Nominee ORDER BY COUNT(*) DESC LIMIT 1

List the most common result of the musicals.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 most common result of the musicals.` to a syntactically-correct PostgreSQL query.

SELECT RESULT FROM musical GROUP BY RESULT ORDER BY COUNT(*) DESC LIMIT 1

Return the most frequent result across all musicals.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 most frequent result across all musicals.` to a syntactically-correct PostgreSQL query.

SELECT RESULT FROM musical GROUP BY RESULT ORDER BY COUNT(*) DESC LIMIT 1

List the nominees that have been nominated more than two musicals.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 nominees that have been nominated more than two musicals.` to a syntactically-correct PostgreSQL query.

SELECT Nominee FROM musical GROUP BY Nominee HAVING COUNT(*) > 2

Who are the nominees who have been nominated more than two times?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 nominees who have been nominated more than two times?` to a syntactically-correct PostgreSQL query.

SELECT Nominee FROM musical GROUP BY Nominee HAVING COUNT(*) > 2

List the name of musicals that do not have actors.

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 name of musicals that do not have actors.` to a syntactically-correct PostgreSQL query.

SELECT Name FROM musical WHERE Musical_ID NOT IN (SELECT Musical_ID FROM actor)

What are the names of musicals who have no actors?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 musicals who have no actors?` to a syntactically-correct PostgreSQL query.

SELECT Name FROM musical WHERE Musical_ID NOT IN (SELECT Musical_ID FROM actor)

Show the nominees that have nominated musicals for both "Tony Award" and "Drama Desk Award".

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 nominees that have nominated musicals for both "Tony Award" and "Drama Desk Award".` to a syntactically-correct PostgreSQL query.

SELECT Nominee FROM musical WHERE Award = "Tony Award" INTERSECT SELECT Nominee FROM musical WHERE Award = "Drama Desk Award"

Who are the nominees who have been nominated for both a Tony Award and a Drama Desk Award?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 nominees who have been nominated for both a Tony Award and a Drama Desk Award?` to a syntactically-correct PostgreSQL query.

SELECT Nominee FROM musical WHERE Award = "Tony Award" INTERSECT SELECT Nominee FROM musical WHERE Award = "Drama Desk Award"

Show the musical nominee with award "Bob Fosse" or "Cleavant Derricks".

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 musical nominee with award "Bob Fosse" or "Cleavant Derricks".` to a syntactically-correct PostgreSQL query.

SELECT Nominee FROM musical WHERE Award = "Tony Award" OR Award = "Cleavant Derricks"

Who are the nominees who were nominated for either of the Bob Fosse or Cleavant Derricks awards?

-- Language PostgreSQL -- Tables: -- Table: musical columns : [['musical id', 'number'], ['name', 'text'], ['year', 'number'], ['award', 'text'], ['category', 'text'], ['nominee', 'text'], ['result', 'text']] -- Table: actor columns : [['actor id', 'number'], ['name', 'text'], ['musical id', 'number'], ['character', 'text'], ['duration', 'text'], ['age', '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 nominees who were nominated for either of the Bob Fosse or Cleavant Derricks awards?` to a syntactically-correct PostgreSQL query.

SELECT Nominee FROM musical WHERE Award = "Tony Award" OR Award = "Cleavant Derricks"

Find the emails of the user named "Mary".

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 emails of the user named "Mary".` to a syntactically-correct PostgreSQL query.

SELECT email FROM user_profiles WHERE name = 'Mary'

What is the partition id of the user named "Iron Man".

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 partition id of the user named "Iron Man".` to a syntactically-correct PostgreSQL query.

SELECT partitionid FROM user_profiles WHERE name = 'Iron Man'

How many users are there?

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 users are there?` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM user_profiles

How many followers does each user have?

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 followers does each user have?` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM follows

Find the number of followers for each user.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 number of followers for each user.` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM follows GROUP BY f1

Find the number of tweets in record.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 number of tweets in record.` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM tweets

Find the number of users who posted some tweets.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 number of users who posted some tweets.` to a syntactically-correct PostgreSQL query.

SELECT count(DISTINCT UID) FROM tweets

Find the name and email of the user whose name contains the word ‘Swift’.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 name and email of the user whose name contains the word ‘Swift’.` to a syntactically-correct PostgreSQL query.

SELECT name , email FROM user_profiles WHERE name LIKE '%Swift%'

Find the names of users whose emails contain ‘superstar’ or ‘edu’.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 names of users whose emails contain ‘superstar’ or ‘edu’.` to a syntactically-correct PostgreSQL query.

SELECT name FROM user_profiles WHERE email LIKE '%superstar%' OR email LIKE '%edu%'

Return the text of tweets about the topic 'intern'.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 text of tweets about the topic 'intern'.` to a syntactically-correct PostgreSQL query.

SELECT text FROM tweets WHERE text LIKE '%intern%'

Find the name and email of the users who have more than 1000 followers.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 name and email of the users who have more than 1000 followers.` to a syntactically-correct PostgreSQL query.

SELECT name , email FROM user_profiles WHERE followers > 1000

Find the names of the users whose number of followers is greater than that of the user named "Tyler Swift".

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 names of the users whose number of followers is greater than that of the user named "Tyler Swift".` to a syntactically-correct PostgreSQL query.

SELECT T1.name FROM user_profiles AS T1 JOIN follows AS T2 ON T1.uid = T2.f1 GROUP BY T2.f1 HAVING count(*) > (SELECT count(*) FROM user_profiles AS T1 JOIN follows AS T2 ON T1.uid = T2.f1 WHERE T1.name = 'Tyler Swift')

Find the name and email for the users who have more than one follower.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 name and email for the users who have more than one follower.` to a syntactically-correct PostgreSQL query.

SELECT T1.name , T1.email FROM user_profiles AS T1 JOIN follows AS T2 ON T1.uid = T2.f1 GROUP BY T2.f1 HAVING count(*) > 1

Find the names of users who have more than one tweet.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 names of users who have more than one tweet.` to a syntactically-correct PostgreSQL query.

SELECT T1.name FROM user_profiles AS T1 JOIN tweets AS T2 ON T1.uid = T2.uid GROUP BY T2.uid HAVING count(*) > 1

Find the id of users who are followed by Mary and Susan.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 id of users who are followed by Mary and Susan.` to a syntactically-correct PostgreSQL query.

SELECT T2.f1 FROM user_profiles AS T1 JOIN follows AS T2 ON T1.uid = T2.f2 WHERE T1.name = "Mary" INTERSECT SELECT T2.f1 FROM user_profiles AS T1 JOIN follows AS T2 ON T1.uid = T2.f2 WHERE T1.name = "Susan"

Find the id of users who are followed by Mary or Susan.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 id of users who are followed by Mary or Susan.` to a syntactically-correct PostgreSQL query.

SELECT T2.f1 FROM user_profiles AS T1 JOIN follows AS T2 ON T1.uid = T2.f2 WHERE T1.name = "Mary" OR T1.name = "Susan"

Find the name of the user who has the largest number of followers.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 name of the user who has the largest number of followers.` to a syntactically-correct PostgreSQL query.

SELECT name FROM user_profiles ORDER BY followers DESC LIMIT 1

Find the name and email of the user followed by the least number of people.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 name and email of the user followed by the least number of people.` to a syntactically-correct PostgreSQL query.

SELECT name , email FROM user_profiles ORDER BY followers LIMIT 1

List the name and number of followers for each user, and sort the results by the number of followers in descending order.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 name and number of followers for each user, and sort the results by the number of followers in descending order.` to a syntactically-correct PostgreSQL query.

SELECT name , followers FROM user_profiles ORDER BY followers DESC

List the names of 5 users followed by the largest number of other users.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 names of 5 users followed by the largest number of other users.` to a syntactically-correct PostgreSQL query.

SELECT name FROM user_profiles ORDER BY followers DESC LIMIT 5

List the text of all tweets in the order of date.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 text of all tweets in the order of date.` to a syntactically-correct PostgreSQL query.

SELECT text FROM tweets ORDER BY createdate

Find the name of each user and number of tweets tweeted by each of them.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 name of each user and number of tweets tweeted by each of them.` to a syntactically-correct PostgreSQL query.

SELECT T1.name , count(*) FROM user_profiles AS T1 JOIN tweets AS T2 ON T1.uid = T2.uid GROUP BY T2.uid

Find the name and partition id for users who tweeted less than twice.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 name and partition id for users who tweeted less than twice.` to a syntactically-correct PostgreSQL query.

SELECT T1.name , T1.partitionid FROM user_profiles AS T1 JOIN tweets AS T2 ON T1.uid = T2.uid GROUP BY T2.uid HAVING count(*) < 2

Find the name of the user who tweeted more than once, and number of tweets tweeted by them.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 name of the user who tweeted more than once, and number of tweets tweeted by them.` to a syntactically-correct PostgreSQL query.

SELECT T1.name , count(*) FROM user_profiles AS T1 JOIN tweets AS T2 ON T1.uid = T2.uid GROUP BY T2.uid HAVING count(*) > 1

Find the average number of followers for the users who do not have any tweet.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 average number of followers for the users who do not have any tweet.` to a syntactically-correct PostgreSQL query.

SELECT avg(followers) FROM user_profiles WHERE UID NOT IN (SELECT UID FROM tweets)

Find the average number of followers for the users who had some tweets.

-- Language PostgreSQL -- Tables: -- Table: follows columns : [['user id', 'number'], ['follower id', 'number']] -- Table: tweets columns : [['id', 'number'], ['user id', 'number'], ['text', 'text'], ['create date', 'time']] -- Table: user profiles columns : [['uid', 'number'], ['name', 'text'], ['email', 'text'], ['partition id', 'number'], ['followers', '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 average number of followers for the users who had some tweets.` to a syntactically-correct PostgreSQL query.

SELECT avg(followers) FROM user_profiles WHERE UID IN (SELECT UID FROM tweets)