Datasets:

sert121

/

SpiderSQL

like 0

How many heads of the departments are older than 56 ?

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 heads of the departments are older than 56 ?` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM head WHERE age > 56

List the name, born state and age of the heads of departments ordered by age.

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 name, born state and age of the heads of departments ordered by age.` to a syntactically-correct PostgreSQL query.

SELECT name , born_state , age FROM head ORDER BY age

List the creation year, name and budget of each department.

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 creation year, name and budget of each department.` to a syntactically-correct PostgreSQL query.

SELECT creation , name , budget_in_billions FROM department

What are the maximum and minimum budget of the departments?

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 maximum and minimum budget of the departments?` to a syntactically-correct PostgreSQL query.

SELECT max(budget_in_billions) , min(budget_in_billions) FROM department

What is the average number of employees of the departments whose rank is between 10 and 15?

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 average number of employees of the departments whose rank is between 10 and 15?` to a syntactically-correct PostgreSQL query.

SELECT avg(num_employees) FROM department WHERE ranking BETWEEN 10 AND 15

What are the names of the heads who are born outside the California state?

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 names of the heads who are born outside the California state?` to a syntactically-correct PostgreSQL query.

SELECT name FROM head WHERE born_state != 'California'

What are the distinct creation years of the departments managed by a secretary born in state 'Alabama'?

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 creation years of the departments managed by a secretary born in state 'Alabama'?` to a syntactically-correct PostgreSQL query.

SELECT DISTINCT T1.creation FROM department AS T1 JOIN management AS T2 ON T1.department_id = T2.department_id JOIN head AS T3 ON T2.head_id = T3.head_id WHERE T3.born_state = 'Alabama'

What are the names of the states where at least 3 heads were born?

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 names of the states where at least 3 heads were born?` to a syntactically-correct PostgreSQL query.

SELECT born_state FROM head GROUP BY born_state HAVING count(*) >= 3

In which year were most departments established?

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 `In which year were most departments established?` to a syntactically-correct PostgreSQL query.

SELECT creation FROM department GROUP BY creation ORDER BY count(*) DESC LIMIT 1

Show the name and number of employees for the departments managed by heads whose temporary acting value is 'Yes'?

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 name and number of employees for the departments managed by heads whose temporary acting value is 'Yes'?` to a syntactically-correct PostgreSQL query.

SELECT T1.name , T1.num_employees FROM department AS T1 JOIN management AS T2 ON T1.department_id = T2.department_id WHERE T2.temporary_acting = 'Yes'

How many acting statuses are there?

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 acting statuses are there?` to a syntactically-correct PostgreSQL query.

SELECT count(DISTINCT temporary_acting) FROM management

How many departments are led by heads who are not mentioned?

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 departments are led by heads who are not mentioned?` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM department WHERE department_id NOT IN (SELECT department_id FROM management);

What are the distinct ages of the heads who are acting?

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 ages of the heads who are acting?` to a syntactically-correct PostgreSQL query.

SELECT DISTINCT T1.age FROM management AS T2 JOIN head AS T1 ON T1.head_id = T2.head_id WHERE T2.temporary_acting = 'Yes'

List the states where both the secretary of 'Treasury' department and the secretary of 'Homeland Security' were born.

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 states where both the secretary of 'Treasury' department and the secretary of 'Homeland Security' were born.` to a syntactically-correct PostgreSQL query.

SELECT T3.born_state FROM department AS T1 JOIN management AS T2 ON T1.department_id = T2.department_id JOIN head AS T3 ON T2.head_id = T3.head_id WHERE T1.name = 'Treasury' INTERSECT SELECT T3.born_state FROM department AS T1 JOIN management AS T2 ON T1.department_id = T2.department_id JOIN head AS T3 ON T2.head_id = T3.head_id WHERE T1.name = 'Homeland Security'

Which department has more than 1 head at a time? List the id, name and the number of heads.

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 `Which department has more than 1 head at a time? List the id, name and the number of heads.` to a syntactically-correct PostgreSQL query.

SELECT T1.department_id , T1.name , count(*) FROM management AS T2 JOIN department AS T1 ON T1.department_id = T2.department_id GROUP BY T1.department_id HAVING count(*) > 1

Which head's name has the substring 'Ha'? List the id and name.

-- Language PostgreSQL -- Tables: -- Table: department columns : [['department id', 'number'], ['name', 'text'], ['creation', 'text'], ['ranking', 'number'], ['budget in billions', 'number'], ['num employees', 'number']] -- Table: head columns : [['head id', 'number'], ['name', 'text'], ['born state', 'text'], ['age', 'number']] -- Table: management columns : [['department id', 'number'], ['head id', 'number'], ['temporary acting', '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 `Which head's name has the substring 'Ha'? List the id and name.` to a syntactically-correct PostgreSQL query.

