db_id stringclasses 146
values | question stringlengths 3 224 | sql stringlengths 18 577 | database_schema stringclasses 146
values |
|---|---|---|---|
music_2 | Find all the songs whose name contains the word "the". | SELECT title FROM songs WHERE title LIKE '% the %' | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the names of the songs whose title has the word "the"? | SELECT title FROM songs WHERE title LIKE '% the %' | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are all the instruments used? | SELECT DISTINCT instrument FROM Instruments | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the different instruments listed in the database? | SELECT DISTINCT instrument FROM Instruments | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What instrument did the musician with last name "Heilo" use in the song "Le Pop"? | 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" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What instruments did the musician with the last name "Heilo" play in the song "Le Pop"? | 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" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What is the most used instrument? | SELECT instrument FROM instruments GROUP BY instrument ORDER BY count(*) DESC LIMIT 1 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What instrument is used the most? | SELECT instrument FROM instruments GROUP BY instrument ORDER BY count(*) DESC LIMIT 1 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | How many songs have used the instrument "drums"? | SELECT count(*) FROM instruments WHERE instrument = "drums" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | How many songs use drums as an instrument? | SELECT count(*) FROM instruments WHERE instrument = "drums" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What instruments does the the song "Le Pop" use? | SELECT instrument FROM instruments AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Le Pop" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the instruments are used in the song "Le Pop"? | SELECT instrument FROM instruments AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Le Pop" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | How many instruments does the song "Le Pop" use? | SELECT count(DISTINCT instrument) FROM instruments AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Le Pop" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | How many different instruments are used in the song "Le Pop"? | SELECT count(DISTINCT instrument) FROM instruments AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Le Pop" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | How many instrument does the musician with last name "Heilo" use? | SELECT count(DISTINCT instrument) FROM instruments AS T1 JOIN Band AS T2 ON T1.bandmateid = T2.id WHERE T2.lastname = "Heilo" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | How many different instruments does the musician with the last name "Heilo" use? | SELECT count(DISTINCT instrument) FROM instruments AS T1 JOIN Band AS T2 ON T1.bandmateid = T2.id WHERE T2.lastname = "Heilo" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Find all the instruments ever used by the musician with last name "Heilo"? | SELECT instrument FROM instruments AS T1 JOIN Band AS T2 ON T1.bandmateid = T2.id WHERE T2.lastname = "Heilo" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are all the instruments used by the musician with the last name "Heilo"? | SELECT instrument FROM instruments AS T1 JOIN Band AS T2 ON T1.bandmateid = T2.id WHERE T2.lastname = "Heilo" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Which song has the most vocals? | 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 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What is the song with the most vocals? | 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 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Which vocal type is the most frequently appearring type? | SELECT TYPE FROM vocals GROUP BY TYPE ORDER BY count(*) DESC LIMIT 1 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What is the type of vocables that appears most frequently? | SELECT TYPE FROM vocals GROUP BY TYPE ORDER BY count(*) DESC LIMIT 1 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Which vocal type has the band mate with last name "Heilo" played the most? | 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 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What is the type of vocals that the band member with the last name "Heilo" played the most? | 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 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the vocal types used in song "Le Pop"? | SELECT TYPE FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Le Pop" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the types of vocals used in the song "Le Pop"? | SELECT TYPE FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Le Pop" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Find the number of vocal types used in song "Demon Kitty Rag"? | SELECT count(*) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Demon Kitty Rag" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the types of vocals used in the song "Demon Kitty Rag"? | SELECT count(*) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Demon Kitty Rag" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | How many songs have a lead vocal? | SELECT count(DISTINCT title) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE TYPE = "lead" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | How many songs have vocals of type lead? | SELECT count(DISTINCT title) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE TYPE = "lead" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Which vocal type did the musician with first name "Solveig" played in the song with title "A Bar in Amsterdam"? | 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" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the types of vocals that the musician with the first name "Solveig" played in the song "A Bar in Amsterdam"? | 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" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Find all the songs that do not have a lead vocal. | 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" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the names of the songs without a lead vocal? | 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" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Find all the vocal types. | SELECT DISTINCT TYPE FROM vocals | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the different types of vocals? | SELECT DISTINCT TYPE FROM vocals | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the albums produced in year 2010? | SELECT * FROM Albums WHERE YEAR = 2010 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What information is there on albums from 2010? | SELECT * FROM Albums WHERE YEAR = 2010 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Who performed the song named "Le Pop"? | 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" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What is the first and last name of artist who performed "Le Pop"? | 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" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What is the last name of the musician that have produced the most songs? | 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 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What is the last name of the artist who sang the most songs? | 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 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What instrument did the musician with last name "Heilo" use in the song "Badlands"? | 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 = "Badlands" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What instruments did the musician with the last name "Heilo" play in "Badlands"? | 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 = "Badlands" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | How many instruments does the song "Badlands" use? | SELECT count(DISTINCT instrument) FROM instruments AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Badlands" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | How many different instruments are used in the song "Badlands"? | SELECT count(DISTINCT instrument) FROM instruments AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Badlands" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the vocal types used in song "Badlands"? | SELECT TYPE FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Badlands" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What types of vocals are used in the song "Badlands"? | SELECT TYPE FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Badlands" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Find the number of vocal types used in song "Le Pop" | SELECT count(*) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Le Pop" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | How many vocal types are used in the song "Le Pop"? | SELECT count(*) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE title = "Le Pop" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | How many songs have a shared vocal? | SELECT count(DISTINCT title) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE TYPE = "shared" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | How many different songs have shared vocals? | SELECT count(DISTINCT title) FROM vocals AS T1 JOIN songs AS T2 ON T1.songid = T2.songid WHERE TYPE = "shared" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Find all the songs that do not have a back vocal. | 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 = "back" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the different names of all songs without back vocals? | 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 = "back" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Which vocal type has the band mate with first name "Solveig" played the most? | SELECT TYPE FROM vocals AS T1 JOIN band AS T2 ON T1.bandmate = T2.id WHERE firstname = "Solveig" GROUP BY TYPE ORDER BY count(*) DESC LIMIT 1 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the types of vocals that the band member with the first name "Solveig" played the most? | SELECT TYPE FROM vocals AS T1 JOIN band AS T2 ON T1.bandmate = T2.id WHERE firstname = "Solveig" GROUP BY TYPE ORDER BY count(*) DESC LIMIT 1 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Which vocal type did the musician with last name "Heilo" played in the song with title "Der Kapitan"? | 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.lastname = "Heilo" AND T2.title = "Der Kapitan" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the types of vocals that the musician with the last name "Heilo" played in "Der Kapitan"? | 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.lastname = "Heilo" AND T2.title = "Der Kapitan" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Find the first name of the band mate that has performed in most songs. | SELECT t2.firstname FROM Performance AS t1 JOIN Band AS t2 ON t1.bandmate = t2.id JOIN Songs AS T3 ON T3.SongId = T1.SongId GROUP BY firstname ORDER BY count(*) DESC LIMIT 1 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What is the first name of the band mate who perfomed in the most songs? | SELECT t2.firstname FROM Performance AS t1 JOIN Band AS t2 ON t1.bandmate = t2.id JOIN Songs AS T3 ON T3.SongId = T1.SongId GROUP BY firstname ORDER BY count(*) DESC LIMIT 1 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Which vocal type has the band mate with first name "Marianne" played the most? | SELECT TYPE FROM vocals AS T1 JOIN band AS T2 ON T1.bandmate = T2.id WHERE firstname = "Marianne" GROUP BY TYPE ORDER BY count(*) DESC LIMIT 1 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What is the vocal type of the band mate whose first name is "Marianne" played the most? | SELECT TYPE FROM vocals AS T1 JOIN band AS T2 ON T1.bandmate = T2.id WHERE firstname = "Marianne" GROUP BY TYPE ORDER BY count(*) DESC LIMIT 1 | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Who is performing in the back stage position for the song "Der Kapitan"? Show the first name and last name. | 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 = "Der Kapitan" AND T1.StagePosition = "back" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What is the first and last name of the artist who performed back stage for the song "Der Kapitan"? | 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 = "Der Kapitan" AND T1.StagePosition = "back" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Find the name of songs that does not have a back vocal. | 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 = "back" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the names of the songs that do not have back vocals? | 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 = "back" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the songs in album "A Kiss Before You Go: Live in Hamburg"? | SELECT T3.title FROM albums AS T1 JOIN tracklists AS T2 ON T1.aid = T2.albumid JOIN songs AS T3 ON T2.songid = T3.songid WHERE T1.title = "A Kiss Before You Go: Live in Hamburg" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the song titles on the album "A Kiss Before You Go: Live in Hamburg"? | SELECT T3.title FROM albums AS T1 JOIN tracklists AS T2 ON T1.aid = T2.albumid JOIN songs AS T3 ON T2.songid = T3.songid WHERE T1.title = "A Kiss Before You Go: Live in Hamburg" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are all the songs in albums under label "Universal Music Group"? | SELECT T3.title FROM albums AS T1 JOIN tracklists AS T2 ON T1.aid = T2.albumid JOIN songs AS T3 ON T2.songid = T3.songid WHERE t1.label = "Universal Music Group" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | What are the names of all the songs whose album is under the label of "Universal Music Group"? | SELECT T3.title FROM albums AS T1 JOIN tracklists AS T2 ON T1.aid = T2.albumid JOIN songs AS T3 ON T2.songid = T3.songid WHERE t1.label = "Universal Music Group" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | Find the number of songs in all the studio albums. | SELECT count(DISTINCT T3.title) FROM albums AS T1 JOIN tracklists AS T2 ON T1.aid = T2.albumid JOIN songs AS T3 ON T2.songid = T3.songid WHERE t1.type = "Studio" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
music_2 | How many songs appear in studio albums? | SELECT count(DISTINCT T3.title) FROM albums AS T1 JOIN tracklists AS T2 ON T1.aid = T2.albumid JOIN songs AS T3 ON T2.songid = T3.songid WHERE t1.type = "Studio" | CREATE TABLE "Songs" (
"SongId" INTEGER PRIMARY KEY,
"Title" TEXT
)
3 rows from Songs table:
Empty DataFrame
Columns: [SongId, Title]
Index: []
CREATE TABLE "Albums" (
"AId" INTEGER PRIMARY KEY,
"Title" TEXT,
"Year" INTEGER,
"Label" TEXT,
"Type" TEXT )
3 rows from Albums table:
Empty DataFrame
Columns: [AId, Title, Year, Label, Type]
Index: []
CREATE TABLE "Band" (
"Id" INTEGER PRIMARY KEY,
"Firstname" TEXT,
"Lastname" TEXT )
3 rows from Band table:
Empty DataFrame
Columns: [Id, Firstname, Lastname]
Index: []
CREATE TABLE "Instruments" (
"SongId" INTEGER,
"BandmateId" INTEGER,
"Instrument" TEXT ,
PRIMARY KEY(SongId, BandmateId, Instrument),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (BandmateId) REFERENCES Band(Id)
)
3 rows from Instruments table:
Empty DataFrame
Columns: [SongId, BandmateId, Instrument]
Index: []
CREATE TABLE "Performance" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"StagePosition" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Performance table:
Empty DataFrame
Columns: [SongId, Bandmate, StagePosition]
Index: []
CREATE TABLE "Tracklists" (
"AlbumId" INTEGER,
"Position" INTEGER,
"SongId" INTEGER ,
PRIMARY KEY(AlbumId, Position),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (AlbumId) REFERENCES Albums(AId)
)
3 rows from Tracklists table:
Empty DataFrame
Columns: [AlbumId, Position, SongId]
Index: []
CREATE TABLE "Vocals" (
"SongId" INTEGER,
"Bandmate" INTEGER,
"Type" TEXT,
PRIMARY KEY(SongId, Bandmate),
FOREIGN KEY (SongId) REFERENCES Songs(SongId),
FOREIGN KEY (Bandmate) REFERENCES Band(Id)
)
3 rows from Vocals table:
Empty DataFrame
Columns: [SongId, Bandmate, Type]
Index: []
|
manufactory_1 | Who is the founder of Sony? | SELECT founder FROM manufacturers WHERE name = 'Sony' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Return the founder of Sony. | SELECT founder FROM manufacturers WHERE name = 'Sony' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Where is the headquarter of the company founded by James? | SELECT headquarter FROM manufacturers WHERE founder = 'James' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | What is the headquarter of the company whose founder is James? | SELECT headquarter FROM manufacturers WHERE founder = 'James' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Find all manufacturers' names and their headquarters, sorted by the ones with highest revenue first. | SELECT name , headquarter FROM manufacturers ORDER BY revenue DESC | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | What are the names and headquarters of all manufacturers, ordered by revenue descending? | SELECT name , headquarter FROM manufacturers ORDER BY revenue DESC | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | What are the average, maximum and total revenues of all companies? | SELECT avg(revenue) , max(revenue) , sum(revenue) FROM manufacturers | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Return the average, maximum, and total revenues across all manufacturers. | SELECT avg(revenue) , max(revenue) , sum(revenue) FROM manufacturers | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | How many companies were created by Andy? | SELECT count(*) FROM manufacturers WHERE founder = 'Andy' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Return the number of companies created by Andy. | SELECT count(*) FROM manufacturers WHERE founder = 'Andy' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Find the total revenue created by the companies whose headquarter is located at Austin. | SELECT sum(revenue) FROM manufacturers WHERE headquarter = 'Austin' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | What is the sum of revenue from companies with headquarters in Austin? | SELECT sum(revenue) FROM manufacturers WHERE headquarter = 'Austin' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | What are the different cities listed? | SELECT DISTINCT headquarter FROM manufacturers | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Give the distinct headquarters of manufacturers. | SELECT DISTINCT headquarter FROM manufacturers | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Find the number of manufactures that are based in Tokyo or Beijing. | SELECT count(*) FROM manufacturers WHERE headquarter = 'Tokyo' OR headquarter = 'Beijing' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | How many manufacturers have headquarters in either Tokyo or Beijing? | SELECT count(*) FROM manufacturers WHERE headquarter = 'Tokyo' OR headquarter = 'Beijing' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Find the founder of the company whose name begins with the letter 'S'. | SELECT founder FROM manufacturers WHERE name LIKE 'S%' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Who is the founders of companies whose first letter is S? | SELECT founder FROM manufacturers WHERE name LIKE 'S%' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Find the name of companies whose revenue is between 100 and 150. | SELECT name FROM manufacturers WHERE revenue BETWEEN 100 AND 150 | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | What are the names of companies with revenue between 100 and 150? | SELECT name FROM manufacturers WHERE revenue BETWEEN 100 AND 150 | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | What is the total revenue of all companies whose main office is at Tokyo or Taiwan? | SELECT sum(revenue) FROM manufacturers WHERE Headquarter = 'Tokyo' OR Headquarter = 'Taiwan' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Return the total revenue of companies with headquarters in Tokyo or Taiwan. | SELECT sum(revenue) FROM manufacturers WHERE Headquarter = 'Tokyo' OR Headquarter = 'Taiwan' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Find the name of product that is produced by both companies Creative Labs and Sony. | SELECT T1.name FROM products AS T1 JOIN manufacturers AS T2 ON T1.Manufacturer = T2.code WHERE T2.name = 'Creative Labs' INTERSECT SELECT T1.name FROM products AS T1 JOIN manufacturers AS T2 ON T1.Manufacturer = T2.code WHERE T2.name = 'Sony' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | What are the names of products produced by both Creative Labs and Sony? | SELECT T1.name FROM products AS T1 JOIN manufacturers AS T2 ON T1.Manufacturer = T2.code WHERE T2.name = 'Creative Labs' INTERSECT SELECT T1.name FROM products AS T1 JOIN manufacturers AS T2 ON T1.Manufacturer = T2.code WHERE T2.name = 'Sony' | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Find the name, headquarter and founder of the manufacturer that has the highest revenue. | SELECT name , headquarter , founder FROM manufacturers ORDER BY revenue DESC LIMIT 1 | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | What are the names, headquarters and founders of the company with the highest revenue? | SELECT name , headquarter , founder FROM manufacturers ORDER BY revenue DESC LIMIT 1 | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | Find the name, headquarter and revenue of all manufacturers sorted by their revenue in the descending order. | SELECT name , headquarter , revenue FROM manufacturers ORDER BY revenue DESC | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
manufactory_1 | What are the names, headquarters and revenues for manufacturers, sorted by revenue descending? | SELECT name , headquarter , revenue FROM manufacturers ORDER BY revenue DESC | CREATE TABLE Manufacturers (
Code INTEGER,
Name VARCHAR(255) NOT NULL,
Headquarter VARCHAR(255) NOT NULL,
Founder VARCHAR(255) NOT NULL,
Revenue REAL,
PRIMARY KEY (Code)
)
3 rows from Manufacturers table:
Code Name Headquarter Founder Revenue
1 Sony Tokyo Andy 120.0
2 Creative Labs Austin Owen 100.0
3 Hewlett-Packard Los Angeles James 50.0
CREATE TABLE Products (
Code INTEGER,
Name VARCHAR(255) NOT NULL ,
Price DECIMAL NOT NULL ,
Manufacturer INTEGER NOT NULL,
PRIMARY KEY (Code),
FOREIGN KEY (Manufacturer) REFERENCES Manufacturers(Code)
)
3 rows from Products table:
Code Name Price Manufacturer
1 Hard drive 240 5
2 Memory 120 6
3 ZIP drive 150 4
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.