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
Find all the songs whose name contains the word "the".	-- 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. Translate `Find all the songs whose name contains the word "the".` to a syntactically-correct PostgreSQL query.	SELECT title FROM songs WHERE title LIKE '% the %'
What are the names of the songs whose title has the word "the"?	-- 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. Translate `What are the names of the songs whose title has the word "the"?` to a syntactically-correct PostgreSQL query.	SELECT title FROM songs WHERE title LIKE '% the %'
What are all the instruments used?	-- 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. Translate `What are all the instruments used?` to a syntactically-correct PostgreSQL query.	SELECT DISTINCT instrument FROM Instruments
What are the different instruments listed in the database?	-- 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. Translate `What are the different instruments listed in the database?` to a syntactically-correct PostgreSQL query.	SELECT DISTINCT instrument FROM Instruments
What instrument did the musician with last name "Heilo" use in the song "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. Translate `What instrument did the musician with last name "Heilo" use in the song "Le Pop"?` to a syntactically-correct PostgreSQL query.	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"
What instruments did the musician with the last name "Heilo" play in the song "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. Translate `What instruments did the musician with the last name "Heilo" play in the song "Le Pop"?` to a syntactically-correct PostgreSQL query.	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"
What is the most used instrument?	-- 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. Translate `What is the most used instrument?` to a syntactically-correct PostgreSQL query.	SELECT instrument FROM instruments GROUP BY instrument ORDER BY count(*) DESC LIMIT 1
What instrument is used the most?	-- 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. Translate `What instrument is used the most?` to a syntactically-correct PostgreSQL query.	SELECT instrument FROM instruments GROUP BY instrument ORDER BY count(*) DESC LIMIT 1
How many songs have used the 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. Translate `How many songs have used the instrument "drums"?` to a syntactically-correct PostgreSQL query.	SELECT count(*) FROM instruments WHERE instrument = "drums"
How many songs use drums as an instrument?	-- 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. Translate `How many songs use drums as an instrument?` to a syntactically-correct PostgreSQL query.	SELECT count(*) FROM instruments WHERE instrument = "drums"
What instruments does the the song "Le Pop" use?	-- 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. Translate `What instruments does the the song "Le Pop" use?` to a syntactically-correct PostgreSQL query.	SELECT instrument FROM instruments AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Le Pop"
What are the instruments are used in the song "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. Translate `What are the instruments are used in the song "Le Pop"?` to a syntactically-correct PostgreSQL query.	SELECT instrument FROM instruments AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Le Pop"
How many instruments does the song "Le Pop" use?	-- 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. Translate `How many instruments does the song "Le Pop" use?` to a syntactically-correct PostgreSQL query.	SELECT count(DISTINCT instrument) FROM instruments AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Le Pop"
How many different instruments are used in the song "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. Translate `How many different instruments are used in the song "Le Pop"?` to a syntactically-correct PostgreSQL query.	SELECT count(DISTINCT instrument) FROM instruments AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Le Pop"
How many instrument does the musician with last name "Heilo" use?	-- 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. Translate `How many instrument does the musician with last name "Heilo" use?` to a syntactically-correct PostgreSQL query.	SELECT count(DISTINCT instrument) FROM instruments AS T1 JOIN Band AS T2 ON T1.bandmateid = T2.id WHERE T2.lastname = "Heilo"
How many different instruments does the musician with the last name "Heilo" use?	-- 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. Translate `How many different instruments does the musician with the last name "Heilo" use?` to a syntactically-correct PostgreSQL query.	SELECT count(DISTINCT instrument) FROM instruments AS T1 JOIN Band AS T2 ON T1.bandmateid = T2.id WHERE T2.lastname = "Heilo"
Find all the instruments ever used by the musician with last name "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. Translate `Find all the instruments ever used by the musician with last name "Heilo"?` to a syntactically-correct PostgreSQL query.	SELECT instrument FROM instruments AS T1 JOIN Band AS T2 ON T1.bandmateid = T2.id WHERE T2.lastname = "Heilo"
What are all the instruments used by the musician with the last name "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. Translate `What are all the instruments used by the musician with the last name "Heilo"?` to a syntactically-correct PostgreSQL query.	SELECT instrument FROM instruments AS T1 JOIN Band AS T2 ON T1.bandmateid = T2.id WHERE T2.lastname = "Heilo"
Which song has the most 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. Translate `Which song has the most vocals?` to a syntactically-correct PostgreSQL query.	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
What is the song with the most 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. Translate `What is the song with the most vocals?` to a syntactically-correct PostgreSQL query.	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
Which vocal type is the most frequently appearring type?	-- 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. Translate `Which vocal type is the most frequently appearring type?` to a syntactically-correct PostgreSQL query.	SELECT TYPE FROM vocals GROUP BY TYPE ORDER BY count(*) DESC LIMIT 1
What is the type of vocables that appears most frequently?	-- 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. Translate `What is the type of vocables that appears most frequently?` to a syntactically-correct PostgreSQL query.	SELECT TYPE FROM vocals GROUP BY TYPE ORDER BY count(*) DESC LIMIT 1
Which vocal type has the band mate with last name "Heilo" played the most?	-- 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. Translate `Which vocal type has the band mate with last name "Heilo" played the most?` to a syntactically-correct PostgreSQL query.	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
What is the type of vocals that the band member with the last name "Heilo" played the most?	-- 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. Translate `What is the type of vocals that the band member with the last name "Heilo" played the most?` to a syntactically-correct PostgreSQL query.	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
What are the vocal types used in song "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. Translate `What are the vocal types used in song "Le Pop"?` to a syntactically-correct PostgreSQL query.	SELECT TYPE FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Le Pop"
What are the types of vocals used in the song "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. Translate `What are the types of vocals used in the song "Le Pop"?` to a syntactically-correct PostgreSQL query.	SELECT TYPE FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Le Pop"
Find the number of vocal types used in song "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. Translate `Find the number of vocal types used in song "Demon Kitty Rag"?` to a syntactically-correct PostgreSQL query.	SELECT count(*) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Demon Kitty Rag"
What are the types of vocals used in the song "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. Translate `What are the types of vocals used in the song "Demon Kitty Rag"?` to a syntactically-correct PostgreSQL query.	SELECT count(*) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Demon Kitty Rag"
How many songs have a lead vocal?	-- 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. Translate `How many songs have a lead vocal?` to a syntactically-correct PostgreSQL query.	SELECT count(DISTINCT title) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE TYPE = "lead"
How many songs have vocals of 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. Translate `How many songs have vocals of type lead?` to a syntactically-correct PostgreSQL query.	SELECT count(DISTINCT title) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE TYPE = "lead"
Which vocal type did the musician with first name "Solveig" played in the song with 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. Translate `Which vocal type did the musician with first name "Solveig" played in the song with title "A Bar in Amsterdam"?` to a syntactically-correct PostgreSQL query.	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"
What are the types of vocals that the musician with the first name "Solveig" played in the song "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. Translate `What are the types of vocals that the musician with the first name "Solveig" played in the song "A Bar in Amsterdam"?` to a syntactically-correct PostgreSQL query.	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"
Find all the songs that do not have a lead vocal.	-- 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. Translate `Find all the songs that do not have a lead vocal.` to a syntactically-correct PostgreSQL query.	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"
What are the names of the songs without a lead vocal?	-- 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. Translate `What are the names of the songs without a lead vocal?` to a syntactically-correct PostgreSQL query.	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"
Find all the vocal types.	-- 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. Translate `Find all the vocal types.` to a syntactically-correct PostgreSQL query.	SELECT DISTINCT TYPE FROM vocals
What are the different types of 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. Translate `What are the different types of vocals?` to a syntactically-correct PostgreSQL query.	SELECT DISTINCT TYPE FROM vocals
What are the albums produced in 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. Translate `What are the albums produced in year 2010?` to a syntactically-correct PostgreSQL query.	SELECT * FROM Albums WHERE YEAR = 2010
What information is there on albums from 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. Translate `What information is there on albums from 2010?` to a syntactically-correct PostgreSQL query.	SELECT * FROM Albums WHERE YEAR = 2010
Who performed the song named "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. Translate `Who performed the song named "Le Pop"?` to a syntactically-correct PostgreSQL query.	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"
What is the first and last name of artist who performed "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. Translate `What is the first and last name of artist who performed "Le Pop"?` to a syntactically-correct PostgreSQL query.	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"