SELECT head_id , name FROM head WHERE name LIKE '%Ha%'

How many farms are there?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 farms are there?` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM farm

Count the number of farms.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 farms.` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM farm

List the total number of horses on farms in ascending order.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 total number of horses on farms in ascending order.` to a syntactically-correct PostgreSQL query.

SELECT Total_Horses FROM farm ORDER BY Total_Horses ASC

What is the total horses record for each farm, sorted ascending?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `What is the total horses record for each farm, sorted ascending?` to a syntactically-correct PostgreSQL query.

SELECT Total_Horses FROM farm ORDER BY Total_Horses ASC

What are the hosts of competitions whose theme is not "Aliens"?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 hosts of competitions whose theme is not "Aliens"?` to a syntactically-correct PostgreSQL query.

SELECT Hosts FROM farm_competition WHERE Theme != 'Aliens'

Return the hosts of competitions for which the theme is not Aliens?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 hosts of competitions for which the theme is not Aliens?` to a syntactically-correct PostgreSQL query.

SELECT Hosts FROM farm_competition WHERE Theme != 'Aliens'

What are the themes of farm competitions sorted by year in ascending order?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 themes of farm competitions sorted by year in ascending order?` to a syntactically-correct PostgreSQL query.

SELECT Theme FROM farm_competition ORDER BY YEAR ASC

Return the themes of farm competitions, sorted by year ascending.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 themes of farm competitions, sorted by year ascending.` to a syntactically-correct PostgreSQL query.

SELECT Theme FROM farm_competition ORDER BY YEAR ASC

What is the average number of working horses of farms with more than 5000 total number of horses?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 number of working horses of farms with more than 5000 total number of horses?` to a syntactically-correct PostgreSQL query.

SELECT avg(Working_Horses) FROM farm WHERE Total_Horses > 5000

Give the average number of working horses on farms with more than 5000 total horses.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 the average number of working horses on farms with more than 5000 total horses.` to a syntactically-correct PostgreSQL query.

SELECT avg(Working_Horses) FROM farm WHERE Total_Horses > 5000

What are the maximum and minimum number of cows across all farms.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 maximum and minimum number of cows across all farms.` to a syntactically-correct PostgreSQL query.

SELECT max(Cows) , min(Cows) FROM farm

Return the maximum and minimum number of cows across all farms.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 maximum and minimum number of cows across all farms.` to a syntactically-correct PostgreSQL query.

SELECT max(Cows) , min(Cows) FROM farm

How many different statuses do cities have?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 different statuses do cities have?` to a syntactically-correct PostgreSQL query.

SELECT count(DISTINCT Status) FROM city

Count the number of different statuses.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Count the number of different statuses.` to a syntactically-correct PostgreSQL query.

SELECT count(DISTINCT Status) FROM city

List official names of cities in descending order of population.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 official names of cities in descending order of population.` to a syntactically-correct PostgreSQL query.

SELECT Official_Name FROM city ORDER BY Population DESC

What are the official names of cities, ordered descending by population?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 official names of cities, ordered descending by population?` to a syntactically-correct PostgreSQL query.

SELECT Official_Name FROM city ORDER BY Population DESC

List the official name and status of the city with the largest population.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 official name and status of the city with the largest population.` to a syntactically-correct PostgreSQL query.

SELECT Official_Name , Status FROM city ORDER BY Population DESC LIMIT 1

