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 every individual's first name, middle name and last name in alphabetical order by last name. | SELECT individual_first_name, individual_middle_name, individual_last_name FROM individuals ORDER BY individual_last_name | CREATE TABLE individuals (individual_first_name VARCHAR(255), individual_middle_name VARCHAR(255), individual_last_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3578
} |
List all the types of forms. | SELECT DISTINCT form_type_code FROM forms | CREATE TABLE forms (form_type_code 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": 3579
} |
Find the name of the most popular party form. | SELECT t1.form_name FROM forms AS t1 JOIN party_forms AS t2 ON t1.form_id = t2.form_id GROUP BY t2.form_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE party_forms (form_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE forms (form_name VARCHAR(255), form_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 3580
} |
Find the payment method and phone of the party with email "enrico09@example.com". | SELECT payment_method_code, party_phone FROM parties WHERE party_email = 'enrico09@example.com' | CREATE TABLE parties (payment_method_code VARCHAR(255), party_phone VARCHAR(255), party_email 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": 3581
} |
List all the name of organizations in order of the date formed. | SELECT organization_name FROM organizations ORDER BY date_formed | CREATE TABLE organizations (organization_name VARCHAR(255), date_formed VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3583
} |
Find the name of the youngest organization. | SELECT organization_name FROM organizations ORDER BY date_formed DESC LIMIT 1 | CREATE TABLE organizations (organization_name VARCHAR(255), date_formed VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3584
} |
Find the last name of the latest contact individual of the organization "Labour Party". | SELECT t3.individual_last_name FROM organizations AS t1 JOIN organization_contact_individuals AS t2 ON t1.organization_id = t2.organization_id JOIN individuals AS t3 ON t2.individual_id = t3.individual_id WHERE t1.organization_name = 'Labour Party' ORDER BY t2.date_contact_to DESC LIMIT 1 | CREATE TABLE organizations (organization_id VARCHAR(255), organization_name VARCHAR(255)); CREATE TABLE individuals (individual_last_name VARCHAR(255), individual_id VARCHAR(255)); CREATE TABLE organization_contact_individuals (organization_id VARCHAR(255), individual_id VARCHAR(255), date_contact_to VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 5 | 0 | 0 | {
"split": "train",
"row_index": 3585
} |
Find the name of all the cities and states. | SELECT town_city FROM addresses UNION SELECT state_province_county FROM addresses | CREATE TABLE addresses (town_city VARCHAR(255), state_province_county VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 3588
} |
How many cities are there in state "Colorado"? | SELECT COUNT(*) FROM addresses WHERE state_province_county = 'Colorado' | CREATE TABLE addresses (state_province_county 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": 3589
} |
Find the payment method code used by more than 3 parties. | SELECT payment_method_code FROM parties GROUP BY payment_method_code HAVING COUNT(*) > 3 | CREATE TABLE parties (payment_method_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3590
} |
Find the name of organizations whose names contain "Party". | SELECT organization_name FROM organizations WHERE organization_name LIKE '%Party%' | CREATE TABLE organizations (organization_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": 3591
} |
How many distinct payment methods are used by parties? | SELECT COUNT(DISTINCT payment_method_code) FROM parties | CREATE TABLE parties (payment_method_code 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": 3592
} |
Which is the email of the party that has used the services the most number of times? | SELECT t1.party_email FROM parties AS t1 JOIN party_services AS t2 ON t1.party_id = t2.customer_id GROUP BY t1.party_email ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE parties (party_email VARCHAR(255), party_id VARCHAR(255)); CREATE TABLE party_services (customer_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 3593
} |
Which state can address "6862 Kaitlyn Knolls" possibly be in? | SELECT state_province_county FROM addresses WHERE line_1_number_building LIKE '%6862 Kaitlyn Knolls%' | CREATE TABLE addresses (state_province_county VARCHAR(255), line_1_number_building VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3594
} |
What is the name of organization that has the greatest number of contact individuals? | SELECT t1.organization_name FROM organizations AS t1 JOIN organization_contact_individuals AS t2 ON t1.organization_id = t2.organization_id GROUP BY t1.organization_name ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE organization_contact_individuals (organization_id VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE organizations (organization_name VARCHAR(255), organization_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 3595
} |
Find the last name of the individuals that have been contact individuals of an organization. | SELECT DISTINCT t1.individual_last_name FROM individuals AS t1 JOIN organization_contact_individuals AS t2 ON t1.individual_id = t2.individual_id | CREATE TABLE individuals (individual_last_name VARCHAR(255), individual_id VARCHAR(255)); CREATE TABLE organization_contact_individuals (individual_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": 3596
} |
How many drivers are there? | SELECT COUNT(*) FROM driver | CREATE TABLE driver (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3597
} |
Show the name, home city, and age for all drivers. | SELECT name, home_city, age FROM driver | CREATE TABLE driver (name VARCHAR(255), home_city VARCHAR(255), age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3598
} |
Show the party and the number of drivers in each party. | SELECT party, COUNT(*) FROM driver GROUP BY party | CREATE TABLE driver (party VARCHAR(255), name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3599
} |
Show the name of drivers in descending order of age. | SELECT name FROM driver ORDER BY age DESC | CREATE TABLE driver (name VARCHAR(255), age VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3600
} |
Show all different home cities. | SELECT DISTINCT home_city FROM driver | CREATE TABLE driver (home_city VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3601
} |
Show the home city with the most number of drivers. | SELECT home_city FROM driver GROUP BY home_city ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE driver (home_city VARCHAR(255), name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3602
} |
Show the party with drivers from Hartford and drivers older than 40. | SELECT party FROM driver WHERE home_city = 'Hartford' AND age > 40 | CREATE TABLE driver (party VARCHAR(255), home_city VARCHAR(255), age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3603
} |
Show home city where at least two drivers older than 40 are from. | SELECT home_city FROM driver WHERE age > 40 GROUP BY home_city HAVING COUNT(*) >= 2 | CREATE TABLE driver (home_city VARCHAR(255), age INTEGER) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3604
} |
Show all home cities except for those having a driver older than 40. | SELECT home_city FROM driver EXCEPT SELECT home_city FROM driver WHERE age > 40 | CREATE TABLE driver (home_city VARCHAR(255), age INTEGER) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 3605
} |
Show the names of the drivers without a school bus. | SELECT name FROM driver WHERE NOT driver_id IN (SELECT driver_id FROM school_bus) | CREATE TABLE school_bus (name VARCHAR(255), driver_id VARCHAR(255)); CREATE TABLE driver (name VARCHAR(255), driver_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 3606
} |
Show the types of schools that have two schools. | SELECT TYPE FROM school GROUP BY TYPE HAVING COUNT(*) = 2 | CREATE TABLE school (TYPE 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": 3607
} |
Show the school name and driver name for all school buses. | SELECT T2.school, T3.name FROM school_bus AS T1 JOIN school AS T2 ON T1.school_id = T2.school_id JOIN driver AS T3 ON T1.driver_id = T3.driver_id | CREATE TABLE school (school VARCHAR(255), school_id VARCHAR(255)); CREATE TABLE school_bus (school_id VARCHAR(255), driver_id VARCHAR(255)); CREATE TABLE driver (name VARCHAR(255), driver_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3608
} |
What is the maximum, minimum and average years spent working on a school bus? | SELECT MAX(years_working), MIN(years_working), AVG(years_working) FROM school_bus | CREATE TABLE school_bus (years_working 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": 3609
} |
Show the school name and type for schools without a school bus. | SELECT school, TYPE FROM school WHERE NOT school_id IN (SELECT school_id FROM school_bus) | CREATE TABLE school_bus (school VARCHAR(255), TYPE VARCHAR(255), school_id VARCHAR(255)); CREATE TABLE school (school VARCHAR(255), TYPE VARCHAR(255), school_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 3610
} |
Show the type of school and the number of buses for each type. | SELECT T2.type, COUNT(*) FROM school_bus AS T1 JOIN school AS T2 ON T1.school_id = T2.school_id GROUP BY T2.type | CREATE TABLE school (type VARCHAR(255), school_id VARCHAR(255)); CREATE TABLE school_bus (school_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": 3611
} |
How many drivers are from Hartford city or younger than 40? | SELECT COUNT(*) FROM driver WHERE home_city = 'Hartford' OR age < 40 | CREATE TABLE driver (home_city VARCHAR(255), age 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": 3612
} |
List names for drivers from Hartford city and younger than 40. | SELECT name FROM driver WHERE home_city = 'Hartford' AND age < 40 | CREATE TABLE driver (name VARCHAR(255), home_city VARCHAR(255), age VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3613
} |
How many flights have a velocity larger than 200? | SELECT COUNT(*) FROM flight WHERE velocity > 200 | CREATE TABLE flight (velocity INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3615
} |
List the vehicle flight number, date and pilot of all the flights, ordered by altitude. | SELECT vehicle_flight_number, date, pilot FROM flight ORDER BY altitude | CREATE TABLE flight (vehicle_flight_number VARCHAR(255), date VARCHAR(255), pilot VARCHAR(255), altitude VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3616
} |
List the id, country, city and name of the airports ordered alphabetically by the name. | SELECT id, country, city, name FROM airport ORDER BY name | CREATE TABLE airport (id VARCHAR(255), country VARCHAR(255), city VARCHAR(255), name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3617
} |
What is maximum group equity shareholding of the companies? | SELECT MAX(group_equity_shareholding) FROM operate_company | CREATE TABLE operate_company (group_equity_shareholding 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": 3618
} |
What is the velocity of the pilot named 'Thompson'? | SELECT AVG(velocity) FROM flight WHERE pilot = 'Thompson' | CREATE TABLE flight (velocity INTEGER, pilot VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3619
} |
What are the names of the airports which are not in the country 'Iceland'? | SELECT name FROM airport WHERE country <> 'Iceland' | CREATE TABLE airport (name VARCHAR(255), 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": 3621
} |
What is the id, name and IATA code of the airport that had most number of flights? | SELECT T1.id, T1.name, T1.IATA FROM airport AS T1 JOIN flight AS T2 ON T1.id = T2.airport_id GROUP BY T2.id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE airport (id VARCHAR(255), name VARCHAR(255), IATA VARCHAR(255)); CREATE TABLE flight (id VARCHAR(255), airport_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 3624
} |
What are the different pilot names who had piloted a flight in the country 'United States' or in the airport named 'Billund Airport'? | SELECT DISTINCT T2.pilot FROM airport AS T1 JOIN flight AS T2 ON T1.id = T2.airport_id WHERE T1.country = 'United States' OR T1.name = 'Billund Airport' | CREATE TABLE airport (id VARCHAR(255), country VARCHAR(255), name VARCHAR(255)); CREATE TABLE flight (pilot VARCHAR(255), airport_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 1 | {
"split": "train",
"row_index": 3625
} |
What is the most common company type, and how many are there? | SELECT TYPE, COUNT(*) FROM operate_company GROUP BY TYPE ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE operate_company (TYPE 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": 3626
} |
How many airports haven't the pilot 'Thompson' driven an aircraft? | SELECT COUNT(*) FROM airport WHERE NOT id IN (SELECT airport_id FROM flight WHERE pilot = 'Thompson') | CREATE TABLE airport (id VARCHAR(255), airport_id VARCHAR(255), pilot VARCHAR(255)); CREATE TABLE flight (id VARCHAR(255), airport_id VARCHAR(255), pilot VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 3627
} |
Which of the airport names contains the word 'international'? | SELECT name FROM airport WHERE name LIKE '%international%' | CREATE TABLE airport (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": 3629
} |
how many airports are there in each country? | SELECT COUNT(*), country FROM airport GROUP BY country | CREATE TABLE airport (country 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": 3631
} |
which countries have more than 2 airports? | SELECT country FROM airport GROUP BY country HAVING COUNT(*) > 2 | CREATE TABLE airport (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": 3632
} |
which pilot is in charge of the most number of flights? | SELECT pilot FROM flight GROUP BY pilot ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE flight (pilot 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": 3633
} |
Show all account ids and account details. | SELECT account_id, account_details FROM Accounts | CREATE TABLE Accounts (account_id VARCHAR(255), account_details VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3634
} |
How many statements do we have? | SELECT COUNT(*) FROM Statements | CREATE TABLE Statements (Id VARCHAR(255), info VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3635
} |
List all statement ids and statement details. | SELECT STATEMENT_ID, statement_details FROM Statements | CREATE TABLE Statements (STATEMENT_ID VARCHAR(255), statement_details VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3636
} |
Show statement id, statement detail, account detail for accounts. | SELECT T1.statement_id, T2.statement_details, T1.account_details FROM Accounts AS T1 JOIN Statements AS T2 ON T1.statement_id = T2.statement_id | CREATE TABLE Accounts (statement_id VARCHAR(255), account_details VARCHAR(255)); CREATE TABLE Statements (statement_details VARCHAR(255), statement_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3637
} |
Show all statement id and the number of accounts for each statement. | SELECT STATEMENT_ID, COUNT(*) FROM Accounts GROUP BY STATEMENT_ID | CREATE TABLE Accounts (STATEMENT_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": 3638
} |
Show the statement id and the statement detail for the statement with most number of accounts. | SELECT T1.statement_id, T2.statement_details FROM Accounts AS T1 JOIN Statements AS T2 ON T1.statement_id = T2.statement_id GROUP BY T1.statement_id ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Accounts (statement_id VARCHAR(255), account_name VARCHAR(255)); CREATE TABLE Statements (statement_details VARCHAR(255), statement_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 3639
} |
Show the number of documents. | SELECT COUNT(*) FROM Documents | CREATE TABLE Documents (Id VARCHAR(255), title VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3640
} |
List the document type code, document name, and document description for the document with name 'Noel CV' or name 'King Book'. | SELECT document_type_code, document_name, document_description FROM Documents WHERE document_name = 'Noel CV' OR document_name = 'King Book' | CREATE TABLE Documents (document_type_code VARCHAR(255), document_name VARCHAR(255), document_description VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 2 | {
"split": "train",
"row_index": 3641
} |
Show the ids and names of all documents. | SELECT document_id, document_name FROM Documents | CREATE TABLE Documents (document_id VARCHAR(255), document_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3642
} |
Find names and ids of all documents with document type code BK. | SELECT document_name, document_id FROM Documents WHERE document_type_code = 'BK' | CREATE TABLE Documents (document_name VARCHAR(255), document_id VARCHAR(255), document_type_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3643
} |
How many documents are with document type code BK for each product id? | SELECT COUNT(*), project_id FROM Documents WHERE document_type_code = 'BK' GROUP BY project_id | CREATE TABLE Documents (project_id VARCHAR(255), document_type_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3644
} |
Show project ids and the number of documents in each project. | SELECT project_id, COUNT(*) FROM Documents GROUP BY project_id | CREATE TABLE Documents (project_id 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": 3646
} |
What is the id of the project with least number of documents? | SELECT project_id FROM Documents GROUP BY project_id ORDER BY COUNT(*) LIMIT 1 | CREATE TABLE Documents (project_id 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": 3647
} |
Show the ids for projects with at least 2 documents. | SELECT project_id FROM Documents GROUP BY project_id HAVING COUNT(*) >= 2 | CREATE TABLE Documents (project_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": 3648
} |
List document type codes and the number of documents in each code. | SELECT document_type_code, COUNT(*) FROM Documents GROUP BY document_type_code | CREATE TABLE Documents (document_type_code 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": 3649
} |
What is the document type code with most number of documents? | SELECT document_type_code FROM Documents GROUP BY document_type_code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Documents (document_type_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3650
} |
Show the document type code with fewer than 3 documents. | SELECT document_type_code FROM Documents GROUP BY document_type_code HAVING COUNT(*) < 3 | CREATE TABLE Documents (document_type_code VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3651
} |
Show the statement detail and the corresponding document name for the statement with detail 'Private Project'. | SELECT T1.statement_details, T2.document_name FROM Statements AS T1 JOIN Documents AS T2 ON T1.statement_id = T2.document_id WHERE T1.statement_details = 'Private Project' | CREATE TABLE Statements (statement_details VARCHAR(255), statement_id VARCHAR(255)); CREATE TABLE Documents (document_name VARCHAR(255), document_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 1 | {
"split": "train",
"row_index": 3652
} |
Show all document type codes, document type names, document type descriptions. | SELECT document_type_code, document_type_name, document_type_description FROM Ref_document_types | CREATE TABLE Ref_document_types (document_type_code VARCHAR(255), document_type_name VARCHAR(255), document_type_description VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3653
} |
What is the document type description for document type named Film? | SELECT document_type_description FROM Ref_document_types WHERE document_type_name = 'Film' | CREATE TABLE Ref_document_types (document_type_description VARCHAR(255), document_type_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3654
} |
What is the document type name and the document type description and creation date for all the documents? | SELECT T1.document_type_name, T1.document_type_description, T2.Document_date FROM Ref_document_types AS T1 JOIN Documents AS T2 ON T1.document_type_code = T2.document_type_code | CREATE TABLE Ref_document_types (document_type_name VARCHAR(255), document_type_description VARCHAR(255), document_type_code VARCHAR(255)); CREATE TABLE Documents (Document_date VARCHAR(255), document_type_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3655
} |
Show the number of projects. | SELECT COUNT(*) FROM Projects | CREATE TABLE Projects (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3656
} |
List ids and details for all projects. | SELECT project_id, project_details FROM Projects | CREATE TABLE Projects (project_id VARCHAR(255), project_details VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3657
} |
What is the project id and detail for the project with at least two documents? | SELECT T1.project_id, T1.project_details FROM Projects AS T1 JOIN Documents AS T2 ON T1.project_id = T2.project_id GROUP BY T1.project_id HAVING COUNT(*) > 2 | CREATE TABLE Projects (project_id VARCHAR(255), project_details VARCHAR(255)); CREATE TABLE Documents (project_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": 3658
} |
What is the project detail for the project with document "King Book"? | SELECT T1.project_details FROM Projects AS T1 JOIN Documents AS T2 ON T1.project_id = T2.project_id WHERE T2.document_name = 'King Book' | CREATE TABLE Projects (project_details VARCHAR(255), project_id VARCHAR(255)); CREATE TABLE Documents (project_id VARCHAR(255), document_name VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3659
} |
How many budget types do we have? | SELECT COUNT(*) FROM Ref_budget_codes | CREATE TABLE Ref_budget_codes (Id VARCHAR(255), description VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3660
} |
List all budget type codes and descriptions. | SELECT budget_type_code, budget_type_description FROM Ref_budget_codes | CREATE TABLE Ref_budget_codes (budget_type_code VARCHAR(255), budget_type_description VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 1 | {
"split": "train",
"row_index": 3661
} |
What is the description for the budget type with code ORG? | SELECT budget_type_description FROM Ref_budget_codes WHERE budget_type_code = 'ORG' | CREATE TABLE Ref_budget_codes (budget_type_description VARCHAR(255), budget_type_code VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3662
} |
How many documents have expenses? | SELECT COUNT(*) FROM Documents_with_expenses | CREATE TABLE Documents_with_expenses (Id VARCHAR(255), budget_type_code VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3663
} |
What are the document ids for the budget type code 'SF'? | SELECT document_id FROM Documents_with_expenses WHERE budget_type_code = 'SF' | CREATE TABLE Documents_with_expenses (document_id VARCHAR(255), budget_type_code VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3664
} |
Show the budget type code and description and the corresponding document id. | SELECT T2.budget_type_code, T2.budget_type_description, T1.document_id FROM Documents_with_expenses AS T1 JOIN Ref_budget_codes AS T2 ON T1.budget_type_code = T2.budget_type_code | CREATE TABLE Ref_budget_codes (budget_type_code VARCHAR(255), budget_type_description VARCHAR(255)); CREATE TABLE Documents_with_expenses (document_id VARCHAR(255), budget_type_code VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3665
} |
Show ids for all documents with budget types described as 'Government'. | SELECT T1.document_id FROM Documents_with_expenses AS T1 JOIN Ref_Budget_Codes AS T2 ON T1.Budget_Type_code = T2.Budget_Type_code WHERE T2.budget_type_Description = 'Government' | CREATE TABLE Documents_with_expenses (document_id VARCHAR(255), Budget_Type_code VARCHAR(255)); CREATE TABLE Ref_Budget_Codes (Budget_Type_code VARCHAR(255), budget_type_Description VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 0 | 0 | {
"split": "train",
"row_index": 3666
} |
Show budget type codes and the number of documents in each budget type. | SELECT budget_type_code, COUNT(*) FROM Documents_with_expenses GROUP BY budget_type_code | CREATE TABLE Documents_with_expenses (budget_type_code VARCHAR(255), document_id VARCHAR(255)) | generic | medium | medium | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 1 | {
"split": "train",
"row_index": 3667
} |
What is the budget type code with most number of documents. | SELECT budget_type_code FROM Documents_with_expenses GROUP BY budget_type_code ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE Documents_with_expenses (budget_type_code VARCHAR(255), document_id VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3668
} |
What are the ids of documents which don't have expense budgets? | SELECT document_id FROM Documents EXCEPT SELECT document_id FROM Documents_with_expenses | CREATE TABLE Documents (document_id VARCHAR(255), document_name VARCHAR(255)); CREATE TABLE Documents_with_expenses (document_id VARCHAR(255), budget_type_code VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 3669
} |
Show ids for all documents in type CV without expense budgets. | SELECT document_id FROM Documents WHERE document_type_code = 'CV' EXCEPT SELECT document_id FROM Documents_with_expenses | CREATE TABLE Documents_with_expenses (document_id VARCHAR(255), document_type_code VARCHAR(255)); CREATE TABLE Documents (document_id VARCHAR(255), document_type_code VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 3670
} |
What are the ids of documents with letter 's' in the name with any expense budgets. | SELECT T1.document_id FROM Documents AS T1 JOIN Documents_with_expenses AS T2 ON T1.document_id = T2.document_id WHERE T1.document_name LIKE '%s%' | CREATE TABLE Documents_with_expenses (document_id VARCHAR(255), budget_type_code VARCHAR(255)); CREATE TABLE Documents (document_id VARCHAR(255), document_name VARCHAR(255)) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 0 | 0 | {
"split": "train",
"row_index": 3671
} |
How many documents do not have any expense? | SELECT COUNT(*) FROM Documents WHERE NOT document_id IN (SELECT document_id FROM Documents_with_expenses) | CREATE TABLE Documents (document_id VARCHAR(255), document_type_code VARCHAR(255)); CREATE TABLE Documents_with_expenses (document_id VARCHAR(255), budget_type_code VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 1 | {
"split": "train",
"row_index": 3672
} |
What are the dates for the documents with both 'GV' type and 'SF' type expenses? | SELECT T1.document_date FROM Documents AS T1 JOIN Documents_with_Expenses AS T2 ON T1.document_id = T2.document_id WHERE T2.budget_type_code = 'GV' INTERSECT SELECT T1.document_date FROM Documents AS T1 JOIN Documents_with_Expenses AS T2 ON T1.document_id = T2.document_id WHERE T2.budget_type_code = 'SF' | CREATE TABLE Documents_with_Expenses (document_id VARCHAR(255), budget_type_code VARCHAR(255)); CREATE TABLE Documents (document_date VARCHAR(255), document_id VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 2 | 1 | 0 | {
"split": "train",
"row_index": 3673
} |
What are the account details with the largest value or with value having char '5' in it? | SELECT MAX(Account_details) FROM Accounts UNION SELECT Account_details FROM Accounts WHERE Account_details LIKE '%5%' | CREATE TABLE Accounts (Account_details INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 1 | 0 | {
"split": "train",
"row_index": 3674
} |
Find the total number of scientists. | SELECT COUNT(*) FROM scientists | CREATE TABLE scientists (Id VARCHAR(255), name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3675
} |
Find the total hours of all projects. | SELECT SUM(hours) FROM projects | CREATE TABLE projects (hours INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT, project_name VARCHAR(255)) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 0 | 0 | 0 | {
"split": "train",
"row_index": 3676
} |
How many different scientists are assigned to any project? | SELECT COUNT(DISTINCT scientist) FROM assignedto | CREATE TABLE assignedto (scientist 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": 3677
} |
Find the number of distinct projects. | SELECT COUNT(DISTINCT name) FROM projects | CREATE TABLE projects (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": 3678
} |
Find the average hours of all projects. | SELECT AVG(hours) FROM projects | CREATE TABLE projects (hours 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": 3679
} |
Find the name of project that continues for the longest time. | SELECT name FROM projects ORDER BY hours DESC LIMIT 1 | CREATE TABLE projects (name VARCHAR(255), hours 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": 3680
} |
List the name of all projects that are operated longer than the average working hours of all projects. | SELECT name FROM projects WHERE hours > (SELECT AVG(hours) FROM projects) | CREATE TABLE projects (name VARCHAR(255), hours INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | hard | hard | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 1 | 0 | {
"split": "train",
"row_index": 3681
} |
Find the name and hours of project that has the most number of scientists. | SELECT T1.name, T1.hours FROM projects AS T1 JOIN assignedto AS T2 ON T1.code = T2.project GROUP BY T2.project ORDER BY COUNT(*) DESC LIMIT 1 | CREATE TABLE assignedto (project VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE projects (name VARCHAR(255), hours VARCHAR(255), code VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 3682
} |
Find the name of the project for which a scientist whose name contains ‘Smith’ is assigned to. | SELECT T2.name FROM assignedto AS T1 JOIN projects AS T2 ON T1.project = T2.code JOIN scientists AS T3 ON T1.scientist = T3.SSN WHERE T3.name LIKE '%Smith%' | CREATE TABLE scientists (SSN VARCHAR(255), name VARCHAR(255)); CREATE TABLE assignedto (project VARCHAR(255), scientist VARCHAR(255)); CREATE TABLE projects (name VARCHAR(255), code VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 0 | {
"split": "train",
"row_index": 3683
} |
Find the total hours of the projects that scientists named Michael Rogers or Carol Smith are assigned to. | SELECT SUM(T2.hours) FROM assignedto AS T1 JOIN projects AS T2 ON T1.project = T2.code JOIN scientists AS T3 ON T1.scientist = T3.SSN WHERE T3.name = 'Michael Rogers' OR T3.name = 'Carol Smith' | CREATE TABLE scientists (SSN VARCHAR(255), name VARCHAR(255)); CREATE TABLE projects (hours INTEGER, code VARCHAR(255)); CREATE TABLE assignedto (project VARCHAR(255), scientist VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 4 | 0 | 1 | {
"split": "train",
"row_index": 3684
} |
Find the name of projects that require between 100 and 300 hours of work. | SELECT name FROM projects WHERE hours BETWEEN 100 AND 300 | CREATE TABLE projects (name VARCHAR(255), hours INTEGER, id INTEGER PRIMARY KEY AUTO_INCREMENT) | generic | easy | easy | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 1 | 0 | 0 | {
"split": "train",
"row_index": 3685
} |
Find the name of the scientist who worked on both a project named 'Matter of Time' and a project named 'A Puzzling Parallax'. | SELECT T3.name FROM assignedto AS T1 JOIN projects AS T2 ON T1.project = T2.code JOIN scientists AS T3 ON T1.scientist = T3.SSN WHERE T2.name = 'Matter of Time' INTERSECT SELECT T3.name FROM assignedto AS T1 JOIN projects AS T2 ON T1.project = T2.code JOIN scientists AS T3 ON T1.scientist = T3.SSN WHERE T2.name = 'A Pu... | CREATE TABLE projects (code VARCHAR(255), name VARCHAR(255), id INTEGER PRIMARY KEY AUTO_INCREMENT); CREATE TABLE scientists (name VARCHAR(255), SSN VARCHAR(255)); CREATE TABLE assignedto (project VARCHAR(255), scientist VARCHAR(255)) | generic | extra | extra | classified | valid | valid | valid | [] | [] | [] | [] | [
"validated",
"extended",
"classified"
] | null | 3 | 1 | 0 | {
"split": "train",
"row_index": 3686
} |
List the names of all scientists sorted in alphabetical order. | SELECT name FROM scientists ORDER BY name | CREATE TABLE scientists (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": 3687
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.