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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
List Aerosmith's albums. | SELECT T1.title FROM albums AS T1 JOIN artists AS T2 ON T1.artist_id = T2.id WHERE T2.name = 'Aerosmith' | CREATE TABLE artists (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE albums (title VARCHAR(255), artist_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": 316
} |
How many albums does Billy Cobham has? | SELECT COUNT(*) FROM albums AS T1 JOIN artists AS T2 ON T1.artist_id = T2.id WHERE T2.name = 'Billy Cobham' | CREATE TABLE artists (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE albums (artist_id VARCHAR(255), title 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": 317
} |
Eduardo Martins is a customer at which company? | SELECT company FROM customers WHERE first_name = 'Eduardo' AND last_name = 'Martins' | CREATE TABLE customers (company VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 318
} |
What is Astrid Gruber's email and phone number? | SELECT email, phone FROM customers WHERE first_name = 'Astrid' AND last_name = 'Gruber' | CREATE TABLE customers (email VARCHAR(255), phone VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 319
} |
How many customers live in Prague city? | SELECT COUNT(*) FROM customers WHERE city = 'Prague' | CREATE TABLE customers (city 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": 320
} |
How many customers in state of CA? | SELECT COUNT(*) FROM customers WHERE state = 'CA' | CREATE TABLE customers (state 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": 321
} |
What country does Roberto Almeida live? | SELECT country FROM customers WHERE first_name = 'Roberto' AND last_name = 'Almeida' | CREATE TABLE customers (country VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 322
} |
List the name of albums that are released by aritist whose name has 'Led' | SELECT T2.title FROM artists AS T1 JOIN albums AS T2 ON T1.id = T2.artist_id WHERE T1.name LIKE '%Led%' | CREATE TABLE artists (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE albums (title VARCHAR(255), artist_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 323
} |
How many customers does Steve Johnson support? | SELECT COUNT(*) FROM employees AS T1 JOIN customers AS T2 ON T2.support_rep_id = T1.id WHERE T1.first_name = 'Steve' AND T1.last_name = 'Johnson' | CREATE TABLE employees (id VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)); CREATE TABLE customers (support_rep_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": 324
} |
What is the title, phone and hire date of Nancy Edwards? | SELECT title, phone, hire_date FROM employees WHERE first_name = 'Nancy' AND last_name = 'Edwards' | CREATE TABLE employees (title VARCHAR(255), phone VARCHAR(255), hire_date VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 325
} |
What is the address of employee Nancy Edwards? | SELECT address FROM employees WHERE first_name = 'Nancy' AND last_name = 'Edwards' | CREATE TABLE employees (address VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 327
} |
Find the full name of employee who supported the most number of customers. | SELECT T1.first_name, T1.last_name FROM employees AS T1 JOIN customers AS T2 ON T1.id = T2.support_rep_id GROUP BY T1.id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE employees (first_name VARCHAR(255), last_name VARCHAR(255), id VARCHAR(255)); CREATE TABLE customers (support_rep_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 328
} |
How many employees are living in Canada? | SELECT COUNT(*) FROM employees WHERE country = 'Canada' | CREATE TABLE employees (country 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": 329
} |
What is employee Nancy Edwards's phone number? | SELECT phone FROM employees WHERE first_name = 'Nancy' AND last_name = 'Edwards' | CREATE TABLE employees (phone VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 330
} |
Who is the youngest employee in the company? List employee's first and last name. | SELECT first_name, last_name FROM employees ORDER BY birth_date DESC LIMIT 1 | CREATE TABLE employees (first_name VARCHAR(255), last_name VARCHAR(255), birth_date VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 331
} |
List top 10 employee work longest in the company. List employee's first and last name. | SELECT first_name, last_name FROM employees ORDER BY hire_date LIMIT 10 | CREATE TABLE employees (first_name VARCHAR(255), last_name VARCHAR(255), hire_date VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 332
} |
Find the number of employees whose title is IT Staff from each city? | SELECT COUNT(*), city FROM employees WHERE title = 'IT Staff' GROUP BY city | CREATE TABLE employees (city VARCHAR(255), title VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 333
} |
How many orders does Lucas Mancini has? | SELECT COUNT(*) FROM customers AS T1 JOIN invoices AS T2 ON T1.id = T2.customer_id WHERE T1.first_name = 'Lucas' AND T1.last_name = 'Mancini' | CREATE TABLE invoices (customer_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE customers (id VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 335
} |
What is the total amount of money spent by Lucas Mancini? | SELECT SUM(T2.total) FROM customers AS T1 JOIN invoices AS T2 ON T1.id = T2.customer_id WHERE T1.first_name = 'Lucas' AND T1.last_name = 'Mancini' | CREATE TABLE invoices (total INTEGER, customer_id VARCHAR(255)); CREATE TABLE customers (id VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 336
} |
List all media types. | SELECT name FROM media_types | CREATE TABLE media_types (name 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": 337
} |
List all different genre types. | SELECT DISTINCT name FROM genres | CREATE TABLE genres (name 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": 338
} |
List the name of all playlist. | SELECT name FROM playlists | CREATE TABLE playlists (name 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": 339
} |
Who is the composer of track Fast As a Shark? | SELECT composer FROM tracks WHERE name = 'Fast As a Shark' | CREATE TABLE tracks (composer VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 340
} |
How long does track Fast As a Shark has? | SELECT milliseconds FROM tracks WHERE name = 'Fast As a Shark' | CREATE TABLE tracks (milliseconds VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 341
} |
What is the name of tracks whose genre is Rock? | SELECT T2.name FROM genres AS T1 JOIN tracks AS T2 ON T1.id = T2.genre_id WHERE T1.name = 'Rock' | CREATE TABLE genres (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE tracks (name VARCHAR(255), genre_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 342
} |
What is title of album which track Balls to the Wall belongs to? | SELECT T1.title FROM albums AS T1 JOIN tracks AS T2 ON T1.id = T2.genre_id WHERE T2.name = 'Balls to the Wall' | CREATE TABLE tracks (genre_id VARCHAR(255), name VARCHAR(255)); CREATE TABLE albums (title VARCHAR(255), id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 343
} |
List name of all tracks in Balls to the Wall. | SELECT T2.name FROM albums AS T1 JOIN tracks AS T2 ON T1.id = T2.genre_id WHERE T1.title = 'Balls to the Wall' | CREATE TABLE tracks (name VARCHAR(255), genre_id VARCHAR(255)); CREATE TABLE albums (id VARCHAR(255), title VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 344
} |
List title of albums have the number of tracks greater than 10. | SELECT T1.title FROM albums AS T1 JOIN tracks AS T2 ON T1.id = T2.album_id GROUP BY T1.id HAVING COUNT(T1.id) > 10 | CREATE TABLE tracks (album_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE albums (title VARCHAR(255), id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 345
} |
List the name of tracks belongs to genre Rock and whose media type is MPEG audio file. | SELECT T2.name FROM genres AS T1 JOIN tracks AS T2 ON T1.id = T2.genre_id JOIN media_types AS T3 ON T3.id = T2.media_type_id WHERE T1.name = 'Rock' AND T3.name = 'MPEG audio file' | CREATE TABLE genres (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE tracks (name VARCHAR(255), genre_id VARCHAR(255), media_type_id VARCHAR(255)); CREATE TABLE media_types (id VARCHAR(255), name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 346
} |
List the name of tracks belongs to genre Rock or media type is MPEG audio file. | SELECT T2.name FROM genres AS T1 JOIN tracks AS T2 ON T1.id = T2.genre_id JOIN media_types AS T3 ON T3.id = T2.media_type_id WHERE T1.name = 'Rock' OR T3.name = 'MPEG audio file' | CREATE TABLE genres (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE tracks (name VARCHAR(255), genre_id VARCHAR(255), media_type_id VARCHAR(255)); CREATE TABLE media_types (id VARCHAR(255), name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 347
} |
List the name of tracks belongs to genre Rock or genre Jazz. | SELECT T2.name FROM genres AS T1 JOIN tracks AS T2 ON T1.id = T2.genre_id WHERE T1.name = 'Rock' OR T1.name = 'Jazz' | CREATE TABLE genres (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE tracks (name VARCHAR(255), genre_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 348
} |
List the name of all tracks in the playlists of Movies. | SELECT T1.name FROM tracks AS T1 JOIN playlist_tracks AS T2 ON T1.id = T2.track_id JOIN playlists AS T3 ON T3.id = T2.playlist_id WHERE T3.name = 'Movies' | CREATE TABLE playlists (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE playlist_tracks (track_id VARCHAR(255), playlist_id VARCHAR(255)); CREATE TABLE tracks (name VARCHAR(255), id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 349
} |
List the name of playlist which has number of tracks greater than 100. | SELECT T2.name FROM playlist_tracks AS T1 JOIN playlists AS T2 ON T2.id = T1.playlist_id GROUP BY T1.playlist_id HAVING COUNT(T1.track_id) > 100 | CREATE TABLE playlist_tracks (playlist_id VARCHAR(255), track_id VARCHAR(255)); CREATE TABLE playlists (name VARCHAR(255), id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 350
} |
List all tracks bought by customer Daan Peeters. | SELECT T1.name FROM tracks AS T1 JOIN invoice_lines AS T2 ON T1.id = T2.track_id JOIN invoices AS T3 ON T3.id = T2.invoice_id JOIN customers AS T4 ON T4.id = T3.customer_id WHERE T4.first_name = 'Daan' AND T4.last_name = 'Peeters' | CREATE TABLE invoices (id VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE invoice_lines (track_id VARCHAR(255), invoice_id VARCHAR(255)); CREATE TABLE tracks (name VARCHAR(255), id VARCHAR(255)); CREATE TABLE customers (id VARCHAR(255), first_name VARCHAR(255), last_name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 351
} |
How much is the track Fast As a Shark? | SELECT unit_price FROM tracks WHERE name = 'Fast As a Shark' | CREATE TABLE tracks (unit_price VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 352
} |
Find the name of tracks which are in Movies playlist but not in music playlist. | SELECT T1.name FROM tracks AS T1 JOIN playlist_tracks AS T2 ON T1.id = T2.track_id JOIN playlists AS T3 ON T2.playlist_id = T3.id WHERE T3.name = 'Movies' EXCEPT SELECT T1.name FROM tracks AS T1 JOIN playlist_tracks AS T2 ON T1.id = T2.track_id JOIN playlists AS T3 ON T2.playlist_id = T3.id WHERE T3.name = 'Music' | CREATE TABLE playlists (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE playlist_tracks (track_id VARCHAR(255), playlist_id VARCHAR(255)); CREATE TABLE tracks (name VARCHAR(255), id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 1 | 0 | {
"split": "train",
"row_index": 353
} |
Find the name of tracks which are in both Movies and music playlists. | SELECT T1.name FROM tracks AS T1 JOIN playlist_tracks AS T2 ON T1.id = T2.track_id JOIN playlists AS T3 ON T2.playlist_id = T3.id WHERE T3.name = 'Movies' INTERSECT SELECT T1.name FROM tracks AS T1 JOIN playlist_tracks AS T2 ON T1.id = T2.track_id JOIN playlists AS T3 ON T2.playlist_id = T3.id WHERE T3.name = 'Music' | CREATE TABLE playlists (id VARCHAR(255), name VARCHAR(255)); CREATE TABLE playlist_tracks (track_id VARCHAR(255), playlist_id VARCHAR(255)); CREATE TABLE tracks (name VARCHAR(255), id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 1 | 0 | {
"split": "train",
"row_index": 354
} |
Find number of tracks in each genre? | SELECT COUNT(*), T1.name FROM genres AS T1 JOIN tracks AS T2 ON T1.id = T2.genre_id GROUP BY T1.name | CREATE TABLE tracks (genre_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE genres (name VARCHAR(255), id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 355
} |
How many editors are there? | SELECT COUNT(*) FROM editor | CREATE TABLE editor (Id VARCHAR(255), Name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 356
} |
List the names of editors in ascending order of age. | SELECT Name FROM editor ORDER BY Age | CREATE TABLE editor (Name VARCHAR(255), Age VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 357
} |
What are the names and ages of editors? | SELECT Name, Age FROM editor | CREATE TABLE editor (Name VARCHAR(255), Age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 358
} |
List the names of editors who are older than 25. | SELECT Name FROM editor WHERE Age > 25 | CREATE TABLE editor (Name VARCHAR(255), Age INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 359
} |
Show the names of editors of age either 24 or 25. | SELECT Name FROM editor WHERE Age = 24 OR Age = 25 | CREATE TABLE editor (Name VARCHAR(255), Age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 360
} |
What is the name of the youngest editor? | SELECT Name FROM editor ORDER BY Age LIMIT 1 | CREATE TABLE editor (Name VARCHAR(255), Age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 361
} |
What are the different ages of editors? Show each age along with the number of editors of that age. | SELECT Age, COUNT(*) FROM editor GROUP BY Age | CREATE TABLE editor (Age 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": 362
} |
Please show the most common age of editors. | SELECT Age FROM editor GROUP BY Age ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE editor (Age 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": 363
} |
Show the distinct themes of journals. | SELECT DISTINCT Theme FROM journal | CREATE TABLE journal (Theme VARCHAR(255), Journal_ID 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": 364
} |
Show the names of editors and the theme of journals for which they serve on committees. | SELECT T2.Name, T3.Theme FROM journal_committee AS T1 JOIN editor AS T2 ON T1.Editor_ID = T2.Editor_ID JOIN journal AS T3 ON T1.Journal_ID = T3.Journal_ID | CREATE TABLE journal_committee (Editor_ID VARCHAR(255), Journal_ID VARCHAR(255)); CREATE TABLE editor (Name VARCHAR(255), Editor_ID VARCHAR(255)); CREATE TABLE journal (Theme VARCHAR(255), Journal_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 365
} |
Show the names and ages of editors and the theme of journals for which they serve on committees, in ascending alphabetical order of theme. | SELECT T2.Name, T2.age, T3.Theme FROM journal_committee AS T1 JOIN editor AS T2 ON T1.Editor_ID = T2.Editor_ID JOIN journal AS T3 ON T1.Journal_ID = T3.Journal_ID ORDER BY T3.Theme | CREATE TABLE journal_committee (Editor_ID VARCHAR(255), Journal_ID VARCHAR(255)); CREATE TABLE editor (Name VARCHAR(255), age VARCHAR(255), Editor_ID VARCHAR(255)); CREATE TABLE journal (Theme VARCHAR(255), Journal_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 366
} |
Show the names of editors that are on the committee of journals with sales bigger than 3000. | SELECT T2.Name FROM journal_committee AS T1 JOIN editor AS T2 ON T1.Editor_ID = T2.Editor_ID JOIN journal AS T3 ON T1.Journal_ID = T3.Journal_ID WHERE T3.Sales > 3000 | CREATE TABLE journal_committee (Editor_ID VARCHAR(255), Journal_ID VARCHAR(255)); CREATE TABLE editor (Name VARCHAR(255), Editor_ID VARCHAR(255)); CREATE TABLE journal (Journal_ID VARCHAR(255), Sales INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 367
} |
Show the names of editors that are on at least two journal committees. | SELECT T1.Name FROM editor AS T1 JOIN journal_committee AS T2 ON T1.Editor_ID = T2.Editor_ID GROUP BY T1.Name HAVING COUNT(*) >= 2 | CREATE TABLE editor (Name VARCHAR(255), Editor_ID VARCHAR(255)); CREATE TABLE journal_committee (Editor_ID VARCHAR(255), Journal_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 369
} |
List the names of editors that are not on any journal committee. | SELECT Name FROM editor WHERE NOT editor_id IN (SELECT editor_id FROM journal_committee) | CREATE TABLE editor (Name VARCHAR(255), editor_id VARCHAR(255)); CREATE TABLE journal_committee (Name VARCHAR(255), editor_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 370
} |
What is the average sales of the journals that have an editor whose work type is 'Photo'? | SELECT AVG(T1.sales) FROM journal AS T1 JOIN journal_committee AS T2 ON T1.journal_ID = T2.journal_ID WHERE T2.work_type = 'Photo' | CREATE TABLE journal_committee (journal_ID VARCHAR(255), work_type VARCHAR(255)); CREATE TABLE journal (sales INTEGER, journal_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 372
} |
How many accounts do we have? | SELECT COUNT(*) FROM Accounts | CREATE TABLE Accounts (Id VARCHAR(255), account_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 373
} |
Show ids, customer ids, names for all accounts. | SELECT account_id, customer_id, account_name FROM Accounts | CREATE TABLE Accounts (account_id VARCHAR(255), customer_id VARCHAR(255), account_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 374
} |
Show other account details for account with name 338. | SELECT other_account_details FROM Accounts WHERE account_name = '338' | CREATE TABLE Accounts (other_account_details VARCHAR(255), account_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 375
} |
What is the first name, last name, and phone of the customer with account name 162? | SELECT T2.customer_first_name, T2.customer_last_name, T2.customer_phone FROM Accounts AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id WHERE T1.account_name = '162' | CREATE TABLE Customers (customer_first_name VARCHAR(255), customer_last_name VARCHAR(255), customer_phone VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE Accounts (customer_id VARCHAR(255), account_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 376
} |
How many accounts does the customer with first name Art and last name Turcotte have? | SELECT COUNT(*) FROM Accounts AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id WHERE T2.customer_first_name = 'Art' AND T2.customer_last_name = 'Turcotte' | CREATE TABLE Accounts (customer_id VARCHAR(255), account_id VARCHAR(255)); CREATE TABLE Customers (customer_id VARCHAR(255), customer_first_name VARCHAR(255), customer_last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 377
} |
Show all customer ids and the number of accounts for each customer. | SELECT customer_id, COUNT(*) FROM Accounts GROUP BY customer_id | CREATE TABLE Accounts (customer_id VARCHAR(255), account_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 378
} |
Show the customer id and number of accounts with most accounts. | SELECT customer_id, COUNT(*) FROM Accounts GROUP BY customer_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Accounts (customer_id VARCHAR(255), account_number VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 379
} |
What is the customer first, last name and id with least number of accounts. | SELECT T2.customer_first_name, T2.customer_last_name, T1.customer_id FROM Accounts AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id GROUP BY T1.customer_id ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE Accounts (customer_id VARCHAR(255), account_type VARCHAR(255)); CREATE TABLE Customers (customer_first_name VARCHAR(255), customer_last_name VARCHAR(255), customer_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 380
} |
Show the number of all customers without an account. | SELECT COUNT(*) FROM Customers WHERE NOT customer_id IN (SELECT customer_id FROM Accounts) | CREATE TABLE Customers (customer_id VARCHAR(255), customer_name VARCHAR(255)); CREATE TABLE Accounts (customer_id VARCHAR(255), account_number VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 381
} |
Show distinct first and last names for all customers with an account. | SELECT DISTINCT T1.customer_first_name, T1.customer_last_name FROM Customers AS T1 JOIN Accounts AS T2 ON T1.customer_id = T2.customer_id | CREATE TABLE Accounts (customer_id VARCHAR(255), account_type VARCHAR(255)); CREATE TABLE Customers (customer_first_name VARCHAR(255), customer_last_name VARCHAR(255), customer_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 383
} |
How many customers have an account? | SELECT COUNT(DISTINCT customer_id) FROM Accounts | CREATE TABLE Accounts (customer_id VARCHAR(255), account_status VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 384
} |
How many customers do we have? | SELECT COUNT(*) FROM Customers | CREATE TABLE Customers (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 385
} |
Show ids, first names, last names, and phones for all customers. | SELECT customer_id, customer_first_name, customer_last_name, customer_phone FROM Customers | CREATE TABLE Customers (customer_id VARCHAR(255), customer_first_name VARCHAR(255), customer_last_name VARCHAR(255), customer_phone VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 386
} |
What is the phone and email for customer with first name Aniyah and last name Feest? | SELECT customer_phone, customer_email FROM Customers WHERE customer_first_name = 'Aniyah' AND customer_last_name = 'Feest' | CREATE TABLE Customers (customer_phone VARCHAR(255), customer_email VARCHAR(255), customer_first_name VARCHAR(255), customer_last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 2 | {
"split": "train",
"row_index": 387
} |
Show the number of customer cards. | SELECT COUNT(*) FROM Customers_cards | CREATE TABLE Customers_cards (Id VARCHAR(255), card_number VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 388
} |
Show ids, customer ids, card type codes, card numbers for all cards. | SELECT card_id, customer_id, card_type_code, card_number FROM Customers_cards | CREATE TABLE Customers_cards (card_id VARCHAR(255), customer_id VARCHAR(255), card_type_code VARCHAR(255), card_number VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 389
} |
Show the date valid from and the date valid to for the card with card number '4560596484842'. | SELECT date_valid_from, date_valid_to FROM Customers_cards WHERE card_number = '4560596484842' | CREATE TABLE Customers_cards (date_valid_from VARCHAR(255), date_valid_to VARCHAR(255), card_number VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 390
} |
What is the first name, last name, and phone of the customer with card 4560596484842. | SELECT T2.customer_first_name, T2.customer_last_name, T2.customer_phone FROM Customers_cards AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id WHERE T1.card_number = '4560596484842' | CREATE TABLE Customers (customer_first_name VARCHAR(255), customer_last_name VARCHAR(255), customer_phone VARCHAR(255), customer_id VARCHAR(255)); CREATE TABLE Customers_cards (customer_id VARCHAR(255), card_number VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 391
} |
How many cards does customer Art Turcotte have? | SELECT COUNT(*) FROM Customers_cards AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id WHERE T2.customer_first_name = 'Art' AND T2.customer_last_name = 'Turcotte' | CREATE TABLE Customers_cards (customer_id VARCHAR(255), card_number VARCHAR(255)); CREATE TABLE Customers (customer_id VARCHAR(255), customer_first_name VARCHAR(255), customer_last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 392
} |
How many debit cards do we have? | SELECT COUNT(*) FROM Customers_cards WHERE card_type_code = 'Debit' | CREATE TABLE Customers_cards (card_type_code VARCHAR(255), card_number VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 393
} |
How many credit cards does customer Blanche Huels have? | SELECT COUNT(*) FROM Customers_cards AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id WHERE T2.customer_first_name = 'Blanche' AND T2.customer_last_name = 'Huels' AND T1.card_type_code = 'Credit' | CREATE TABLE Customers_cards (customer_id VARCHAR(255), card_type_code VARCHAR(255)); CREATE TABLE Customers (customer_id VARCHAR(255), customer_first_name VARCHAR(255), customer_last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 394
} |
Show all customer ids and the number of cards owned by each customer. | SELECT customer_id, COUNT(*) FROM Customers_cards GROUP BY customer_id | CREATE TABLE Customers_cards (customer_id VARCHAR(255), card_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 395
} |
What is the customer id with most number of cards, and how many does he have? | SELECT customer_id, COUNT(*) FROM Customers_cards GROUP BY customer_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Customers_cards (customer_id VARCHAR(255), card_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 396
} |
Show id, first and last names for all customers with at least two cards. | SELECT T1.customer_id, T2.customer_first_name, T2.customer_last_name FROM Customers_cards AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id GROUP BY T1.customer_id HAVING COUNT(*) >= 2 | CREATE TABLE Customers_cards (customer_id VARCHAR(255), card_id VARCHAR(255)); CREATE TABLE Customers (customer_first_name VARCHAR(255), customer_last_name VARCHAR(255), customer_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 397
} |
What is the customer id, first and last name with least number of accounts. | SELECT T1.customer_id, T2.customer_first_name, T2.customer_last_name FROM Customers_cards AS T1 JOIN Customers AS T2 ON T1.customer_id = T2.customer_id GROUP BY T1.customer_id ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE Customers_cards (customer_id VARCHAR(255), card_id VARCHAR(255)); CREATE TABLE Customers (customer_first_name VARCHAR(255), customer_last_name VARCHAR(255), customer_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 398
} |
Show all card type codes and the number of cards in each type. | SELECT card_type_code, COUNT(*) FROM Customers_cards GROUP BY card_type_code | CREATE TABLE Customers_cards (card_type_code VARCHAR(255), card_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 399
} |
What is the card type code with most number of cards? | SELECT card_type_code FROM Customers_cards GROUP BY card_type_code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Customers_cards (card_type_code VARCHAR(255), card_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 400
} |
Show card type codes with at least 5 cards. | SELECT card_type_code FROM Customers_cards GROUP BY card_type_code HAVING COUNT(*) >= 5 | CREATE TABLE Customers_cards (card_type_code VARCHAR(255), card_id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 401
} |
Show all card type codes and the number of customers holding cards in each type. | SELECT card_type_code, COUNT(DISTINCT customer_id) FROM Customers_cards GROUP BY card_type_code | CREATE TABLE Customers_cards (card_type_code VARCHAR(255), customer_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 402
} |
Show all card type codes. | SELECT DISTINCT card_type_code FROM Customers_Cards | CREATE TABLE Customers_Cards (card_type_code VARCHAR(255), card_id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 404
} |
Show the number of card types. | SELECT COUNT(DISTINCT card_type_code) FROM Customers_Cards | CREATE TABLE Customers_Cards (card_type_code VARCHAR(255), card_id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 405
} |
Show all transaction types. | SELECT DISTINCT transaction_type FROM Financial_Transactions | CREATE TABLE Financial_Transactions (transaction_type VARCHAR(255), transaction_amount INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 406
} |
Show the number of transaction types. | SELECT COUNT(DISTINCT transaction_type) FROM Financial_Transactions | CREATE TABLE Financial_Transactions (transaction_type VARCHAR(255), transaction_amount INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 407
} |
What is the average and total transaction amount? | SELECT AVG(transaction_amount), SUM(transaction_amount) FROM Financial_transactions | CREATE TABLE Financial_transactions (transaction_amount INTEGER, transaction_type VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 2 | {
"split": "train",
"row_index": 408
} |
Show the card type codes and the number of transactions. | SELECT T2.card_type_code, COUNT(*) FROM Financial_transactions AS T1 JOIN Customers_cards AS T2 ON T1.card_id = T2.card_id GROUP BY T2.card_type_code | CREATE TABLE Financial_transactions (card_id VARCHAR(255), transaction_amount INTEGER); CREATE TABLE Customers_cards (card_type_code VARCHAR(255), card_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 409
} |
Show the transaction type and the number of transactions. | SELECT transaction_type, COUNT(*) FROM Financial_transactions GROUP BY transaction_type | CREATE TABLE Financial_transactions (transaction_type VARCHAR(255), transaction_amount INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 410
} |
What is the transaction type that has processed the greatest total amount in transactions? | SELECT transaction_type FROM Financial_transactions GROUP BY transaction_type ORDER BY SUM(transaction_amount) DESC LIMIT 1 | CREATE TABLE Financial_transactions (transaction_type VARCHAR(255), transaction_amount INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 411
} |
Show the account id and the number of transactions for each account | SELECT account_id, COUNT(*) FROM Financial_transactions GROUP BY account_id | CREATE TABLE Financial_transactions (account_id VARCHAR(255), transaction_amount INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 412
} |
How many tracks do we have? | SELECT COUNT(*) FROM track | CREATE TABLE track (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 413
} |
Show the name and location for all tracks. | SELECT name, LOCATION FROM track | CREATE TABLE track (name VARCHAR(255), LOCATION VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 414
} |
Show names and seatings, ordered by seating for all tracks opened after 2000. | SELECT name, seating FROM track WHERE year_opened > 2000 ORDER BY seating | CREATE TABLE track (name VARCHAR(255), seating VARCHAR(255), year_opened INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 415
} |
What is the name, location and seating for the most recently opened track? | SELECT name, LOCATION, seating FROM track ORDER BY year_opened DESC LIMIT 1 | CREATE TABLE track (name VARCHAR(255), LOCATION VARCHAR(255), seating VARCHAR(255), year_opened VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 416
} |
What is the minimum, maximum, and average seating for all tracks. | SELECT MIN(seating), MAX(seating), AVG(seating) FROM track | CREATE TABLE track (seating 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": 417
} |
Show the name, location, open year for all tracks with a seating higher than the average. | SELECT name, LOCATION, year_opened FROM track WHERE seating > (SELECT AVG(seating) FROM track) | CREATE TABLE track (name VARCHAR(255), LOCATION VARCHAR(255), year_opened VARCHAR(255), seating INTEGER) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 418
} |
What are distinct locations where tracks are located? | SELECT DISTINCT LOCATION FROM track | CREATE TABLE track (LOCATION 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": 419
} |
How many races are there? | SELECT COUNT(*) FROM race | CREATE TABLE race (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 420
} |
What are the distinct classes that races can have? | SELECT DISTINCT CLASS FROM race | CREATE TABLE race (CLASS 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": 421
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.