What is the official name and status of the city with the most residents?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 official name and status of the city with the most residents?` to a syntactically-correct PostgreSQL query.

SELECT Official_Name , Status FROM city ORDER BY Population DESC LIMIT 1

Show the years and the official names of the host cities of competitions.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 years and the official names of the host cities of competitions.` to a syntactically-correct PostgreSQL query.

SELECT T2.Year , T1.Official_Name FROM city AS T1 JOIN farm_competition AS T2 ON T1.City_ID = T2.Host_city_ID

Give the years and official names of the cities of each competition.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 the years and official names of the cities of each competition.` to a syntactically-correct PostgreSQL query.

SELECT T2.Year , T1.Official_Name FROM city AS T1 JOIN farm_competition AS T2 ON T1.City_ID = T2.Host_city_ID

Show the official names of the cities that have hosted more than one competition.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 official names of the cities that have hosted more than one competition.` to a syntactically-correct PostgreSQL query.

SELECT T1.Official_Name FROM city AS T1 JOIN farm_competition AS T2 ON T1.City_ID = T2.Host_city_ID GROUP BY T2.Host_city_ID HAVING COUNT(*) > 1

What are the official names of cities that have hosted more than one competition?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 official names of cities that have hosted more than one competition?` to a syntactically-correct PostgreSQL query.

SELECT T1.Official_Name FROM city AS T1 JOIN farm_competition AS T2 ON T1.City_ID = T2.Host_city_ID GROUP BY T2.Host_city_ID HAVING COUNT(*) > 1

Show the status of the city that has hosted the greatest number of competitions.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 status of the city that has hosted the greatest number of competitions.` to a syntactically-correct PostgreSQL query.

SELECT T1.Status FROM city AS T1 JOIN farm_competition AS T2 ON T1.City_ID = T2.Host_city_ID GROUP BY T2.Host_city_ID ORDER BY COUNT(*) DESC LIMIT 1

What is the status of the city that has hosted the most competitions?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 status of the city that has hosted the most competitions?` to a syntactically-correct PostgreSQL query.

SELECT T1.Status FROM city AS T1 JOIN farm_competition AS T2 ON T1.City_ID = T2.Host_city_ID GROUP BY T2.Host_city_ID ORDER BY COUNT(*) DESC LIMIT 1

Please show the themes of competitions with host cities having populations larger than 1000.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 themes of competitions with host cities having populations larger than 1000.` to a syntactically-correct PostgreSQL query.

SELECT T2.Theme FROM city AS T1 JOIN farm_competition AS T2 ON T1.City_ID = T2.Host_city_ID WHERE T1.Population > 1000

What are the themes of competitions that have corresponding host cities with more than 1000 residents?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 themes of competitions that have corresponding host cities with more than 1000 residents?` to a syntactically-correct PostgreSQL query.

SELECT T2.Theme FROM city AS T1 JOIN farm_competition AS T2 ON T1.City_ID = T2.Host_city_ID WHERE T1.Population > 1000

Please show the different statuses of cities and the average population of cities with each status.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 different statuses of cities and the average population of cities with each status.` to a syntactically-correct PostgreSQL query.

SELECT Status , avg(Population) FROM city GROUP BY Status

What are the statuses and average populations of each city?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 statuses and average populations of each city?` to a syntactically-correct PostgreSQL query.

SELECT Status , avg(Population) FROM city GROUP BY Status

Please show the different statuses, ordered by the number of cities that have each.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 different statuses, ordered by the number of cities that have each.` to a syntactically-correct PostgreSQL query.

SELECT Status FROM city GROUP BY Status ORDER BY COUNT(*) ASC

Return the different statuses of cities, ascending by frequency.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 statuses of cities, ascending by frequency.` to a syntactically-correct PostgreSQL query.

SELECT Status FROM city GROUP BY Status ORDER BY COUNT(*) ASC

List the most common type of Status across cities.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 type of Status across cities.` to a syntactically-correct PostgreSQL query.

SELECT Status FROM city GROUP BY Status ORDER BY COUNT(*) DESC LIMIT 1

