question string | answer string | context string | dialect string | spider_hardness string | extended_hardness string | classification_status string | syntax_status string | ddl_syntax_status string | schema_status string | syntax_errors list | ddl_syntax_errors list | schema_errors list | classification_errors list | status_history list | correction_status string | component1 int64 | component2 int64 | others int64 | validation_source dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Show name, class, and date for all races. | SELECT name, CLASS, date FROM race | CREATE TABLE race (name VARCHAR(255), CLASS VARCHAR(255), date VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 422
} |
Show the race class and number of races in each class. | SELECT CLASS, COUNT(*) FROM race GROUP BY CLASS | CREATE TABLE race (CLASS VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 423
} |
What is the race class with most number of races. | SELECT CLASS FROM race GROUP BY CLASS ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE race (CLASS VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 424
} |
List the race class with at least two races. | SELECT CLASS FROM race GROUP BY CLASS HAVING COUNT(*) >= 2 | CREATE TABLE race (CLASS VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 425
} |
Show all track names that have had no races. | SELECT name FROM track WHERE NOT track_id IN (SELECT track_id FROM race) | CREATE TABLE track (name VARCHAR(255), track_id VARCHAR(255)); CREATE TABLE race (name VARCHAR(255), track_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 427
} |
Show year where a track with a seating at least 5000 opened and a track with seating no more than 4000 opened. | SELECT year_opened FROM track WHERE seating BETWEEN 4000 AND 5000 | CREATE TABLE track (year_opened VARCHAR(255), seating INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 428
} |
Show the name of track and the number of races in each track. | SELECT T2.name, COUNT(*) FROM race AS T1 JOIN track AS T2 ON T1.track_id = T2.track_id GROUP BY T1.track_id | CREATE TABLE track (name VARCHAR(255), track_id VARCHAR(255)); CREATE TABLE race (track_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 429
} |
Show the name of track with most number of races. | SELECT T2.name FROM race AS T1 JOIN track AS T2 ON T1.track_id = T2.track_id GROUP BY T1.track_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE track (name VARCHAR, track_id VARCHAR); CREATE TABLE race (track_id VARCHAR, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 430
} |
Show the name and location of track with 1 race. | SELECT T2.name, T2.location FROM race AS T1 JOIN track AS T2 ON T1.track_id = T2.track_id GROUP BY T1.track_id HAVING COUNT(*) = 1 | CREATE TABLE race (track_id VARCHAR, id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE track (name VARCHAR, location VARCHAR, track_id VARCHAR) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 432
} |
How many members have the black membership card? | SELECT COUNT(*) FROM member WHERE Membership_card = 'Black' | CREATE TABLE member (Membership_card VARCHAR, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 434
} |
Find the number of members living in each address. | SELECT COUNT(*), address FROM member GROUP BY address | CREATE TABLE member (address VARCHAR, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 435
} |
Which membership card has more than 5 members? | SELECT Membership_card FROM member GROUP BY Membership_card HAVING COUNT(*) > 5 | CREATE TABLE member (Membership_card VARCHAR, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 439
} |
How many members are not living in Hartford? | SELECT COUNT(*) FROM member WHERE address <> 'Hartford' | CREATE TABLE member (address VARCHAR, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 442
} |
Find the id and address of the shops whose score is below the average score. | SELECT shop_id, address FROM shop WHERE score < (SELECT AVG(score) FROM shop) | CREATE TABLE shop (shop_id VARCHAR(255), address VARCHAR(255), score INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 446
} |
Find the address and staff number of the shops that do not have any happy hour. | SELECT address, num_of_staff FROM shop WHERE NOT shop_id IN (SELECT shop_id FROM happy_hour) | CREATE TABLE shop (address VARCHAR(255), num_of_staff VARCHAR(255), shop_id VARCHAR(255)); CREATE TABLE happy_hour (address VARCHAR(255), num_of_staff VARCHAR(255), shop_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 447
} |
which shop has happy hour most frequently? List its id and number of happy hours. | SELECT shop_id, COUNT(*) FROM happy_hour GROUP BY shop_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE happy_hour (shop_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 449
} |
Which month has the most happy hours? | SELECT MONTH FROM happy_hour GROUP BY MONTH ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE happy_hour (MONTH VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 450
} |
Which months have more than 2 happy hours? | SELECT MONTH FROM happy_hour GROUP BY MONTH HAVING COUNT(*) > 2 | CREATE TABLE happy_hour (MONTH VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 451
} |
How many albums are there? | SELECT COUNT(*) FROM ALBUM | CREATE TABLE ALBUM (Id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 452
} |
List the names of all music genres. | SELECT Name FROM GENRE | CREATE TABLE GENRE (Name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 453
} |
What are the first names and last names of the employees who live in Calgary city. | SELECT FirstName, LastName FROM EMPLOYEE WHERE City = 'Calgary' | CREATE TABLE EMPLOYEE (FirstName VARCHAR(255), LastName VARCHAR(255), City VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 455
} |
What are the distinct billing countries of the invoices? | SELECT DISTINCT (BillingCountry) FROM INVOICE | CREATE TABLE INVOICE (BillingCountry VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 456
} |
Find the names of all artists that have "a" in their names. | SELECT Name FROM ARTIST WHERE Name LIKE '%a%' | CREATE TABLE ARTIST (Name VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 457
} |
Hom many albums does the artist "Metallica" have? | SELECT COUNT(*) FROM ALBUM AS T1 JOIN ARTIST AS T2 ON T1.ArtistId = T2.ArtistId WHERE T2.Name = 'Metallica' | CREATE TABLE ARTIST (ArtistId VARCHAR(255), Name VARCHAR(255)); CREATE TABLE ALBUM (ArtistId VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 459
} |
Which artist does the album "Balls to the Wall" belong to? | SELECT T2.Name FROM ALBUM AS T1 JOIN ARTIST AS T2 ON T1.ArtistId = T2.ArtistId WHERE T1.Title = 'Balls to the Wall' | CREATE TABLE ALBUM (ArtistId VARCHAR(255), Title VARCHAR(255)); CREATE TABLE ARTIST (Name VARCHAR(255), ArtistId VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 460
} |
Which artist has the most albums? | SELECT T2.Name FROM ALBUM AS T1 JOIN ARTIST AS T2 ON T1.ArtistId = T2.ArtistId GROUP BY T2.Name ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE ALBUM (ArtistId VARCHAR(255)); CREATE TABLE ARTIST (Name VARCHAR(255), ArtistId VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 461
} |
Find the names of all the tracks that contain the word "you". | SELECT Name FROM TRACK WHERE Name LIKE '%you%' | CREATE TABLE TRACK (Name VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 462
} |
What is the average unit price of all the tracks? | SELECT AVG(UnitPrice) FROM TRACK | CREATE TABLE TRACK (UnitPrice INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 463
} |
What are the durations of the longest and the shortest tracks in milliseconds? | SELECT MAX(Milliseconds), MIN(Milliseconds) FROM TRACK | CREATE TABLE TRACK (Milliseconds INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 2 | {
"split": "train",
"row_index": 464
} |
What is the name of the most common genre in all tracks? | SELECT T1.Name FROM GENRE AS T1 JOIN TRACK AS T2 ON T1.GenreId = T2.GenreId GROUP BY T2.GenreId ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE GENRE (Name VARCHAR(255), GenreId VARCHAR(255)); CREATE TABLE TRACK (GenreId VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 466
} |
What is the least common media type in all tracks? | SELECT T1.Name FROM MEDIATYPE AS T1 JOIN TRACK AS T2 ON T1.MediaTypeId = T2.MediaTypeId GROUP BY T2.MediaTypeId ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE MEDIATYPE (Name VARCHAR(255), MediaTypeId VARCHAR(255)); CREATE TABLE TRACK (MediaTypeId VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 467
} |
How many tracks belong to rock genre? | SELECT COUNT(*) FROM GENRE AS T1 JOIN TRACK AS T2 ON T1.GenreId = T2.GenreId WHERE T1.Name = 'Rock' | CREATE TABLE TRACK (GenreId VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE GENRE (GenreId VARCHAR(255), Name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 469
} |
What is the first name and last name of the customer that has email "luisg@embraer.com.br"? | SELECT FirstName, LastName FROM CUSTOMER WHERE Email = 'luisg@embraer.com.br' | CREATE TABLE CUSTOMER (FirstName VARCHAR(255), LastName VARCHAR(255), Email VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 471
} |
How many customers have email that contains "gmail.com"? | SELECT COUNT(*) FROM CUSTOMER WHERE Email LIKE '%gmail.com%' | CREATE TABLE CUSTOMER (Email VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 472
} |
What is the first name and last name employee helps the customer with first name Leonie? | SELECT T2.FirstName, T2.LastName FROM CUSTOMER AS T1 JOIN EMPLOYEE AS T2 ON T1.SupportRepId = T2.EmployeeId WHERE T1.FirstName = 'Leonie' | CREATE TABLE CUSTOMER (SupportRepId VARCHAR(255), FirstName VARCHAR(255)); CREATE TABLE EMPLOYEE (FirstName VARCHAR(255), LastName VARCHAR(255), EmployeeId VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 473
} |
What city does the employee who helps the customer with postal code 70174 live in? | SELECT T2.City FROM CUSTOMER AS T1 JOIN EMPLOYEE AS T2 ON T1.SupportRepId = T2.EmployeeId WHERE T1.PostalCode = '70174' | CREATE TABLE EMPLOYEE (City VARCHAR(255), EmployeeId VARCHAR(255)); CREATE TABLE CUSTOMER (SupportRepId VARCHAR(255), PostalCode VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 474
} |
How many distinct cities does the employees live in? | SELECT COUNT(DISTINCT city) FROM EMPLOYEE | CREATE TABLE EMPLOYEE (city VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 475
} |
Find the first names of all customers that live in Brazil and have an invoice. | SELECT DISTINCT T1.FirstName FROM CUSTOMER AS T1 JOIN INVOICE AS T2 ON T1.CustomerId = T2.CustomerId WHERE T1.country = 'Brazil' | CREATE TABLE CUSTOMER (FirstName VARCHAR(255), CustomerId VARCHAR(255), country VARCHAR(255)); CREATE TABLE INVOICE (CustomerId VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 478
} |
Find the address of all customers that live in Germany and have invoice. | SELECT DISTINCT T1.Address FROM CUSTOMER AS T1 JOIN INVOICE AS T2 ON T1.CustomerId = T2.CustomerId WHERE T1.country = 'Germany' | CREATE TABLE INVOICE (CustomerId VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE CUSTOMER (Address VARCHAR(255), CustomerId VARCHAR(255), country VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 479
} |
List the phone numbers of all employees. | SELECT Phone FROM EMPLOYEE | CREATE TABLE EMPLOYEE (Phone VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 480
} |
How many tracks are in the AAC audio file media type? | SELECT COUNT(*) FROM MEDIATYPE AS T1 JOIN TRACK AS T2 ON T1.MediaTypeId = T2.MediaTypeId WHERE T1.Name = 'AAC audio file' | CREATE TABLE MEDIATYPE (MediaTypeId VARCHAR(255), Name VARCHAR(255)); CREATE TABLE TRACK (MediaTypeId VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 481
} |
Please show the employee first names and ids of employees who serve at least 10 customers. | SELECT T1.FirstName, T1.SupportRepId FROM CUSTOMER AS T1 JOIN EMPLOYEE AS T2 ON T1.SupportRepId = T2.EmployeeId GROUP BY T1.SupportRepId HAVING COUNT(*) >= 10 | CREATE TABLE CUSTOMER (FirstName VARCHAR(255), SupportRepId VARCHAR(255)); CREATE TABLE EMPLOYEE (EmployeeId VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 483
} |
Please show the employee last names that serves no more than 20 customers. | SELECT T1.LastName FROM CUSTOMER AS T1 JOIN EMPLOYEE AS T2 ON T1.SupportRepId = T2.EmployeeId GROUP BY T1.SupportRepId HAVING COUNT(*) <= 20 | CREATE TABLE EMPLOYEE (EmployeeId VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE CUSTOMER (LastName VARCHAR(255), SupportRepId VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 484
} |
Please list all album titles in alphabetical order. | SELECT Title FROM ALBUM ORDER BY Title | CREATE TABLE ALBUM (Title VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 485
} |
Please list the name and id of all artists that have at least 3 albums in alphabetical order. | SELECT T2.Name, T1.ArtistId FROM ALBUM AS T1 JOIN ARTIST AS T2 ON T1.ArtistId = T2.ArtistID GROUP BY T1.ArtistId HAVING COUNT(*) >= 3 ORDER BY T2.Name | CREATE TABLE ARTIST (Name VARCHAR(255), ArtistID VARCHAR(255)); CREATE TABLE ALBUM (ArtistId VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 486
} |
What is the average unit price of rock tracks? | SELECT AVG(T2.UnitPrice) FROM GENRE AS T1 JOIN TRACK AS T2 ON T1.GenreId = T2.GenreId WHERE T1.Name = 'Rock' | CREATE TABLE GENRE (GenreId VARCHAR(255), Name VARCHAR(255)); CREATE TABLE TRACK (UnitPrice INTEGER, GenreId VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 488
} |
What are the birth dates of employees living in Edmonton? | SELECT BirthDate FROM EMPLOYEE WHERE City = 'Edmonton' | CREATE TABLE EMPLOYEE (BirthDate VARCHAR(255), City VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 490
} |
What are the distinct unit prices of all tracks? | SELECT DISTINCT (UnitPrice) FROM TRACK | CREATE TABLE TRACK (UnitPrice VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 491
} |
How many artists do not have any album? | SELECT COUNT(*) FROM ARTIST WHERE NOT artistid IN (SELECT artistid FROM ALBUM) | CREATE TABLE ARTIST (artistid VARCHAR(255), Name VARCHAR(255)); CREATE TABLE ALBUM (artistid VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 492
} |
What are the album titles for albums containing both 'Reggae' and 'Rock' genre tracks? | SELECT T1.Title FROM Album AS T1 JOIN Track AS T2 ON T1.AlbumId = T2.AlbumId JOIN Genre AS T3 ON T2.GenreID = T3.GenreID WHERE T3.Name = 'Reggae' INTERSECT SELECT T1.Title FROM Album AS T1 JOIN Track AS T2 ON T1.AlbumId = T2.AlbumId JOIN Genre AS T3 ON T2.GenreID = T3.GenreID WHERE T3.Name = 'Rock' | CREATE TABLE Genre (GenreID VARCHAR(255), Name VARCHAR(255)); CREATE TABLE Track (AlbumId VARCHAR(255), GenreID VARCHAR(255)); CREATE TABLE Album (Title VARCHAR(255), AlbumId VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 1 | 0 | {
"split": "train",
"row_index": 493
} |
Find all the phone numbers. | SELECT customer_phone FROM available_policies | CREATE TABLE available_policies (customer_phone VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 494
} |
What are the customer phone numbers under the policy "Life Insurance"? | SELECT customer_phone FROM available_policies WHERE policy_type_code = 'Life Insurance' | CREATE TABLE available_policies (customer_phone VARCHAR(255), policy_type_code VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 495
} |
Which policy type has the most records in the database? | SELECT policy_type_code FROM available_policies GROUP BY policy_type_code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE available_policies (policy_type_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 496
} |
What are all the customer phone numbers under the most popular policy type? | SELECT customer_phone FROM available_policies WHERE policy_type_code = (SELECT policy_type_code FROM available_policies GROUP BY policy_type_code ORDER BY COUNT(*) DESC LIMIT 1) | CREATE TABLE available_policies (customer_phone VARCHAR(255), policy_type_code VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 497
} |
Find the policy type used by more than 4 customers. | SELECT policy_type_code FROM available_policies GROUP BY policy_type_code HAVING COUNT(*) > 4 | CREATE TABLE available_policies (policy_type_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 498
} |
Find the total and average amount of settlements. | SELECT SUM(settlement_amount), AVG(settlement_amount) FROM settlements | CREATE TABLE settlements (settlement_amount INTEGER, settlement_id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 2 | {
"split": "train",
"row_index": 499
} |
Find the name of services that have been used for more than 2 times in first notification of loss. | SELECT t2.service_name FROM first_notification_of_loss AS t1 JOIN services AS t2 ON t1.service_id = t2.service_id GROUP BY t1.service_id HAVING COUNT(*) > 2 | CREATE TABLE services (service_name VARCHAR(255), service_id VARCHAR(255)); CREATE TABLE first_notification_of_loss (service_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 500
} |
What is the effective date of the claim that has the largest amount of total settlement? | SELECT t1.Effective_Date FROM claims AS t1 JOIN settlements AS t2 ON t1.claim_id = t2.claim_id GROUP BY t1.claim_id ORDER BY SUM(t2.settlement_amount) DESC LIMIT 1 | CREATE TABLE settlements (claim_id VARCHAR(255), settlement_amount INTEGER); CREATE TABLE claims (Effective_Date VARCHAR(255), claim_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 501
} |
How many policies are listed for the customer named "Dayana Robel"? | SELECT COUNT(*) FROM customers AS t1 JOIN customers_policies AS t2 ON t1.customer_id = t2.customer_id WHERE t1.customer_name = 'Dayana Robel' | CREATE TABLE customers (customer_id VARCHAR(255), customer_name VARCHAR(255)); CREATE TABLE customers_policies (customer_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 502
} |
What is the name of the customer who has the most policies listed? | SELECT t1.customer_name FROM customers AS t1 JOIN customers_policies AS t2 ON t1.customer_id = t2.customer_id GROUP BY t1.customer_name ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE customers (customer_name VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE customers_policies (customer_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 503
} |
What are all the policy types of the customer named "Dayana Robel"? | SELECT DISTINCT t3.policy_type_code FROM customers AS t1 JOIN customers_policies AS t2 ON t1.customer_id = t2.customer_id JOIN available_policies AS t3 ON t2.policy_id = t3.policy_id WHERE t1.customer_name = 'Dayana Robel' | CREATE TABLE customers (customer_id VARCHAR(255), customer_name VARCHAR(255)); CREATE TABLE available_policies (policy_type_code VARCHAR(255), policy_id VARCHAR(255)); CREATE TABLE customers_policies (customer_id VARCHAR(255), policy_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 504
} |
What are all the policy types of the customer that has the most policies listed? | SELECT DISTINCT t3.policy_type_code FROM customers AS t1 JOIN customers_policies AS t2 ON t1.customer_id = t2.customer_id JOIN available_policies AS t3 ON t2.policy_id = t3.policy_id WHERE t1.customer_name = (SELECT t1.customer_name FROM customers AS t1 JOIN customers_policies AS t2 ON t1.customer_id = t2.customer_id G... | CREATE TABLE customers (customer_id VARCHAR(255), customer_name VARCHAR(255)); CREATE TABLE available_policies (policy_type_code VARCHAR(255), policy_id VARCHAR(255)); CREATE TABLE customers_policies (customer_id VARCHAR(255), policy_id VARCHAR(255)) | generic | extra | extreme | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 1 | 0 | {
"split": "train",
"row_index": 505
} |
List all the services in the alphabetical order. | SELECT service_name FROM services ORDER BY service_name | CREATE TABLE services (service_name VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 506
} |
How many services are there? | SELECT COUNT(*) FROM services | CREATE TABLE services (Id VARCHAR(255), service_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 507
} |
Find the names of customers who have used either the service "Close a policy" or the service "Upgrade a policy". | SELECT t1.customer_name FROM customers AS t1 JOIN first_notification_of_loss AS t2 ON t1.customer_id = t2.customer_id JOIN services AS t3 ON t2.service_id = t3.service_id WHERE t3.service_name = 'Close a policy' OR t3.service_name = 'Upgrade a policy' | CREATE TABLE first_notification_of_loss (customer_id VARCHAR(255), service_id VARCHAR(255)); CREATE TABLE customers (customer_name VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE services (service_id VARCHAR(255), service_name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 509
} |
Find the names of customers who have used both the service "Close a policy" and the service "New policy application". | SELECT t1.customer_name FROM customers AS t1 JOIN first_notification_of_loss AS t2 ON t1.customer_id = t2.customer_id JOIN services AS t3 ON t2.service_id = t3.service_id WHERE t3.service_name = 'Close a policy' INTERSECT SELECT t1.customer_name FROM customers AS t1 JOIN first_notification_of_loss AS t2 ON t1.customer_... | CREATE TABLE first_notification_of_loss (customer_id VARCHAR(255), service_id VARCHAR(255)); CREATE TABLE customers (customer_name VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE services (service_id VARCHAR(255), service_name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 1 | 0 | {
"split": "train",
"row_index": 510
} |
Find the IDs of customers whose name contains "Diana". | SELECT customer_id FROM customers WHERE customer_name LIKE '%Diana%' | CREATE TABLE customers (customer_id VARCHAR(255), customer_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 511
} |
What are the maximum and minimum settlement amount on record? | SELECT MAX(settlement_amount), MIN(settlement_amount) FROM settlements | CREATE TABLE settlements (settlement_amount INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 2 | {
"split": "train",
"row_index": 512
} |
List all the customers in increasing order of IDs. | SELECT customer_id, customer_name FROM customers ORDER BY customer_id | CREATE TABLE customers (customer_id VARCHAR(255), customer_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 513
} |
Retrieve the open and close dates of all the policies associated with the customer whose name contains "Diana" | SELECT t2.date_opened, t2.date_closed FROM customers AS t1 JOIN customers_policies AS t2 ON t1.customer_id = t2.customer_id WHERE t1.customer_name LIKE '%Diana%' | CREATE TABLE customers (customer_id VARCHAR(255), customer_name VARCHAR(255)); CREATE TABLE customers_policies (date_opened VARCHAR(255), date_closed VARCHAR(255), customer_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 514
} |
How many kinds of enzymes are there? | SELECT COUNT(*) FROM enzyme | CREATE TABLE enzyme (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 515
} |
List the name of enzymes in descending lexicographical order. | SELECT name FROM enzyme ORDER BY name DESC | CREATE TABLE enzyme (name VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 516
} |
List the names and the locations that the enzymes can make an effect. | SELECT name, LOCATION FROM enzyme | CREATE TABLE enzyme (name VARCHAR(255), LOCATION VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 517
} |
What is the maximum Online Mendelian Inheritance in Man (OMIM) value of the enzymes? | SELECT MAX(OMIM) FROM enzyme | CREATE TABLE enzyme (OMIM INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 518
} |
What is the product, chromosome and porphyria related to the enzymes which take effect at the location 'Cytosol'? | SELECT product, chromosome, porphyria FROM enzyme WHERE LOCATION = 'Cytosol' | CREATE TABLE enzyme (product VARCHAR(255), chromosome VARCHAR(255), porphyria VARCHAR(255), LOCATION VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 519
} |
What are the names of enzymes who does not produce 'Heme'? | SELECT name FROM enzyme WHERE product <> 'Heme' | CREATE TABLE enzyme (name VARCHAR(255), product VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 520
} |
What are the names and trade names of the medicines which has 'Yes' value in the FDA record? | SELECT name, trade_name FROM medicine WHERE FDA_approved = 'Yes' | CREATE TABLE medicine (name VARCHAR(255), trade_name VARCHAR(255), FDA_approved VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 521
} |
What are the names of enzymes in the medicine named 'Amisulpride' that can serve as an 'inhibitor'? | SELECT T1.name FROM enzyme AS T1 JOIN medicine_enzyme_interaction AS T2 ON T1.id = T2.enzyme_id JOIN medicine AS T3 ON T2.medicine_id = T3.id WHERE T3.name = 'Amisulpride' AND T2.interaction_type = 'inhibitor' | CREATE TABLE medicine (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE medicine_enzyme_interaction (enzyme_id VARCHAR(255), medicine_id VARCHAR(255), interaction_type VARCHAR(255)); CREATE TABLE enzyme (name VARCHAR(255), id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 522
} |
What are the ids and names of the medicine that can interact with two or more enzymes? | SELECT T1.id, T1.Name FROM medicine AS T1 JOIN medicine_enzyme_interaction AS T2 ON T2.medicine_id = T1.id GROUP BY T1.id HAVING COUNT(*) >= 2 | CREATE TABLE medicine_enzyme_interaction (medicine_id VARCHAR(255), enzyme_id VARCHAR(255)); CREATE TABLE medicine (id VARCHAR(255), Name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 523
} |
What are the ids, names and FDA approval status of medicines in descending order of the number of enzymes that it can interact with. | SELECT T1.id, T1.Name, T1.FDA_approved FROM medicine AS T1 JOIN medicine_enzyme_interaction AS T2 ON T2.medicine_id = T1.id GROUP BY T1.id ORDER BY COUNT(*) DESC | CREATE TABLE medicine_enzyme_interaction (medicine_id VARCHAR(255), enzyme_id VARCHAR(255)); CREATE TABLE medicine (id VARCHAR(255), Name VARCHAR(255), FDA_approved VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 524
} |
What is the id and name of the enzyme with most number of medicines that can interact as 'activator'? | SELECT T1.id, T1.name FROM enzyme AS T1 JOIN medicine_enzyme_interaction AS T2 ON T1.id = T2.enzyme_id WHERE T2.interaction_type = 'activitor' GROUP BY T1.id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE medicine_enzyme_interaction (enzyme_id VARCHAR(255), interaction_type VARCHAR(255)); CREATE TABLE enzyme (id VARCHAR(255), name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 5 | 0 | 1 | {
"split": "train",
"row_index": 525
} |
What is the interaction type of the enzyme named 'ALA synthase' and the medicine named 'Aripiprazole'? | SELECT T1.interaction_type FROM medicine_enzyme_interaction AS T1 JOIN medicine AS T2 ON T1.medicine_id = T2.id JOIN enzyme AS T3 ON T1.enzyme_id = T3.id WHERE T3.name = 'ALA synthase' AND T2.name = 'Aripiprazole' | CREATE TABLE enzyme (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE medicine (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE medicine_enzyme_interaction (interaction_type VARCHAR(255), medicine_id VARCHAR(255), enzyme_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 526
} |
What is the most common interaction type between enzymes and medicine? And how many are there? | SELECT interaction_type, COUNT(*) FROM medicine_enzyme_interaction GROUP BY interaction_type ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE medicine_enzyme_interaction (interaction_type VARCHAR(255), medicine_id VARCHAR(255), enzyme_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 527
} |
How many medicines have the FDA approval status 'No' ? | SELECT COUNT(*) FROM medicine WHERE FDA_approved = 'No' | CREATE TABLE medicine (FDA_approved VARCHAR(255), id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 528
} |
How many enzymes do not have any interactions? | SELECT COUNT(*) FROM enzyme WHERE NOT id IN (SELECT enzyme_id FROM medicine_enzyme_interaction) | CREATE TABLE medicine_enzyme_interaction (id VARCHAR(255), enzyme_id VARCHAR(255)); CREATE TABLE enzyme (id VARCHAR(255), enzyme_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 529
} |
What is the id and trade name of the medicines can interact with at least 3 enzymes? | SELECT T1.id, T1.trade_name FROM medicine AS T1 JOIN medicine_enzyme_interaction AS T2 ON T2.medicine_id = T1.id GROUP BY T1.id HAVING COUNT(*) >= 3 | CREATE TABLE medicine (id VARCHAR(255), trade_name VARCHAR(255)); CREATE TABLE medicine_enzyme_interaction (medicine_id VARCHAR(255), enzyme_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 530
} |
What are the distinct name, location and products of the enzymes which has any 'inhibitor' interaction? | SELECT DISTINCT T1.name, T1.location, T1.product FROM enzyme AS T1 JOIN medicine_enzyme_interaction AS T2 ON T2.enzyme_id = T1.id WHERE T2.interaction_type = 'inhibitor' | CREATE TABLE enzyme (name VARCHAR(255), location VARCHAR(255), product VARCHAR(255), id VARCHAR(255)); CREATE TABLE medicine_enzyme_interaction (enzyme_id VARCHAR(255), interaction_type VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 531
} |
How many distinct FDA approval statuses are there for the medicines? | SELECT COUNT(DISTINCT FDA_approved) FROM medicine | CREATE TABLE medicine (FDA_approved VARCHAR(255), id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 534
} |
Which enzyme names have the substring "ALA"? | SELECT name FROM enzyme WHERE name LIKE '%ALA%' | CREATE TABLE enzyme (name VARCHAR(255), id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 535
} |
find the number of medicines offered by each trade. | SELECT trade_name, COUNT(*) FROM medicine GROUP BY trade_name | CREATE TABLE medicine (trade_name VARCHAR(255), id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 536
} |
List all schools and their nicknames in the order of founded year. | SELECT school, nickname FROM university ORDER BY founded | CREATE TABLE university (school VARCHAR(255), nickname VARCHAR(255), founded VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 537
} |
List all public schools and their locations. | SELECT school, LOCATION FROM university WHERE affiliation = 'Public' | CREATE TABLE university (school VARCHAR(255), LOCATION VARCHAR(255), affiliation VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 538
} |
When was the school with the largest enrollment founded? | SELECT founded FROM university ORDER BY enrollment DESC LIMIT 1 | CREATE TABLE university (founded VARCHAR(255), enrollment VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 539
} |
Find the founded year of the newest non public school. | SELECT founded FROM university WHERE affiliation <> 'Public' ORDER BY founded DESC LIMIT 1 | CREATE TABLE university (founded VARCHAR(255), affiliation VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 540
} |
How many schools are in the basketball match? | SELECT COUNT(DISTINCT school_id) FROM basketball_match | CREATE TABLE basketball_match (school_id VARCHAR(255), match_date DATE) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 541
} |
What is the highest acc percent score in the competition? | SELECT acc_percent FROM basketball_match ORDER BY acc_percent DESC LIMIT 1 | CREATE TABLE basketball_match (acc_percent VARCHAR(255), school_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 542
} |
What is the primary conference of the school that has the lowest acc percent score in the competition? | SELECT t1.Primary_conference FROM university AS t1 JOIN basketball_match AS t2 ON t1.school_id = t2.school_id ORDER BY t2.acc_percent LIMIT 1 | CREATE TABLE basketball_match (school_id VARCHAR(255), acc_percent VARCHAR(255)); CREATE TABLE university (Primary_conference VARCHAR(255), school_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 543
} |
What is the team name and acc regular season score of the school that was founded for the longest time? | SELECT t2.team_name, t2.ACC_Regular_Season FROM university AS t1 JOIN basketball_match AS t2 ON t1.school_id = t2.school_id ORDER BY t1.founded LIMIT 1 | CREATE TABLE university (school_id VARCHAR(255), founded VARCHAR(255)); CREATE TABLE basketball_match (team_name VARCHAR(255), ACC_Regular_Season VARCHAR(255), school_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 544
} |
Show the enrollment and primary_conference of the oldest college. | SELECT enrollment, primary_conference FROM university ORDER BY founded LIMIT 1 | CREATE TABLE university (enrollment VARCHAR(255), primary_conference VARCHAR(255), founded VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 547
} |
What is the total and minimum enrollment of all schools? | SELECT SUM(enrollment), MIN(enrollment) FROM university | CREATE TABLE university (enrollment INTEGER, school_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 2 | {
"split": "train",
"row_index": 548
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.