train/task077_splash_explanation_to_sql_train.jsonl

{"task_name": "task077_splash_explanation_to_sql", "id": "task077-081263a282794e7cb4deba9eb66516c5", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Apartments table, find the corresponding rows in Apartment_Bookings table.\nStep 2: find the average bathroom_count in the results of step 1 whose booking_status_code equals Provisional", "targets": "SELECT Avg ( T1.bathroom_count ) FROM Apartments AS T1 JOIN Apartment_Bookings AS T2 ON T1.apt_id = T2.apt_id WHERE T2.booking_status_code = \"Provisional\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-4cc47f5c5a1d4b46a9eee99ccfadc401", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Campuses table, find corresponding rows in csu_fees table and in faculty table.\nStep 2: find the average CampusFee in the results of step 1 whose faculty's Year equals 1996 and csu_fees's Year equals 1996", "targets": "SELECT Avg ( T2.CampusFee ) FROM Campuses AS T1 JOIN csu_fees AS T2 ON T2.Campus = T1.Id JOIN faculty AS T3 ON T1.Id = T3.Campus WHERE T3.Year = 1996 AND T2.Year = 1996"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-f424f4bde946415ba0f36bfd62032f4a", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find each value of product_name in Products table along with the summation of the corresponding rows to each value", "targets": "SELECT product_name , Sum ( * ) FROM Products GROUP BY product_name"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-3680b027a649448bb060cf0365906458", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Addresses table, find the corresponding rows in Student_Addresses table.\nStep 2: find the average monthly_rental of each value of student_id in the results of step 1.\nStep 3: find student_id, city of step 1 results with largest value in the results of step 2", "targets": "SELECT T2.student_id , T1.city FROM Addresses AS T1 JOIN Student_Addresses AS T2 ON T1.address_id = T2.address_id GROUP BY T2.student_id ORDER BY Avg ( T2.monthly_rental ) Desc LIMIT 1"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-61c440b5ce6545deba9d5b43f30f3a0b", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Apartment_Buildings table, find the corresponding rows in Apartments table.\nStep 2: find the summation of bathroom_count in the results of step 1 whose apt_number equals Columbus Square and building_short_name equals Normandie Court", "targets": "SELECT Sum ( T2.bathroom_count ) FROM Apartment_Buildings AS T1 JOIN Apartments AS T2 ON T1.building_id = T2.building_id WHERE T2.apt_number = \"Columbus Square\" AND T1.building_short_name = \"Normandie Court\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-1f93d136c8374c9586559a6948dbf490", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: find the number of rows of each value of facility_code in Apartment_Facilities table.\nStep 2: find facility_code in Apartment_Facilities table whose corresponding value in step 1 is greater than 4", "targets": "SELECT facility_code FROM Apartment_Facilities GROUP BY facility_code HAVING Count ( * ) > 4"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-2c41bac62837450eaa41c8955aa01598", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Campuses table, find the corresponding rows in faculty table.\nStep 2: find the number of rows in the results of step 1 whose Campuses's Campus equals Long Beach State University and faculty's Year equals 2002", "targets": "SELECT Count ( * ) FROM Campuses AS T1 JOIN faculty AS T2 ON T1.Id = T2.Campus WHERE T1.Campus = \"Long Beach State University\" AND T2.Year = 2002"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-e8e59c08a2c34ff7a49d4bd5a4c252a3", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Campuses table, find corresponding rows in csu_fees table and in discipline_enrollments table.\nStep 2: find CampusFee of the results of step 1 whose discipline_enrollments's Year equals 1996 and discipline_enrollments's Year equals San Jose State University", "targets": "SELECT T2.CampusFee FROM Campuses AS T1 JOIN csu_fees AS T2 ON T2.Campus = T1.Id JOIN discipline_enrollments AS T3 ON T1.Id = T3.Campus WHERE T3.Year = \"San Jose State University\" AND T3.Year = 1996"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-c719fe8674ee4b27823be231b5651267", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: find the number of rows of each value of city in Addresses table.\nStep 2: find city of Addresses table with largest value in the results of step 1", "targets": "SELECT city FROM Addresses GROUP BY city ORDER BY Count ( * ) Desc LIMIT 1"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-08309803267e4d29b1ed7c7693e26922", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: find the average stars in Rating table.\nStep 2: For each row in Movie table, find the corresponding rows in Rating table.\nStep 3: find title, director in the results of step 2 whose stars greater than the results of step 1", "targets": "SELECT T1.title , T1.director FROM Movie AS T1 JOIN Rating AS T2 ON T1.mID = T2.mID WHERE T2.stars > ( SELECT Avg ( T2.stars ) FROM Rating AS T2 )"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-419692cc09d04d6490251308c17c0e01", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Orders table, find the corresponding rows in Invoices table.\nStep 2: find date_order_placed, Invoices's order_id of the results of step 1", "targets": "SELECT T1.date_order_placed , T2.order_id FROM Orders AS T1 JOIN Invoices AS T2 ON T1.order_id = T2.order_id"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-bb2acaf0de7d47c480bb48b709fc955d", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find the summation of amount_outstanding in Customers table whose first_name equals Carole and last_name equals Bernhard", "targets": "SELECT Sum ( amount_outstanding ) FROM Customers WHERE first_name = \"Carole\" AND last_name = \"Bernhard\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-47fe7639eff34eac847eaabb78b7e150", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: find the rows in faculty table whose Year equals 2003.\nStep 2: find each value of Faculty in the results of step 1 ordered descending by number of rows that correspond of each value.\nStep 3: only show the first row of the results", "targets": "SELECT Faculty FROM faculty WHERE Year = 2003 GROUP BY Campus ORDER BY Count ( * ) Desc LIMIT 1"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-f008f9c05d5f4b64841eb48b9bd24c83", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Movie table, find the corresponding rows in Rating table.\nStep 2: find each value of director in the results of step 1 along with the average stars of the corresponding rows to each value", "targets": "SELECT T1.title , Avg ( T2.stars ) FROM Movie AS T1 JOIN Rating AS T2 ON T1.mID = T2.mID GROUP BY T1.director"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-e243bf2e0ca44dc9ba065195600aa38d", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find the number of rows in faculty table whose Year equals 2002 and Year equals Long Beach State University", "targets": "SELECT Count ( * ) FROM faculty WHERE Year = \"Long Beach State University\" AND Year = 2002"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-9d4efe07605c45b3baec8c719188a757", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: find the number of rows of each value of product in product table.\nStep 2: find product of product table with largest value in the results of step 1", "targets": "SELECT product FROM product GROUP BY product ORDER BY Count ( * ) Desc LIMIT 1"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-c4a063910aa940ee91038b5661f324ae", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find the number of rows in Customers table whose first_name equals Rylan and last_name equals Goodwin", "targets": "SELECT Count ( * ) FROM Customers WHERE first_name = \"Rylan\" AND last_name = \"Goodwin\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-af65bc4f749545a996e6630b8270fe71", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Campuses table, find the corresponding rows in faculty table.\nStep 2: find Campuses's Campus of the results of step 1 whose County equals Los Angeles and Campuses's Year greater than 1950 and faculty's Year greater than 2002", "targets": "SELECT T1.Campus FROM Campuses AS T1 JOIN faculty AS T2 ON T1.Id = T2.Campus WHERE T1.County = \"Los Angeles\" AND T1.Year > 1950 AND T2.Year > 2002"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-bd780bc906644b738472f6ae58b8d59b", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find the city of Addresses table for which line_1_number_building equals Janessa", "targets": "SELECT city FROM Addresses WHERE line_1_number_building = \"Janessa\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-617e7e72f94e47c4a7ae2dc919255cd1", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: find the average transaction_amount in Financial_Transactions table.\nStep 2: find the account_id of Financial_Transactions table whose transaction_amount greater than the results of step 1", "targets": "SELECT account_id FROM Financial_Transactions WHERE transaction_amount > ( SELECT Avg ( transaction_amount ) FROM Financial_Transactions )"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-4ce581372079456a8037a296806bcd03", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: find the number of rows of each value of customer_id in Customers table.\nStep 2: find first_name, last_name in Customers table whose corresponding value in step 1 is greater than 2", "targets": "SELECT first_name , last_name FROM Customers GROUP BY customer_id HAVING Count ( * ) > 2"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-1825d3d4f23a49b3a4045ca579dda3dd", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Reviewer table, find the corresponding rows in Rating table.\nStep 2: find name of the results of step 1 whose stars equals null", "targets": "SELECT T1.name FROM Reviewer AS T1 JOIN Rating AS T2 ON T1.rID = T2.rID WHERE T2.stars = \"null\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-787995944e274d91b466e41ebb54fea0", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find the Name of people table", "targets": "SELECT Name FROM people"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-db5d58f7849b43faa80047cd5920b5eb", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Apartment_Buildings table, find the corresponding rows in Apartments table.\nStep 2: find the summation of bathroom_count in the results of step 1 whose building_full_name equals Columbus Square and building_short_name equals Normandie Court", "targets": "SELECT Sum ( T2.bathroom_count ) FROM Apartment_Buildings AS T1 JOIN Apartments AS T2 ON T1.building_id = T2.building_id WHERE T1.building_full_name = \"Columbus Square\" AND T1.building_short_name = \"Normandie Court\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-773da15bb5154538b6ed1dfb50d77627", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find the order_id, date_order_placed, order_details of Orders table", "targets": "SELECT order_id , date_order_placed , order_details FROM Orders"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-5e6a9d88dac248b18d0fba05219fedf6", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find without repetition the District_name of district table ordered descending by City_Population", "targets": "SELECT DISTINCT District_name FROM district ORDER BY City_Population Desc"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-6ce64a0647374ff7a3093747a08631aa", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find each value of product_id in Products table along with the number of the corresponding rows to each value", "targets": "SELECT product_id , Count ( * ) FROM Products GROUP BY product_id"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-fb2405abc2ad419f92f2642c498940de", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find each value of apt_number in Apartments table along with the number of the corresponding rows to each value", "targets": "SELECT apt_number , Count ( * ) FROM Apartments GROUP BY apt_number"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-abb776a10a3d4bfda1a397b87f3de191", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Guests table, find the corresponding rows in Apartment_Bookings table.\nStep 2: find booking_start_date, booking_end_date of the results of step 1 whose gender_code equals Female", "targets": "SELECT T2.booking_start_date , T2.booking_end_date FROM Guests AS T1 JOIN Apartment_Bookings AS T2 ON T1.guest_id = T2.guest_id WHERE T1.gender_code = \"Female\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-8f7123bd0a9a48389e79167888f57494", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Teachers table, find the corresponding rows in Assessment_Notes table.\nStep 2: find notes_id of the results of step 1 whose last_name equals Schuster", "targets": "SELECT T2.notes_id FROM Teachers AS T1 JOIN Assessment_Notes AS T2 ON T1.teacher_id = T2.teacher_id WHERE T1.last_name = \"Schuster\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-b557006d8b654ac2a86ea4806cac02e4", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Campuses table, find corresponding rows in degrees table and in discipline_enrollments table.\nStep 2: find the average Degrees of each value of discipline_enrollments's Year in the results of step 1.\nStep 3: find discipline_enrollments's Year of the results of step 1 with largest value in the results of step 2", "targets": "SELECT T3.Year FROM Campuses AS T1 JOIN degrees AS T2 ON T2.Campus = T1.Id JOIN discipline_enrollments AS T3 ON T1.Id = T3.Campus GROUP BY T3.Year ORDER BY Avg ( T2.Degrees ) Desc LIMIT 1"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-ca7caf7cee254b64b77edb46f6d87132", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Campuses table, find corresponding rows in discipline_enrollments table and in faculty table.\nStep 2: find faculty's Year of the results of step 1 whose Undergraduate greater than 400.\nStep 3: find the discipline_enrollments's Campus of discipline_enrollments table for which Discipline greater than 1956.\nStep 4: show the rows that are in both the results of step 2 and the results of step 3", "targets": "SELECT T3.Year FROM Campuses AS T1 JOIN discipline_enrollments AS T2 ON T2.Campus = T1.Id JOIN faculty AS T3 ON T1.Id = T3.Campus WHERE T2.Undergraduate > 400 INTERSECT SELECT T2.Campus FROM discipline_enrollments AS T2 WHERE T2.Discipline > 1956"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-8945581983e14ae0bd5597f18ef27bb0", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find the average bathroom_count in Apartments table", "targets": "SELECT Avg ( bathroom_count ) FROM Apartments"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-73305c9522434fa3bbc38d8d7b439d85", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Campuses table, find the corresponding rows in faculty table.\nStep 2: find County of the results of step 1 whose County equals Los Angeles and Campuses's Year greater than 1950 and faculty's Year greater than 2002", "targets": "SELECT T1.County FROM Campuses AS T1 JOIN faculty AS T2 ON T1.Id = T2.Campus WHERE T1.County = \"Los Angeles\" AND T1.Year > 1950 AND T2.Year > 2002"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-70eb96e9bef648a1b3d45b8059c0d20f", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find the rows of Behavior_Incident table ordered ascending by date_incident_start", "targets": "SELECT * FROM Behavior_Incident ORDER BY date_incident_start Asc"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-c4c29612770541758649a44b12431e79", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find the Id of Campuses table for which County equals Los Angeles", "targets": "SELECT Id FROM Campuses WHERE County = \"Los Angeles\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-ae8895f4e6ba4c1e926bc8432d6b842a", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Movie table, find the corresponding rows in Rating table.\nStep 2: find title of the results of step 1 whose stars contains 4 or stars contains 3", "targets": "SELECT T1.title FROM Movie AS T1 JOIN Rating AS T2 ON T1.mID = T2.mID WHERE T2.stars LIKE 3 OR T2.stars LIKE 4"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-be954f217fde4c888f41205ec7ee0a4c", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Campuses table, find corresponding rows in csu_fees table and in discipline_enrollments table.\nStep 2: find CampusFee of the results of step 1 whose csu_fees's Year equals 1996 and discipline_enrollments's Year equals San Jose State University", "targets": "SELECT T2.CampusFee FROM Campuses AS T1 JOIN csu_fees AS T2 ON T2.Campus = T1.Id JOIN discipline_enrollments AS T3 ON T1.Id = T3.Campus WHERE T2.Year = 1996 AND T3.Year = \"San Jose State University\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-fa395396e55f40d2a1833539badc0453", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Campuses table, find corresponding rows in csu_fees table and in faculty table.\nStep 2: find faculty's Campus of the results of step 1 whose faculty's Year greater than or equals 1935 and csu_fees's Year less than or equals 1939", "targets": "SELECT T3.Campus FROM Campuses AS T1 JOIN csu_fees AS T2 ON T2.Campus = T1.Id JOIN faculty AS T3 ON T1.Id = T3.Campus WHERE T3.Year > = 1935 AND T2.Year < = 1939"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-89a2a67721104e73a2dc56a37c97751f", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find the average Clean_Jerk in body_builder table", "targets": "SELECT Avg ( Clean_Jerk ) FROM body_builder"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-53e7d3c2787c4bc2a519a662dc5de684", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: find the number of rows of each value of building_description in Apartment_Buildings table.\nStep 2: find building_description in Apartment_Buildings table whose corresponding value in step 1 is greater than 2", "targets": "SELECT building_description FROM Apartment_Buildings GROUP BY building_description HAVING Count ( * ) > 2"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-abb64851385140178515d2ed07725f2d", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in people table, find the corresponding rows in body_builder table.\nStep 2: find the summation of Total in the results of step 1 whose Name contains January", "targets": "SELECT Sum ( T1.Total ) FROM body_builder AS T1 JOIN people AS T2 ON T1.People_ID = T2.People_ID WHERE T2.Name LIKE \"January\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-30d96a2e27de4e8d9cdff0d825e6a907", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Campuses table, find corresponding rows in csu_fees table and in discipline_enrollments table.\nStep 2: find CampusFee of the results of step 1 whose Undergraduate equals 1996 and csu_fees's Year equals San Jose State University", "targets": "SELECT T2.CampusFee FROM Campuses AS T1 JOIN csu_fees AS T2 ON T2.Campus = T1.Id JOIN discipline_enrollments AS T3 ON T1.Id = T3.Campus WHERE T3.Undergraduate = 1996 AND T2.Year = \"San Jose State University\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-181e255a5ccc4e95819561f9c5652f7b", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Apartments table, find the corresponding rows in Apartment_Bookings table.\nStep 2: find apt_number of the results of step 1 whose booking_status_code equals 0.\nStep 3: find apt_number of the results of step 1 whose booking_status_code equals 1.\nStep 4: show the rows that are in both the results of step 2 and the results of step 3", "targets": "SELECT T1.apt_number FROM Apartments AS T1 JOIN Apartment_Bookings AS T2 ON T1.apt_id = T2.apt_id WHERE T2.booking_status_code = 0 INTERSECT SELECT T1.apt_number FROM Apartments AS T1 JOIN Apartment_Bookings AS T2 ON T1.apt_id = T2.apt_id WHERE T2.booking_status_code = 1"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-76553eee7e564f3b9f57a157f69161df", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Campuses table, find corresponding rows in csu_fees table and in faculty table.\nStep 2: find CampusFee of the results of step 1 whose faculty's Year equals 1996 and faculty's Year equals San Jose State University", "targets": "SELECT T2.CampusFee FROM Campuses AS T1 JOIN csu_fees AS T2 ON T2.Campus = T1.Id JOIN faculty AS T3 ON T1.Id = T3.Campus WHERE T3.Year = \"San Jose State University\" AND T3.Year = 1996"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-f64fc1c4a86f4d00a983d62867406407", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "find the Accreditation_type, Company_name of phone table for which Accreditation_type contains Full", "targets": "SELECT Accreditation_type , Company_name FROM phone WHERE Accreditation_type LIKE \"Full\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-a363777742d948e18214e44ac6f38b06", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: find the number of rows of each value of apt_type_code in Apartments table.\nStep 2: find apt_type_code in Apartments table whose corresponding value in step 1 is greater than 1", "targets": "SELECT apt_type_code FROM Apartments GROUP BY apt_type_code HAVING Count ( * ) > 1"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-fa7e1fa7d5ef47e3a783600407b5c35f", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: find the Hardware_colours of screen_mode table.\nStep 2: find the number of rows in screen_mode table whose Hardware_colours not one of the results of step 1", "targets": "SELECT Count ( * ) FROM screen_mode WHERE Hardware_colours NOT IN ( SELECT Hardware_colours FROM screen_mode )"}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-39c92a6d106248a4a98cbc0d4dfbe958", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: For each row in Reviewer table, find the corresponding rows in Rating table.\nStep 2: find stars of the results of step 1 whose name contains Mike", "targets": "SELECT T2.stars FROM Reviewer AS T1 JOIN Rating AS T2 ON T1.rID = T2.rID WHERE T1.name LIKE \"Mike\""}
{"task_name": "task077_splash_explanation_to_sql", "id": "task077-d40b9bfb89fb430d913e6059eb75adea", "definition": "In this task you are expected to provide an SQL statement from an english description of what that SQL statement does. The description may include multiple steps but you should only ouput one SQL statement that accomplishes every step. An SQL query works by selecting data from a table where certain conditions apply. A table contains columns where every row in that table must have a value for each column. Every table has a primary key that uniquely identifies each row, usually an id. To choose which columns are returned you specify that after the \"SELECT\" statement. Next, you use a \"FROM\" statement to specify what tables you want to select the data from. When you specify a table you can rename it with the \"AS\" statement. You can reference that table by whatever name follows the \"AS\" statement. If you want to select data from multiple tables you need to use the \"JOIN\" statement. This will join the tables together by pairing a row in one table with every row in the other table (Cartesian Product). To limit the number of rows returned you should use the \"ON\" statement. This will only return rows where the condition specified after the statement is true, this is usually an equals operator with primary keys. You can also use the \"WHERE\" statement to specify that only rows with column values statisfying a certain condition, should be returned. The \"GROUP BY\" statement will group rows together that have equal column values for whatever columns follows the statement. The \"HAVING\" statement will return groups that statisfy whatever condition follows the statement. Any column(s) being returned from grouped rows must either be an aggregate function, (AVG, MAX, COUNT, SUM, ...) of a column, or the column(s) that the data was grouped by. To sort the returned data you can use the \"ORDER BY\" command which will order the data by whatever aggregate function or column follows the statement. The \"DESC\" statement will sort in descending order and the \"ASC\" statement will sort in ascending order. Finally, you can use the \"LIMIT\" statement to return a certain number of rows. When \"*\" is used in an SQL statement every column is returned. For example, SELECT * FROM table WHERE attribute = 1, will select every column from rows with the attribute column equal to 1.", "inputs": "Step 1: find the director of Movie table for which title equals null.\nStep 2: find the name of Reviewer table whose rID not one of the results of step 1", "targets": "SELECT T1.name FROM Reviewer AS T1 WHERE T1.rID NOT IN ( SELECT T2.director FROM Movie AS T2 WHERE T2.title = \"null\" )"}