What is the most common status across all cities?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 most common status across all cities?` to a syntactically-correct PostgreSQL query.

SELECT Status FROM city GROUP BY Status ORDER BY COUNT(*) DESC LIMIT 1

List the official names of cities that have not held any competition.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 official names of cities that have not held any competition.` to a syntactically-correct PostgreSQL query.

SELECT Official_Name FROM city WHERE City_ID NOT IN (SELECT Host_city_ID FROM farm_competition)

What are the official names of cities that have not hosted a farm competition?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 official names of cities that have not hosted a farm competition?` to a syntactically-correct PostgreSQL query.

SELECT Official_Name FROM city WHERE City_ID NOT IN (SELECT Host_city_ID FROM farm_competition)

Show the status shared by cities with population bigger than 1500 and smaller than 500.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 status shared by cities with population bigger than 1500 and smaller than 500.` to a syntactically-correct PostgreSQL query.

SELECT Status FROM city WHERE Population > 1500 INTERSECT SELECT Status FROM city WHERE Population < 500

Which statuses correspond to both cities that have a population over 1500 and cities that have a population lower than 500?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Which statuses correspond to both cities that have a population over 1500 and cities that have a population lower than 500?` to a syntactically-correct PostgreSQL query.

SELECT Status FROM city WHERE Population > 1500 INTERSECT SELECT Status FROM city WHERE Population < 500

Find the official names of cities with population bigger than 1500 or smaller than 500.

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 official names of cities with population bigger than 1500 or smaller than 500.` to a syntactically-correct PostgreSQL query.

SELECT Official_Name FROM city WHERE Population > 1500 OR Population < 500

What are the official names of cities that have population over 1500 or less than 500?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 official names of cities that have population over 1500 or less than 500?` to a syntactically-correct PostgreSQL query.

SELECT Official_Name FROM city WHERE Population > 1500 OR Population < 500

Show the census ranking of cities whose status are not "Village".

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 census ranking of cities whose status are not "Village".` to a syntactically-correct PostgreSQL query.

SELECT Census_Ranking FROM city WHERE Status != "Village"

What are the census rankings of cities that do not have the status "Village"?

