Split (1)

train · 7k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

brief_instruction stringlengths 16 224	instruction stringlengths 687 8.77k	output stringlengths 18 577
Show the distinct venues of debates	-- Language PostgreSQL -- Tables: -- Table: people columns : [['people id', 'number'], ['district', 'text'], ['name', 'text'], ['party', 'text'], ['age', 'number']] -- Table: debate columns : [['debate id', 'number'], ['date', 'text'], ['venue', 'text'], ['num of audience', 'number']] -- Table: debate people columns : [['debate id', 'number'], ['affirmative', 'number'], ['negative', 'number'], ['if affirmative win', 'others']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables 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 distinct venues of debates` to a syntactically-correct PostgreSQL query.	SELECT DISTINCT Venue FROM debate
Show the names of people, and dates and venues of debates they are on the affirmative side.	-- Language PostgreSQL -- Tables: -- Table: people columns : [['people id', 'number'], ['district', 'text'], ['name', 'text'], ['party', 'text'], ['age', 'number']] -- Table: debate columns : [['debate id', 'number'], ['date', 'text'], ['venue', 'text'], ['num of audience', 'number']] -- Table: debate people columns : [['debate id', 'number'], ['affirmative', 'number'], ['negative', 'number'], ['if affirmative win', 'others']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Show the names of people, and dates and venues of debates they are on the affirmative side.` to a syntactically-correct PostgreSQL query.	SELECT T3.Name , T2.Date , T2.Venue FROM debate_people AS T1 JOIN debate AS T2 ON T1.Debate_ID = T2.Debate_ID JOIN people AS T3 ON T1.Affirmative = T3.People_ID
Show the names of people, and dates and venues of debates they are on the negative side, ordered in ascending alphabetical order of name.	-- Language PostgreSQL -- Tables: -- Table: people columns : [['people id', 'number'], ['district', 'text'], ['name', 'text'], ['party', 'text'], ['age', 'number']] -- Table: debate columns : [['debate id', 'number'], ['date', 'text'], ['venue', 'text'], ['num of audience', 'number']] -- Table: debate people columns : [['debate id', 'number'], ['affirmative', 'number'], ['negative', 'number'], ['if affirmative win', 'others']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Show the names of people, and dates and venues of debates they are on the negative side, ordered in ascending alphabetical order of name.` to a syntactically-correct PostgreSQL query.	SELECT T3.Name , T2.Date , T2.Venue FROM debate_people AS T1 JOIN debate AS T2 ON T1.Debate_ID = T2.Debate_ID JOIN people AS T3 ON T1.Negative = T3.People_ID ORDER BY T3.Name ASC
Show the names of people that are on affirmative side of debates with number of audience bigger than 200.	-- Language PostgreSQL -- Tables: -- Table: people columns : [['people id', 'number'], ['district', 'text'], ['name', 'text'], ['party', 'text'], ['age', 'number']] -- Table: debate columns : [['debate id', 'number'], ['date', 'text'], ['venue', 'text'], ['num of audience', 'number']] -- Table: debate people columns : [['debate id', 'number'], ['affirmative', 'number'], ['negative', 'number'], ['if affirmative win', 'others']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Show the names of people that are on affirmative side of debates with number of audience bigger than 200.` to a syntactically-correct PostgreSQL query.	SELECT T3.Name FROM debate_people AS T1 JOIN debate AS T2 ON T1.Debate_ID = T2.Debate_ID JOIN people AS T3 ON T1.Affirmative = T3.People_ID WHERE T2.Num_of_Audience > 200
Show the names of people and the number of times they have been on the affirmative side of debates.	-- Language PostgreSQL -- Tables: -- Table: people columns : [['people id', 'number'], ['district', 'text'], ['name', 'text'], ['party', 'text'], ['age', 'number']] -- Table: debate columns : [['debate id', 'number'], ['date', 'text'], ['venue', 'text'], ['num of audience', 'number']] -- Table: debate people columns : [['debate id', 'number'], ['affirmative', 'number'], ['negative', 'number'], ['if affirmative win', 'others']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Show the names of people and the number of times they have been on the affirmative side of debates.` to a syntactically-correct PostgreSQL query.	SELECT T2.Name , COUNT(*) FROM debate_people AS T1 JOIN people AS T2 ON T1.Affirmative = T2.People_ID GROUP BY T2.Name
Show the names of people who have been on the negative side of debates at least twice.	-- Language PostgreSQL -- Tables: -- Table: people columns : [['people id', 'number'], ['district', 'text'], ['name', 'text'], ['party', 'text'], ['age', 'number']] -- Table: debate columns : [['debate id', 'number'], ['date', 'text'], ['venue', 'text'], ['num of audience', 'number']] -- Table: debate people columns : [['debate id', 'number'], ['affirmative', 'number'], ['negative', 'number'], ['if affirmative win', 'others']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Show the names of people who have been on the negative side of debates at least twice.` to a syntactically-correct PostgreSQL query.	SELECT T2.Name FROM debate_people AS T1 JOIN people AS T2 ON T1.Negative = T2.People_ID GROUP BY T2.Name HAVING COUNT(*) >= 2
List the names of people that have not been on the affirmative side of debates.	-- Language PostgreSQL -- Tables: -- Table: people columns : [['people id', 'number'], ['district', 'text'], ['name', 'text'], ['party', 'text'], ['age', 'number']] -- Table: debate columns : [['debate id', 'number'], ['date', 'text'], ['venue', 'text'], ['num of audience', 'number']] -- Table: debate people columns : [['debate id', 'number'], ['affirmative', 'number'], ['negative', 'number'], ['if affirmative win', 'others']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables 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 people that have not been on the affirmative side of debates.` to a syntactically-correct PostgreSQL query.	SELECT Name FROM people WHERE People_id NOT IN (SELECT Affirmative FROM debate_people)
List the names of all the customers in alphabetical order.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `List the names of all the customers in alphabetical order.` to a syntactically-correct PostgreSQL query.	SELECT customer_details FROM customers ORDER BY customer_details
Sort the customer names in alphabetical order.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Sort the customer names in alphabetical order.` to a syntactically-correct PostgreSQL query.	SELECT customer_details FROM customers ORDER BY customer_details
Find all the policy type codes associated with the customer "Dayana Robel"	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Find all the policy type codes associated with the customer "Dayana Robel"` to a syntactically-correct PostgreSQL query.	SELECT policy_type_code FROM policies AS t1 JOIN customers AS t2 ON t1.customer_id = t2.customer_id WHERE t2.customer_details = "Dayana Robel"
What are the type codes of the policies used by the customer "Dayana Robel"?	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `What are the type codes of the policies used by the customer "Dayana Robel"?` to a syntactically-correct PostgreSQL query.	SELECT policy_type_code FROM policies AS t1 JOIN customers AS t2 ON t1.customer_id = t2.customer_id WHERE t2.customer_details = "Dayana Robel"
Which type of policy is most frequently used? Give me the policy type code.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Which type of policy is most frequently used? Give me the policy type code.` to a syntactically-correct PostgreSQL query.	SELECT policy_type_code FROM policies GROUP BY policy_type_code ORDER BY count(*) DESC LIMIT 1
Find the type code of the most frequently used policy.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Find the type code of the most frequently used policy.` to a syntactically-correct PostgreSQL query.	SELECT policy_type_code FROM policies GROUP BY policy_type_code ORDER BY count(*) DESC LIMIT 1
Find all the policy types that are used by more than 2 customers.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Find all the policy types that are used by more than 2 customers.` to a syntactically-correct PostgreSQL query.	SELECT policy_type_code FROM policies GROUP BY policy_type_code HAVING count(*) > 2
Which types of policy are chosen by more than 2 customers? Give me the policy type codes.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Which types of policy are chosen by more than 2 customers? Give me the policy type codes.` to a syntactically-correct PostgreSQL query.	SELECT policy_type_code FROM policies GROUP BY policy_type_code HAVING count(*) > 2
Find the total and average amount paid in claim headers.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Find the total and average amount paid in claim headers.` to a syntactically-correct PostgreSQL query.	SELECT sum(amount_piad) , avg(amount_piad) FROM claim_headers
What are the total amount and average amount paid in claim headers?	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `What are the total amount and average amount paid in claim headers?` to a syntactically-correct PostgreSQL query.	SELECT sum(amount_piad) , avg(amount_piad) FROM claim_headers
Find the total amount claimed in the most recently created document.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Find the total amount claimed in the most recently created document.` to a syntactically-correct PostgreSQL query.	SELECT sum(t1.amount_claimed) FROM claim_headers AS t1 JOIN claims_documents AS t2 ON t1.claim_header_id = t2.claim_id WHERE t2.created_date = (SELECT created_date FROM claims_documents ORDER BY created_date LIMIT 1)
How much amount in total were claimed in the most recently created document?	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `How much amount in total were claimed in the most recently created document?` to a syntactically-correct PostgreSQL query.	SELECT sum(t1.amount_claimed) FROM claim_headers AS t1 JOIN claims_documents AS t2 ON t1.claim_header_id = t2.claim_id WHERE t2.created_date = (SELECT created_date FROM claims_documents ORDER BY created_date LIMIT 1)
What is the name of the customer who has made the largest amount of claim in a single claim?	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `What is the name of the customer who has made the largest amount of claim in a single claim?` to a syntactically-correct PostgreSQL query.	SELECT t3.customer_details FROM claim_headers AS t1 JOIN policies AS t2 ON t1.policy_id = t2.policy_id JOIN customers AS t3 ON t2.customer_id = t3.customer_id WHERE t1.amount_claimed = (SELECT max(amount_claimed) FROM claim_headers)
Which customer made the largest amount of claim in a single claim? Return the customer details.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Which customer made the largest amount of claim in a single claim? Return the customer details.` to a syntactically-correct PostgreSQL query.	SELECT t3.customer_details FROM claim_headers AS t1 JOIN policies AS t2 ON t1.policy_id = t2.policy_id JOIN customers AS t3 ON t2.customer_id = t3.customer_id WHERE t1.amount_claimed = (SELECT max(amount_claimed) FROM claim_headers)
What is the name of the customer who has made the minimum amount of payment in one claim?	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `What is the name of the customer who has made the minimum amount of payment in one claim?` to a syntactically-correct PostgreSQL query.	SELECT t3.customer_details FROM claim_headers AS t1 JOIN policies AS t2 ON t1.policy_id = t2.policy_id JOIN customers AS t3 ON t2.customer_id = t3.customer_id WHERE t1.amount_piad = (SELECT min(amount_piad) FROM claim_headers)
Which customer made the smallest amount of claim in one claim? Return the customer details.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Which customer made the smallest amount of claim in one claim? Return the customer details.` to a syntactically-correct PostgreSQL query.	SELECT t3.customer_details FROM claim_headers AS t1 JOIN policies AS t2 ON t1.policy_id = t2.policy_id JOIN customers AS t3 ON t2.customer_id = t3.customer_id WHERE t1.amount_piad = (SELECT min(amount_piad) FROM claim_headers)
Find the names of customers who have no policies associated.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Find the names of customers who have no policies associated.` to a syntactically-correct PostgreSQL query.	SELECT customer_details FROM customers EXCEPT SELECT t2.customer_details FROM policies AS t1 JOIN customers AS t2 ON t1.customer_id = t2.customer_id
What are the names of customers who do not have any policies?	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `What are the names of customers who do not have any policies?` to a syntactically-correct PostgreSQL query.	SELECT customer_details FROM customers EXCEPT SELECT t2.customer_details FROM policies AS t1 JOIN customers AS t2 ON t1.customer_id = t2.customer_id
How many claim processing stages are there in total?	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `How many claim processing stages are there in total?` to a syntactically-correct PostgreSQL query.	SELECT count(*) FROM claims_processing_stages
Find the number of distinct stages in claim processing.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Find the number of distinct stages in claim processing.` to a syntactically-correct PostgreSQL query.	SELECT count(*) FROM claims_processing_stages
What is the name of the claim processing stage that most of the claims are on?	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `What is the name of the claim processing stage that most of the claims are on?` to a syntactically-correct PostgreSQL query.	SELECT t2.claim_status_name FROM claims_processing AS t1 JOIN claims_processing_stages AS t2 ON t1.claim_stage_id = t2.claim_stage_id GROUP BY t1.claim_stage_id ORDER BY count(*) DESC LIMIT 1
Which claim processing stage has the most claims? Show the claim status name.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Which claim processing stage has the most claims? Show the claim status name.` to a syntactically-correct PostgreSQL query.	SELECT t2.claim_status_name FROM claims_processing AS t1 JOIN claims_processing_stages AS t2 ON t1.claim_stage_id = t2.claim_stage_id GROUP BY t1.claim_stage_id ORDER BY count(*) DESC LIMIT 1
Find the names of customers whose name contains "Diana".	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Find the names of customers whose name contains "Diana".` to a syntactically-correct PostgreSQL query.	SELECT customer_details FROM customers WHERE customer_details LIKE "%Diana%"
Which customers have the substring "Diana" in their names? Return the customer details.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Which customers have the substring "Diana" in their names? Return the customer details.` to a syntactically-correct PostgreSQL query.	SELECT customer_details FROM customers WHERE customer_details LIKE "%Diana%"
Find the names of the customers who have an deputy policy.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Find the names of the customers who have an deputy policy.` to a syntactically-correct PostgreSQL query.	SELECT DISTINCT t2.customer_details FROM policies AS t1 JOIN customers AS t2 ON t1.customer_id = t2.customer_id WHERE t1.policy_type_code = "Deputy"
Which customers have an insurance policy with the type code "Deputy"? Give me the customer details.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Which customers have an insurance policy with the type code "Deputy"? Give me the customer details.` to a syntactically-correct PostgreSQL query.	SELECT DISTINCT t2.customer_details FROM policies AS t1 JOIN customers AS t2 ON t1.customer_id = t2.customer_id WHERE t1.policy_type_code = "Deputy"
Find the names of customers who either have an deputy policy or uniformed policy.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Find the names of customers who either have an deputy policy or uniformed policy.` to a syntactically-correct PostgreSQL query.	SELECT DISTINCT t2.customer_details FROM policies AS t1 JOIN customers AS t2 ON t1.customer_id = t2.customer_id WHERE t1.policy_type_code = "Deputy" OR t1.policy_type_code = "Uniform"
Which customers have an insurance policy with the type code "Deputy" or "Uniform"? Return the customer details.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Which customers have an insurance policy with the type code "Deputy" or "Uniform"? Return the customer details.` to a syntactically-correct PostgreSQL query.	SELECT DISTINCT t2.customer_details FROM policies AS t1 JOIN customers AS t2 ON t1.customer_id = t2.customer_id WHERE t1.policy_type_code = "Deputy" OR t1.policy_type_code = "Uniform"
Find the names of all the customers and staff members.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Find the names of all the customers and staff members.` to a syntactically-correct PostgreSQL query.	SELECT customer_details FROM customers UNION SELECT staff_details FROM staff
What are the names of the customers and staff members?	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `What are the names of the customers and staff members?` to a syntactically-correct PostgreSQL query.	SELECT customer_details FROM customers UNION SELECT staff_details FROM staff
Find the number of records of each policy type and its type code.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Find the number of records of each policy type and its type code.` to a syntactically-correct PostgreSQL query.	SELECT policy_type_code , count(*) FROM policies GROUP BY policy_type_code
For each policy type, return its type code and its count in the record.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `For each policy type, return its type code and its count in the record.` to a syntactically-correct PostgreSQL query.	SELECT policy_type_code , count(*) FROM policies GROUP BY policy_type_code
Find the name of the customer that has been involved in the most policies.	-- Language PostgreSQL -- Tables: -- Table: customers columns : [['customer id', 'number'], ['customer details', 'text']] -- Table: staff columns : [['staff id', 'number'], ['staff details', 'text']] -- Table: policies columns : [['policy id', 'number'], ['customer id', 'number'], ['policy type code', 'text'], ['start date', 'time'], ['end date', 'time']] -- Table: claim headers columns : [['claim header id', 'number'], ['claim status code', 'text'], ['claim type code', 'text'], ['policy id', 'number'], ['date of claim', 'time'], ['date of settlement', 'time'], ['amount claimed', 'number'], ['amount piad', 'number']] -- Table: claims documents columns : [['claim id', 'number'], ['document type code', 'text'], ['created by staff id', 'number'], ['created date', 'number']] -- Table: claims processing stages columns : [['claim stage id', 'number'], ['next claim stage id', 'number'], ['claim status name', 'text'], ['claim status description', 'text']] -- Table: claims processing columns : [['claim processing id', 'number'], ['claim id', 'number'], ['claim outcome code', 'text'], ['claim stage id', 'number'], ['staff id', 'number']] You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL. You should not select columns that are not part of the tables provided to you. Think step by step. Your only output should be SQL code. Do not include any other text. Only SQL code. Translate `Find the name of the customer that has been involved in the most policies.` to a syntactically-correct PostgreSQL query.	SELECT t2.customer_details FROM policies AS t1 JOIN customers AS t2 ON t1.customer_id = t2.customer_id GROUP BY t2.customer_details ORDER BY count(*) DESC LIMIT 1