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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
What are the names and id of courses having at most 2 sections? | SELECT T1.course_name, T1.course_id FROM Courses AS T1 JOIN Sections AS T2 ON T1.course_id = T2.course_id GROUP BY T1.course_id HAVING COUNT(*) <= 2 | CREATE TABLE Courses (course_name VARCHAR(255), course_id VARCHAR(255)); CREATE TABLE Sections (course_id VARCHAR(255), section_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 4249
} |
List the section_name in reversed lexicographical order. | SELECT section_name FROM Sections ORDER BY section_name DESC | CREATE TABLE Sections (section_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": 4250
} |
What is the semester which most student registered in? Show both the name and the id. | SELECT T1.semester_name, T1.semester_id FROM Semesters AS T1 JOIN Student_Enrolment AS T2 ON T1.semester_id = T2.semester_id GROUP BY T1.semester_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Student_Enrolment (semester_id VARCHAR(255), student_id VARCHAR(255)); CREATE TABLE Semesters (semester_name VARCHAR(255), semester_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 4251
} |
What is the description of the department whose name has the substring the computer? | SELECT department_description FROM Departments WHERE department_name LIKE '%computer%' | CREATE TABLE Departments (department_description VARCHAR(255), department_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 4252
} |
Who are enrolled in 2 degree programs in one semester? List the first name, middle name and last name and the id. | SELECT T1.first_name, T1.middle_name, T1.last_name, T1.student_id FROM Students AS T1 JOIN Student_Enrolment AS T2 ON T1.student_id = T2.student_id GROUP BY T1.student_id HAVING COUNT(*) = 2 | CREATE TABLE Students (first_name VARCHAR(255), middle_name VARCHAR(255), last_name VARCHAR(255), student_id VARCHAR(255)); CREATE TABLE Student_Enrolment (student_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": 4253
} |
Who is enrolled in a Bachelor degree program? List the first name, middle name, last name. | SELECT DISTINCT T1.first_name, T1.middle_name, T1.last_name FROM Students AS T1 JOIN Student_Enrolment AS T2 ON T1.student_id = T2.student_id JOIN Degree_Programs AS T3 ON T2.degree_program_id = T3.degree_program_id WHERE T3.degree_summary_name = 'Bachelor' | CREATE TABLE Degree_Programs (degree_program_id VARCHAR(255), degree_summary_name VARCHAR(255)); CREATE TABLE Students (first_name VARCHAR(255), middle_name VARCHAR(255), last_name VARCHAR(255), student_id VARCHAR(255)); CREATE TABLE Student_Enrolment (student_id VARCHAR(255), degree_program_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 4254
} |
Find the kind of program which most number of students are enrolled in? | SELECT T1.degree_summary_name FROM Degree_Programs AS T1 JOIN Student_Enrolment AS T2 ON T1.degree_program_id = T2.degree_program_id GROUP BY T1.degree_summary_name ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Student_Enrolment (degree_program_id VARCHAR(255), student_id VARCHAR(255)); CREATE TABLE Degree_Programs (degree_summary_name VARCHAR(255), degree_program_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 4255
} |
Find the program which most number of students are enrolled in. List both the id and the summary. | SELECT T1.degree_program_id, T1.degree_summary_name FROM Degree_Programs AS T1 JOIN Student_Enrolment AS T2 ON T1.degree_program_id = T2.degree_program_id GROUP BY T1.degree_program_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Degree_Programs (degree_program_id VARCHAR(255), degree_summary_name VARCHAR(255)); CREATE TABLE Student_Enrolment (degree_program_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": 4256
} |
Which student has enrolled for the most times in any program? List the id, first name, middle name, last name, the number of enrollments and student id. | SELECT T1.student_id, T1.first_name, T1.middle_name, T1.last_name, COUNT(*), T1.student_id FROM Students AS T1 JOIN Student_Enrolment AS T2 ON T1.student_id = T2.student_id GROUP BY T1.student_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Students (student_id VARCHAR(255), first_name VARCHAR(255), middle_name VARCHAR(255), last_name VARCHAR(255)); CREATE TABLE Student_Enrolment (student_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 2 | {
"split": "train",
"row_index": 4257
} |
Which semesters do not have any student enrolled? List the semester name. | SELECT semester_name FROM Semesters WHERE NOT semester_id IN (SELECT semester_id FROM Student_Enrolment) | CREATE TABLE Student_Enrolment (semester_name VARCHAR(255), semester_id VARCHAR(255)); CREATE TABLE Semesters (semester_name VARCHAR(255), semester_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 4258
} |
What are all the course names of the courses which ever have students enrolled in? | SELECT DISTINCT T1.course_name FROM Courses AS T1 JOIN Student_Enrolment_Courses AS T2 ON T1.course_id = T2.course_id | CREATE TABLE Courses (course_name VARCHAR(255), course_id VARCHAR(255)); CREATE TABLE Student_Enrolment_Courses (course_id 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": 4259
} |
What's the name of the course with most number of enrollments? | SELECT T1.course_name FROM Courses AS T1 JOIN Student_Enrolment_Courses AS T2 ON T1.course_id = T2.course_id GROUP BY T1.course_name ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Courses (course_name VARCHAR(255), course_id VARCHAR(255)); CREATE TABLE Student_Enrolment_Courses (course_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": 4260
} |
Show the date and id of the transcript with at least 2 course results. | SELECT T2.transcript_date, T1.transcript_id FROM Transcript_Contents AS T1 JOIN Transcripts AS T2 ON T1.transcript_id = T2.transcript_id GROUP BY T1.transcript_id HAVING COUNT(*) >= 2 | CREATE TABLE Transcript_Contents (transcript_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Transcripts (transcript_date VARCHAR(255), transcript_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 4262
} |
What is the phone number of the man with the first name Timmothy and the last name Ward? | SELECT cell_mobile_number FROM Students WHERE first_name = 'Timmothy' AND last_name = 'Ward' | CREATE TABLE Students (cell_mobile_number 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": 4263
} |
What is the mobile phone number of the student named Timmothy Ward ? | SELECT cell_mobile_number FROM students WHERE first_name = 'timmothy' AND last_name = 'ward' | CREATE TABLE students (cell_mobile_number 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": 4264
} |
Who is the first student to register? List the first name, middle name and last name. | SELECT first_name, middle_name, last_name FROM Students ORDER BY date_first_registered LIMIT 1 | CREATE TABLE Students (first_name VARCHAR(255), middle_name VARCHAR(255), last_name VARCHAR(255), date_first_registered VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 4265
} |
Who is the earliest graduate of the school? List the first name, middle name and last name. | SELECT first_name, middle_name, last_name FROM Students ORDER BY date_left LIMIT 1 | CREATE TABLE Students (first_name VARCHAR(255), middle_name VARCHAR(255), last_name VARCHAR(255), date_left VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 4266
} |
Whose permanent address is different from his or her current address? List his or her first name. | SELECT first_name FROM Students WHERE current_address_id <> permanent_address_id | CREATE TABLE Students (first_name VARCHAR(255), current_address_id VARCHAR(255), permanent_address_id VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4267
} |
Which address holds the most number of students currently? List the address id and all lines. | SELECT T1.address_id, T1.line_1, T1.line_2 FROM Addresses AS T1 JOIN Students AS T2 ON T1.address_id = T2.current_address_id GROUP BY T1.address_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Addresses (address_id VARCHAR(255), line_1 VARCHAR(255), line_2 VARCHAR(255)); CREATE TABLE Students (current_address_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": 4268
} |
On average, when were the transcripts printed? | SELECT AVG(transcript_date) FROM Transcripts | CREATE TABLE Transcripts (transcript_date 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": 4269
} |
When is the first transcript released? List the date and details. | SELECT transcript_date, other_details FROM Transcripts ORDER BY transcript_date LIMIT 1 | CREATE TABLE Transcripts (transcript_date VARCHAR(255), other_details VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 4270
} |
How many transcripts are released? | SELECT COUNT(*) FROM Transcripts | CREATE TABLE Transcripts (Id VARCHAR(255), other_column VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 4271
} |
What is the last transcript release date? | SELECT transcript_date FROM Transcripts ORDER BY transcript_date DESC LIMIT 1 | CREATE TABLE Transcripts (transcript_date 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": 4272
} |
How many times at most can a course enrollment result show in different transcripts? Also show the course enrollment id. | SELECT COUNT(*), student_course_id FROM Transcript_Contents GROUP BY student_course_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Transcript_Contents (student_course_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": 4273
} |
Show the date of the transcript which shows the least number of results, also list the id. | SELECT T2.transcript_date, T1.transcript_id FROM Transcript_Contents AS T1 JOIN Transcripts AS T2 ON T1.transcript_id = T2.transcript_id GROUP BY T1.transcript_id ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE Transcript_Contents (transcript_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE Transcripts (transcript_date VARCHAR(255), transcript_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 4274
} |
How many different addresses do the students currently live? | SELECT COUNT(DISTINCT current_address_id) FROM Students | CREATE TABLE Students (current_address_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": 4276
} |
List all the student details in reversed lexicographical order. | SELECT other_student_details FROM Students ORDER BY other_student_details DESC | CREATE TABLE Students (other_student_details 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": 4277
} |
Describe the section h. | SELECT section_description FROM Sections WHERE section_name = 'h' | CREATE TABLE Sections (section_description VARCHAR(255), section_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4278
} |
Find the first name of the students who permanently live in the country Haiti or have the cell phone number 09700166582 . | SELECT t1.first_name FROM students AS t1 JOIN addresses AS t2 ON t1.permanent_address_id = t2.address_id WHERE t2.country = 'haiti' OR t1.cell_mobile_number = '09700166582' | CREATE TABLE students (first_name VARCHAR(255), permanent_address_id VARCHAR(255), cell_mobile_number VARCHAR(255)); CREATE TABLE addresses (address_id VARCHAR(255), country VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 4279
} |
List all cartoon directed by "Ben Jones". | SELECT Title FROM Cartoon WHERE Directed_by = 'Ben Jones' | CREATE TABLE Cartoon (Title VARCHAR(255), Directed_by VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4281
} |
How many cartoons were written by "Joseph Kuhr"? | SELECT COUNT(*) FROM Cartoon WHERE Written_by = 'Joseph Kuhr' | CREATE TABLE Cartoon (Written_by VARCHAR(255), Title VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4282
} |
list all cartoon titles and their directors ordered by their air date | SELECT title, Directed_by FROM Cartoon ORDER BY Original_air_date | CREATE TABLE Cartoon (title VARCHAR(255), Directed_by VARCHAR(255), Original_air_date VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 4283
} |
List the title of all cartoon directed by "Ben Jones" or "Brandon Vietti". | SELECT Title FROM Cartoon WHERE Directed_by = 'Ben Jones' OR Directed_by = 'Brandon Vietti' | CREATE TABLE Cartoon (Title VARCHAR(255), Directed_by VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 4284
} |
Which country has the most of TV Channels? List the country and number of TV Channels it has. | SELECT Country, COUNT(*) FROM TV_Channel GROUP BY Country ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE TV_Channel (Country 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": 4285
} |
List the number of different series names and contents in the TV Channel table. | SELECT COUNT(DISTINCT series_name), COUNT(DISTINCT content) FROM TV_Channel | CREATE TABLE TV_Channel (series_name VARCHAR(255), content VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 2 | {
"split": "train",
"row_index": 4286
} |
What is the content of TV Channel with serial name "Sky Radio"? | SELECT Content FROM TV_Channel WHERE series_name = 'Sky Radio' | CREATE TABLE TV_Channel (Content VARCHAR(255), series_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4287
} |
What is the Package Option of TV Channel with serial name "Sky Radio"? | SELECT Package_Option FROM TV_Channel WHERE series_name = 'Sky Radio' | CREATE TABLE TV_Channel (Package_Option VARCHAR(255), series_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4288
} |
How many TV Channel using language English? | SELECT COUNT(*) FROM TV_Channel WHERE LANGUAGE = 'English' | CREATE TABLE TV_Channel (LANGUAGE VARCHAR(255), channel_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4289
} |
List the language used least number of TV Channel. List language and number of TV Channel. | SELECT LANGUAGE, COUNT(*) FROM TV_Channel GROUP BY LANGUAGE ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE TV_Channel (LANGUAGE VARCHAR(255), channel_name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 2 | {
"split": "train",
"row_index": 4290
} |
List each language and the number of TV Channels using it. | SELECT LANGUAGE, COUNT(*) FROM TV_Channel GROUP BY LANGUAGE | CREATE TABLE TV_Channel (LANGUAGE 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": 4291
} |
What is the TV Channel that shows the cartoon "The Rise of the Blue Beetle!"? List the TV Channel's series name. | SELECT T1.series_name FROM TV_Channel AS T1 JOIN Cartoon AS T2 ON T1.id = T2.Channel WHERE T2.Title = 'The Rise of the Blue Beetle!' | CREATE TABLE Cartoon (Channel VARCHAR(255), Title VARCHAR(255)); CREATE TABLE TV_Channel (series_name VARCHAR(255), id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 4292
} |
List the title of all Cartoons showed on TV Channel with series name "Sky Radio". | SELECT T2.Title FROM TV_Channel AS T1 JOIN Cartoon AS T2 ON T1.id = T2.Channel WHERE T1.series_name = 'Sky Radio' | CREATE TABLE Cartoon (Title VARCHAR(255), Channel VARCHAR(255)); CREATE TABLE TV_Channel (id VARCHAR(255), series_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 4293
} |
List the Episode of all TV series sorted by rating. | SELECT Episode FROM TV_series ORDER BY rating | CREATE TABLE TV_series (Episode VARCHAR(255), rating VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4294
} |
List top 3 highest Rating TV series. List the TV series's Episode and Rating. | SELECT Episode, Rating FROM TV_series ORDER BY Rating DESC LIMIT 3 | CREATE TABLE TV_series (Episode VARCHAR(255), Rating VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 4295
} |
What is minimum and maximum share of TV series? | SELECT MAX(SHARE), MIN(SHARE) FROM TV_series | CREATE TABLE TV_series (SHARE 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": 4296
} |
What is the air date of TV series with Episode "A Love of a Lifetime"? | SELECT Air_Date FROM TV_series WHERE Episode = 'A Love of a Lifetime' | CREATE TABLE TV_series (Air_Date VARCHAR(255), Episode VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4297
} |
What is Weekly Rank of TV series with Episode "A Love of a Lifetime"? | SELECT Weekly_Rank FROM TV_series WHERE Episode = 'A Love of a Lifetime' | CREATE TABLE TV_series (Weekly_Rank VARCHAR(255), Episode VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4298
} |
What is the TV Channel of TV series with Episode "A Love of a Lifetime"? List the TV Channel's series name. | SELECT T1.series_name FROM TV_Channel AS T1 JOIN TV_series AS T2 ON T1.id = T2.Channel WHERE T2.Episode = 'A Love of a Lifetime' | CREATE TABLE TV_series (Channel VARCHAR(255), Episode VARCHAR(255)); CREATE TABLE TV_Channel (series_name VARCHAR(255), id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 4299
} |
List the Episode of all TV series showed on TV Channel with series name "Sky Radio". | SELECT T2.Episode FROM TV_Channel AS T1 JOIN TV_series AS T2 ON T1.id = T2.Channel WHERE T1.series_name = 'Sky Radio' | CREATE TABLE TV_Channel (id VARCHAR(255), series_name VARCHAR(255)); CREATE TABLE TV_series (Episode VARCHAR(255), Channel VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 4300
} |
Find the number of cartoons directed by each of the listed directors. | SELECT COUNT(*), Directed_by FROM cartoon GROUP BY Directed_by | CREATE TABLE cartoon (Directed_by 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": 4301
} |
Find the production code and channel of the most recently aired cartoon . | SELECT production_code, channel FROM cartoon ORDER BY original_air_date DESC LIMIT 1 | CREATE TABLE cartoon (production_code VARCHAR(255), channel VARCHAR(255), original_air_date VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 4302
} |
Find the package choice and series name of the TV channel that has high definition TV. | SELECT package_option, series_name FROM TV_Channel WHERE hight_definition_TV = 'yes' | CREATE TABLE TV_Channel (package_option VARCHAR(255), series_name VARCHAR(255), hight_definition_TV VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 4303
} |
which countries' tv channels are playing some cartoon written by Todd Casey? | SELECT T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.written_by = 'Todd Casey' | CREATE TABLE TV_Channel (country VARCHAR(255), id VARCHAR(255)); CREATE TABLE cartoon (Channel VARCHAR(255), written_by VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 4304
} |
Find the series name and country of the tv channel that is playing some cartoons directed by Ben Jones and Michael Chang? | SELECT T1.series_name, T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.directed_by = 'Michael Chang' INTERSECT SELECT T1.series_name, T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.directed_by = 'Ben Jones' | CREATE TABLE TV_Channel (series_name VARCHAR(255), country VARCHAR(255), id VARCHAR(255)); CREATE TABLE cartoon (Channel VARCHAR(255), directed_by VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 1 | {
"split": "train",
"row_index": 4306
} |
find the pixel aspect ratio and nation of the tv channels that do not use English. | SELECT Pixel_aspect_ratio_PAR, country FROM tv_channel WHERE LANGUAGE <> 'English' | CREATE TABLE tv_channel (Pixel_aspect_ratio_PAR VARCHAR(255), country VARCHAR(255), LANGUAGE VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 4307
} |
find id of the tv channels that from the countries where have more than two tv channels. | SELECT id FROM tv_channel GROUP BY country HAVING COUNT(*) > 2 | CREATE TABLE tv_channel (id VARCHAR(255), country VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4308
} |
find the id of tv channels that do not play any cartoon directed by Ben Jones. | SELECT id FROM TV_Channel EXCEPT SELECT channel FROM cartoon WHERE directed_by = 'Ben Jones' | CREATE TABLE TV_Channel (id VARCHAR(255), channel VARCHAR(255), directed_by VARCHAR(255)); CREATE TABLE cartoon (id VARCHAR(255), channel VARCHAR(255), directed_by VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 4309
} |
find the package option of the tv channel that do not have any cartoon directed by Ben Jones. | SELECT package_option FROM TV_Channel WHERE NOT id IN (SELECT channel FROM cartoon WHERE directed_by = 'Ben Jones') | CREATE TABLE cartoon (package_option VARCHAR(255), id VARCHAR(255), channel VARCHAR(255), directed_by VARCHAR(255)); CREATE TABLE TV_Channel (package_option VARCHAR(255), id VARCHAR(255), channel VARCHAR(255), directed_by VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 4310
} |
How many poker players are there? | SELECT COUNT(*) FROM poker_player | CREATE TABLE poker_player (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 4311
} |
List the earnings of poker players in descending order. | SELECT Earnings FROM poker_player ORDER BY Earnings DESC | CREATE TABLE poker_player (Earnings 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": 4312
} |
List the final tables made and the best finishes of poker players. | SELECT Final_Table_Made, Best_Finish FROM poker_player | CREATE TABLE poker_player (Final_Table_Made VARCHAR(255), Best_Finish VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 4313
} |
What is the average earnings of poker players? | SELECT AVG(Earnings) FROM poker_player | CREATE TABLE poker_player (Earnings 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": 4314
} |
What is the money rank of the poker player with the highest earnings? | SELECT Money_Rank FROM poker_player ORDER BY Earnings DESC LIMIT 1 | CREATE TABLE poker_player (Money_Rank VARCHAR(255), Earnings VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 4315
} |
What are the names of poker players? | SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID = T2.People_ID | CREATE TABLE poker_player (People_ID VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4317
} |
What are the names of poker players whose earnings is higher than 300000? | SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID = T2.People_ID WHERE T2.Earnings > 300000 | CREATE TABLE poker_player (People_ID VARCHAR(255), Earnings INTEGER); CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 4318
} |
List the names of poker players ordered by the final tables made in ascending order. | SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID = T2.People_ID ORDER BY T2.Final_Table_Made | CREATE TABLE poker_player (People_ID VARCHAR(255), Final_Table_Made VARCHAR(255)); CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 4319
} |
What is the birth date of the poker player with the lowest earnings? | SELECT T1.Birth_Date FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID = T2.People_ID ORDER BY T2.Earnings LIMIT 1 | CREATE TABLE poker_player (People_ID VARCHAR(255), Earnings VARCHAR(255)); CREATE TABLE people (Birth_Date VARCHAR(255), People_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 4320
} |
What is the money rank of the tallest poker player? | SELECT T2.Money_Rank FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID = T2.People_ID ORDER BY T1.Height DESC LIMIT 1 | CREATE TABLE people (People_ID VARCHAR(255), Height VARCHAR(255)); CREATE TABLE poker_player (Money_Rank VARCHAR(255), People_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 4321
} |
What is the average earnings of poker players with height higher than 200? | SELECT AVG(T2.Earnings) FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID = T2.People_ID WHERE T1.Height > 200 | CREATE TABLE people (People_ID VARCHAR(255), Height INTEGER); CREATE TABLE poker_player (Earnings INTEGER, People_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 4322
} |
What are the names of poker players in descending order of earnings? | SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID = T2.People_ID ORDER BY T2.Earnings DESC | CREATE TABLE poker_player (People_ID VARCHAR(255), Earnings VARCHAR(255)); CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 4323
} |
What are different nationalities of people and the corresponding number of people from each nation? | SELECT Nationality, COUNT(*) FROM people GROUP BY Nationality | CREATE TABLE people (Nationality VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 4324
} |
What is the most common nationality of people? | SELECT Nationality FROM people GROUP BY Nationality ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE people (Nationality VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 4325
} |
What are the nationalities that are shared by at least two people? | SELECT Nationality FROM people GROUP BY Nationality HAVING COUNT(*) >= 2 | CREATE TABLE people (Nationality VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4326
} |
List the names and birth dates of people in ascending alphabetical order of name. | SELECT Name, Birth_Date FROM people ORDER BY Name | CREATE TABLE people (Name VARCHAR(255), Birth_Date VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 4327
} |
Show names of people whose nationality is not "Russia". | SELECT Name FROM people WHERE Nationality <> 'Russia' | CREATE TABLE people (Name VARCHAR(255), Nationality VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4328
} |
List the names of people that are not poker players. | SELECT Name FROM people WHERE NOT People_ID IN (SELECT People_ID FROM poker_player) | CREATE TABLE poker_player (Name VARCHAR(255), People_ID VARCHAR(255)); CREATE TABLE people (Name VARCHAR(255), People_ID VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 4329
} |
How many distinct nationalities are there? | SELECT COUNT(DISTINCT Nationality) FROM people | CREATE TABLE people (Nationality VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 4330
} |
How many states are there? | SELECT COUNT(*) FROM area_code_state | CREATE TABLE area_code_state (Id VARCHAR(255), description VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 4331
} |
List the contestant numbers and names, ordered by contestant name descending. | SELECT contestant_number, contestant_name FROM contestants ORDER BY contestant_name DESC | CREATE TABLE contestants (contestant_number VARCHAR(255), contestant_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 4332
} |
List the vote ids, phone numbers and states of all votes. | SELECT vote_id, phone_number, state FROM votes | CREATE TABLE votes (vote_id VARCHAR(255), phone_number VARCHAR(255), state VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 4333
} |
What are the maximum and minimum values of area codes? | SELECT MAX(area_code), MIN(area_code) FROM area_code_state | CREATE TABLE area_code_state (area_code INTEGER, id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 2 | {
"split": "train",
"row_index": 4334
} |
What is last date created of votes from the state 'CA'? | SELECT MAX(created) FROM votes WHERE state = 'CA' | CREATE TABLE votes (created INTEGER, state VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4335
} |
What are the names of the contestants whose names are not 'Jessie Alloway' | SELECT contestant_name FROM contestants WHERE contestant_name <> 'Jessie Alloway' | CREATE TABLE contestants (contestant_name VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4336
} |
What are the distinct states and create time of all votes? | SELECT DISTINCT state, created FROM votes | CREATE TABLE votes (state VARCHAR(255), created VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 4337
} |
What are the contestant numbers and names of the contestants who had at least two votes? | SELECT T1.contestant_number, T1.contestant_name FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number = T2.contestant_number GROUP BY T1.contestant_number HAVING COUNT(*) >= 2 | CREATE TABLE votes (contestant_number VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT); CREATE TABLE contestants (contestant_number VARCHAR(255), contestant_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 4338
} |
Of all the contestants who got voted, what is the contestant number and name of the contestant who got least votes? | SELECT T1.contestant_number, T1.contestant_name FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number = T2.contestant_number GROUP BY T1.contestant_number ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE votes (contestant_number VARCHAR(255), id INTEGER PRIMARY KEY AUTOINCREMENT); CREATE TABLE contestants (contestant_number VARCHAR(255), contestant_name VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 4339
} |
What are the number of votes from state 'NY' or 'CA'? | SELECT COUNT(*) FROM votes WHERE state = 'NY' OR state = 'CA' | CREATE TABLE votes (state 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": 4340
} |
How many contestants did not get voted? | SELECT COUNT(*) FROM contestants WHERE NOT contestant_number IN (SELECT contestant_number FROM votes) | CREATE TABLE contestants (contestant_number VARCHAR(255), name VARCHAR(255)); CREATE TABLE votes (contestant_number 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": 4341
} |
What is the area code in which the most voters voted? | SELECT T1.area_code FROM area_code_state AS T1 JOIN votes AS T2 ON T1.state = T2.state GROUP BY T1.area_code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE area_code_state (area_code VARCHAR(255), state VARCHAR(255)); CREATE TABLE votes (state 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": 4342
} |
What are the create dates, states, and phone numbers of the votes that were for the contestant named 'Tabatha Gehling'? | SELECT T2.created, T2.state, T2.phone_number FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number = T2.contestant_number WHERE T1.contestant_name = 'Tabatha Gehling' | CREATE TABLE contestants (contestant_number VARCHAR(255), contestant_name VARCHAR(255)); CREATE TABLE votes (created VARCHAR(255), state VARCHAR(255), phone_number VARCHAR(255), contestant_number VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 4343
} |
List the area codes in which voters voted both for the contestant 'Tabatha Gehling' and the contestant 'Kelly Clauss'. | SELECT T3.area_code FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number = T2.contestant_number JOIN area_code_state AS T3 ON T2.state = T3.state WHERE T1.contestant_name = 'Tabatha Gehling' INTERSECT SELECT T3.area_code FROM contestants AS T1 JOIN votes AS T2 ON T1.contestant_number = T2.contestant_number J... | CREATE TABLE votes (contestant_number VARCHAR(255), state VARCHAR(255)); CREATE TABLE contestants (contestant_number VARCHAR(255), contestant_name VARCHAR(255)); CREATE TABLE area_code_state (area_code VARCHAR(255), state VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 1 | 0 | {
"split": "train",
"row_index": 4344
} |
Return the names of the contestants whose names contain the substring 'Al' . | SELECT contestant_name FROM contestants WHERE contestant_name LIKE '%al%' | CREATE TABLE contestants (contestant_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": 4345
} |
What are the names of all the countries that became independent after 1950? | SELECT Name FROM country WHERE IndepYear > 1950 | CREATE TABLE country (Name VARCHAR(255), IndepYear INTEGER) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4346
} |
How many countries have a republic as their form of government? | SELECT COUNT(*) FROM country WHERE GovernmentForm = 'Republic' | CREATE TABLE country (GovernmentForm 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": 4347
} |
What is the total surface area of the countries in the Caribbean region? | SELECT SUM(SurfaceArea) FROM country WHERE Region = 'Caribbean' | CREATE TABLE country (SurfaceArea INTEGER, Region VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4348
} |
Which continent is Anguilla in? | SELECT Continent FROM country WHERE Name = 'Anguilla' | CREATE TABLE country (Continent VARCHAR(255), Name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4349
} |
What are the population and life expectancies in Brazil? | SELECT Population, LifeExpectancy FROM country WHERE Name = 'Brazil' | CREATE TABLE country (Population VARCHAR(255), LifeExpectancy VARCHAR(255), Name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 4352
} |
What are the region and population of Angola? | SELECT Population, Region FROM country WHERE Name = 'Angola' | CREATE TABLE country (Population VARCHAR(255), Region VARCHAR(255), Name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 4353
} |
What is the average expected life expectancy for countries in the region of Central Africa? | SELECT AVG(LifeExpectancy) FROM country WHERE Region = 'Central Africa' | CREATE TABLE country (LifeExpectancy INTEGER, Region VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 4354
} |
What is the name of country that has the shortest life expectancy in Asia? | SELECT Name FROM country WHERE Continent = 'Asia' ORDER BY LifeExpectancy LIMIT 1 | CREATE TABLE country (Name VARCHAR(255), Continent VARCHAR(255), LifeExpectancy VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 4355
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.