sert121/SpiderSQL huggingface dataset:
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What are the different instruments listed in the database?
SQL: SELECT DISTINCT instrument FROM Instruments
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What instrument did the musician with last name "Heilo" use in the song "Le Pop"?
SQL: SELECT T4.instrument FROM Performance AS T1 JOIN Band AS T2 ON T1.bandmate  =  T2.id JOIN Songs AS T3 ON T3.SongId  =  T1.SongId JOIN Instruments AS T4 ON T4.songid  =  T3.songid AND T4.bandmateid  =  T2.id WHERE T2.lastname  =  "Heilo" AND T3.title  =  "Le Pop"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What instruments did the musician with the last name "Heilo" play in the song "Le Pop"?
SQL: SELECT T4.instrument FROM Performance AS T1 JOIN Band AS T2 ON T1.bandmate  =  T2.id JOIN Songs AS T3 ON T3.SongId  =  T1.SongId JOIN Instruments AS T4 ON T4.songid  =  T3.songid AND T4.bandmateid  =  T2.id WHERE T2.lastname  =  "Heilo" AND T3.title  =  "Le Pop"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What is the most used instrument?
SQL: SELECT instrument FROM instruments GROUP BY instrument ORDER BY count(*) DESC LIMIT 1
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What instrument is used the most?
SQL: SELECT instrument FROM instruments GROUP BY instrument ORDER BY count(*) DESC LIMIT 1
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: How many songs have used the instrument "drums"?
SQL: SELECT count(*) FROM instruments WHERE instrument  =  "drums"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: How many songs use drums as an instrument?
SQL: SELECT count(*) FROM instruments WHERE instrument  =  "drums"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What instruments does the the song "Le Pop" use?
SQL: SELECT instrument FROM instruments AS T1 JOIN songs AS T2 ON T1.songid  =  T2.songid WHERE title  =  "Le Pop"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What are the instruments are used in the song "Le Pop"?
SQL: SELECT instrument FROM instruments AS T1 JOIN songs AS T2 ON T1.songid  =  T2.songid WHERE title  =  "Le Pop"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: How many instruments does the song "Le Pop" use?
SQL: SELECT count(DISTINCT instrument) FROM instruments AS T1 JOIN songs AS T2 ON T1.songid  =  T2.songid WHERE title  =  "Le Pop"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: How many different instruments are used in the song "Le Pop"?
SQL: SELECT count(DISTINCT instrument) FROM instruments AS T1 JOIN songs AS T2 ON T1.songid  =  T2.songid WHERE title  =  "Le Pop"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: How many instrument does the musician with last name "Heilo" use?
SQL: SELECT count(DISTINCT instrument) FROM instruments AS T1 JOIN Band AS T2 ON T1.bandmateid  =  T2.id WHERE T2.lastname  =  "Heilo"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: How many different instruments does the musician with the last name "Heilo" use?
SQL: SELECT count(DISTINCT instrument) FROM instruments AS T1 JOIN Band AS T2 ON T1.bandmateid  =  T2.id WHERE T2.lastname  =  "Heilo"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: Find all the instruments ever used by the musician with last name "Heilo"?
SQL: SELECT instrument FROM instruments AS T1 JOIN Band AS T2 ON T1.bandmateid  =  T2.id WHERE T2.lastname  =  "Heilo"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What are all the instruments used by the musician with the last name "Heilo"?
SQL: SELECT instrument FROM instruments AS T1 JOIN Band AS T2 ON T1.bandmateid  =  T2.id WHERE T2.lastname  =  "Heilo"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: Which song has the most vocals?
SQL: SELECT title FROM vocals AS T1 JOIN songs AS T2 ON T1.songid  =  T2.songid GROUP BY T1.songid ORDER BY count(*) DESC LIMIT 1
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What is the song with the most vocals?
SQL: SELECT title FROM vocals AS T1 JOIN songs AS T2 ON T1.songid  =  T2.songid GROUP BY T1.songid ORDER BY count(*) DESC LIMIT 1
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: Which vocal type is the most frequently appearring type?
SQL: SELECT TYPE FROM vocals GROUP BY TYPE ORDER BY count(*) DESC LIMIT 1
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What is the type of vocables that appears most frequently?
SQL: SELECT TYPE FROM vocals GROUP BY TYPE ORDER BY count(*) DESC LIMIT 1
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: Which vocal type has the band mate with last name "Heilo" played the most?
SQL: SELECT TYPE FROM vocals AS T1 JOIN band AS T2 ON T1.bandmate  =  T2.id WHERE lastname  =  "Heilo" GROUP BY TYPE ORDER BY count(*) DESC LIMIT 1
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What is the type of vocals that the band member with the last name "Heilo" played the most?
SQL: SELECT TYPE FROM vocals AS T1 JOIN band AS T2 ON T1.bandmate  =  T2.id WHERE lastname  =  "Heilo" GROUP BY TYPE ORDER BY count(*) DESC LIMIT 1
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What are the vocal types used in song "Le Pop"?
SQL: SELECT TYPE FROM vocals AS T1 JOIN songs AS T2 ON T1.songid  =  T2.songid WHERE title  =  "Le Pop"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What are the types of vocals used in the song "Le Pop"?
SQL: SELECT TYPE FROM vocals AS T1 JOIN songs AS T2 ON T1.songid  =  T2.songid WHERE title  =  "Le Pop"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: Find the number of vocal types used in song "Demon Kitty Rag"?
SQL: SELECT count(*) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid  =  T2.songid WHERE title  =  "Demon Kitty Rag"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What are the types of vocals used in the song "Demon Kitty Rag"?
SQL: SELECT count(*) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid  =  T2.songid WHERE title  =  "Demon Kitty Rag"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: How many songs have a lead vocal?
SQL: SELECT count(DISTINCT title) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid  =  T2.songid WHERE TYPE  =  "lead"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: How many songs have vocals of type lead?
SQL: SELECT count(DISTINCT title) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid  =  T2.songid WHERE TYPE  =  "lead"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: Which vocal type did the musician with first name "Solveig" played in the song with title "A Bar in Amsterdam"?
SQL: SELECT TYPE FROM vocals AS T1 JOIN songs AS T2 ON T1.songid  =  T2.songid JOIN band AS T3 ON T1.bandmate  =  T3.id WHERE T3.firstname  =  "Solveig" AND T2.title  =  "A Bar In Amsterdam"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What are the types of vocals that the musician with the first name "Solveig" played in the song "A Bar in Amsterdam"?
SQL: SELECT TYPE FROM vocals AS T1 JOIN songs AS T2 ON T1.songid  =  T2.songid JOIN band AS T3 ON T1.bandmate  =  T3.id WHERE T3.firstname  =  "Solveig" AND T2.title  =  "A Bar In Amsterdam"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: Find all the songs that do not have a lead vocal.
SQL: SELECT DISTINCT title FROM vocals AS t1 JOIN songs AS t2 ON t1.songid  =  t2.songid EXCEPT SELECT t2.title FROM vocals AS t1 JOIN songs AS t2 ON t1.songid  =  t2.songid WHERE TYPE  =  "lead"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What are the names of the songs without a lead vocal?
SQL: SELECT DISTINCT title FROM vocals AS t1 JOIN songs AS t2 ON t1.songid  =  t2.songid EXCEPT SELECT t2.title FROM vocals AS t1 JOIN songs AS t2 ON t1.songid  =  t2.songid WHERE TYPE  =  "lead"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: Find all the vocal types.
SQL: SELECT DISTINCT TYPE FROM vocals
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What are the different types of vocals?
SQL: SELECT DISTINCT TYPE FROM vocals
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What are the albums produced in year 2010?
SQL: SELECT * FROM Albums WHERE YEAR  =  2010
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What information is there on albums from 2010?
SQL: SELECT * FROM Albums WHERE YEAR  =  2010
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: Who performed the song named "Le Pop"?
SQL: SELECT T2.firstname ,  T2.lastname FROM Performance AS T1 JOIN Band AS T2 ON T1.bandmate  =  T2.id JOIN Songs AS T3 ON T3.SongId  =  T1.SongId WHERE T3.Title  =  "Le Pop"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What is the first and last name of artist who performed "Le Pop"?
SQL: SELECT T2.firstname ,  T2.lastname FROM Performance AS T1 JOIN Band AS T2 ON T1.bandmate  =  T2.id JOIN Songs AS T3 ON T3.SongId  =  T1.SongId WHERE T3.Title  =  "Le Pop"
-- Language PostgreSQL
        -- Tables: 
             -- Table: songs 
columns : [['song id', 'number'], ['title', 'text']]

 -- Table: albums 
columns : [['aid', 'number'], ['title', 'text'], ['year', 'number'], ['label', 'text'], ['type', 'text']]

 -- Table: band 
columns : [['id', 'number'], ['first name', 'text'], ['last name', 'text']]

 -- Table: instruments 
columns : [['song id', 'number'], ['bandmate id', 'number'], ['instrument', 'text']]

 -- Table: performance 
columns : [['song id', 'number'], ['bandmate', 'number'], ['stage position', 'text']]

 -- Table: track lists 
columns : [['album id', 'number'], ['position', 'number'], ['song id', 'number']]

 -- Table: vocals 
columns : [['song id', 'number'], ['bandmate', 'number'], ['type', '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.



Question: What is the last name of the musician that have produced the most songs?
SQL: SELECT T2.lastname FROM Performance AS T1 JOIN Band AS T2 ON T1.bandmate  =  T2.id JOIN Songs AS T3 ON T3.SongId  =  T1.SongId GROUP BY lastname ORDER BY count(*) DESC LIMIT 1