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
Count the number of documents.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 `Count the number of documents.` to a syntactically-correct PostgreSQL query.	SELECT count(*) FROM Documents
List the document type code, document name, and document description for the document with name 'Noel CV' or name 'King Book'.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 document type code, document name, and document description for the document with name 'Noel CV' or name 'King Book'.` to a syntactically-correct PostgreSQL query.	SELECT document_type_code , document_name , document_description FROM Documents WHERE document_name = 'Noel CV' OR document_name = 'King Book'
What are the type come, name, and description of the document that has either the name 'Noel CV' or 'King Book'?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 type come, name, and description of the document that has either the name 'Noel CV' or 'King Book'?` to a syntactically-correct PostgreSQL query.	SELECT document_type_code , document_name , document_description FROM Documents WHERE document_name = 'Noel CV' OR document_name = 'King Book'
Show the ids and names of all documents.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 ids and names of all documents.` to a syntactically-correct PostgreSQL query.	SELECT document_id , document_name FROM Documents
What are the ids and names for each of the documents?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 and names for each of the documents?` to a syntactically-correct PostgreSQL query.	SELECT document_id , document_name FROM Documents
Find names and ids of all documents with document type code BK.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 names and ids of all documents with document type code BK.` to a syntactically-correct PostgreSQL query.	SELECT document_name , document_id FROM Documents WHERE document_type_code = "BK"
What are the names and ids of documents that have the type code BK?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 and ids of documents that have the type code BK?` to a syntactically-correct PostgreSQL query.	SELECT document_name , document_id FROM Documents WHERE document_type_code = "BK"
How many documents are with document type code BK for each product id?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 documents are with document type code BK for each product id?` to a syntactically-correct PostgreSQL query.	SELECT count(*) , project_id FROM Documents WHERE document_type_code = "BK" GROUP BY project_id
Count the number of documents with the type code BK that correspond to each product id.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 `Count the number of documents with the type code BK that correspond to each product id.` to a syntactically-correct PostgreSQL query.	SELECT count(*) , project_id FROM Documents WHERE document_type_code = "BK" GROUP BY project_id
Show the document name and the document date for all documents on project with details 'Graph Database project'.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 document name and the document date for all documents on project with details 'Graph Database project'.` to a syntactically-correct PostgreSQL query.	SELECT document_name , document_date FROM Documents AS T1 JOIN projects AS T2 ON T1.project_id = T2.project_id WHERE T2.project_details = 'Graph Database project'
What are the names and dates for documents corresponding to project that has the details 'Graph Database project'?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 and dates for documents corresponding to project that has the details 'Graph Database project'?` to a syntactically-correct PostgreSQL query.	SELECT document_name , document_date FROM Documents AS T1 JOIN projects AS T2 ON T1.project_id = T2.project_id WHERE T2.project_details = 'Graph Database project'
Show project ids and the number of documents in each project.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 project ids and the number of documents in each project.` to a syntactically-correct PostgreSQL query.	SELECT project_id , count(*) FROM Documents GROUP BY project_id
How many documents correspond with each project id?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 documents correspond with each project id?` to a syntactically-correct PostgreSQL query.	SELECT project_id , count(*) FROM Documents GROUP BY project_id
What is the id of the project with least number of documents?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 project with least number of documents?` to a syntactically-correct PostgreSQL query.	SELECT project_id FROM Documents GROUP BY project_id ORDER BY count(*) ASC LIMIT 1
Return the id of the project that has the fewest corresponding documents.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 `Return the id of the project that has the fewest corresponding documents.` to a syntactically-correct PostgreSQL query.	SELECT project_id FROM Documents GROUP BY project_id ORDER BY count(*) ASC LIMIT 1
Show the ids for projects with at least 2 documents.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 ids for projects with at least 2 documents.` to a syntactically-correct PostgreSQL query.	SELECT project_id FROM Documents GROUP BY project_id HAVING count(*) >= 2
What are project ids of projects that have 2 or more corresponding documents?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 project ids of projects that have 2 or more corresponding documents?` to a syntactically-correct PostgreSQL query.	SELECT project_id FROM Documents GROUP BY project_id HAVING count(*) >= 2
List document type codes and the number of documents in each code.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 document type codes and the number of documents in each code.` to a syntactically-correct PostgreSQL query.	SELECT document_type_code , count(*) FROM Documents GROUP BY document_type_code
How many documents are there of each type?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 documents are there of each type?` to a syntactically-correct PostgreSQL query.	SELECT document_type_code , count(*) FROM Documents GROUP BY document_type_code
What is the document type code with most number of documents?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 document type code with most number of documents?` to a syntactically-correct PostgreSQL query.	SELECT document_type_code FROM Documents GROUP BY document_type_code ORDER BY count(*) DESC LIMIT 1
Return the code of the document type that is most common.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 `Return the code of the document type that is most common.` to a syntactically-correct PostgreSQL query.	SELECT document_type_code FROM Documents GROUP BY document_type_code ORDER BY count(*) DESC LIMIT 1
Show the document type code with fewer than 3 documents.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 document type code with fewer than 3 documents.` to a syntactically-correct PostgreSQL query.	SELECT document_type_code FROM Documents GROUP BY document_type_code HAVING count(*) < 3
What are the codes corresponding to document types for which there are less than 3 documents?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 codes corresponding to document types for which there are less than 3 documents?` to a syntactically-correct PostgreSQL query.	SELECT document_type_code FROM Documents GROUP BY document_type_code HAVING count(*) < 3
Show the statement detail and the corresponding document name for the statement with detail 'Private Project'.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 statement detail and the corresponding document name for the statement with detail 'Private Project'.` to a syntactically-correct PostgreSQL query.	SELECT T1.statement_details , T2.document_name FROM Statements AS T1 JOIN Documents AS T2 ON T1.statement_id = T2.document_id WHERE T1.statement_details = 'Private Project'
What are the details for statements with the details 'Private Project', and what are the names of the corresponding documents?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 for statements with the details 'Private Project', and what are the names of the corresponding documents?` to a syntactically-correct PostgreSQL query.	SELECT T1.statement_details , T2.document_name FROM Statements AS T1 JOIN Documents AS T2 ON T1.statement_id = T2.document_id WHERE T1.statement_details = 'Private Project'
Show all document type codes, document type names, document type descriptions.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 all document type codes, document type names, document type descriptions.` to a syntactically-correct PostgreSQL query.	SELECT document_type_code , document_type_name , document_type_description FROM Ref_document_types
What are the codes, names, and descriptions of the different document types?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 codes, names, and descriptions of the different document types?` to a syntactically-correct PostgreSQL query.	SELECT document_type_code , document_type_name , document_type_description FROM Ref_document_types
What is the document type description for document type named Film?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 document type description for document type named Film?` to a syntactically-correct PostgreSQL query.	SELECT document_type_description FROM Ref_document_types WHERE document_type_name = "Film"
Return the description of the document type name 'Film'.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 `Return the description of the document type name 'Film'.` to a syntactically-correct PostgreSQL query.	SELECT document_type_description FROM Ref_document_types WHERE document_type_name = "Film"
What is the document type name and the document type description and creation date for all the documents?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 document type name and the document type description and creation date for all the documents?` to a syntactically-correct PostgreSQL query.	SELECT T1.document_type_name , T1.document_type_description , T2.Document_date FROM Ref_document_types AS T1 JOIN Documents AS T2 ON T1.document_type_code = T2.document_type_code
Return the type name, type description, and date of creation for each document.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 `Return the type name, type description, and date of creation for each document.` to a syntactically-correct PostgreSQL query.	SELECT T1.document_type_name , T1.document_type_description , T2.Document_date FROM Ref_document_types AS T1 JOIN Documents AS T2 ON T1.document_type_code = T2.document_type_code
Show the number of projects.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 number of projects.` to a syntactically-correct PostgreSQL query.	SELECT count(*) FROM Projects
How many projects are there?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 projects are there?` to a syntactically-correct PostgreSQL query.	SELECT count(*) FROM Projects
List ids and details for all projects.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 ids and details for all projects.` to a syntactically-correct PostgreSQL query.	SELECT project_id , project_details FROM Projects
What are the ids and details for each project?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 and details for each project?` to a syntactically-correct PostgreSQL query.	SELECT project_id , project_details FROM Projects
What is the project id and detail for the project with at least two documents?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 project id and detail for the project with at least two documents?` to a syntactically-correct PostgreSQL query.	SELECT T1.project_id , T1.project_details FROM Projects AS T1 JOIN Documents AS T2 ON T1.project_id = T2.project_id GROUP BY T1.project_id HAVING count(*) > 2
Return the ids and details corresponding to projects for which there are more than two documents.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 `Return the ids and details corresponding to projects for which there are more than two documents.` to a syntactically-correct PostgreSQL query.	SELECT T1.project_id , T1.project_details FROM Projects AS T1 JOIN Documents AS T2 ON T1.project_id = T2.project_id GROUP BY T1.project_id HAVING count(*) > 2
What is the project detail for the project with document "King Book"?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 project detail for the project with document "King Book"?` to a syntactically-correct PostgreSQL query.	SELECT T1.project_details FROM Projects AS T1 JOIN Documents AS T2 ON T1.project_id = T2.project_id WHERE T2.document_name = "King Book"
Give the details of the project with the document name 'King Book'.	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 `Give the details of the project with the document name 'King Book'.` to a syntactically-correct PostgreSQL query.	SELECT T1.project_details FROM Projects AS T1 JOIN Documents AS T2 ON T1.project_id = T2.project_id WHERE T2.document_name = "King Book"
How many budget types do we have?	-- Language PostgreSQL -- Tables: -- Table: reference document types columns : [['document type code', 'text'], ['document type name', 'text'], ['document type description', 'text']] -- Table: reference budget codes columns : [['budget type code', 'text'], ['budget type description', 'text']] -- Table: projects columns : [['project id', 'number'], ['project details', 'text']] -- Table: documents columns : [['document id', 'number'], ['document type code', 'text'], ['project id', 'number'], ['document date', 'time'], ['document name', 'text'], ['document description', 'text'], ['other details', 'text']] -- Table: statements columns : [['statement id', 'number'], ['statement details', 'text']] -- Table: documents with expenses columns : [['document id', 'number'], ['budget type code', 'text'], ['document details', 'text']] -- Table: accounts columns : [['account id', 'number'], ['statement id', 'number'], ['account details', '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 budget types do we have?` to a syntactically-correct PostgreSQL query.	SELECT count(*) FROM Ref_budget_codes