-- Language PostgreSQL -- Tables: -- Table: city columns : [['city id', 'number'], ['official name', 'text'], ['status', 'text'], ['area km 2', 'number'], ['population', 'number'], ['census ranking', 'text']] -- Table: farm columns : [['farm id', 'number'], ['year', 'number'], ['total horses', 'number'], ['working horses', 'number'], ['total cattle', 'number'], ['oxen', 'number'], ['bulls', 'number'], ['cows', 'number'], ['pigs', 'number'], ['sheep and goats', 'number']] -- Table: farm competition columns : [['competition id', 'number'], ['year', 'number'], ['theme', 'text'], ['host city id', 'number'], ['hosts', 'text']] -- Table: competition record columns : [['competition id', 'number'], ['farm id', 'number'], ['rank', '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 census rankings of cities that do not have the status "Village"?` to a syntactically-correct PostgreSQL query.

SELECT Census_Ranking FROM city WHERE Status != "Village"

which course has most number of registered students?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 `which course has most number of registered students?` to a syntactically-correct PostgreSQL query.

SELECT T1.course_name FROM courses AS T1 JOIN student_course_registrations AS T2 ON T1.course_id = T2.course_Id GROUP BY T1.course_id ORDER BY count(*) DESC LIMIT 1

What is the name of the course with the most registered students?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 name of the course with the most registered students?` to a syntactically-correct PostgreSQL query.

SELECT T1.course_name FROM courses AS T1 JOIN student_course_registrations AS T2 ON T1.course_id = T2.course_Id GROUP BY T1.course_id ORDER BY count(*) DESC LIMIT 1

what is id of students who registered some courses but the least number of courses in these students?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 id of students who registered some courses but the least number of courses in these students?` to a syntactically-correct PostgreSQL query.

SELECT student_id FROM student_course_registrations GROUP BY student_id ORDER BY count(*) LIMIT 1

What are the ids of the students who registered for some courses but had the least number of courses for all students?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 ids of the students who registered for some courses but had the least number of courses for all students?` to a syntactically-correct PostgreSQL query.

SELECT student_id FROM student_course_registrations GROUP BY student_id ORDER BY count(*) LIMIT 1

what are the first name and last name of all candidates?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 first name and last name of all candidates?` to a syntactically-correct PostgreSQL query.

SELECT T2.first_name , T2.last_name FROM candidates AS T1 JOIN people AS T2 ON T1.candidate_id = T2.person_id

What are the first and last names of all the candidates?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 first and last names of all the candidates?` to a syntactically-correct PostgreSQL query.

SELECT T2.first_name , T2.last_name FROM candidates AS T1 JOIN people AS T2 ON T1.candidate_id = T2.person_id

List the id of students who never attends courses?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 id of students who never attends courses?` to a syntactically-correct PostgreSQL query.

SELECT student_id FROM students WHERE student_id NOT IN (SELECT student_id FROM student_course_attendance)

What are the ids of every student who has never attended a course?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 ids of every student who has never attended a course?` to a syntactically-correct PostgreSQL query.

SELECT student_id FROM students WHERE student_id NOT IN (SELECT student_id FROM student_course_attendance)

List the id of students who attended some courses?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 id of students who attended some courses?` to a syntactically-correct PostgreSQL query.

SELECT student_id FROM student_course_attendance

What are the ids of all students who have attended at least one course?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 ids of all students who have attended at least one course?` to a syntactically-correct PostgreSQL query.

SELECT student_id FROM student_course_attendance

What are the ids of all students for courses and what are the names of those courses?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 ids of all students for courses and what are the names of those courses?` to a syntactically-correct PostgreSQL query.

SELECT T1.student_id , T2.course_name FROM student_course_registrations AS T1 JOIN courses AS T2 ON T1.course_id = T2.course_id

What is detail of the student who most recently registered course?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 detail of the student who most recently registered course?` to a syntactically-correct PostgreSQL query.

SELECT T2.student_details FROM student_course_registrations AS T1 JOIN students AS T2 ON T1.student_id = T2.student_id ORDER BY T1.registration_date DESC LIMIT 1

What details do we have on the students who registered for courses most recently?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 details do we have on the students who registered for courses most recently?` to a syntactically-correct PostgreSQL query.

SELECT T2.student_details FROM student_course_registrations AS T1 JOIN students AS T2 ON T1.student_id = T2.student_id ORDER BY T1.registration_date DESC LIMIT 1

How many students attend course English?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 students attend course English?` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM courses AS T1 JOIN student_course_attendance AS T2 ON T1.course_id = T2.course_id WHERE T1.course_name = "English"

How many students are attending English courses?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 students are attending English courses?` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM courses AS T1 JOIN student_course_attendance AS T2 ON T1.course_id = T2.course_id WHERE T1.course_name = "English"

How many courses do the student whose id is 171 attend?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 courses do the student whose id is 171 attend?` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM courses AS T1 JOIN student_course_attendance AS T2 ON T1.course_id = T2.course_id WHERE T2.student_id = 171

How many courses does the student with id 171 actually attend?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 courses does the student with id 171 actually attend?` to a syntactically-correct PostgreSQL query.

SELECT count(*) FROM courses AS T1 JOIN student_course_attendance AS T2 ON T1.course_id = T2.course_id WHERE T2.student_id = 171

Find id of the candidate whose email is stanley.monahan@example.org?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 `Find id of the candidate whose email is stanley.monahan@example.org?` to a syntactically-correct PostgreSQL query.

SELECT T2.candidate_id FROM people AS T1 JOIN candidates AS T2 ON T1.person_id = T2.candidate_id WHERE T1.email_address = "stanley.monahan@example.org"

What is the id of the candidate whose email is stanley.monahan@example.org?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 id of the candidate whose email is stanley.monahan@example.org?` to a syntactically-correct PostgreSQL query.

SELECT T2.candidate_id FROM people AS T1 JOIN candidates AS T2 ON T1.person_id = T2.candidate_id WHERE T1.email_address = "stanley.monahan@example.org"

Find id of the candidate who most recently accessed the course?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 `Find id of the candidate who most recently accessed the course?` to a syntactically-correct PostgreSQL query.

SELECT candidate_id FROM candidate_assessments ORDER BY assessment_date DESC LIMIT 1

What is the id of the candidate who most recently accessed the course?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 id of the candidate who most recently accessed the course?` to a syntactically-correct PostgreSQL query.

SELECT candidate_id FROM candidate_assessments ORDER BY assessment_date DESC LIMIT 1

What is detail of the student who registered the most number of courses?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 detail of the student who registered the most number of courses?` to a syntactically-correct PostgreSQL query.

SELECT T1.student_details FROM students AS T1 JOIN student_course_registrations AS T2 ON T1.student_id = T2.student_id GROUP BY T1.student_id ORDER BY count(*) DESC LIMIT 1

What are the details of the student who registered for the most number of courses?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 details of the student who registered for the most number of courses?` to a syntactically-correct PostgreSQL query.

SELECT T1.student_details FROM students AS T1 JOIN student_course_registrations AS T2 ON T1.student_id = T2.student_id GROUP BY T1.student_id ORDER BY count(*) DESC LIMIT 1

List the id of students who registered some courses and the number of their registered courses?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 id of students who registered some courses and the number of their registered courses?` to a syntactically-correct PostgreSQL query.

SELECT T1.student_id , count(*) FROM students AS T1 JOIN student_course_registrations AS T2 ON T1.student_id = T2.student_id GROUP BY T1.student_id

For every student who is registered for some course, how many courses are they registered for?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 `For every student who is registered for some course, how many courses are they registered for?` to a syntactically-correct PostgreSQL query.

SELECT T1.student_id , count(*) FROM students AS T1 JOIN student_course_registrations AS T2 ON T1.student_id = T2.student_id GROUP BY T1.student_id

How many registed students do each course have? List course name and the number of their registered students?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 registed students do each course have? List course name and the number of their registered students?` to a syntactically-correct PostgreSQL query.

SELECT T3.course_name , count(*) FROM students AS T1 JOIN student_course_registrations AS T2 ON T1.student_id = T2.student_id JOIN courses AS T3 ON T2.course_id = T3.course_id GROUP BY T2.course_id

For each course id, how many students are registered and what are the course names?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 `For each course id, how many students are registered and what are the course names?` to a syntactically-correct PostgreSQL query.

SELECT T3.course_name , count(*) FROM students AS T1 JOIN student_course_registrations AS T2 ON T1.student_id = T2.student_id JOIN courses AS T3 ON T2.course_id = T3.course_id GROUP BY T2.course_id

Find id of candidates whose assessment code is "Pass"?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 `Find id of candidates whose assessment code is "Pass"?` to a syntactically-correct PostgreSQL query.

SELECT candidate_id FROM candidate_assessments WHERE asessment_outcome_code = "Pass"

What are the ids of the candidates that have an outcome code of Pass?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 ids of the candidates that have an outcome code of Pass?` to a syntactically-correct PostgreSQL query.

SELECT candidate_id FROM candidate_assessments WHERE asessment_outcome_code = "Pass"

Find the cell mobile number of the candidates whose assessment code is "Fail"?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 `Find the cell mobile number of the candidates whose assessment code is "Fail"?` to a syntactically-correct PostgreSQL query.

SELECT T3.cell_mobile_number FROM candidates AS T1 JOIN candidate_assessments AS T2 ON T1.candidate_id = T2.candidate_id JOIN people AS T3 ON T1.candidate_id = T3.person_id WHERE T2.asessment_outcome_code = "Fail"

What are the cell phone numbers of the candidates that received an assessment code of "Fail"?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 cell phone numbers of the candidates that received an assessment code of "Fail"?` to a syntactically-correct PostgreSQL query.

SELECT T3.cell_mobile_number FROM candidates AS T1 JOIN candidate_assessments AS T2 ON T1.candidate_id = T2.candidate_id JOIN people AS T3 ON T1.candidate_id = T3.person_id WHERE T2.asessment_outcome_code = "Fail"

What are the id of students who registered course 301?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 id of students who registered course 301?` to a syntactically-correct PostgreSQL query.

SELECT student_id FROM student_course_attendance WHERE course_id = 301

What are the ids of the students who registered for course 301?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 ids of the students who registered for course 301?` to a syntactically-correct PostgreSQL query.

SELECT student_id FROM student_course_attendance WHERE course_id = 301

What is the id of the student who most recently registered course 301?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 id of the student who most recently registered course 301?` to a syntactically-correct PostgreSQL query.

SELECT student_id FROM student_course_attendance WHERE course_id = 301 ORDER BY date_of_attendance DESC LIMIT 1

What are the ids of the students who registered for course 301 most recently?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 ids of the students who registered for course 301 most recently?` to a syntactically-correct PostgreSQL query.

SELECT student_id FROM student_course_attendance WHERE course_id = 301 ORDER BY date_of_attendance DESC LIMIT 1

Find distinct cities of addresses of people?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 `Find distinct cities of addresses of people?` to a syntactically-correct PostgreSQL query.

SELECT DISTINCT T1.city FROM addresses AS T1 JOIN people_addresses AS T2 ON T1.address_id = T2.address_id

What are the different cities where people live?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', 'text']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `What are the different cities where people live?` to a syntactically-correct PostgreSQL query.

SELECT DISTINCT T1.city FROM addresses AS T1 JOIN people_addresses AS T2 ON T1.address_id = T2.address_id

Find distinct cities of address of students?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 `Find distinct cities of address of students?` to a syntactically-correct PostgreSQL query.

SELECT DISTINCT T1.city FROM addresses AS T1 JOIN people_addresses AS T2 ON T1.address_id = T2.address_id JOIN students AS T3 ON T2.person_id = T3.student_id

What are the different cities where students live?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', 'text']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `What are the different cities where students live?` to a syntactically-correct PostgreSQL query.

SELECT DISTINCT T1.city FROM addresses AS T1 JOIN people_addresses AS T2 ON T1.address_id = T2.address_id JOIN students AS T3 ON T2.person_id = T3.student_id

List the names of courses in alphabetical order?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', 'text']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `List the names of courses in alphabetical order?` to a syntactically-correct PostgreSQL query.

SELECT course_name FROM courses ORDER BY course_name

What are the names of the courses in alphabetical order?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 names of the courses in alphabetical order?` to a syntactically-correct PostgreSQL query.

SELECT course_name FROM courses ORDER BY course_name

List the first names of people in alphabetical order?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 first names of people in alphabetical order?` to a syntactically-correct PostgreSQL query.

SELECT first_name FROM people ORDER BY first_name

What are the first names of the people in alphabetical order?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 first names of the people in alphabetical order?` to a syntactically-correct PostgreSQL query.

SELECT first_name FROM people ORDER BY first_name

What are the id of students who registered courses or attended courses?

-- Language PostgreSQL -- Tables: -- Table: addresses columns : [['address id', 'number'], ['line 1', 'text'], ['line 2', 'text'], ['city', 'text'], ['zip postcode', 'text'], ['state province county', 'text'], ['country', 'text']] -- Table: people columns : [['person id', 'number'], ['first name', 'text'], ['middle name', 'text'], ['last name', 'text'], ['cell mobile number', 'text'], ['email address', 'text'], ['login name', 'text'], ['password', 'text']] -- Table: students columns : [['student id', 'number'], ['student details', 'text']] -- Table: courses columns : [['course id', 'text'], ['course name', 'text'], ['course description', 'text'], ['other details', 'text']] -- Table: people addresses columns : [['person address id', 'number'], ['person id', 'number'], ['address id', 'number'], ['date from', 'time'], ['date to', 'time']] -- Table: student course registrations columns : [['student id', 'number'], ['course id', 'number'], ['registration date', 'time']] -- Table: student course attendance columns : [['student id', 'number'], ['course id', 'number'], ['date of attendance', 'time']] -- Table: candidates columns : [['candidate id', 'number'], ['candidate details', 'text']] -- Table: candidate assessments columns : [['candidate id', 'number'], ['qualification', 'text'], ['assessment date', 'time'], ['asessment outcome code', '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 id of students who registered courses or attended courses?` to a syntactically-correct PostgreSQL query.

SELECT student_id FROM student_course_registrations UNION SELECT student_id FROM student_course_attendance