bench_dev_full.json

{
  "dataset": "dev",
  "total": 681,
  "exec_accuracy": 0.7093,
  "exact_accuracy": 0.0103,
  "errors": 0,
  "results": [
    {
      "db_id": "concert_singer",
      "question": "How many singers do we have?",
      "gold_sql": "SELECT count(*) FROM singer",
      "predicted_sql": "SELECT COUNT(s.Singer_ID) AS total_singers FROM singer s;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What is the total number of singers?",
      "gold_sql": "SELECT count(*) FROM singer",
      "predicted_sql": "SELECT COUNT(*) AS total_singers\nFROM singer s;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "Show name, country, age for all singers ordered by age from the oldest to the youngest.",
      "gold_sql": "SELECT name ,  country ,  age FROM singer ORDER BY age DESC",
      "predicted_sql": "SELECT s.Name, s.Country, s.Age\nFROM singer AS s\nORDER BY CASE WHEN s.Age IS NULL THEN 1 ELSE 0 END ASC, s.Age DESC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What are the names, countries, and ages for every singer in descending order of age?",
      "gold_sql": "SELECT name ,  country ,  age FROM singer ORDER BY age DESC",
      "predicted_sql": "SELECT s.name, s.country, s.age\nFROM singer AS s\nORDER BY CASE WHEN s.age IS NULL THEN 1 ELSE 0 END, s.age DESC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What is the average, minimum, and maximum age of all singers from France?",
      "gold_sql": "SELECT avg(age) ,  min(age) ,  max(age) FROM singer WHERE country  =  'France'",
      "predicted_sql": "SELECT AVG(s.Age) AS average_age, MIN(s.Age) AS min_age, MAX(s.Age) AS max_age\nFROM singer s\nWHERE UPPER(COALESCE(s.Country, '')) = 'FRANCE' AND s.Age IS NOT NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What is the average, minimum, and maximum age for all French singers?",
      "gold_sql": "SELECT avg(age) ,  min(age) ,  max(age) FROM singer WHERE country  =  'France'",
      "predicted_sql": "SELECT AVG(s.Age) AS average_age, MIN(s.Age) AS min_age, MAX(s.Age) AS max_age\nFROM singer s\nWHERE lower(COALESCE(s.Country, '')) LIKE '%franc%';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "Show the name and the release year of the song by the youngest singer.",
      "gold_sql": "SELECT song_name ,  song_release_year FROM singer ORDER BY age LIMIT 1",
      "predicted_sql": "SELECT s.Song_Name, s.Song_release_year\nFROM singer AS s\nWHERE s.Age IS NOT NULL\n  AND s.Age = (SELECT MIN(s2.Age) FROM singer AS s2 WHERE s2.Age IS NOT NULL);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What are the names and release years for all the songs of the youngest singer?",
      "gold_sql": "SELECT song_name ,  song_release_year FROM singer ORDER BY age LIMIT 1",
      "predicted_sql": "SELECT s.Song_Name, s.Song_release_year\nFROM singer AS s\nWHERE s.Age = (SELECT MIN(s2.Age) FROM singer AS s2 WHERE s2.Age IS NOT NULL);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What are all distinct countries where singers above age 20 are from?",
      "gold_sql": "SELECT DISTINCT country FROM singer WHERE age  >  20",
      "predicted_sql": "SELECT DISTINCT s.Country\nFROM singer AS s\nWHERE s.Age > 20\n  AND s.Country IS NOT NULL\n  AND TRIM(s.Country) <> '';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What are  the different countries with singers above age 20?",
      "gold_sql": "SELECT DISTINCT country FROM singer WHERE age  >  20",
      "predicted_sql": "SELECT DISTINCT s.Country\nFROM singer s\nWHERE s.Age > 20\n  AND s.Country IS NOT NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "Show all countries and the number of singers in each country.",
      "gold_sql": "SELECT country ,  count(*) FROM singer GROUP BY country",
      "predicted_sql": "SELECT COALESCE(s.country, 'Unknown') AS country,\n       COUNT(*) AS singer_count\nFROM singer s\nGROUP BY COALESCE(s.country, 'Unknown')\nORDER BY singer_count DESC, country;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "How many singers are from each country?",
      "gold_sql": "SELECT country ,  count(*) FROM singer GROUP BY country",
      "predicted_sql": "SELECT COALESCE(s.Country, 'Unknown') AS Country, COUNT(s.Singer_ID) AS singer_count\nFROM singer AS s\nGROUP BY COALESCE(s.Country, 'Unknown')\nORDER BY singer_count DESC, Country;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "List all song names by singers above the average age.",
      "gold_sql": "SELECT song_name FROM singer WHERE age  >  (SELECT avg(age) FROM singer)",
      "predicted_sql": "SELECT DISTINCT s.Song_Name\nFROM singer AS s\nWHERE s.Song_Name IS NOT NULL\n  AND s.Age IS NOT NULL\n  AND s.Age > (\n    SELECT AVG(s2.Age)\n    FROM singer AS s2\n    WHERE s2.Age IS NOT NULL\n  );",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What are all the song names by singers who are older than average?",
      "gold_sql": "SELECT song_name FROM singer WHERE age  >  (SELECT avg(age) FROM singer)",
      "predicted_sql": "SELECT DISTINCT s.Song_Name\nFROM singer s\nWHERE s.Song_Name IS NOT NULL\n  AND s.Age IS NOT NULL\n  AND s.Age > (SELECT AVG(a.Age) FROM singer a WHERE a.Age IS NOT NULL);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "Show location and name for all stadiums with a capacity between 5000 and 10000.",
      "gold_sql": "SELECT LOCATION ,  name FROM stadium WHERE capacity BETWEEN 5000 AND 10000",
      "predicted_sql": "SELECT s.Location, s.Name\nFROM stadium AS s\nWHERE s.Capacity IS NOT NULL\n  AND s.Capacity BETWEEN 5000 AND 10000;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What are the locations and names of all stations with capacity between 5000 and 10000?",
      "gold_sql": "SELECT LOCATION ,  name FROM stadium WHERE capacity BETWEEN 5000 AND 10000",
      "predicted_sql": "SELECT s.Location, s.Name\nFROM stadium s\nWHERE s.Capacity IS NOT NULL\n  AND s.Capacity BETWEEN 5000 AND 10000;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What is the average and the maximum capacity of all stadiums?",
      "gold_sql": "SELECT avg(capacity) ,  max(capacity) FROM stadium",
      "predicted_sql": "SELECT AVG(CAST(s.Capacity AS DECIMAL(10,2))) AS average_capacity, MAX(s.Capacity) AS max_capacity\nFROM stadium s;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What is the average and maximum capacities for all stations?",
      "gold_sql": "SELECT avg(capacity) ,  max(capacity) FROM stadium",
      "predicted_sql": "SELECT AVG(s.Capacity) AS average_capacity, MAX(s.Capacity) AS maximum_capacity\nFROM stadium s;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What is the name and capacity for the stadium with highest average attendance?",
      "gold_sql": "SELECT name ,  capacity FROM stadium ORDER BY average DESC LIMIT 1",
      "predicted_sql": "SELECT s.Name, s.Capacity\nFROM stadium AS s\nWHERE s.Average IS NOT NULL\n  AND s.Average = (\n    SELECT MAX(st.Average) FROM stadium AS st WHERE st.Average IS NOT NULL\n  );",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What is the name and capacity for the stadium with the highest average attendance?",
      "gold_sql": "SELECT name ,  capacity FROM stadium ORDER BY average DESC LIMIT 1",
      "predicted_sql": "SELECT s.name, s.capacity\nFROM stadium AS s\nWHERE s.average = (SELECT MAX(st.average) FROM stadium AS st WHERE st.average IS NOT NULL);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "How many concerts are there in year 2014 or 2015?",
      "gold_sql": "SELECT count(*) FROM concert WHERE YEAR  =  2014 OR YEAR  =  2015",
      "predicted_sql": "SELECT COUNT(*) AS concert_count\nFROM concert c\nWHERE c.Year IN (2014, 2015);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "How many concerts occurred in 2014 or 2015?",
      "gold_sql": "SELECT count(*) FROM concert WHERE YEAR  =  2014 OR YEAR  =  2015",
      "predicted_sql": "SELECT COUNT(*) AS concerts_count\nFROM concert c\nWHERE c.Year IN (2014, 2015);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "Show the stadium name and the number of concerts in each stadium.",
      "gold_sql": "SELECT T2.name ,  count(*) FROM concert AS T1 JOIN stadium AS T2 ON T1.stadium_id  =  T2.stadium_id GROUP BY T1.stadium_id",
      "predicted_sql": "SELECT s.name AS stadium_name,\n       COUNT(c.concert_id) AS concert_count\nFROM stadium s\nLEFT JOIN concert c ON s.stadium_id = c.stadium_id\nGROUP BY s.stadium_id, s.name\nORDER BY s.name;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "For each stadium, how many concerts play there?",
      "gold_sql": "SELECT T2.name ,  count(*) FROM concert AS T1 JOIN stadium AS T2 ON T1.stadium_id  =  T2.stadium_id GROUP BY T1.stadium_id",
      "predicted_sql": "SELECT s.Stadium_ID, s.Name, s.Location, COUNT(c.concert_ID) AS concerts_count\nFROM stadium s\nLEFT JOIN concert c ON c.Stadium_ID = s.Stadium_ID\nGROUP BY s.Stadium_ID, s.Name, s.Location\nORDER BY s.Stadium_ID;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "Show the stadium name and capacity with most number of concerts in year 2014 or after.",
      "gold_sql": "SELECT T2.name ,  T2.capacity FROM concert AS T1 JOIN stadium AS T2 ON T1.stadium_id  =  T2.stadium_id WHERE T1.year  >=  2014 GROUP BY T2.stadium_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT s.Name, s.Capacity\nFROM stadium s\nJOIN (\n  SELECT Stadium_ID, COUNT(*) AS concert_count\n  FROM concert\n  WHERE Year >= 2014\n  GROUP BY Stadium_ID\n) c ON s.Stadium_ID = c.Stadium_ID\nWHERE c.concert_count = (\n  SELECT MAX(t.cnt)\n  FROM (\n    SELECT COUNT(*) AS cnt\n    FROM concert\n    WHERE Year >= 2014\n    GROUP BY Stadium_ID\n  ) t\n);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What is the name and capacity of the stadium  with the most concerts after 2013?",
      "gold_sql": "SELECT T2.name ,  T2.capacity FROM concert AS T1 JOIN stadium AS T2 ON T1.stadium_id  =  T2.stadium_id WHERE T1.year  >=  2014 GROUP BY T2.stadium_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT s.Name, s.Capacity\nFROM stadium s\nJOIN (\n  SELECT c.Stadium_ID, COUNT(*) AS cnt\n  FROM concert c\n  WHERE c.Year > '2013' AND c.Stadium_ID IS NOT NULL\n  GROUP BY c.Stadium_ID\n) t ON s.Stadium_ID = t.Stadium_ID\nWHERE t.cnt = (\n  SELECT MAX(cnt) FROM (\n    SELECT COUNT(*) AS cnt\n    FROM concert c2\n    WHERE c2.Year > '2013' AND c2.Stadium_ID IS NOT NULL\n    GROUP BY c2.Stadium_ID\n  ) m\n);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "Which year has most number of concerts?",
      "gold_sql": "SELECT YEAR FROM concert GROUP BY YEAR ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "WITH counts AS (\n  SELECT TRIM(c.Year) AS Year, COUNT(*) AS concert_count\n  FROM concert c\n  WHERE c.Year IS NOT NULL AND TRIM(c.Year) <> ''\n  GROUP BY TRIM(c.Year)\n)\nSELECT Year, concert_count\nFROM counts\nWHERE concert_count = (SELECT MAX(concert_count) FROM counts);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What is the year that had the most concerts?",
      "gold_sql": "SELECT YEAR FROM concert GROUP BY YEAR ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT g.Year\nFROM (\n  SELECT c.Year, COUNT(*) AS cnt\n  FROM concert AS c\n  WHERE c.Year IS NOT NULL\n  GROUP BY c.Year\n) AS g\nWHERE g.cnt = (\n  SELECT MAX(g2.cnt) FROM (\n    SELECT c2.Year, COUNT(*) AS cnt\n    FROM concert AS c2\n    WHERE c2.Year IS NOT NULL\n    GROUP BY c2.Year\n  ) AS g2\n);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "Show the stadium names without any concert.",
      "gold_sql": "SELECT name FROM stadium WHERE stadium_id NOT IN (SELECT stadium_id FROM concert)",
      "predicted_sql": "SELECT s.Name\nFROM stadium AS s\nLEFT JOIN concert AS c ON s.Stadium_ID = c.Stadium_ID\nWHERE c.concert_ID IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What are the names of the stadiums without any concerts?",
      "gold_sql": "SELECT name FROM stadium WHERE stadium_id NOT IN (SELECT stadium_id FROM concert)",
      "predicted_sql": "SELECT s.Name \nFROM stadium s \nLEFT JOIN concert c ON s.Stadium_ID = c.Stadium_ID \nWHERE c.concert_ID IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "Show countries where a singer above age 40 and a singer below 30 are from.",
      "gold_sql": "SELECT country FROM singer WHERE age  >  40 INTERSECT SELECT country FROM singer WHERE age  <  30",
      "predicted_sql": "SELECT DISTINCT s.Country\nFROM singer s\nWHERE s.Age > 40 OR s.Age < 30;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "Show names for all stadiums except for stadiums having a concert in year 2014.",
      "gold_sql": "SELECT name FROM stadium EXCEPT SELECT T2.name FROM concert AS T1 JOIN stadium AS T2 ON T1.stadium_id  =  T2.stadium_id WHERE T1.year  =  2014",
      "predicted_sql": "SELECT s.Name\nFROM stadium s\nWHERE s.Stadium_ID NOT IN (\n    SELECT DISTINCT c.Stadium_ID\n    FROM concert c\n    WHERE c.Year = '2014'\n);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What are the names of all stadiums that did not have a concert in 2014?",
      "gold_sql": "SELECT name FROM stadium EXCEPT SELECT T2.name FROM concert AS T1 JOIN stadium AS T2 ON T1.stadium_id  =  T2.stadium_id WHERE T1.year  =  2014",
      "predicted_sql": "SELECT s.Name\nFROM stadium s\nLEFT JOIN concert c ON s.Stadium_ID = c.Stadium_ID AND YEAR(c.concert_Date) = 2014\nWHERE c.concert_ID IS NULL;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "Show the name and theme for all concerts and the number of singers in each concert.",
      "gold_sql": "SELECT T2.concert_name ,  T2.theme ,  count(*) FROM singer_in_concert AS T1 JOIN concert AS T2 ON T1.concert_id  =  T2.concert_id GROUP BY T2.concert_id",
      "predicted_sql": "SELECT c.concert_Name, c.Theme, COUNT(sic.Singer_ID) AS number_of_singers\nFROM concert c\nLEFT JOIN singer_in_concert sic ON c.concert_ID = sic.concert_ID\nGROUP BY c.concert_ID, c.concert_Name, c.Theme;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What are the names, themes, and number of singers for each and every concert?",
      "gold_sql": "SELECT T2.concert_name ,  T2.theme ,  count(*) FROM singer_in_concert AS T1 JOIN concert AS T2 ON T1.concert_id  =  T2.concert_id GROUP BY T2.concert_id",
      "predicted_sql": "SELECT \n    c.concert_Name, \n    c.Theme, \n    COUNT(sic.Singer_ID) AS number_of_singers\nFROM \n    concert c\nLEFT JOIN \n    singer_in_concert sic ON c.concert_ID = sic.concert_ID\nGROUP BY \n    c.concert_ID, c.concert_Name, c.Theme;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "List singer names and number of concerts for each singer.",
      "gold_sql": "SELECT T2.name ,  count(*) FROM singer_in_concert AS T1 JOIN singer AS T2 ON T1.singer_id  =  T2.singer_id GROUP BY T2.singer_id",
      "predicted_sql": "SELECT s.Name, COUNT(sic.concert_ID) AS Number_of_Concerts\nFROM singer s\nLEFT JOIN singer_in_concert sic ON s.Singer_ID = sic.Singer_ID\nGROUP BY s.Name;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What are the names of the singers and number of concerts for each person?",
      "gold_sql": "SELECT T2.name ,  count(*) FROM singer_in_concert AS T1 JOIN singer AS T2 ON T1.singer_id  =  T2.singer_id GROUP BY T2.singer_id",
      "predicted_sql": "SELECT s.Name, COUNT(sic.concert_ID) AS Number_of_Concerts\nFROM singer s\nLEFT JOIN singer_in_concert sic ON s.Singer_ID = sic.Singer_ID\nGROUP BY s.Name;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "List all singer names in concerts in year 2014.",
      "gold_sql": "SELECT T2.name FROM singer_in_concert AS T1 JOIN singer AS T2 ON T1.singer_id  =  T2.singer_id JOIN concert AS T3 ON T1.concert_id  =  T3.concert_id WHERE T3.year  =  2014",
      "predicted_sql": "SELECT DISTINCT s.Name\nFROM singer s\nJOIN singer_in_concert sic ON s.Singer_ID = sic.Singer_ID\nJOIN concert c ON sic.concert_ID = c.concert_ID\nWHERE c.Year = '2014';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What are the names of the singers who performed in a concert in 2014?",
      "gold_sql": "SELECT T2.name FROM singer_in_concert AS T1 JOIN singer AS T2 ON T1.singer_id  =  T2.singer_id JOIN concert AS T3 ON T1.concert_id  =  T3.concert_id WHERE T3.year  =  2014",
      "predicted_sql": "SELECT DISTINCT s.Name\nFROM singer s\nJOIN singer_in_concert sic ON s.Singer_ID = sic.Singer_ID\nJOIN concert c ON sic.concert_ID = c.concert_ID\nWHERE c.Year = '2014';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "what is the name and nation of the singer who have a song having 'Hey' in its name?",
      "gold_sql": "SELECT name ,  country FROM singer WHERE song_name LIKE '%Hey%'",
      "predicted_sql": "SELECT s.Name, s.Country\nFROM singer s\nWHERE s.Song_Name LIKE '%Hey%';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What is the name and country of origin of every singer who has a song with the word 'Hey' in its title?",
      "gold_sql": "SELECT name ,  country FROM singer WHERE song_name LIKE '%Hey%'",
      "predicted_sql": "SELECT DISTINCT s.Name, s.Country\nFROM singer s\nWHERE s.Song_Name LIKE '%Hey%';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "Find the name and location of the stadiums which some concerts happened in the years of both 2014 and 2015.",
      "gold_sql": "SELECT T2.name ,  T2.location FROM concert AS T1 JOIN stadium AS T2 ON T1.stadium_id  =  T2.stadium_id WHERE T1.Year  =  2014 INTERSECT SELECT T2.name ,  T2.location FROM concert AS T1 JOIN stadium AS T2 ON T1.stadium_id  =  T2.stadium_id WHERE T1.Year  =  2015",
      "predicted_sql": "SELECT DISTINCT s.Name, s.Location\nFROM stadium s\nJOIN concert c ON s.Stadium_ID = c.Stadium_ID\nWHERE c.Year IN ('2014', '2015')\nGROUP BY s.Name, s.Location\nHAVING COUNT(DISTINCT c.Year) = 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What are the names and locations of the stadiums that had concerts that occurred in both 2014 and 2015?",
      "gold_sql": "SELECT T2.name ,  T2.location FROM concert AS T1 JOIN stadium AS T2 ON T1.stadium_id  =  T2.stadium_id WHERE T1.Year  =  2014 INTERSECT SELECT T2.name ,  T2.location FROM concert AS T1 JOIN stadium AS T2 ON T1.stadium_id  =  T2.stadium_id WHERE T1.Year  =  2015",
      "predicted_sql": "SELECT s.Name, s.Location\nFROM stadium s\nJOIN concert c ON s.Stadium_ID = c.Stadium_ID\nWHERE YEAR(c.concert_Date) IN (2014, 2015)\nGROUP BY s.Name, s.Location\nHAVING COUNT(DISTINCT YEAR(c.concert_Date)) = 2;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "Find the number of concerts happened in the stadium with the highest capacity.",
      "gold_sql": "SELECT count(*) FROM concert AS T1 JOIN stadium AS T2 ON T1.stadium_id  =  T2.stadium_id ORDER BY T2.Capacity DESC LIMIT 1",
      "predicted_sql": "SELECT COUNT(c.concert_ID) AS Number_of_Concerts\nFROM concert c\nJOIN stadium s ON c.Stadium_ID = s.Stadium_ID\nWHERE s.Capacity = (SELECT MAX(Capacity) FROM stadium);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "concert_singer",
      "question": "What are the number of concerts that occurred in the stadium with the largest capacity?",
      "gold_sql": "SELECT count(*) FROM concert AS T1 JOIN stadium AS T2 ON T1.stadium_id  =  T2.stadium_id ORDER BY T2.Capacity DESC LIMIT 1",
      "predicted_sql": "SELECT COUNT(c.concert_ID) AS Number_of_Concerts\nFROM concert c\nJOIN stadium s ON c.Stadium_ID = s.Stadium_ID\nWHERE s.Capacity = (SELECT MAX(Capacity) FROM stadium);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the number of pets whose weight is heavier than 10.",
      "gold_sql": "SELECT count(*) FROM pets WHERE weight  >  10",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfHeavyPets\nFROM Pets AS p\nWHERE p.weight > 10;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "How many pets have a greater weight than 10?",
      "gold_sql": "SELECT count(*) FROM pets WHERE weight  >  10",
      "predicted_sql": "SELECT COUNT(*) AS PetCount\nFROM Pets AS p\nWHERE p.weight > 10;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the weight of the youngest dog.",
      "gold_sql": "SELECT weight FROM pets ORDER BY pet_age LIMIT 1",
      "predicted_sql": "SELECT weight \nFROM Pets \nWHERE PetType = 'dog' \nORDER BY pet_age ASC \nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "How much does the youngest dog weigh?",
      "gold_sql": "SELECT weight FROM pets ORDER BY pet_age LIMIT 1",
      "predicted_sql": "SELECT weight \nFROM Pets \nWHERE PetType = 'dog' \nORDER BY pet_age ASC \nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the maximum weight for each type of pet. List the maximum weight and pet type.",
      "gold_sql": "SELECT max(weight) ,  petType FROM pets GROUP BY petType",
      "predicted_sql": "SELECT PetType, MAX(weight) AS MaxWeight\nFROM Pets\nGROUP BY PetType;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "List the maximum weight and type for each type of pet.",
      "gold_sql": "SELECT max(weight) ,  petType FROM pets GROUP BY petType",
      "predicted_sql": "SELECT PetType, MAX(weight) AS MaxWeight\nFROM Pets\nGROUP BY PetType;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find number of pets owned by students who are older than 20.",
      "gold_sql": "SELECT count(*) FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid WHERE T1.age  >  20",
      "predicted_sql": "SELECT COUNT(h.PetID) AS NumberOfPets\nFROM Has_Pet h\nJOIN Student s ON h.StuID = s.StuID\nWHERE s.Age > 20;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "How many pets are owned by students that have an age greater than 20?",
      "gold_sql": "SELECT count(*) FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid WHERE T1.age  >  20",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfPets\nFROM Has_Pet hp\nJOIN Student s ON hp.StuID = s.StuID\nWHERE s.Age > 20;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the number of dog pets that are raised by female students (with sex F).",
      "gold_sql": "SELECT count(*) FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T2.petid  =  T3.petid WHERE T1.sex  =  'F' AND T3.pettype  =  'dog'",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfDogs\nFROM Has_Pet hp\nJOIN Pets p ON hp.PetID = p.PetID\nJOIN Student s ON hp.StuID = s.StuID\nWHERE p.PetType = 'Dog' AND s.Sex = 'F';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "How many dog pets are raised by female students?",
      "gold_sql": "SELECT count(*) FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T2.petid  =  T3.petid WHERE T1.sex  =  'F' AND T3.pettype  =  'dog'",
      "predicted_sql": "SELECT COUNT(*) AS DogPetsByFemaleStudents\nFROM Has_Pet hp\nJOIN Student s ON hp.StuID = s.StuID\nJOIN Pets p ON hp.PetID = p.PetID\nWHERE p.PetType = 'dog' AND s.Sex = 'F';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the number of distinct type of pets.",
      "gold_sql": "SELECT count(DISTINCT pettype) FROM pets",
      "predicted_sql": "SELECT COUNT(DISTINCT PetType) AS DistinctPetTypes\nFROM Pets;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "How many different types of pet are there?",
      "gold_sql": "SELECT count(DISTINCT pettype) FROM pets",
      "predicted_sql": "SELECT COUNT(DISTINCT PetType) AS DifferentPetTypes\nFROM Pets;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the first name of students who have cat or dog pet.",
      "gold_sql": "SELECT DISTINCT T1.Fname FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pettype  =  'cat' OR T3.pettype  =  'dog'",
      "predicted_sql": "SELECT DISTINCT s.Fname\nFROM Student s\nJOIN Has_Pet hp ON s.StuID = hp.StuID\nJOIN Pets p ON hp.PetID = p.PetID\nWHERE p.PetType IN ('cat', 'dog');",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "What are the first names of every student who has a cat or dog as a pet?",
      "gold_sql": "SELECT DISTINCT T1.Fname FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pettype  =  'cat' OR T3.pettype  =  'dog'",
      "predicted_sql": "SELECT DISTINCT s.Fname\nFROM Student s\nJOIN Has_Pet hp ON s.StuID = hp.StuID\nJOIN Pets p ON hp.PetID = p.PetID\nWHERE p.PetType IN ('cat', 'dog');",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the name of students who have both cat and dog pets.",
      "gold_sql": "SELECT T1.Fname FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pettype  =  'cat' INTERSECT SELECT T1.Fname FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pettype  =  'dog'",
      "predicted_sql": "SELECT DISTINCT s.Fname, s.LName\nFROM Student s\nJOIN Has_Pet hp1 ON s.StuID = hp1.StuID\nJOIN Pets p1 ON hp1.PetID = p1.PetID AND p1.PetType = 'cat'\nJOIN Has_Pet hp2 ON s.StuID = hp2.StuID\nJOIN Pets p2 ON hp2.PetID = p2.PetID AND p2.PetType = 'dog';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "What are the students' first names who have both cats and dogs as pets?",
      "gold_sql": "SELECT T1.Fname FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pettype  =  'cat' INTERSECT SELECT T1.Fname FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pettype  =  'dog'",
      "predicted_sql": "SELECT DISTINCT s.Fname\nFROM Student s\nJOIN Has_Pet hp ON s.StuID = hp.StuID\nJOIN Pets p ON hp.PetID = p.PetID\nWHERE p.PetType IN ('cat', 'dog')\nGROUP BY s.StuID, s.Fname\nHAVING COUNT(DISTINCT p.PetType) = 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the major and age of students who do not have a cat pet.",
      "gold_sql": "SELECT major ,  age FROM student WHERE stuid NOT IN (SELECT T1.stuid FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pettype  =  'cat')",
      "predicted_sql": "SELECT DISTINCT s.Major, s.Age\nFROM Student s\nLEFT JOIN Has_Pet hp ON s.StuID = hp.StuID\nLEFT JOIN Pets p ON hp.PetID = p.PetID AND p.PetType = 'cat'\nWHERE p.PetID IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "What major is every student who does not own a cat as a pet, and also how old are they?",
      "gold_sql": "SELECT major ,  age FROM student WHERE stuid NOT IN (SELECT T1.stuid FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pettype  =  'cat')",
      "predicted_sql": "SELECT s.Major, s.Age\nFROM Student s\nLEFT JOIN Has_Pet hp ON s.StuID = hp.StuID\nLEFT JOIN Pets p ON hp.PetID = p.PetID AND p.PetType = 'cat'\nWHERE p.PetID IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the id of students who do not have a cat pet.",
      "gold_sql": "SELECT stuid FROM student EXCEPT SELECT T1.stuid FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pettype  =  'cat'",
      "predicted_sql": "SELECT s.StuID\nFROM Student s\nLEFT JOIN Has_Pet hp ON s.StuID = hp.StuID\nLEFT JOIN Pets p ON hp.PetID = p.PetID AND p.PetType = 'cat'\nWHERE p.PetID IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "What are the ids of the students who do not own cats as pets?",
      "gold_sql": "SELECT stuid FROM student EXCEPT SELECT T1.stuid FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pettype  =  'cat'",
      "predicted_sql": "SELECT s.StuID\nFROM Student s\nWHERE s.StuID NOT IN (\n    SELECT hp.StuID\n    FROM Has_Pet hp\n    JOIN Pets p ON hp.PetID = p.PetID\n    WHERE p.PetType = 'cat'\n);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the first name and age of students who have a dog but do not have a cat as a pet.",
      "gold_sql": "SELECT T1.fname ,  T1.age FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pettype  =  'dog' AND T1.stuid NOT IN (SELECT T1.stuid FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pettype  =  'cat')",
      "predicted_sql": "SELECT s.Fname, s.Age\nFROM Student s\nJOIN Has_Pet hp ON s.StuID = hp.StuID\nJOIN Pets p ON hp.PetID = p.PetID\nWHERE p.PetType = 'dog' AND s.StuID NOT IN (\n    SELECT hp2.StuID\n    FROM Has_Pet hp2\n    JOIN Pets p2 ON hp2.PetID = p2.PetID\n    WHERE p2.PetType = 'cat'\n);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "What is the first name of every student who has a dog but does not have a cat?",
      "gold_sql": "SELECT T1.fname ,  T1.age FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pettype  =  'dog' AND T1.stuid NOT IN (SELECT T1.stuid FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pettype  =  'cat')",
      "predicted_sql": "SELECT DISTINCT s.Fname\nFROM Student s\nJOIN Has_Pet hp ON s.StuID = hp.StuID\nJOIN Pets p ON hp.PetID = p.PetID\nWHERE p.PetType = 'dog' \nAND s.StuID NOT IN (\n    SELECT hp2.StuID\n    FROM Has_Pet hp2\n    JOIN Pets p2 ON hp2.PetID = p2.PetID\n    WHERE p2.PetType = 'cat'\n);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the type and weight of the youngest pet.",
      "gold_sql": "SELECT pettype ,  weight FROM pets ORDER BY pet_age LIMIT 1",
      "predicted_sql": "SELECT PetType, weight \nFROM Pets \nWHERE pet_age = (SELECT MIN(pet_age) FROM Pets);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "What type of pet is the youngest animal, and how much does it weigh?",
      "gold_sql": "SELECT pettype ,  weight FROM pets ORDER BY pet_age LIMIT 1",
      "predicted_sql": "SELECT P.PetType, P.weight\nFROM Pets P\nWHERE P.pet_age = (SELECT MIN(pet_age) FROM Pets);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the id and weight of all pets whose age is older than 1.",
      "gold_sql": "SELECT petid ,  weight FROM pets WHERE pet_age  >  1",
      "predicted_sql": "SELECT P.PetID, P.weight\nFROM Pets P\nWHERE P.pet_age > 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "What is the id and weight of every pet who is older than 1?",
      "gold_sql": "SELECT petid ,  weight FROM pets WHERE pet_age  >  1",
      "predicted_sql": "SELECT PetID, weight \nFROM Pets \nWHERE pet_age > 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the average and maximum age for each type of pet.",
      "gold_sql": "SELECT avg(pet_age) ,  max(pet_age) ,  pettype FROM pets GROUP BY pettype",
      "predicted_sql": "SELECT PetType, \n       AVG(pet_age) AS Average_Age, \n       MAX(pet_age) AS Maximum_Age\nFROM Pets\nGROUP BY PetType;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "What is the average and maximum age for each pet type?",
      "gold_sql": "SELECT avg(pet_age) ,  max(pet_age) ,  pettype FROM pets GROUP BY pettype",
      "predicted_sql": "SELECT PetType, AVG(pet_age) AS Average_Age, MAX(pet_age) AS Maximum_Age\nFROM Pets\nGROUP BY PetType;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the average weight for each pet type.",
      "gold_sql": "SELECT avg(weight) ,  pettype FROM pets GROUP BY pettype",
      "predicted_sql": "SELECT PetType, AVG(weight) AS average_weight\nFROM Pets\nGROUP BY PetType;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "What is the average weight for each type of pet?",
      "gold_sql": "SELECT avg(weight) ,  pettype FROM pets GROUP BY pettype",
      "predicted_sql": "SELECT PetType, AVG(weight) AS AverageWeight\nFROM Pets\nGROUP BY PetType;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the first name and age of students who have a pet.",
      "gold_sql": "SELECT DISTINCT T1.fname ,  T1.age FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid",
      "predicted_sql": "SELECT s.Fname, s.Age\nFROM Student s\nJOIN Has_Pet hp ON s.StuID = hp.StuID;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "What are the different first names and ages of the students who do have pets?",
      "gold_sql": "SELECT DISTINCT T1.fname ,  T1.age FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid",
      "predicted_sql": "SELECT DISTINCT s.Fname, s.Age\nFROM Student s\nJOIN Has_Pet hp ON s.StuID = hp.StuID;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the id of the pet owned by student whose last name is \u2018Smith\u2019.",
      "gold_sql": "SELECT T2.petid FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid WHERE T1.Lname  =  'Smith'",
      "predicted_sql": "SELECT hp.PetID\nFROM Student s\nJOIN Has_Pet hp ON s.StuID = hp.StuID\nWHERE s.LName = 'Smith';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "What is the id of the pet owned by the student whose last name is 'Smith'?",
      "gold_sql": "SELECT T2.petid FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid WHERE T1.Lname  =  'Smith'",
      "predicted_sql": "SELECT hp.PetID\nFROM Has_Pet hp\nJOIN Student s ON hp.StuID = s.StuID\nWHERE s.LName = 'Smith';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the number of pets for each student who has any pet and student id.",
      "gold_sql": "SELECT count(*) ,  T1.stuid FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid GROUP BY T1.stuid",
      "predicted_sql": "SELECT h.StuID, COUNT(h.PetID) AS PetCount\nFROM Has_Pet h\nGROUP BY h.StuID;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "For students who have pets, how many pets does each student have?",
      "gold_sql": "SELECT count(*) ,  T1.stuid FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid GROUP BY T1.stuid",
      "predicted_sql": "SELECT h.StuID, COUNT(h.PetID) AS PetCount\nFROM Has_Pet h\nGROUP BY h.StuID;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the first name and gender of student who have more than one pet.",
      "gold_sql": "SELECT T1.fname ,  T1.sex FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid GROUP BY T1.stuid HAVING count(*)  >  1",
      "predicted_sql": "SELECT s.Fname, s.Sex\nFROM Student s\nJOIN Has_Pet hp ON s.StuID = hp.StuID\nGROUP BY s.StuID, s.Fname, s.Sex\nHAVING COUNT(hp.PetID) > 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "What is the first name and gender of the all the students who have more than one pet?",
      "gold_sql": "SELECT T1.fname ,  T1.sex FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid GROUP BY T1.stuid HAVING count(*)  >  1",
      "predicted_sql": "SELECT s.Fname, s.Sex\nFROM Student s\nJOIN Has_Pet hp ON s.StuID = hp.StuID\nGROUP BY s.StuID, s.Fname, s.Sex\nHAVING COUNT(hp.PetID) > 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the last name of the student who has a cat that is age 3.",
      "gold_sql": "SELECT T1.lname FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pet_age  =  3 AND T3.pettype  =  'cat'",
      "predicted_sql": "SELECT s.LName\nFROM Student s\nJOIN Has_Pet hp ON s.StuID = hp.StuID\nJOIN Pets p ON hp.PetID = p.PetID\nWHERE p.PetType = 'cat' AND p.pet_age = 3;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "What is the last name of the student who has a cat that is 3 years old?",
      "gold_sql": "SELECT T1.lname FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid JOIN pets AS T3 ON T3.petid  =  T2.petid WHERE T3.pet_age  =  3 AND T3.pettype  =  'cat'",
      "predicted_sql": "SELECT s.LName\nFROM Student s\nJOIN Has_Pet hp ON s.StuID = hp.StuID\nJOIN Pets p ON hp.PetID = p.PetID\nWHERE p.PetType = 'cat' AND p.pet_age = 3;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "Find the average age of students who do not have any pet.",
      "gold_sql": "SELECT avg(age) FROM student WHERE stuid NOT IN (SELECT T1.stuid FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid)",
      "predicted_sql": "SELECT AVG(Age) AS AverageAge\nFROM Student s\nWHERE NOT EXISTS (\n    SELECT 1\n    FROM Has_Pet hp\n    WHERE hp.StuID = s.StuID\n);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "pets_1",
      "question": "What is the average age for all students who do not own any pets?",
      "gold_sql": "SELECT avg(age) FROM student WHERE stuid NOT IN (SELECT T1.stuid FROM student AS T1 JOIN has_pet AS T2 ON T1.stuid  =  T2.stuid)",
      "predicted_sql": "SELECT AVG(s.Age) AS AverageAge\nFROM Student s\nWHERE s.StuID NOT IN (SELECT hp.StuID FROM Has_Pet hp);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How many continents are there?",
      "gold_sql": "SELECT count(*) FROM CONTINENTS;",
      "predicted_sql": "SELECT COUNT(*) AS TotalContinents FROM continents;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the number of continents?",
      "gold_sql": "SELECT count(*) FROM CONTINENTS;",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfContinents FROM continents;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How many countries does each continent have? List the continent id, continent name and the number of countries.",
      "gold_sql": "SELECT T1.ContId ,  T1.Continent ,  count(*) FROM CONTINENTS AS T1 JOIN COUNTRIES AS T2 ON T1.ContId  =  T2.Continent GROUP BY T1.ContId;",
      "predicted_sql": "SELECT c.Continent AS ContinentId, co.Continent AS ContinentName, COUNT(c.CountryId) AS CountryCount\nFROM countries c\nJOIN continents co ON c.Continent = co.ContId\nGROUP BY c.Continent, co.Continent;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "For each continent, list its id, name, and how many countries it has?",
      "gold_sql": "SELECT T1.ContId ,  T1.Continent ,  count(*) FROM CONTINENTS AS T1 JOIN COUNTRIES AS T2 ON T1.ContId  =  T2.Continent GROUP BY T1.ContId;",
      "predicted_sql": "SELECT c.ContId, c.Continent, COUNT(co.CountryId) AS CountryCount\nFROM continents c\nLEFT JOIN countries co ON c.ContId = co.Continent\nGROUP BY c.ContId, c.Continent;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How many countries are listed?",
      "gold_sql": "SELECT count(*) FROM COUNTRIES;",
      "predicted_sql": "SELECT COUNT(*) AS CountryCount FROM countries;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How many countries exist?",
      "gold_sql": "SELECT count(*) FROM COUNTRIES;",
      "predicted_sql": "SELECT COUNT(*) AS CountryCount FROM countries;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How many models does each car maker produce? List maker full name, id and the number.",
      "gold_sql": "SELECT T1.FullName ,  T1.Id ,  count(*) FROM CAR_MAKERS AS T1 JOIN MODEL_LIST AS T2 ON T1.Id  =  T2.Maker GROUP BY T1.Id;",
      "predicted_sql": "SELECT cm.FullName, cm.Id, COUNT(DISTINCT ml.Model) AS ModelCount\nFROM car_makers cm\nJOIN model_list ml ON cm.Id = ml.Maker\nGROUP BY cm.FullName, cm.Id;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the full name of each car maker, along with its id and how many models it produces?",
      "gold_sql": "SELECT T1.FullName ,  T1.Id ,  count(*) FROM CAR_MAKERS AS T1 JOIN MODEL_LIST AS T2 ON T1.Id  =  T2.Maker GROUP BY T1.Id;",
      "predicted_sql": "SELECT cm.FullName, cm.Id, COUNT(ml.ModelId) AS ModelCount\nFROM car_makers cm\nLEFT JOIN model_list ml ON cm.Id = ml.Maker\nGROUP BY cm.FullName, cm.Id;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Which model of the car has the minimum horsepower?",
      "gold_sql": "SELECT T1.Model FROM CAR_NAMES AS T1 JOIN CARS_DATA AS T2 ON T1.MakeId  =  T2.Id ORDER BY T2.horsepower ASC LIMIT 1;",
      "predicted_sql": "SELECT ml.Model\nFROM cars_data cd\nJOIN car_names cn ON cd.Id = cn.MakeId\nJOIN model_list ml ON cn.Model = ml.Model\nWHERE cd.Horsepower IS NOT NULL\nORDER BY CAST(cd.Horsepower AS INTEGER) ASC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the model of the car with the smallest amount of horsepower?",
      "gold_sql": "SELECT T1.Model FROM CAR_NAMES AS T1 JOIN CARS_DATA AS T2 ON T1.MakeId  =  T2.Id ORDER BY T2.horsepower ASC LIMIT 1;",
      "predicted_sql": "SELECT ml.Model\nFROM cars_data cd\nJOIN car_names cn ON cd.Id = cn.MakeId\nJOIN model_list ml ON cn.Model = ml.Model\nWHERE cd.Horsepower IS NOT NULL\nORDER BY CAST(cd.Horsepower AS INTEGER) ASC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Find the model of the car whose weight is below the average weight.",
      "gold_sql": "SELECT T1.model FROM CAR_NAMES AS T1 JOIN CARS_DATA AS T2 ON T1.MakeId  =  T2.Id WHERE T2.Weight  <  (SELECT avg(Weight) FROM CARS_DATA)",
      "predicted_sql": "SELECT cn.Model\nFROM car_names cn\nJOIN cars_data cd ON cn.MakeId = cd.Id\nWHERE cd.Weight < (SELECT AVG(Weight) FROM cars_data);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the model for the car with a weight smaller than the average?",
      "gold_sql": "SELECT T1.model FROM CAR_NAMES AS T1 JOIN CARS_DATA AS T2 ON T1.MakeId  =  T2.Id WHERE T2.Weight  <  (SELECT avg(Weight) FROM CARS_DATA)",
      "predicted_sql": "SELECT cn.Model\nFROM car_names cn\nJOIN cars_data cd ON cn.MakeId = cd.Id\nWHERE cd.Weight < (SELECT AVG(Weight) FROM cars_data);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Find the name of the makers that produced some cars in the year of 1970?",
      "gold_sql": "SELECT DISTINCT T1.Maker FROM CAR_MAKERS AS T1 JOIN MODEL_LIST AS T2 ON T1.Id  =  T2.Maker JOIN CAR_NAMES AS T3 ON T2.model  =  T3.model JOIN CARS_DATA AS T4 ON T3.MakeId  =  T4.id WHERE T4.year  =  '1970';",
      "predicted_sql": "SELECT DISTINCT cm.Maker\nFROM car_makers cm\nJOIN model_list ml ON cm.Id = ml.Maker\nJOIN car_names cn ON ml.Model = cn.Model\nJOIN cars_data cd ON cn.MakeId = cd.Id\nWHERE cd.Year = 1970;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the name of the different car makers who produced a car in 1970?",
      "gold_sql": "SELECT DISTINCT T1.Maker FROM CAR_MAKERS AS T1 JOIN MODEL_LIST AS T2 ON T1.Id  =  T2.Maker JOIN CAR_NAMES AS T3 ON T2.model  =  T3.model JOIN CARS_DATA AS T4 ON T3.MakeId  =  T4.id WHERE T4.year  =  '1970';",
      "predicted_sql": "SELECT DISTINCT cm.Maker\nFROM car_makers cm\nJOIN car_names cn ON cm.Id = cn.MakeId\nJOIN cars_data cd ON cn.MakeId = cd.Id\nWHERE cd.Year = 1970;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Find the make and production time of the cars that were produced in the earliest year?",
      "gold_sql": "SELECT T2.Make ,  T1.Year FROM CARS_DATA AS T1 JOIN CAR_NAMES AS T2 ON T1.Id  =  T2.MakeId WHERE T1.Year  =  (SELECT min(YEAR) FROM CARS_DATA);",
      "predicted_sql": "SELECT cn.Make, MIN(cd.Year) AS ProductionYear\nFROM cars_data cd\nJOIN car_names cn ON cd.Id = cn.MakeId\nGROUP BY cn.Make\nHAVING MIN(cd.Year) = (SELECT MIN(Year) FROM cars_data);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the maker of the carr produced in the earliest year and what year was it?",
      "gold_sql": "SELECT T2.Make ,  T1.Year FROM CARS_DATA AS T1 JOIN CAR_NAMES AS T2 ON T1.Id  =  T2.MakeId WHERE T1.Year  =  (SELECT min(YEAR) FROM CARS_DATA);",
      "predicted_sql": "SELECT cm.Maker, MIN(cd.Year) AS EarliestYear\nFROM cars_data cd\nJOIN car_names cn ON cd.Id = cn.MakeId\nJOIN model_list ml ON cn.Make = ml.Model\nJOIN car_makers cm ON ml.Maker = cm.Id\nGROUP BY cm.Maker\nORDER BY EarliestYear\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Which distinct car models are the produced after 1980?",
      "gold_sql": "SELECT DISTINCT T1.model FROM MODEL_LIST AS T1 JOIN CAR_NAMES AS T2 ON T1.model  =  T2.model JOIN CARS_DATA AS T3 ON T2.MakeId  =  T3.id WHERE T3.year  >  1980;",
      "predicted_sql": "SELECT DISTINCT ml.Model\nFROM model_list ml\nJOIN car_names cn ON ml.ModelId = cn.Model\nJOIN cars_data cd ON cn.MakeId = cd.Id\nWHERE cd.Year > 1980;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are the different models for the cards produced after 1980?",
      "gold_sql": "SELECT DISTINCT T1.model FROM MODEL_LIST AS T1 JOIN CAR_NAMES AS T2 ON T1.model  =  T2.model JOIN CARS_DATA AS T3 ON T2.MakeId  =  T3.id WHERE T3.year  >  1980;",
      "predicted_sql": "SELECT DISTINCT ml.Model\nFROM model_list ml\nJOIN car_names cn ON ml.Model = cn.Model\nJOIN cars_data cd ON cn.MakeId = cd.Id\nWHERE cd.Year > 1980;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How many car makers are there in each continents? List the continent name and the count.",
      "gold_sql": "SELECT T1.Continent ,  count(*) FROM CONTINENTS AS T1 JOIN COUNTRIES AS T2 ON T1.ContId  =  T2.continent JOIN car_makers AS T3 ON T2.CountryId  =  T3.Country GROUP BY T1.Continent;",
      "predicted_sql": "SELECT c.Continent, COUNT(cm.Id) AS MakerCount\nFROM continents c\nLEFT JOIN countries co ON c.ContId = co.Continent\nLEFT JOIN car_makers cm ON co.CountryId = cm.Country\nGROUP BY c.Continent;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the name of each continent and how many car makers are there in each one?",
      "gold_sql": "SELECT T1.Continent ,  count(*) FROM CONTINENTS AS T1 JOIN COUNTRIES AS T2 ON T1.ContId  =  T2.continent JOIN car_makers AS T3 ON T2.CountryId  =  T3.Country GROUP BY T1.Continent;",
      "predicted_sql": "SELECT co.CountryName AS Continent, COUNT(cm.Id) AS CarMakersCount\nFROM countries co\nLEFT JOIN car_makers cm ON co.CountryId = cm.Country\nGROUP BY co.CountryName;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Which of the countries has the most car makers? List the country name.",
      "gold_sql": "SELECT T2.CountryName FROM CAR_MAKERS AS T1 JOIN COUNTRIES AS T2 ON T1.Country  =  T2.CountryId GROUP BY T1.Country ORDER BY Count(*) DESC LIMIT 1;",
      "predicted_sql": "SELECT c.CountryName\nFROM countries c\nJOIN car_makers cm ON c.CountryId = cm.Country\nGROUP BY c.CountryName\nORDER BY COUNT(cm.Id) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the name of the country with the most car makers?",
      "gold_sql": "SELECT T2.CountryName FROM CAR_MAKERS AS T1 JOIN COUNTRIES AS T2 ON T1.Country  =  T2.CountryId GROUP BY T1.Country ORDER BY Count(*) DESC LIMIT 1;",
      "predicted_sql": "SELECT c.CountryName\nFROM car_makers cm\nJOIN countries c ON cm.Country = c.CountryId\nGROUP BY c.CountryName\nORDER BY COUNT(cm.Id) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How many car models are produced by each maker? List the count and the maker full name.",
      "gold_sql": "SELECT Count(*) ,  T2.FullName ,  T2.id FROM MODEL_LIST AS T1 JOIN CAR_MAKERS AS T2 ON T1.Maker  =  T2.Id GROUP BY T2.id;",
      "predicted_sql": "SELECT cm.FullName, COUNT(cn.Model) AS ModelCount\nFROM car_makers cm\nJOIN car_names cn ON cm.Id = cn.MakeId\nGROUP BY cm.FullName;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the number of car models that are produced by each maker and what is the id and full name of each maker?",
      "gold_sql": "SELECT Count(*) ,  T2.FullName ,  T2.id FROM MODEL_LIST AS T1 JOIN CAR_MAKERS AS T2 ON T1.Maker  =  T2.Id GROUP BY T2.id;",
      "predicted_sql": "SELECT cm.Id, cm.FullName, COUNT(ml.ModelId) AS NumberOfModels\nFROM car_makers cm\nLEFT JOIN model_list ml ON cm.Id = ml.Maker\nGROUP BY cm.Id, cm.FullName;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the accelerate of the car make amc hornet sportabout (sw)?",
      "gold_sql": "SELECT T1.Accelerate FROM CARS_DATA AS T1 JOIN CAR_NAMES AS T2 ON T1.Id  =  T2.MakeId WHERE T2.Make  =  'amc hornet sportabout (sw)';",
      "predicted_sql": "SELECT cd.Accelerate\nFROM car_names cn\nJOIN cars_data cd ON cn.MakeId = cd.Id\nJOIN model_list ml ON cn.Model = ml.Model\nJOIN car_makers cm ON ml.Maker = cm.Id\nWHERE cm.Maker = 'amc' AND cn.Model = 'hornet sportabout';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How much does the car accelerate that makes amc hornet sportabout (sw)?",
      "gold_sql": "SELECT T1.Accelerate FROM CARS_DATA AS T1 JOIN CAR_NAMES AS T2 ON T1.Id  =  T2.MakeId WHERE T2.Make  =  'amc hornet sportabout (sw)';",
      "predicted_sql": "SELECT cd.Accelerate\nFROM cars_data cd\nJOIN car_names cn ON cd.Id = cn.MakeId\nWHERE cn.Model = 'hornet sportabout' AND cn.Make = 'amc';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How many car makers are there in france?",
      "gold_sql": "SELECT count(*) FROM CAR_MAKERS AS T1 JOIN COUNTRIES AS T2 ON T1.Country  =  T2.CountryId WHERE T2.CountryName  =  'france';",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfCarMakers\nFROM car_makers AS cm\nJOIN countries AS c ON cm.Country = c.CountryId\nWHERE c.CountryName = 'France';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the number of makers of care in France?",
      "gold_sql": "SELECT count(*) FROM CAR_MAKERS AS T1 JOIN COUNTRIES AS T2 ON T1.Country  =  T2.CountryId WHERE T2.CountryName  =  'france';",
      "predicted_sql": "SELECT COUNT(DISTINCT cm.Id) AS NumberOfMakers\nFROM car_makers cm\nJOIN countries c ON cm.Country = c.CountryId\nWHERE c.CountryName = 'France';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How many car models are produced in the usa?",
      "gold_sql": "SELECT count(*) FROM MODEL_LIST AS T1 JOIN CAR_MAKERS AS T2 ON T1.Maker  =  T2.Id JOIN COUNTRIES AS T3 ON T2.Country  =  T3.CountryId WHERE T3.CountryName  =  'usa';",
      "predicted_sql": "SELECT COUNT(DISTINCT ml.Model) AS NumberOfCarModels\nFROM model_list ml\nJOIN car_makers cm ON ml.Maker = cm.Id\nJOIN countries c ON cm.Country = c.CountryId\nWHERE c.CountryName = 'USA';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the count of the car models produced in the United States?",
      "gold_sql": "SELECT count(*) FROM MODEL_LIST AS T1 JOIN CAR_MAKERS AS T2 ON T1.Maker  =  T2.Id JOIN COUNTRIES AS T3 ON T2.Country  =  T3.CountryId WHERE T3.CountryName  =  'usa';",
      "predicted_sql": "SELECT COUNT(DISTINCT ml.Model) AS ModelCount\nFROM model_list ml\nJOIN car_makers cm ON ml.Maker = cm.Id\nJOIN countries c ON cm.Country = c.CountryId\nWHERE c.CountryName = 'United States';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the average miles per gallon(mpg) of the cars with 4 cylinders?",
      "gold_sql": "SELECT avg(mpg) FROM CARS_DATA WHERE Cylinders  =  4;",
      "predicted_sql": "SELECT AVG(CAST(c.MPG AS REAL)) AS AverageMPG\nFROM cars_data c\nWHERE c.Cylinders = 4;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the average miles per gallon of all the cards with 4 cylinders?",
      "gold_sql": "SELECT avg(mpg) FROM CARS_DATA WHERE Cylinders  =  4;",
      "predicted_sql": "SELECT AVG(CAST(MPG AS REAL)) AS AverageMPG\nFROM cars_data\nWHERE Cylinders = 4;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the smallest weight of the car produced with 8 cylinders on 1974?",
      "gold_sql": "SELECT Weight FROM CARS_DATA WHERE Cylinders  =  4 AND YEAR  =  1974 ORDER BY Weight ASC LIMIT 1;",
      "predicted_sql": "SELECT MIN(cd.Weight) AS SmallestWeight\nFROM cars_data cd\nJOIN car_names cn ON cd.Id = cn.MakeId\nWHERE cd.Cylinders = 8 AND cd.Year = 1974;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the minimu weight of the car with 8 cylinders produced in 1974?",
      "gold_sql": "SELECT Weight FROM CARS_DATA WHERE Cylinders  =  4 AND YEAR  =  1974 ORDER BY Weight ASC LIMIT 1;",
      "predicted_sql": "SELECT MIN(cd.Weight) AS MinimumWeight\nFROM cars_data cd\nJOIN car_names cn ON cd.Id = cn.MakeId\nWHERE cd.Cylinders = 8 AND cd.Year = 1974;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are all the makers and models?",
      "gold_sql": "SELECT Maker ,  Model FROM MODEL_LIST;",
      "predicted_sql": "SELECT cm.Maker, ml.Model\nFROM car_makers cm\nJOIN model_list ml ON cm.Id = ml.Maker;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are the makers and models?",
      "gold_sql": "SELECT Maker ,  Model FROM MODEL_LIST;",
      "predicted_sql": "SELECT cm.Maker, ml.Model\nFROM car_makers cm\nJOIN model_list ml ON cm.Id = ml.Maker;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are the countries having at least one car maker? List name and id.",
      "gold_sql": "SELECT T1.CountryName ,  T1.CountryId FROM COUNTRIES AS T1 JOIN CAR_MAKERS AS T2 ON T1.CountryId  =  T2.Country GROUP BY T1.CountryId HAVING count(*)  >=  1;",
      "predicted_sql": "SELECT DISTINCT c.CountryId, c.CountryName\nFROM countries c\nJOIN car_makers cm ON c.CountryId = cm.Country;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are the names and ids of all countries with at least one car maker?",
      "gold_sql": "SELECT T1.CountryName ,  T1.CountryId FROM COUNTRIES AS T1 JOIN CAR_MAKERS AS T2 ON T1.CountryId  =  T2.Country GROUP BY T1.CountryId HAVING count(*)  >=  1;",
      "predicted_sql": "SELECT DISTINCT c.CountryId, c.CountryName\nFROM countries c\nJOIN car_makers cm ON c.CountryId = cm.Country;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the number of the cars with horsepower more than 150?",
      "gold_sql": "SELECT count(*) FROM CARS_DATA WHERE horsepower  >  150;",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfCars\nFROM cars_data\nWHERE CAST(Horsepower AS INTEGER) > 150;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the number of cars with a horsepower greater than 150?",
      "gold_sql": "SELECT count(*) FROM CARS_DATA WHERE horsepower  >  150;",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfCars\nFROM cars_data\nWHERE Horsepower IS NOT NULL AND CAST(Horsepower AS INTEGER) > 150;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the average weight of cars each year?",
      "gold_sql": "SELECT avg(Weight) ,  YEAR FROM CARS_DATA GROUP BY YEAR;",
      "predicted_sql": "SELECT Year, AVG(Weight) AS AverageWeight\nFROM cars_data\nGROUP BY Year;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the average weight and year for each year?",
      "gold_sql": "SELECT avg(Weight) ,  YEAR FROM CARS_DATA GROUP BY YEAR;",
      "predicted_sql": "SELECT Year, AVG(Weight) AS AverageWeight\nFROM cars_data\nGROUP BY Year;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Which countries in europe have at least 3 car manufacturers?",
      "gold_sql": "SELECT T1.CountryName FROM COUNTRIES AS T1 JOIN CONTINENTS AS T2 ON T1.Continent  =  T2.ContId JOIN CAR_MAKERS AS T3 ON T1.CountryId  =  T3.Country WHERE T2.Continent  =  'europe' GROUP BY T1.CountryName HAVING count(*)  >=  3;",
      "predicted_sql": "SELECT c.CountryName\nFROM countries c\nJOIN car_makers cm ON c.CountryId = cm.Country\nWHERE c.Continent = (SELECT ContId FROM continents WHERE ContinentName = 'Europe')\nGROUP BY c.CountryName\nHAVING COUNT(cm.Id) >= 3;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are the names of all European countries with at least 3 manufacturers?",
      "gold_sql": "SELECT T1.CountryName FROM COUNTRIES AS T1 JOIN CONTINENTS AS T2 ON T1.Continent  =  T2.ContId JOIN CAR_MAKERS AS T3 ON T1.CountryId  =  T3.Country WHERE T2.Continent  =  'europe' GROUP BY T1.CountryName HAVING count(*)  >=  3;",
      "predicted_sql": "SELECT c.CountryName\nFROM countries c\nJOIN car_makers cm ON c.CountryId = cm.Country\nJOIN continents con ON c.Continent = con.ContId\nWHERE con.Continent = 'Europe'\nGROUP BY c.CountryId, c.CountryName\nHAVING COUNT(cm.Id) >= 3;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the maximum horsepower and the make of the car models with 3 cylinders?",
      "gold_sql": "SELECT T2.horsepower ,  T1.Make FROM CAR_NAMES AS T1 JOIN CARS_DATA AS T2 ON T1.MakeId  =  T2.Id WHERE T2.cylinders  =  3 ORDER BY T2.horsepower DESC LIMIT 1;",
      "predicted_sql": "SELECT MAX(cd.Horsepower) AS MaxHorsepower, cn.Make\nFROM cars_data cd\nJOIN car_names cn ON cd.Id = cn.MakeId\nWHERE cd.Cylinders = 3\nGROUP BY cn.Make;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the largest amount of horsepower for the models with 3 cylinders and what make is it?",
      "gold_sql": "SELECT T2.horsepower ,  T1.Make FROM CAR_NAMES AS T1 JOIN CARS_DATA AS T2 ON T1.MakeId  =  T2.Id WHERE T2.cylinders  =  3 ORDER BY T2.horsepower DESC LIMIT 1;",
      "predicted_sql": "SELECT cm.Maker, MAX(cd.Horsepower) AS MaxHorsepower\nFROM cars_data cd\nJOIN car_names cn ON cd.Id = cn.MakeId\nJOIN model_list ml ON cn.Model = ml.Model\nJOIN car_makers cm ON ml.Maker = cm.Id\nWHERE cd.Cylinders = 3\nGROUP BY cm.Maker\nORDER BY MaxHorsepower DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Which model saves the most gasoline? That is to say, have the maximum miles per gallon.",
      "gold_sql": "SELECT T1.Model FROM CAR_NAMES AS T1 JOIN CARS_DATA AS T2 ON T1.MakeId  =  T2.Id ORDER BY T2.mpg DESC LIMIT 1;",
      "predicted_sql": "SELECT ml.Model\nFROM model_list ml\nJOIN cars_data cd ON ml.ModelId = cd.Id\nORDER BY CAST(cd.MPG AS REAL) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the car wmodel with the highest mpg?",
      "gold_sql": "SELECT T1.Model FROM CAR_NAMES AS T1 JOIN CARS_DATA AS T2 ON T1.MakeId  =  T2.Id ORDER BY T2.mpg DESC LIMIT 1;",
      "predicted_sql": "SELECT cl.Model\nFROM cars_data cd\nJOIN car_names cn ON cd.Id = cn.MakeId\nJOIN model_list ml ON cn.Model = ml.Model\nORDER BY CAST(cd.MPG AS REAL) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the average horsepower of the cars before 1980?",
      "gold_sql": "SELECT avg(horsepower) FROM CARS_DATA WHERE YEAR  <  1980;",
      "predicted_sql": "SELECT AVG(CAST(Horsepower AS REAL)) AS AverageHorsepower\nFROM cars_data\nWHERE Year < 1980;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the average horsepower for all cards produced before 1980?",
      "gold_sql": "SELECT avg(horsepower) FROM CARS_DATA WHERE YEAR  <  1980;",
      "predicted_sql": "SELECT AVG(CAST(Horsepower AS REAL)) AS AverageHorsepower\nFROM cars_data\nWHERE Year < 1980;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the average edispl of the cars of model volvo?",
      "gold_sql": "SELECT avg(T2.edispl) FROM CAR_NAMES AS T1 JOIN CARS_DATA AS T2 ON T1.MakeId  =  T2.Id WHERE T1.Model  =  'volvo';",
      "predicted_sql": "SELECT AVG(cd.Edispl) AS AverageEdispl\nFROM cars_data cd\nJOIN car_names cn ON cd.Id = cn.MakeId\nJOIN model_list ml ON cn.Model = ml.Model\nJOIN car_makers cm ON ml.Maker = cm.Id\nWHERE LOWER(ml.Model) = 'volvo';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the average edispl for all volvos?",
      "gold_sql": "SELECT avg(T2.edispl) FROM CAR_NAMES AS T1 JOIN CARS_DATA AS T2 ON T1.MakeId  =  T2.Id WHERE T1.Model  =  'volvo';",
      "predicted_sql": "SELECT AVG(c.Edispl) AS AverageEdispl\nFROM cars_data c\nJOIN car_names cn ON c.Id = cn.MakeId\nJOIN model_list ml ON cn.Model = ml.Model\nJOIN car_makers cm ON ml.Maker = cm.Id\nWHERE cm.Maker = 'Volvo';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the maximum accelerate for different number of cylinders?",
      "gold_sql": "SELECT max(Accelerate) ,  Cylinders FROM CARS_DATA GROUP BY Cylinders;",
      "predicted_sql": "SELECT Cylinders, MAX(Accelerate) AS MaxAccelerate\nFROM cars_data\nGROUP BY Cylinders;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the maximum accelerate for all the different cylinders?",
      "gold_sql": "SELECT max(Accelerate) ,  Cylinders FROM CARS_DATA GROUP BY Cylinders;",
      "predicted_sql": "SELECT Cylinders, MAX(Accelerate) AS MaxAccelerate\nFROM cars_data\nGROUP BY Cylinders;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Which model has the most version(make) of cars?",
      "gold_sql": "SELECT Model FROM CAR_NAMES GROUP BY Model ORDER BY count(*) DESC LIMIT 1;",
      "predicted_sql": "SELECT ml.Model, COUNT(cn.MakeId) AS VersionCount\nFROM model_list ml\nJOIN car_names cn ON ml.Model = cn.Model\nGROUP BY ml.Model\nORDER BY VersionCount DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What model has the most different versions?",
      "gold_sql": "SELECT Model FROM CAR_NAMES GROUP BY Model ORDER BY count(*) DESC LIMIT 1;",
      "predicted_sql": "SELECT ml.Model, COUNT(DISTINCT cd.Id) AS VersionCount\nFROM model_list ml\nJOIN car_names cn ON ml.Model = cn.Model\nJOIN cars_data cd ON cn.Model = cd.Model\nGROUP BY ml.Model\nORDER BY VersionCount DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How many cars have more than 4 cylinders?",
      "gold_sql": "SELECT count(*) FROM CARS_DATA WHERE Cylinders  >  4;",
      "predicted_sql": "SELECT COUNT(*) AS CarsWithMoreThan4Cylinders\nFROM cars_data\nWHERE Cylinders > 4;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the number of cars with more than 4 cylinders?",
      "gold_sql": "SELECT count(*) FROM CARS_DATA WHERE Cylinders  >  4;",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfCars\nFROM cars_data AS cd\nWHERE cd.Cylinders > 4;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "how many cars were produced in 1980?",
      "gold_sql": "SELECT count(*) FROM CARS_DATA WHERE YEAR  =  1980;",
      "predicted_sql": "SELECT COUNT(*) AS TotalCarsProduced\nFROM cars_data\nWHERE Year = 1980;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "In 1980, how many cars were made?",
      "gold_sql": "SELECT count(*) FROM CARS_DATA WHERE YEAR  =  1980;",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfCars\nFROM cars_data cd\nWHERE cd.Year = 1980;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How many car models were produced by the maker with full name American Motor Company?",
      "gold_sql": "SELECT count(*) FROM CAR_MAKERS AS T1 JOIN MODEL_LIST AS T2 ON T1.Id  =  T2.Maker WHERE T1.FullName  =  'American Motor Company';",
      "predicted_sql": "SELECT COUNT(*) AS ModelCount\nFROM car_names cn\nJOIN car_makers cm ON cn.MakeId = cm.Id\nWHERE cm.FullName = 'American Motor Company';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the number of car models created by the car maker American Motor Company?",
      "gold_sql": "SELECT count(*) FROM CAR_MAKERS AS T1 JOIN MODEL_LIST AS T2 ON T1.Id  =  T2.Maker WHERE T1.FullName  =  'American Motor Company';",
      "predicted_sql": "SELECT COUNT(DISTINCT ml.Model) AS NumberOfCarModels\nFROM car_makers cm\nJOIN model_list ml ON cm.Id = ml.Maker\nWHERE cm.Maker = 'American Motor Company';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Which makers designed more than 3 car models? List full name and the id.",
      "gold_sql": "SELECT T1.FullName ,  T1.Id FROM CAR_MAKERS AS T1 JOIN MODEL_LIST AS T2 ON T1.Id  =  T2.Maker GROUP BY T1.Id HAVING count(*)  >  3;",
      "predicted_sql": "SELECT cm.FullName, cm.Id\nFROM car_makers cm\nJOIN model_list ml ON cm.Id = ml.Maker\nGROUP BY cm.FullName, cm.Id\nHAVING COUNT(ml.Model) > 3;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are the names and ids of all makers with more than 3 models?",
      "gold_sql": "SELECT T1.FullName ,  T1.Id FROM CAR_MAKERS AS T1 JOIN MODEL_LIST AS T2 ON T1.Id  =  T2.Maker GROUP BY T1.Id HAVING count(*)  >  3;",
      "predicted_sql": "SELECT cm.Id, cm.Maker\nFROM car_makers cm\nJOIN model_list ml ON cm.Id = ml.Maker\nGROUP BY cm.Id, cm.Maker\nHAVING COUNT(ml.ModelId) > 3;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Which distinctive models are produced by maker with the full name General Motors or weighing more than 3500?",
      "gold_sql": "SELECT DISTINCT T2.Model FROM CAR_NAMES AS T1 JOIN MODEL_LIST AS T2 ON T1.Model  =  T2.Model JOIN CAR_MAKERS AS T3 ON T2.Maker  =  T3.Id JOIN CARS_DATA AS T4 ON T1.MakeId  =  T4.Id WHERE T3.FullName  =  'General Motors' OR T4.weight  >  3500;",
      "predicted_sql": "SELECT DISTINCT ml.Model\nFROM model_list ml\nJOIN car_makers cm ON ml.Maker = cm.Id\nJOIN car_names cn ON ml.Model = cn.Model\nJOIN cars_data cd ON cn.MakeId = cd.Id\nWHERE cm.FullName = 'General Motors' OR cd.Weight > 3500;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are the different models created by either the car maker General Motors or weighed more than 3500?",
      "gold_sql": "SELECT DISTINCT T2.Model FROM CAR_NAMES AS T1 JOIN MODEL_LIST AS T2 ON T1.Model  =  T2.Model JOIN CAR_MAKERS AS T3 ON T2.Maker  =  T3.Id JOIN CARS_DATA AS T4 ON T1.MakeId  =  T4.Id WHERE T3.FullName  =  'General Motors' OR T4.weight  >  3500;",
      "predicted_sql": "SELECT DISTINCT ml.Model\nFROM model_list ml\nJOIN car_makers cm ON ml.Maker = cm.Id\nJOIN car_names cn ON ml.Model = cn.Model\nJOIN cars_data cd ON cn.MakeId = cd.Id\nWHERE cm.Maker = 'General Motors' OR cd.Weight > 3500;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "In which years cars were produced weighing no less than 3000 and no more than 4000?",
      "gold_sql": "SELECT DISTINCT T1.Year FROM CARS_DATA AS T1 WHERE T1.Weight  >  3000 AND T1.weight  <  4000;",
      "predicted_sql": "SELECT DISTINCT cd.Year\nFROM cars_data cd\nWHERE cd.Weight >= 3000 AND cd.Weight <= 4000;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are the different years in which there were cars produced that weighed less than 4000 and also cars that weighted more than 3000?",
      "gold_sql": "SELECT DISTINCT T1.Year FROM CARS_DATA AS T1 WHERE T1.Weight  >  3000 AND T1.weight  <  4000;",
      "predicted_sql": "SELECT DISTINCT cd.Year\nFROM cars_data cd\nWHERE cd.Weight < 4000 OR cd.Weight > 3000;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the horsepower of the car with the largest accelerate?",
      "gold_sql": "SELECT T1.horsepower FROM CARS_DATA AS T1 ORDER BY T1.accelerate DESC LIMIT 1;",
      "predicted_sql": "SELECT cd.Horsepower\nFROM cars_data cd\nORDER BY cd.Accelerate DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the horsepower of the car with the greatest accelerate?",
      "gold_sql": "SELECT T1.horsepower FROM CARS_DATA AS T1 ORDER BY T1.accelerate DESC LIMIT 1;",
      "predicted_sql": "SELECT c.Horsepower\nFROM cars_data c\nORDER BY c.Accelerate DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "For model volvo, how many cylinders does the car with the least accelerate have?",
      "gold_sql": "SELECT T1.cylinders FROM CARS_DATA AS T1 JOIN CAR_NAMES AS T2 ON T1.Id  =  T2.MakeId WHERE T2.Model  =  'volvo' ORDER BY T1.accelerate ASC LIMIT 1;",
      "predicted_sql": "SELECT c.Cylinders\nFROM cars_data c\nJOIN car_names cn ON c.Id = cn.MakeId\nJOIN model_list ml ON cn.Model = ml.Model\nWHERE ml.Model = 'volvo'\nORDER BY c.Accelerate ASC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "For a volvo model, how many cylinders does the version with least accelerate have?",
      "gold_sql": "SELECT T1.cylinders FROM CARS_DATA AS T1 JOIN CAR_NAMES AS T2 ON T1.Id  =  T2.MakeId WHERE T2.Model  =  'volvo' ORDER BY T1.accelerate ASC LIMIT 1;",
      "predicted_sql": "SELECT cd.Cylinders\nFROM cars_data cd\nJOIN car_names cn ON cd.Id = cn.MakeId\nJOIN model_list ml ON cn.Model = ml.Model\nWHERE ml.Maker = (SELECT Id FROM car_makers WHERE Maker = 'Volvo')\nORDER BY cd.Accelerate ASC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How many cars have a larger accelerate than the car with the largest horsepower?",
      "gold_sql": "SELECT COUNT(*) FROM CARS_DATA WHERE Accelerate  >  ( SELECT Accelerate FROM CARS_DATA ORDER BY Horsepower DESC LIMIT 1 );",
      "predicted_sql": "SELECT COUNT(*) AS CarCount\nFROM cars_data c\nWHERE c.Accelerate > (SELECT MAX(CAST(Horsepower AS REAL)) FROM cars_data);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the number of cars with a greater accelerate than the one with the most horsepower?",
      "gold_sql": "SELECT COUNT(*) FROM CARS_DATA WHERE Accelerate  >  ( SELECT Accelerate FROM CARS_DATA ORDER BY Horsepower DESC LIMIT 1 );",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfCars\nFROM cars_data c\nWHERE c.Accelerate > (SELECT MAX(CAST(c2.Horsepower AS REAL)) \n                       FROM cars_data c2);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How many countries has more than 2 car makers?",
      "gold_sql": "SELECT COUNT(*) FROM ( SELECT T1.CountryId ,  COUNT(*) FROM COUNTRIES AS T1 JOIN CAR_MAKERS AS T2 ON T1.CountryId  =  T2.Country GROUP BY T1.CountryId HAVING count(*)  >  2 );",
      "predicted_sql": "SELECT COUNT(*) AS CountryCount\nFROM (\n    SELECT cm.Country, COUNT(cm.Id) AS MakerCount\n    FROM car_makers cm\n    GROUP BY cm.Country\n    HAVING COUNT(cm.Id) > 2\n) AS subquery;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the number of countries with more than 2 car makers?",
      "gold_sql": "SELECT COUNT(*) FROM ( SELECT T1.CountryId ,  COUNT(*) FROM COUNTRIES AS T1 JOIN CAR_MAKERS AS T2 ON T1.CountryId  =  T2.Country GROUP BY T1.CountryId HAVING count(*)  >  2 );",
      "predicted_sql": "SELECT COUNT(*) AS CountryCount\nFROM (\n    SELECT c.CountryId\n    FROM car_makers cm\n    JOIN countries c ON cm.Country = c.CountryId\n    GROUP BY c.CountryId\n    HAVING COUNT(cm.Id) > 2\n) AS subquery;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "How many cars has over 6 cylinders?",
      "gold_sql": "SELECT COUNT(*) FROM CARS_DATA WHERE Cylinders  >  6;",
      "predicted_sql": "SELECT COUNT(*) AS Cars_Over_6_Cylinders\nFROM cars_data\nWHERE Cylinders > 6;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the number of carsw ith over 6 cylinders?",
      "gold_sql": "SELECT COUNT(*) FROM CARS_DATA WHERE Cylinders  >  6;",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfCars\nFROM cars_data\nWHERE Cylinders > 6;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "For the cars with 4 cylinders, which model has the largest horsepower?",
      "gold_sql": "SELECT T1.Model FROM CAR_NAMES AS T1 JOIN CARS_DATA AS T2 ON T1.MakeId  =  T2.Id WHERE T2.Cylinders  =  4 ORDER BY T2.horsepower DESC LIMIT 1;",
      "predicted_sql": "SELECT mdl.Model, MAX(CAST(cd.Horsepower AS INTEGER)) AS MaxHorsepower\nFROM cars_data cd\nJOIN model_list mdl ON cd.Id = mdl.ModelId\nWHERE cd.Cylinders = 4\nGROUP BY mdl.Model\nORDER BY MaxHorsepower DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "For all of the 4 cylinder cars, which model has the most horsepower?",
      "gold_sql": "SELECT T1.Model FROM CAR_NAMES AS T1 JOIN CARS_DATA AS T2 ON T1.MakeId  =  T2.Id WHERE T2.Cylinders  =  4 ORDER BY T2.horsepower DESC LIMIT 1;",
      "predicted_sql": "SELECT cl.Model\nFROM cars_data cd\nJOIN car_names cn ON cd.Id = cn.MakeId\nJOIN model_list ml ON cn.Model = ml.Model\nJOIN car_makers cm ON ml.Maker = cm.Id\nWHERE cd.Cylinders = 4\nORDER BY CAST(cd.Horsepower AS INTEGER) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Among the cars with more than lowest horsepower, which ones do not have more than 3 cylinders? List the car makeid and make name.",
      "gold_sql": "SELECT T2.MakeId ,  T2.Make FROM CARS_DATA AS T1 JOIN CAR_NAMES AS T2 ON T1.Id  =  T2.MakeId WHERE T1.Horsepower  >  (SELECT min(Horsepower) FROM CARS_DATA) AND T1.Cylinders  <=  3;",
      "predicted_sql": "SELECT cn.MakeId, cn.Make\nFROM car_names cn\nJOIN cars_data cd ON cn.MakeId = cd.Id\nWHERE cd.Horsepower IS NOT NULL \nAND cd.Horsepower > (SELECT MIN(Horsepower) FROM cars_data WHERE Horsepower IS NOT NULL)\nAND (cd.Cylinders IS NULL OR cd.Cylinders <= 3);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Among the cars that do not have the minimum horsepower, what are the make ids and names of al those with less than 4 cylinders?",
      "gold_sql": "SELECT T2.MakeId ,  T2.Make FROM CARS_DATA AS T1 JOIN CAR_NAMES AS T2 ON T1.Id  =  T2.MakeId WHERE T1.Horsepower  >  (SELECT min(Horsepower) FROM CARS_DATA) AND T1.Cylinders  <=  3;",
      "predicted_sql": "SELECT cn.MakeId, cn.Make\nFROM cars_data cd\nJOIN car_names cn ON cd.Id = cn.MakeId\nWHERE cd.Cylinders < 4 AND cd.Horsepower IS NOT NULL\nAND cd.Horsepower < (SELECT MIN(CAST(Horsepower AS REAL)) FROM cars_data WHERE Horsepower IS NOT NULL);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the maximum miles per gallon of the car with 8 cylinders or produced before 1980?",
      "gold_sql": "SELECT mpg FROM CARS_DATA WHERE Cylinders  =  8 OR YEAR  <  1980 ORDER BY mpg DESC LIMIT 1;",
      "predicted_sql": "SELECT MAX(CAST(MPG AS REAL)) AS MaxMPG\nFROM cars_data\nWHERE Cylinders = 8 OR Year < 1980;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What is the maximum mpg of the cars that had 8 cylinders or that were produced before 1980?",
      "gold_sql": "SELECT mpg FROM CARS_DATA WHERE Cylinders  =  8 OR YEAR  <  1980 ORDER BY mpg DESC LIMIT 1;",
      "predicted_sql": "SELECT MAX(CAST(cars.MPG AS REAL)) AS MaxMPG\nFROM cars_data AS cars\nWHERE cars.Cylinders = 8 OR cars.Year < 1980;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Which models are lighter than 3500 but not built by the 'Ford Motor Company'?",
      "gold_sql": "SELECT DISTINCT T1.model FROM MODEL_LIST AS T1 JOIN CAR_NAMES AS T2 ON T1.Model  =  T2.Model JOIN CARS_DATA AS T3 ON T2.MakeId  =  T3.Id JOIN CAR_MAKERS AS T4 ON T1.Maker  =  T4.Id WHERE T3.weight  <  3500 AND T4.FullName != 'Ford Motor Company';",
      "predicted_sql": "SELECT ml.Model\nFROM model_list AS ml\nJOIN car_makers AS cm ON ml.Maker = cm.Id\nJOIN car_names AS cn ON ml.Model = cn.Model\nJOIN cars_data AS cd ON cn.MakeId = cd.Id\nWHERE cd.Weight < 3500 AND cm.FullName <> 'Ford Motor Company';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are the different models wthat are lighter than 3500 but were not built by the Ford Motor Company?",
      "gold_sql": "SELECT DISTINCT T1.model FROM MODEL_LIST AS T1 JOIN CAR_NAMES AS T2 ON T1.Model  =  T2.Model JOIN CARS_DATA AS T3 ON T2.MakeId  =  T3.Id JOIN CAR_MAKERS AS T4 ON T1.Maker  =  T4.Id WHERE T3.weight  <  3500 AND T4.FullName != 'Ford Motor Company';",
      "predicted_sql": "SELECT DISTINCT ml.Model\nFROM model_list AS ml\nJOIN car_names AS cn ON ml.Model = cn.Model\nJOIN cars_data AS cd ON cn.MakeId = cd.Id\nJOIN car_makers AS cm ON ml.Maker = cm.Id\nWHERE cd.Weight < 3500 AND cm.Maker <> 'Ford Motor Company';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are the name of the countries where there is not a single car maker?",
      "gold_sql": "SELECT CountryName FROM countries EXCEPT SELECT T1.CountryName FROM countries AS T1 JOIN CAR_MAKERS AS T2 ON T1.countryId  =  T2.Country;",
      "predicted_sql": "SELECT c.CountryName\nFROM countries c\nLEFT JOIN car_makers cm ON c.CountryId = cm.Country\nWHERE cm.Id IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are the names of the countries with no car makers?",
      "gold_sql": "SELECT CountryName FROM countries EXCEPT SELECT T1.CountryName FROM countries AS T1 JOIN CAR_MAKERS AS T2 ON T1.countryId  =  T2.Country;",
      "predicted_sql": "SELECT c.CountryName\nFROM countries c\nLEFT JOIN car_makers cm ON c.CountryId = cm.Country\nWHERE cm.Id IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "Which are the car makers which produce at least 2 models and more than 3 car makes? List the id and the maker.",
      "gold_sql": "SELECT T1.Id ,  T1.Maker FROM CAR_MAKERS AS T1 JOIN MODEL_LIST AS T2 ON T1.Id  =  T2.Maker GROUP BY T1.Id HAVING count(*)  >=  2 INTERSECT SELECT T1.Id ,  T1.Maker FROM CAR_MAKERS AS T1 JOIN MODEL_LIST AS T2 ON T1.Id  =  T2.Maker JOIN CAR_NAMES AS T3 ON T2.model  =  T3.model GROUP BY T1.Id HAVING count(*)  >  3;",
      "predicted_sql": "SELECT cm.Id, cm.Maker\nFROM car_makers cm\nJOIN model_list ml ON cm.Id = ml.Maker\nJOIN car_names cn ON cn.Model = ml.Model\nGROUP BY cm.Id, cm.Maker\nHAVING COUNT(DISTINCT ml.Model) >= 2 AND COUNT(DISTINCT cn.Make) > 3;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are the ids and makers of all car makers that produce at least 2 models and make more than 3 cars?",
      "gold_sql": "SELECT T1.Id ,  T1.Maker FROM CAR_MAKERS AS T1 JOIN MODEL_LIST AS T2 ON T1.Id  =  T2.Maker GROUP BY T1.Id HAVING count(*)  >=  2 INTERSECT SELECT T1.Id ,  T1.Maker FROM CAR_MAKERS AS T1 JOIN MODEL_LIST AS T2 ON T1.Id  =  T2.Maker JOIN CAR_NAMES AS T3 ON T2.model  =  T3.model GROUP BY T1.Id HAVING count(*)  >  3;",
      "predicted_sql": "SELECT cm.Id, cm.Maker\nFROM car_makers cm\nJOIN model_list ml ON cm.Id = ml.Maker\nJOIN car_names cn ON ml.ModelId = cn.MakeId\nGROUP BY cm.Id, cm.Maker\nHAVING COUNT(DISTINCT ml.ModelId) >= 2 AND COUNT(cn.MakeId) > 3;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are the id and names of the countries which have more than 3 car makers or produce the 'fiat' model?",
      "gold_sql": "SELECT T1.countryId ,  T1.CountryName FROM Countries AS T1 JOIN CAR_MAKERS AS T2 ON T1.CountryId  =  T2.Country GROUP BY T1.countryId HAVING count(*)  >  3 UNION SELECT T1.countryId ,  T1.CountryName FROM Countries AS T1 JOIN CAR_MAKERS AS T2 ON T1.CountryId  =  T2.Country JOIN MODEL_LIST AS T3 ON T2.Id  =  T3.Maker WHERE T3.Model  =  'fiat';",
      "predicted_sql": "SELECT DISTINCT c.CountryId, c.CountryName\nFROM countries c\nLEFT JOIN car_makers cm ON c.CountryId = cm.Country\nLEFT JOIN model_list ml ON cm.Id = ml.Maker\nWHERE (SELECT COUNT(*) FROM car_makers WHERE Country = c.CountryId) > 3\n   OR ml.Model = 'fiat';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "car_1",
      "question": "What are the ids and names of all countries that either have more than 3 car makers or produce fiats?",
      "gold_sql": "SELECT T1.countryId ,  T1.CountryName FROM Countries AS T1 JOIN CAR_MAKERS AS T2 ON T1.CountryId  =  T2.Country GROUP BY T1.countryId HAVING count(*)  >  3 UNION SELECT T1.countryId ,  T1.CountryName FROM Countries AS T1 JOIN CAR_MAKERS AS T2 ON T1.CountryId  =  T2.Country JOIN MODEL_LIST AS T3 ON T2.Id  =  T3.Maker WHERE T3.Model  =  'fiat';",
      "predicted_sql": "SELECT DISTINCT c.CountryId, c.CountryName\nFROM countries AS c\nLEFT JOIN car_makers AS cm ON c.CountryId = cm.Country\nGROUP BY c.CountryId, c.CountryName\nHAVING COUNT(cm.Id) > 3 OR EXISTS (\n    SELECT 1 \n    FROM car_makers AS cm2 \n    WHERE cm2.Maker = 'Fiat' AND cm2.Country = c.CountryId\n);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which country does Airline \"JetBlue Airways\" belong to?",
      "gold_sql": "SELECT Country FROM AIRLINES WHERE Airline  =  \"JetBlue Airways\"",
      "predicted_sql": "SELECT a.Country\nFROM airlines a\nWHERE a.Airline = 'JetBlue Airways';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What country is Jetblue Airways affiliated with?",
      "gold_sql": "SELECT Country FROM AIRLINES WHERE Airline  =  \"JetBlue Airways\"",
      "predicted_sql": "SELECT Country \nFROM airlines \nWHERE Airline = 'Jetblue Airways';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What is the abbreviation of Airline \"JetBlue Airways\"?",
      "gold_sql": "SELECT Abbreviation FROM AIRLINES WHERE Airline  =  \"JetBlue Airways\"",
      "predicted_sql": "SELECT a.Abbreviation \nFROM airlines a \nWHERE a.Airline = 'JetBlue Airways';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which abbreviation corresponds to Jetblue Airways?",
      "gold_sql": "SELECT Abbreviation FROM AIRLINES WHERE Airline  =  \"JetBlue Airways\"",
      "predicted_sql": "SELECT Abbreviation \nFROM airlines AS a \nWHERE a.Airline = 'Jetblue Airways';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "List all airline names and their abbreviations in \"USA\".",
      "gold_sql": "SELECT Airline ,  Abbreviation FROM AIRLINES WHERE Country  =  \"USA\"",
      "predicted_sql": "SELECT a.Airline, a.Abbreviation\nFROM airlines AS a\nWHERE a.Country = 'USA';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What are the airline names and abbreviations for airlines in the USA?",
      "gold_sql": "SELECT Airline ,  Abbreviation FROM AIRLINES WHERE Country  =  \"USA\"",
      "predicted_sql": "SELECT a.Airline, a.Abbreviation \nFROM airlines a \nWHERE a.Country = 'USA';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "List the airport code and name in the city of Anthony.",
      "gold_sql": "SELECT AirportCode ,  AirportName FROM AIRPORTS WHERE city  =  \"Anthony\"",
      "predicted_sql": "SELECT a.AirportCode, a.AirportName\nFROM airports a\nWHERE a.City = 'Anthony';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Give the airport code and airport name corresonding to the city Anthony.",
      "gold_sql": "SELECT AirportCode ,  AirportName FROM AIRPORTS WHERE city  =  \"Anthony\"",
      "predicted_sql": "SELECT a.AirportCode, a.AirportName\nFROM airports a\nWHERE a.City = 'Anthony';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many airlines do we have?",
      "gold_sql": "SELECT count(*) FROM AIRLINES",
      "predicted_sql": "SELECT COUNT(*) AS TotalAirlines FROM airlines;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What is the total number of airlines?",
      "gold_sql": "SELECT count(*) FROM AIRLINES",
      "predicted_sql": "SELECT COUNT(*) AS TotalAirlines FROM airlines;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many airports do we have?",
      "gold_sql": "SELECT count(*) FROM AIRPORTS",
      "predicted_sql": "SELECT COUNT(*) AS TotalAirports FROM airports;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Return the number of  airports.",
      "gold_sql": "SELECT count(*) FROM AIRPORTS",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfAirports FROM airports;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many flights do we have?",
      "gold_sql": "SELECT count(*) FROM FLIGHTS",
      "predicted_sql": "SELECT COUNT(*) AS TotalFlights FROM flights;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Return the number of flights.",
      "gold_sql": "SELECT count(*) FROM FLIGHTS",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfFlights FROM flights;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which airline has abbreviation 'UAL'?",
      "gold_sql": "SELECT Airline FROM AIRLINES WHERE Abbreviation  =  \"UAL\"",
      "predicted_sql": "SELECT Airline \nFROM airlines \nWHERE Abbreviation = 'UAL';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Give the airline with abbreviation 'UAL'.",
      "gold_sql": "SELECT Airline FROM AIRLINES WHERE Abbreviation  =  \"UAL\"",
      "predicted_sql": "SELECT Airline FROM airlines WHERE Abbreviation = 'UAL';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many airlines are from USA?",
      "gold_sql": "SELECT count(*) FROM AIRLINES WHERE Country  =  \"USA\"",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfAirlines\nFROM airlines AS a\nWHERE a.Country = 'USA';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Return the number of airlines in the USA.",
      "gold_sql": "SELECT count(*) FROM AIRLINES WHERE Country  =  \"USA\"",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfAirlines\nFROM airlines\nWHERE Country = 'USA';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which city and country is the Alton airport at?",
      "gold_sql": "SELECT City ,  Country FROM AIRPORTS WHERE AirportName  =  \"Alton\"",
      "predicted_sql": "SELECT a.City, a.Country\nFROM airports a\nWHERE a.AirportCode = 'Alton';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Give the city and country for the Alton airport.",
      "gold_sql": "SELECT City ,  Country FROM AIRPORTS WHERE AirportName  =  \"Alton\"",
      "predicted_sql": "SELECT a.City, a.Country\nFROM airports a\nWHERE a.AirportName = 'Alton';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What is the airport name for airport 'AKO'?",
      "gold_sql": "SELECT AirportName FROM AIRPORTS WHERE AirportCode  =  \"AKO\"",
      "predicted_sql": "SELECT AirportName \nFROM airports \nWHERE AirportCode = 'AKO';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Return the name of the airport with code 'AKO'.",
      "gold_sql": "SELECT AirportName FROM AIRPORTS WHERE AirportCode  =  \"AKO\"",
      "predicted_sql": "SELECT AirportName \nFROM airports \nWHERE AirportCode = 'AKO';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What are airport names at City 'Aberdeen'?",
      "gold_sql": "SELECT AirportName FROM AIRPORTS WHERE City = \"Aberdeen\"",
      "predicted_sql": "SELECT a.AirportName\nFROM airports a\nWHERE a.City = 'Aberdeen';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What are the names of airports in Aberdeen?",
      "gold_sql": "SELECT AirportName FROM AIRPORTS WHERE City = \"Aberdeen\"",
      "predicted_sql": "SELECT a.AirportName \nFROM airports a \nWHERE a.City = 'Aberdeen';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many flights depart from 'APG'?",
      "gold_sql": "SELECT count(*) FROM FLIGHTS WHERE SourceAirport  =  \"APG\"",
      "predicted_sql": "SELECT COUNT(*) AS FlightCount\nFROM flights f\nWHERE f.SourceAirport = 'APG';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Count the number of flights departing from 'APG'.",
      "gold_sql": "SELECT count(*) FROM FLIGHTS WHERE SourceAirport  =  \"APG\"",
      "predicted_sql": "SELECT COUNT(*) AS FlightCount\nFROM flights f\nWHERE f.SourceAirport = 'APG';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many flights have destination ATO?",
      "gold_sql": "SELECT count(*) FROM FLIGHTS WHERE DestAirport  =  \"ATO\"",
      "predicted_sql": "SELECT COUNT(*) AS FlightCount\nFROM flights f\nWHERE f.DestAirport = 'ATO';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Count the number of flights into ATO.",
      "gold_sql": "SELECT count(*) FROM FLIGHTS WHERE DestAirport  =  \"ATO\"",
      "predicted_sql": "SELECT COUNT(*) AS FlightCount\nFROM flights f\nWHERE f.DestAirport = 'ATO';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many flights depart from City Aberdeen?",
      "gold_sql": "SELECT count(*) FROM FLIGHTS AS T1 JOIN AIRPORTS AS T2 ON T1.SourceAirport  =  T2.AirportCode WHERE T2.City  =  \"Aberdeen\"",
      "predicted_sql": "SELECT COUNT(*) AS FlightCount\nFROM flights f\nJOIN airports a ON f.SourceAirport = a.AirportCode\nWHERE a.City = 'Aberdeen';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Return the number of flights departing from Aberdeen.",
      "gold_sql": "SELECT count(*) FROM FLIGHTS AS T1 JOIN AIRPORTS AS T2 ON T1.SourceAirport  =  T2.AirportCode WHERE T2.City  =  \"Aberdeen\"",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfFlights\nFROM flights f\nJOIN airports a ON f.SourceAirport = a.AirportCode\nWHERE a.City = 'Aberdeen';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many flights arriving in Aberdeen city?",
      "gold_sql": "SELECT count(*) FROM FLIGHTS AS T1 JOIN AIRPORTS AS T2 ON T1.DestAirport  =  T2.AirportCode WHERE T2.City  =  \"Aberdeen\"",
      "predicted_sql": "SELECT COUNT(*) AS FlightCount\nFROM flights f\nJOIN airports a ON f.DestAirport = a.AirportCode\nWHERE a.City = 'Aberdeen';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Return the number of flights arriving in Aberdeen.",
      "gold_sql": "SELECT count(*) FROM FLIGHTS AS T1 JOIN AIRPORTS AS T2 ON T1.DestAirport  =  T2.AirportCode WHERE T2.City  =  \"Aberdeen\"",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfFlights\nFROM flights f\nJOIN airports a ON f.DestAirport = a.AirportCode\nWHERE a.City = 'Aberdeen';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many flights depart from City 'Aberdeen' and have destination City 'Ashley'?",
      "gold_sql": "SELECT count(*) FROM FLIGHTS AS T1 JOIN AIRPORTS AS T2 ON T1.DestAirport  =  T2.AirportCode JOIN AIRPORTS AS T3 ON T1.SourceAirport  =  T3.AirportCode WHERE T2.City  =  \"Ashley\" AND T3.City  =  \"Aberdeen\"",
      "predicted_sql": "SELECT COUNT(*) AS FlightCount\nFROM flights f\nJOIN airports a1 ON f.SourceAirport = a1.AirportCode\nJOIN airports a2 ON f.DestAirport = a2.AirportCode\nWHERE a1.City = 'Aberdeen' AND a2.City = 'Ashley';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many flights fly from Aberdeen to Ashley?",
      "gold_sql": "SELECT count(*) FROM FLIGHTS AS T1 JOIN AIRPORTS AS T2 ON T1.DestAirport  =  T2.AirportCode JOIN AIRPORTS AS T3 ON T1.SourceAirport  =  T3.AirportCode WHERE T2.City  =  \"Ashley\" AND T3.City  =  \"Aberdeen\"",
      "predicted_sql": "SELECT COUNT(*) AS FlightCount\nFROM flights f\nJOIN airports a1 ON f.SourceAirport = a1.AirportCode\nJOIN airports a2 ON f.DestAirport = a2.AirportCode\nWHERE a1.City = 'Aberdeen' AND a2.City = 'Ashley';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many flights does airline 'JetBlue Airways' have?",
      "gold_sql": "SELECT count(*) FROM FLIGHTS AS T1 JOIN AIRLINES AS T2 ON T1.Airline  =  T2.uid WHERE T2.Airline = \"JetBlue Airways\"",
      "predicted_sql": "SELECT COUNT(*) AS FlightCount\nFROM flights f\nJOIN airlines a ON f.Airline = a.uid\nWHERE a.Airline = 'JetBlue Airways';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Give the number of Jetblue Airways flights.",
      "gold_sql": "SELECT count(*) FROM FLIGHTS AS T1 JOIN AIRLINES AS T2 ON T1.Airline  =  T2.uid WHERE T2.Airline = \"JetBlue Airways\"",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfJetblueFlights\nFROM flights f\nJOIN airlines a ON f.Airline = a.uid\nWHERE a.Airline = 'Jetblue Airways';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many 'United Airlines' flights go to Airport 'ASY'?",
      "gold_sql": "SELECT count(*) FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T2.Airline  =  T1.uid WHERE T1.Airline  =  \"United Airlines\" AND T2.DestAirport  =  \"ASY\"",
      "predicted_sql": "SELECT COUNT(*) AS FlightCount\nFROM flights f\nJOIN airlines a ON f.Airline = a.uid\nWHERE a.Airline = 'United Airlines' AND f.DestAirport = 'ASY';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Count the number of United Airlines flights arriving in ASY Airport.",
      "gold_sql": "SELECT count(*) FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T2.Airline  =  T1.uid WHERE T1.Airline  =  \"United Airlines\" AND T2.DestAirport  =  \"ASY\"",
      "predicted_sql": "SELECT COUNT(*) AS FlightCount\nFROM flights f\nJOIN airlines a ON f.Airline = a.uid\nWHERE a.Airline = 'United Airlines' AND f.DestAirport = 'ASY';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many 'United Airlines' flights depart from Airport 'AHD'?",
      "gold_sql": "SELECT count(*) FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T2.Airline  =  T1.uid WHERE T1.Airline  =  \"United Airlines\" AND T2.SourceAirport  =  \"AHD\"",
      "predicted_sql": "SELECT COUNT(*) AS FlightCount\nFROM flights f\nJOIN airlines a ON f.Airline = a.uid\nWHERE a.Airline = 'United Airlines' AND f.SourceAirport = 'AHD';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Return the number of United Airlines flights leaving from AHD Airport.",
      "gold_sql": "SELECT count(*) FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T2.Airline  =  T1.uid WHERE T1.Airline  =  \"United Airlines\" AND T2.SourceAirport  =  \"AHD\"",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfFlights\nFROM flights f\nJOIN airlines a ON f.Airline = a.uid\nWHERE a.Airline = 'United Airlines' AND f.SourceAirport = 'AHD';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many United Airlines flights go to City 'Aberdeen'?",
      "gold_sql": "SELECT count(*) FROM FLIGHTS AS T1 JOIN AIRPORTS AS T2 ON T1.DestAirport  =  T2.AirportCode JOIN AIRLINES AS T3 ON T3.uid  =  T1.Airline WHERE T2.City  =  \"Aberdeen\" AND T3.Airline  =  \"United Airlines\"",
      "predicted_sql": "SELECT COUNT(*) AS FlightCount\nFROM flights f\nJOIN airlines a ON f.Airline = a.uid\nJOIN airports ap ON f.DestAirport = ap.AirportCode\nWHERE a.Airline = 'United Airlines' AND ap.City = 'Aberdeen';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Count the number of United Airlines flights that arrive in Aberdeen.",
      "gold_sql": "SELECT count(*) FROM FLIGHTS AS T1 JOIN AIRPORTS AS T2 ON T1.DestAirport  =  T2.AirportCode JOIN AIRLINES AS T3 ON T3.uid  =  T1.Airline WHERE T2.City  =  \"Aberdeen\" AND T3.Airline  =  \"United Airlines\"",
      "predicted_sql": "SELECT COUNT(*) AS UnitedAirlinesFlightsToAberdeen\nFROM flights f\nJOIN airlines a ON f.Airline = a.uid\nWHERE a.Airline = 'United Airlines' AND f.DestAirport IN (SELECT AirportCode FROM airports WHERE City = 'Aberdeen');",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which city has most number of arriving flights?",
      "gold_sql": "SELECT T1.City FROM AIRPORTS AS T1 JOIN FLIGHTS AS T2 ON T1.AirportCode  =  T2.DestAirport GROUP BY T1.City ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT a.City, COUNT(f.DestAirport) AS ArrivingFlights\nFROM flights f\nJOIN airports a ON f.DestAirport = a.AirportCode\nGROUP BY a.City\nORDER BY ArrivingFlights DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which city has the most frequent destination airport?",
      "gold_sql": "SELECT T1.City FROM AIRPORTS AS T1 JOIN FLIGHTS AS T2 ON T1.AirportCode  =  T2.DestAirport GROUP BY T1.City ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT a.City, COUNT(f.DestAirport) AS DestinationCount\nFROM flights f\nJOIN airports a ON f.DestAirport = a.AirportCode\nGROUP BY a.City\nORDER BY DestinationCount DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which city has most number of departing flights?",
      "gold_sql": "SELECT T1.City FROM AIRPORTS AS T1 JOIN FLIGHTS AS T2 ON T1.AirportCode  =  T2.SourceAirport GROUP BY T1.City ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT a.City, COUNT(f.FlightNo) AS DepartingFlights\nFROM flights f\nJOIN airports a ON f.SourceAirport = a.AirportCode\nGROUP BY a.City\nORDER BY DepartingFlights DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which city is the most frequent source airport?",
      "gold_sql": "SELECT T1.City FROM AIRPORTS AS T1 JOIN FLIGHTS AS T2 ON T1.AirportCode  =  T2.SourceAirport GROUP BY T1.City ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT a.City, COUNT(f.SourceAirport) AS FlightCount\nFROM flights f\nJOIN airports a ON f.SourceAirport = a.AirportCode\nGROUP BY a.City\nORDER BY FlightCount DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What is the code of airport that has the highest number of flights?",
      "gold_sql": "SELECT T1.AirportCode FROM AIRPORTS AS T1 JOIN FLIGHTS AS T2 ON T1.AirportCode  =  T2.DestAirport OR T1.AirportCode  =  T2.SourceAirport GROUP BY T1.AirportCode ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT SourceAirport AS AirportCode\nFROM flights\nGROUP BY SourceAirport\nORDER BY COUNT(*) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What is the airport code of the airport with the most flights?",
      "gold_sql": "SELECT T1.AirportCode FROM AIRPORTS AS T1 JOIN FLIGHTS AS T2 ON T1.AirportCode  =  T2.DestAirport OR T1.AirportCode  =  T2.SourceAirport GROUP BY T1.AirportCode ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT f.SourceAirport AS AirportCode\nFROM flights f\nGROUP BY f.SourceAirport\nORDER BY COUNT(*) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What is the code of airport that has fewest number of flights?",
      "gold_sql": "SELECT T1.AirportCode FROM AIRPORTS AS T1 JOIN FLIGHTS AS T2 ON T1.AirportCode  =  T2.DestAirport OR T1.AirportCode  =  T2.SourceAirport GROUP BY T1.AirportCode ORDER BY count(*) LIMIT 1",
      "predicted_sql": "SELECT f.SourceAirport AS AirportCode\nFROM flights f\nGROUP BY f.SourceAirport\nORDER BY COUNT(*) ASC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Give the code of the airport with the least flights.",
      "gold_sql": "SELECT T1.AirportCode FROM AIRPORTS AS T1 JOIN FLIGHTS AS T2 ON T1.AirportCode  =  T2.DestAirport OR T1.AirportCode  =  T2.SourceAirport GROUP BY T1.AirportCode ORDER BY count(*) LIMIT 1",
      "predicted_sql": "SELECT f.SourceAirport AS AirportCode\nFROM flights f\nGROUP BY f.SourceAirport\nORDER BY COUNT(*) ASC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which airline has most number of flights?",
      "gold_sql": "SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline GROUP BY T1.Airline ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT a.Airline, COUNT(f.FlightNo) AS FlightCount\nFROM airlines a\nJOIN flights f ON a.uid = f.Airline\nGROUP BY a.Airline\nORDER BY FlightCount DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What airline serves the most flights?",
      "gold_sql": "SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline GROUP BY T1.Airline ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT a.Airline, COUNT(f.FlightNo) AS FlightCount\nFROM airlines a\nJOIN flights f ON a.uid = f.Airline\nGROUP BY a.Airline\nORDER BY FlightCount DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Find the abbreviation and country of the airline that has fewest number of flights?",
      "gold_sql": "SELECT T1.Abbreviation ,  T1.Country FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline GROUP BY T1.Airline ORDER BY count(*) LIMIT 1",
      "predicted_sql": "SELECT a.Abbreviation, a.Country\nFROM airlines a\nJOIN (\n    SELECT Airline, COUNT(*) AS FlightCount\n    FROM flights\n    GROUP BY Airline\n    ORDER BY FlightCount ASC\n    LIMIT 1\n) AS f ON a.uid = f.Airline;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What is the abbreviation of the airilne has the fewest flights and what country is it in?",
      "gold_sql": "SELECT T1.Abbreviation ,  T1.Country FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline GROUP BY T1.Airline ORDER BY count(*) LIMIT 1",
      "predicted_sql": "SELECT a.Abbreviation, a.Country\nFROM airlines a\nJOIN (\n    SELECT Airline, COUNT(*) AS FlightCount\n    FROM flights\n    GROUP BY Airline\n    ORDER BY FlightCount\n    LIMIT 1\n) f ON a.uid = f.Airline;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What are airlines that have some flight departing from airport 'AHD'?",
      "gold_sql": "SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline WHERE T2.SourceAirport  =  \"AHD\"",
      "predicted_sql": "SELECT DISTINCT a.Airline\nFROM airlines a\nJOIN flights f ON a.uid = f.Airline\nWHERE f.SourceAirport = 'AHD';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which airlines have a flight with source airport AHD?",
      "gold_sql": "SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline WHERE T2.SourceAirport  =  \"AHD\"",
      "predicted_sql": "SELECT DISTINCT a.Airline, a.Abbreviation, a.Country\nFROM airlines a\nJOIN flights f ON a.uid = f.Airline\nWHERE f.SourceAirport = 'AHD';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What are airlines that have flights arriving at airport 'AHD'?",
      "gold_sql": "SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline WHERE T2.DestAirport  =  \"AHD\"",
      "predicted_sql": "SELECT DISTINCT a.Airline, a.Abbreviation, a.Country\nFROM airlines a\nJOIN flights f ON a.uid = f.Airline\nWHERE f.DestAirport = 'AHD';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which airlines have a flight with destination airport AHD?",
      "gold_sql": "SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline WHERE T2.DestAirport  =  \"AHD\"",
      "predicted_sql": "SELECT DISTINCT a.Airline\nFROM airlines a\nJOIN flights f ON a.uid = f.Airline\nWHERE f.DestAirport = 'AHD';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Find all airlines that have flights from both airports 'APG' and 'CVO'.",
      "gold_sql": "SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline WHERE T2.SourceAirport  =  \"APG\" INTERSECT SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline WHERE T2.SourceAirport  =  \"CVO\"",
      "predicted_sql": "SELECT DISTINCT a.Airline\nFROM airlines a\nJOIN flights f1 ON a.uid = f1.Airline AND f1.SourceAirport = 'APG'\nJOIN flights f2 ON a.uid = f2.Airline AND f2.SourceAirport = 'CVO';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which airlines have departing flights from both APG and CVO airports?",
      "gold_sql": "SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline WHERE T2.SourceAirport  =  \"APG\" INTERSECT SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline WHERE T2.SourceAirport  =  \"CVO\"",
      "predicted_sql": "SELECT DISTINCT a.Airline\nFROM flights f\nJOIN airlines a ON f.Airline = a.uid\nWHERE f.SourceAirport IN ('APG', 'CVO')\nGROUP BY a.Airline\nHAVING COUNT(DISTINCT f.SourceAirport) = 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Find all airlines that have flights from airport 'CVO' but not from 'APG'.",
      "gold_sql": "SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline WHERE T2.SourceAirport  =  \"CVO\" EXCEPT SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline WHERE T2.SourceAirport  =  \"APG\"",
      "predicted_sql": "SELECT DISTINCT a.Airline, a.Abbreviation, a.Country\nFROM airlines a\nJOIN flights f ON a.uid = f.Airline\nWHERE f.SourceAirport = 'CVO'\nAND a.uid NOT IN (\n    SELECT f2.Airline\n    FROM flights f2\n    WHERE f2.SourceAirport = 'APG'\n);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which airlines have departures from CVO but not from APG airports?",
      "gold_sql": "SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline WHERE T2.SourceAirport  =  \"CVO\" EXCEPT SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline WHERE T2.SourceAirport  =  \"APG\"",
      "predicted_sql": "SELECT DISTINCT a.Airline\nFROM airlines a\nJOIN flights f ON a.uid = f.Airline\nWHERE f.SourceAirport = 'CVO'\nAND a.uid NOT IN (\n    SELECT DISTINCT f2.Airline\n    FROM flights f2\n    WHERE f2.SourceAirport = 'APG'\n);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Find all airlines that have at least 10 flights.",
      "gold_sql": "SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline GROUP BY T1.Airline HAVING count(*)  >  10",
      "predicted_sql": "SELECT a.Airline, a.Abbreviation, a.Country\nFROM airlines a\nJOIN flights f ON a.uid = f.Airline\nGROUP BY a.Airline, a.Abbreviation, a.Country\nHAVING COUNT(f.FlightNo) >= 10;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which airlines have at least 10 flights?",
      "gold_sql": "SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline GROUP BY T1.Airline HAVING count(*)  >  10",
      "predicted_sql": "SELECT a.Airline, COUNT(f.FlightNo) AS FlightCount\nFROM airlines a\nJOIN flights f ON a.uid = f.Airline\nGROUP BY a.Airline\nHAVING COUNT(f.FlightNo) >= 10;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Find all airlines that have fewer than 200 flights.",
      "gold_sql": "SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline GROUP BY T1.Airline HAVING count(*)  <  200",
      "predicted_sql": "SELECT a.Airline, a.Abbreviation, a.Country\nFROM airlines a\nJOIN flights f ON a.uid = f.Airline\nGROUP BY a.uid, a.Airline, a.Abbreviation, a.Country\nHAVING COUNT(f.FlightNo) < 200;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which airlines have less than 200 flights?",
      "gold_sql": "SELECT T1.Airline FROM AIRLINES AS T1 JOIN FLIGHTS AS T2 ON T1.uid  =  T2.Airline GROUP BY T1.Airline HAVING count(*)  <  200",
      "predicted_sql": "SELECT a.Airline, a.Abbreviation\nFROM airlines a\nJOIN flights f ON a.uid = f.Airline\nGROUP BY a.Airline, a.Abbreviation\nHAVING COUNT(f.FlightNo) < 200;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What are flight numbers of Airline \"United Airlines\"?",
      "gold_sql": "SELECT T1.FlightNo FROM FLIGHTS AS T1 JOIN AIRLINES AS T2 ON T2.uid  =  T1.Airline WHERE T2.Airline  =  \"United Airlines\"",
      "predicted_sql": "SELECT f.FlightNo\nFROM flights f\nJOIN airlines a ON f.Airline = a.uid\nWHERE a.Airline = 'United Airlines';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which flight numbers correspond to United Airlines flights?",
      "gold_sql": "SELECT T1.FlightNo FROM FLIGHTS AS T1 JOIN AIRLINES AS T2 ON T2.uid  =  T1.Airline WHERE T2.Airline  =  \"United Airlines\"",
      "predicted_sql": "SELECT f.FlightNo\nFROM flights f\nJOIN airlines a ON f.Airline = a.uid\nWHERE a.Airline = 'United Airlines';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What are flight numbers of flights departing from Airport \"APG\"?",
      "gold_sql": "SELECT FlightNo FROM FLIGHTS WHERE SourceAirport  =  \"APG\"",
      "predicted_sql": "SELECT f.FlightNo\nFROM flights f\nWHERE f.SourceAirport = 'APG';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Give the flight numbers of flights leaving from APG.",
      "gold_sql": "SELECT FlightNo FROM FLIGHTS WHERE SourceAirport  =  \"APG\"",
      "predicted_sql": "SELECT f.FlightNo\nFROM flights f\nWHERE f.SourceAirport = 'APG';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What are flight numbers of flights arriving at Airport \"APG\"?",
      "gold_sql": "SELECT FlightNo FROM FLIGHTS WHERE DestAirport  =  \"APG\"",
      "predicted_sql": "SELECT f.FlightNo\nFROM flights f\nWHERE f.DestAirport = 'APG';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Give the flight numbers of flights landing at APG.",
      "gold_sql": "SELECT FlightNo FROM FLIGHTS WHERE DestAirport  =  \"APG\"",
      "predicted_sql": "SELECT f.FlightNo\nFROM flights f\nWHERE f.DestAirport = 'APG';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What are flight numbers of flights departing from City \"Aberdeen \"?",
      "gold_sql": "SELECT T1.FlightNo FROM FLIGHTS AS T1 JOIN AIRPORTS AS T2 ON T1.SourceAirport   =  T2.AirportCode WHERE T2.City  =  \"Aberdeen\"",
      "predicted_sql": "SELECT f.FlightNo\nFROM flights f\nJOIN airports a ON f.SourceAirport = a.AirportCode\nWHERE a.City = 'Aberdeen';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Give the flight numbers of flights leaving from Aberdeen.",
      "gold_sql": "SELECT T1.FlightNo FROM FLIGHTS AS T1 JOIN AIRPORTS AS T2 ON T1.SourceAirport   =  T2.AirportCode WHERE T2.City  =  \"Aberdeen\"",
      "predicted_sql": "SELECT f.FlightNo\nFROM flights f\nJOIN airports a ON f.SourceAirport = a.AirportCode\nWHERE a.City = 'Aberdeen';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "What are flight numbers of flights arriving at City \"Aberdeen\"?",
      "gold_sql": "SELECT T1.FlightNo FROM FLIGHTS AS T1 JOIN AIRPORTS AS T2 ON T1.DestAirport   =  T2.AirportCode WHERE T2.City  =  \"Aberdeen\"",
      "predicted_sql": "SELECT f.FlightNo\nFROM flights f\nJOIN airports a ON f.DestAirport = a.AirportCode\nWHERE a.City = 'Aberdeen';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Give the flight numbers of flights arriving in Aberdeen.",
      "gold_sql": "SELECT T1.FlightNo FROM FLIGHTS AS T1 JOIN AIRPORTS AS T2 ON T1.DestAirport   =  T2.AirportCode WHERE T2.City  =  \"Aberdeen\"",
      "predicted_sql": "SELECT f.FlightNo\nFROM flights f\nJOIN airports a ON f.DestAirport = a.AirportCode\nWHERE a.City = 'Aberdeen';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Find the number of flights landing in the city of Aberdeen or Abilene.",
      "gold_sql": "SELECT count(*) FROM Flights AS T1 JOIN Airports AS T2 ON T1.DestAirport  =  T2.AirportCode WHERE T2.city  =  \"Aberdeen\" OR T2.city  =  \"Abilene\"",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfFlights\nFROM flights f\nJOIN airports a ON f.DestAirport = a.AirportCode\nWHERE a.City IN ('Aberdeen', 'Abilene');",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "How many flights land in Aberdeen or Abilene?",
      "gold_sql": "SELECT count(*) FROM Flights AS T1 JOIN Airports AS T2 ON T1.DestAirport  =  T2.AirportCode WHERE T2.city  =  \"Aberdeen\" OR T2.city  =  \"Abilene\"",
      "predicted_sql": "SELECT COUNT(*) AS FlightCount\nFROM flights f\nWHERE f.DestAirport IN (\n    SELECT a.AirportCode\n    FROM airports a\n    WHERE a.City IN ('Aberdeen', 'Abilene')\n);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Find the name of airports which do not have any flight in and out.",
      "gold_sql": "SELECT AirportName FROM Airports WHERE AirportCode NOT IN (SELECT SourceAirport FROM Flights UNION SELECT DestAirport FROM Flights)",
      "predicted_sql": "SELECT a.AirportName\nFROM airports a\nLEFT JOIN flights f1 ON a.AirportCode = f1.SourceAirport\nLEFT JOIN flights f2 ON a.AirportCode = f2.DestAirport\nWHERE f1.FlightNo IS NULL AND f2.FlightNo IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "flight_2",
      "question": "Which airports do not have departing or arriving flights?",
      "gold_sql": "SELECT AirportName FROM Airports WHERE AirportCode NOT IN (SELECT SourceAirport FROM Flights UNION SELECT DestAirport FROM Flights)",
      "predicted_sql": "SELECT a.AirportCode, a.AirportName, a.City, a.Country\nFROM airports a\nLEFT JOIN flights f1 ON a.AirportCode = f1.SourceAirport\nLEFT JOIN flights f2 ON a.AirportCode = f2.DestAirport\nWHERE f1.FlightNo IS NULL AND f2.FlightNo IS NULL;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "How many employees are there?",
      "gold_sql": "SELECT count(*) FROM employee",
      "predicted_sql": "SELECT COUNT(*) AS total_employees FROM employee;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Count the number of employees",
      "gold_sql": "SELECT count(*) FROM employee",
      "predicted_sql": "SELECT COUNT(*) AS Employee_Count FROM employee;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Sort employee names by their age in ascending order.",
      "gold_sql": "SELECT name FROM employee ORDER BY age",
      "predicted_sql": "SELECT Name \nFROM employee \nORDER BY Age ASC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "List the names of employees and sort in ascending order of age.",
      "gold_sql": "SELECT name FROM employee ORDER BY age",
      "predicted_sql": "SELECT e.Name\nFROM employee e\nORDER BY e.Age ASC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "What is the number of employees from each city?",
      "gold_sql": "SELECT count(*) ,  city FROM employee GROUP BY city",
      "predicted_sql": "SELECT e.City, COUNT(e.Employee_ID) AS Number_of_Employees\nFROM employee e\nGROUP BY e.City;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Count the number of employees for each city.",
      "gold_sql": "SELECT count(*) ,  city FROM employee GROUP BY city",
      "predicted_sql": "SELECT e.City, COUNT(e.Employee_ID) AS Employee_Count\nFROM employee e\nGROUP BY e.City;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Which cities do more than one employee under age 30 come from?",
      "gold_sql": "SELECT city FROM employee WHERE age  <  30 GROUP BY city HAVING count(*)  >  1",
      "predicted_sql": "SELECT e.City\nFROM employee e\nWHERE e.Age < 30\nGROUP BY e.City\nHAVING COUNT(e.Employee_ID) > 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Find the cities that have more than one employee under age 30.",
      "gold_sql": "SELECT city FROM employee WHERE age  <  30 GROUP BY city HAVING count(*)  >  1",
      "predicted_sql": "SELECT e.City\nFROM employee e\nWHERE e.Age < 30\nGROUP BY e.City\nHAVING COUNT(e.Employee_ID) > 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Find the number of shops in each location.",
      "gold_sql": "SELECT count(*) ,  LOCATION FROM shop GROUP BY LOCATION",
      "predicted_sql": "SELECT Location, COUNT(*) AS Number_of_Shops\nFROM shop\nGROUP BY Location;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "How many shops are there in each location?",
      "gold_sql": "SELECT count(*) ,  LOCATION FROM shop GROUP BY LOCATION",
      "predicted_sql": "SELECT Location, COUNT(*) AS Number_of_Shops\nFROM shop\nGROUP BY Location;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Find the manager name and district of the shop whose number of products is the largest.",
      "gold_sql": "SELECT manager_name ,  district FROM shop ORDER BY number_products DESC LIMIT 1",
      "predicted_sql": "SELECT s.Manager_name, s.District\nFROM shop s\nWHERE s.Number_products = (SELECT MAX(Number_products) FROM shop);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "What are the manager name and district of the shop that sells the largest number of products?",
      "gold_sql": "SELECT manager_name ,  district FROM shop ORDER BY number_products DESC LIMIT 1",
      "predicted_sql": "SELECT s.Manager_name, s.District\nFROM shop s\nWHERE s.Number_products = (SELECT MAX(Number_products) FROM shop);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "find the minimum and maximum number of products of all stores.",
      "gold_sql": "SELECT min(Number_products) ,  max(Number_products) FROM shop",
      "predicted_sql": "SELECT MIN(Number_products) AS Min_Products, MAX(Number_products) AS Max_Products\nFROM shop;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "What are the minimum and maximum number of products across all the shops?",
      "gold_sql": "SELECT min(Number_products) ,  max(Number_products) FROM shop",
      "predicted_sql": "SELECT MIN(Number_products) AS Min_Products, MAX(Number_products) AS Max_Products\nFROM shop;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Return the name, location and district of all shops in descending order of number of products.",
      "gold_sql": "SELECT name ,  LOCATION ,  district FROM shop ORDER BY number_products DESC",
      "predicted_sql": "SELECT s.Name, s.Location, s.District \nFROM shop s \nORDER BY s.Number_products DESC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Sort all the shops by number products in descending order, and return the name, location and district of each shop.",
      "gold_sql": "SELECT name ,  LOCATION ,  district FROM shop ORDER BY number_products DESC",
      "predicted_sql": "SELECT s.Name, s.Location, s.District\nFROM shop s\nORDER BY s.Number_products DESC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Find the names of stores whose number products is more than the average number of products.",
      "gold_sql": "SELECT name FROM shop WHERE number_products  >  (SELECT avg(number_products) FROM shop)",
      "predicted_sql": "SELECT s.Name\nFROM shop s\nWHERE s.Number_products > (SELECT AVG(Number_products) FROM shop);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Which shops' number products is above the average? Give me the shop names.",
      "gold_sql": "SELECT name FROM shop WHERE number_products  >  (SELECT avg(number_products) FROM shop)",
      "predicted_sql": "SELECT s.Name\nFROM shop s\nWHERE s.Number_products > (SELECT AVG(Number_products) FROM shop);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "find the name of employee who was awarded the most times in the evaluation.",
      "gold_sql": "SELECT t1.name FROM employee AS t1 JOIN evaluation AS t2 ON t1.Employee_ID  =  t2.Employee_ID GROUP BY t2.Employee_ID ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT e.Name\nFROM employee e\nJOIN evaluation ev ON e.Employee_ID = ev.Employee_ID\nGROUP BY e.Employee_ID, e.Name\nORDER BY COUNT(ev.Year_awarded) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Which employee received the most awards in evaluations? Give me the employee name.",
      "gold_sql": "SELECT t1.name FROM employee AS t1 JOIN evaluation AS t2 ON t1.Employee_ID  =  t2.Employee_ID GROUP BY t2.Employee_ID ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT e.Name\nFROM employee e\nJOIN evaluation ev ON e.Employee_ID = ev.Employee_ID\nGROUP BY e.Employee_ID, e.Name\nORDER BY COUNT(ev.Year_awarded) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Find the name of the employee who got the highest one time bonus.",
      "gold_sql": "SELECT t1.name FROM employee AS t1 JOIN evaluation AS t2 ON t1.Employee_ID  =  t2.Employee_ID ORDER BY t2.bonus DESC LIMIT 1",
      "predicted_sql": "SELECT e.Name\nFROM employee e\nJOIN evaluation ev ON e.Employee_ID = ev.Employee_ID\nWHERE ev.Bonus = (SELECT MAX(Bonus) FROM evaluation)\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Which employee received the biggest bonus? Give me the employee name.",
      "gold_sql": "SELECT t1.name FROM employee AS t1 JOIN evaluation AS t2 ON t1.Employee_ID  =  t2.Employee_ID ORDER BY t2.bonus DESC LIMIT 1",
      "predicted_sql": "SELECT e.Name\nFROM employee e\nJOIN evaluation ev ON e.Employee_ID = ev.Employee_ID\nORDER BY ev.Bonus DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Find the names of employees who never won any award in the evaluation.",
      "gold_sql": "SELECT name FROM employee WHERE Employee_ID NOT IN (SELECT Employee_ID FROM evaluation)",
      "predicted_sql": "SELECT e.Name\nFROM employee e\nLEFT JOIN evaluation ev ON e.Employee_ID = ev.Employee_ID\nWHERE ev.Employee_ID IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "What are the names of the employees who never received any evaluation?",
      "gold_sql": "SELECT name FROM employee WHERE Employee_ID NOT IN (SELECT Employee_ID FROM evaluation)",
      "predicted_sql": "SELECT e.Name\nFROM employee e\nLEFT JOIN evaluation ev ON e.Employee_ID = ev.Employee_ID\nWHERE ev.Employee_ID IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "What is the name of the shop that is hiring the largest number of employees?",
      "gold_sql": "SELECT t2.name FROM hiring AS t1 JOIN shop AS t2 ON t1.shop_id  =  t2.shop_id GROUP BY t1.shop_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT s.Name\nFROM shop s\nJOIN hiring h ON s.Shop_ID = h.Shop_ID\nGROUP BY s.Shop_ID, s.Name\nORDER BY COUNT(h.Employee_ID) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Which shop has the most employees? Give me the shop name.",
      "gold_sql": "SELECT t2.name FROM hiring AS t1 JOIN shop AS t2 ON t1.shop_id  =  t2.shop_id GROUP BY t1.shop_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT s.Name\nFROM shop s\nJOIN hiring h ON s.Shop_ID = h.Shop_ID\nGROUP BY s.Shop_ID, s.Name\nORDER BY COUNT(h.Employee_ID) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Find the name of the shops that do not hire any employee.",
      "gold_sql": "SELECT name FROM shop WHERE shop_id NOT IN (SELECT shop_id FROM hiring)",
      "predicted_sql": "SELECT s.Name\nFROM shop s\nLEFT JOIN hiring h ON s.Shop_ID = h.Shop_ID\nWHERE h.Employee_ID IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Which shops run with no employees? Find the shop names",
      "gold_sql": "SELECT name FROM shop WHERE shop_id NOT IN (SELECT shop_id FROM hiring)",
      "predicted_sql": "SELECT s.Name \nFROM shop s \nLEFT JOIN hiring h ON s.Shop_ID = h.Shop_ID \nWHERE h.Employee_ID IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Find the number of employees hired in each shop; show the shop name as well.",
      "gold_sql": "SELECT count(*) ,  t2.name FROM hiring AS t1 JOIN shop AS t2 ON t1.shop_id  =  t2.shop_id GROUP BY t2.name",
      "predicted_sql": "SELECT s.Name AS Shop_Name, COUNT(h.Employee_ID) AS Number_of_Employees\nFROM shop s\nLEFT JOIN hiring h ON s.Shop_ID = h.Shop_ID\nGROUP BY s.Shop_ID, s.Name;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "For each shop, return the number of employees working there and the name of the shop.",
      "gold_sql": "SELECT count(*) ,  t2.name FROM hiring AS t1 JOIN shop AS t2 ON t1.shop_id  =  t2.shop_id GROUP BY t2.name",
      "predicted_sql": "SELECT s.Name AS Shop_Name, COUNT(h.Employee_ID) AS Number_of_Employees\nFROM shop s\nLEFT JOIN hiring h ON s.Shop_ID = h.Shop_ID\nGROUP BY s.Shop_ID, s.Name;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "What is total bonus given in all evaluations?",
      "gold_sql": "SELECT sum(bonus) FROM evaluation",
      "predicted_sql": "SELECT SUM(Bonus) AS Total_Bonus\nFROM evaluation;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Find the total amount of bonus given in all the evaluations.",
      "gold_sql": "SELECT sum(bonus) FROM evaluation",
      "predicted_sql": "SELECT SUM(Bonus) AS Total_Bonus\nFROM evaluation;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Give me all the information about hiring.",
      "gold_sql": "SELECT * FROM hiring",
      "predicted_sql": "SELECT h.Shop_ID, h.Employee_ID, h.Start_from, h.Is_full_time\nFROM hiring h;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "What is all the information about hiring?",
      "gold_sql": "SELECT * FROM hiring",
      "predicted_sql": "SELECT h.Shop_ID, h.Employee_ID, h.Start_from, h.Is_full_time\nFROM hiring AS h;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Which district has both stores with less than 3000 products and stores with more than 10000 products?",
      "gold_sql": "SELECT district FROM shop WHERE Number_products  <  3000 INTERSECT SELECT district FROM shop WHERE Number_products  >  10000",
      "predicted_sql": "SELECT DISTINCT s1.District\nFROM shop s1\nJOIN shop s2 ON s1.District = s2.District\nWHERE s1.Number_products < 3000 AND s2.Number_products > 10000;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Find the districts in which there are both shops selling less than 3000 products and shops selling more than 10000 products.",
      "gold_sql": "SELECT district FROM shop WHERE Number_products  <  3000 INTERSECT SELECT district FROM shop WHERE Number_products  >  10000",
      "predicted_sql": "SELECT DISTINCT s1.District\nFROM shop s1\nJOIN shop s2 ON s1.District = s2.District\nWHERE s1.Number_products < 3000 AND s2.Number_products > 10000;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "How many different store locations are there?",
      "gold_sql": "SELECT count(DISTINCT LOCATION) FROM shop",
      "predicted_sql": "SELECT COUNT(DISTINCT Location) AS Different_Locations\nFROM shop;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "employee_hire_evaluation",
      "question": "Count the number of distinct store locations.",
      "gold_sql": "SELECT count(DISTINCT LOCATION) FROM shop",
      "predicted_sql": "SELECT COUNT(DISTINCT Location) AS distinct_store_locations\nFROM shop;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "How many documents do we have?",
      "gold_sql": "SELECT count(*) FROM Documents",
      "predicted_sql": "SELECT COUNT(*) AS Total_Documents FROM Documents;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Count the number of documents.",
      "gold_sql": "SELECT count(*) FROM Documents",
      "predicted_sql": "SELECT COUNT(*) AS Document_Count\nFROM Documents;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "List document IDs, document names, and document descriptions for all documents.",
      "gold_sql": "SELECT document_id ,  document_name ,  document_description FROM Documents",
      "predicted_sql": "SELECT d.Document_ID, d.Document_Name, d.Document_Description\nFROM Documents AS d;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the ids, names, and descriptions for all documents?",
      "gold_sql": "SELECT document_id ,  document_name ,  document_description FROM Documents",
      "predicted_sql": "SELECT d.Document_ID, d.Document_Name, d.Document_Description\nFROM Documents AS d;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What is the document name and template id for document with description with the letter 'w' in it?",
      "gold_sql": "SELECT document_name ,  template_id FROM Documents WHERE Document_Description LIKE \"%w%\"",
      "predicted_sql": "SELECT d.Document_Name, d.Template_ID\nFROM Documents d\nWHERE d.Document_Description LIKE '%w%';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the names and template ids for documents that contain the letter w in their description.",
      "gold_sql": "SELECT document_name ,  template_id FROM Documents WHERE Document_Description LIKE \"%w%\"",
      "predicted_sql": "SELECT d.Document_Name, d.Template_ID\nFROM Documents d\nWHERE d.Document_Description LIKE '%w%';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What is the document id, template id and description for document named \"Robbin CV\"?",
      "gold_sql": "SELECT document_id ,  template_id ,  Document_Description FROM Documents WHERE document_name  =  \"Robbin CV\"",
      "predicted_sql": "SELECT d.Document_ID, d.Template_ID, d.Document_Description\nFROM Documents d\nWHERE d.Document_Name = 'Robbin CV';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the document id, template id, and description for the document with the name Robbin CV.",
      "gold_sql": "SELECT document_id ,  template_id ,  Document_Description FROM Documents WHERE document_name  =  \"Robbin CV\"",
      "predicted_sql": "SELECT d.Document_ID, d.Template_ID, d.Document_Description\nFROM Documents d\nWHERE d.Document_Name = 'Robbin CV';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "How many different templates do all document use?",
      "gold_sql": "SELECT count(DISTINCT template_id) FROM Documents",
      "predicted_sql": "SELECT COUNT(DISTINCT t.Template_ID) AS Different_Template_Count\nFROM Templates t\nJOIN Documents d ON t.Template_ID = d.Template_ID;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Count the number of different templates used for documents.",
      "gold_sql": "SELECT count(DISTINCT template_id) FROM Documents",
      "predicted_sql": "SELECT COUNT(DISTINCT t.Template_ID) AS Different_Template_Count\nFROM Templates t\nJOIN Documents d ON t.Template_ID = d.Template_ID;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "How many documents are using the template with type code 'PPT'?",
      "gold_sql": "SELECT count(*) FROM Documents AS T1 JOIN Templates AS T2 ON T1.Template_ID  =  T2.Template_ID WHERE T2.Template_Type_Code  =  'PPT'",
      "predicted_sql": "SELECT COUNT(DISTINCT d.Document_ID) AS Document_Count\nFROM Documents d\nJOIN Templates t ON d.Template_ID = t.Template_ID\nWHERE t.Template_Type_Code = 'PPT';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Count the number of documents that use the PPT template type.",
      "gold_sql": "SELECT count(*) FROM Documents AS T1 JOIN Templates AS T2 ON T1.Template_ID  =  T2.Template_ID WHERE T2.Template_Type_Code  =  'PPT'",
      "predicted_sql": "SELECT COUNT(DISTINCT d.Document_ID) AS Document_Count\nFROM Documents d\nJOIN Templates t ON d.Template_ID = t.Template_ID\nWHERE t.Template_Type_Code = 'PPT';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show all template ids and number of documents using each template.",
      "gold_sql": "SELECT template_id ,  count(*) FROM Documents GROUP BY template_id",
      "predicted_sql": "SELECT t.Template_ID, COUNT(d.Document_ID) AS Number_of_Documents\nFROM Templates t\nLEFT JOIN Documents d ON t.Template_ID = d.Template_ID\nGROUP BY t.Template_ID;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are all different template ids used for documents, and how many times were each of them used?",
      "gold_sql": "SELECT template_id ,  count(*) FROM Documents GROUP BY template_id",
      "predicted_sql": "SELECT d.Template_ID, COUNT(d.Document_ID) AS Usage_Count\nFROM Documents d\nGROUP BY d.Template_ID;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What is the id and type code for the template used by the most documents?",
      "gold_sql": "SELECT T1.template_id ,  T2.Template_Type_Code FROM Documents AS T1 JOIN Templates AS T2 ON T1.template_id  =  T2.template_id GROUP BY T1.template_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT t.Template_ID, t.Template_Type_Code\nFROM Templates t\nJOIN Documents d ON t.Template_ID = d.Template_ID\nGROUP BY t.Template_ID, t.Template_Type_Code\nORDER BY COUNT(d.Document_ID) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the id and type code of the template that is used for the greatest number of documents.",
      "gold_sql": "SELECT T1.template_id ,  T2.Template_Type_Code FROM Documents AS T1 JOIN Templates AS T2 ON T1.template_id  =  T2.template_id GROUP BY T1.template_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT t.Template_ID, t.Template_Type_Code\nFROM Templates t\nJOIN Documents d ON t.Template_ID = d.Template_ID\nGROUP BY t.Template_ID, t.Template_Type_Code\nORDER BY COUNT(d.Document_ID) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show ids for all templates that are used by more than one document.",
      "gold_sql": "SELECT template_id FROM Documents GROUP BY template_id HAVING count(*)  >  1",
      "predicted_sql": "SELECT t.Template_ID\nFROM Templates t\nJOIN Documents d ON t.Template_ID = d.Template_ID\nGROUP BY t.Template_ID\nHAVING COUNT(d.Document_ID) > 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the template ids of any templates used in more than a single document?",
      "gold_sql": "SELECT template_id FROM Documents GROUP BY template_id HAVING count(*)  >  1",
      "predicted_sql": "SELECT t.Template_ID\nFROM Templates t\nJOIN Documents d ON t.Template_ID = d.Template_ID\nGROUP BY t.Template_ID\nHAVING COUNT(d.Document_ID) > 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show ids for all templates not used by any document.",
      "gold_sql": "SELECT template_id FROM Templates EXCEPT SELECT template_id FROM Documents",
      "predicted_sql": "SELECT t.Template_ID\nFROM Templates t\nLEFT JOIN Documents d ON t.Template_ID = d.Template_ID\nWHERE d.Document_ID IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the ids for templates that are not used in any documents?",
      "gold_sql": "SELECT template_id FROM Templates EXCEPT SELECT template_id FROM Documents",
      "predicted_sql": "SELECT t.Template_ID\nFROM Templates t\nLEFT JOIN Documents d ON t.Template_ID = d.Template_ID\nWHERE d.Document_ID IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "How many templates do we have?",
      "gold_sql": "SELECT count(*) FROM Templates",
      "predicted_sql": "SELECT COUNT(*) AS Total_Templates FROM Templates;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Count the number of templates.",
      "gold_sql": "SELECT count(*) FROM Templates",
      "predicted_sql": "SELECT COUNT(*) AS Template_Count FROM Templates;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show template ids, version numbers, and template type codes for all templates.",
      "gold_sql": "SELECT template_id ,  version_number ,  template_type_code FROM Templates",
      "predicted_sql": "SELECT t.Template_ID, t.Version_Number, t.Template_Type_Code\nFROM Templates t;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the ids, version numbers, and type codes for each template?",
      "gold_sql": "SELECT template_id ,  version_number ,  template_type_code FROM Templates",
      "predicted_sql": "SELECT t.Template_ID, t.Version_Number, t.Template_Type_Code\nFROM Templates t;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show all distinct template type codes for all templates.",
      "gold_sql": "SELECT DISTINCT template_type_code FROM Templates",
      "predicted_sql": "SELECT DISTINCT t.Template_Type_Code\nFROM Templates t;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the different template type codes?",
      "gold_sql": "SELECT DISTINCT template_type_code FROM Templates",
      "predicted_sql": "SELECT DISTINCT Template_Type_Code FROM Ref_Template_Types;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the ids of templates with template type code PP or PPT?",
      "gold_sql": "SELECT template_id FROM Templates WHERE template_type_code  =  \"PP\" OR template_type_code  =  \"PPT\"",
      "predicted_sql": "SELECT t.Template_ID\nFROM Templates t\nWHERE t.Template_Type_Code IN ('PP', 'PPT');",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the ids of templates that have the code PP or PPT.",
      "gold_sql": "SELECT template_id FROM Templates WHERE template_type_code  =  \"PP\" OR template_type_code  =  \"PPT\"",
      "predicted_sql": "SELECT t.Template_ID\nFROM Templates t\nWHERE t.Template_Type_Code IN ('PP', 'PPT');",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "How many templates have template type code CV?",
      "gold_sql": "SELECT count(*) FROM Templates WHERE template_type_code  =  \"CV\"",
      "predicted_sql": "SELECT COUNT(*) AS Template_Count\nFROM Templates t\nWHERE t.Template_Type_Code = 'CV';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Count the number of templates of the type CV.",
      "gold_sql": "SELECT count(*) FROM Templates WHERE template_type_code  =  \"CV\"",
      "predicted_sql": "SELECT COUNT(*) AS Template_Count\nFROM Templates t\nWHERE t.Template_Type_Code = 'CV';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What is the version number and template type code for the template with version number later than 5?",
      "gold_sql": "SELECT version_number ,  template_type_code FROM Templates WHERE version_number  >  5",
      "predicted_sql": "SELECT t.Version_Number, t.Template_Type_Code\nFROM Templates t\nWHERE t.Version_Number > 5;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the version numbers and template type codes of templates with a version number greater than 5.",
      "gold_sql": "SELECT version_number ,  template_type_code FROM Templates WHERE version_number  >  5",
      "predicted_sql": "SELECT t.Version_Number, t.Template_Type_Code\nFROM Templates t\nWHERE t.Version_Number > 5;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show all template type codes and number of templates for each.",
      "gold_sql": "SELECT template_type_code ,  count(*) FROM Templates GROUP BY template_type_code",
      "predicted_sql": "SELECT rtt.Template_Type_Code, COUNT(t.Template_ID) AS Number_of_Templates\nFROM Ref_Template_Types rtt\nLEFT JOIN Templates t ON rtt.Template_Type_Code = t.Template_Type_Code\nGROUP BY rtt.Template_Type_Code;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the different template type codes, and how many templates correspond to each?",
      "gold_sql": "SELECT template_type_code ,  count(*) FROM Templates GROUP BY template_type_code",
      "predicted_sql": "SELECT rtt.Template_Type_Code, COUNT(t.Template_ID) AS Template_Count\nFROM Ref_Template_Types rtt\nLEFT JOIN Templates t ON rtt.Template_Type_Code = t.Template_Type_Code\nGROUP BY rtt.Template_Type_Code;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Which template type code has most number of templates?",
      "gold_sql": "SELECT template_type_code FROM Templates GROUP BY template_type_code ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT t.Template_Type_Code\nFROM Templates t\nGROUP BY t.Template_Type_Code\nORDER BY COUNT(t.Template_ID) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the type code of the template type that the most templates belong to.",
      "gold_sql": "SELECT template_type_code FROM Templates GROUP BY template_type_code ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT tt.Template_Type_Code\nFROM Templates t\nJOIN Ref_Template_Types tt ON t.Template_Type_Code = tt.Template_Type_Code\nGROUP BY tt.Template_Type_Code\nORDER BY COUNT(t.Template_ID) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show all template type codes with less than three templates.",
      "gold_sql": "SELECT template_type_code FROM Templates GROUP BY template_type_code HAVING count(*)  <  3",
      "predicted_sql": "SELECT rtt.Template_Type_Code\nFROM Ref_Template_Types rtt\nLEFT JOIN Templates t ON rtt.Template_Type_Code = t.Template_Type_Code\nGROUP BY rtt.Template_Type_Code\nHAVING COUNT(t.Template_ID) < 3;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the codes of template types that have fewer than 3 templates?",
      "gold_sql": "SELECT template_type_code FROM Templates GROUP BY template_type_code HAVING count(*)  <  3",
      "predicted_sql": "SELECT rtt.Template_Type_Code\nFROM Ref_Template_Types rtt\nLEFT JOIN Templates t ON rtt.Template_Type_Code = t.Template_Type_Code\nGROUP BY rtt.Template_Type_Code\nHAVING COUNT(t.Template_ID) < 3;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What the smallest version number and its template type code?",
      "gold_sql": "SELECT min(Version_Number) ,  template_type_code FROM Templates",
      "predicted_sql": "SELECT MIN(t.Version_Number) AS Smallest_Version_Number, t.Template_Type_Code\nFROM Templates t\nGROUP BY t.Template_Type_Code\nORDER BY Smallest_Version_Number\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the lowest version number, along with its corresponding template type code.",
      "gold_sql": "SELECT min(Version_Number) ,  template_type_code FROM Templates",
      "predicted_sql": "SELECT MIN(t.Version_Number) AS Lowest_Version_Number, t.Template_Type_Code\nFROM Templates t\nGROUP BY t.Template_Type_Code\nORDER BY Lowest_Version_Number\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What is the template type code of the template used by document with the name \"Data base\"?",
      "gold_sql": "SELECT T1.template_type_code FROM Templates AS T1 JOIN Documents AS T2 ON T1.template_id  =  T2.template_id WHERE T2.document_name  =  \"Data base\"",
      "predicted_sql": "SELECT t.Template_Type_Code\nFROM Documents d\nJOIN Templates t ON d.Template_ID = t.Template_ID\nWHERE d.Document_Name = 'Data base';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the template type code of the template that is used by a document named Data base.",
      "gold_sql": "SELECT T1.template_type_code FROM Templates AS T1 JOIN Documents AS T2 ON T1.template_id  =  T2.template_id WHERE T2.document_name  =  \"Data base\"",
      "predicted_sql": "SELECT t.Template_Type_Code\nFROM Templates t\nJOIN Documents d ON t.Template_ID = d.Template_ID\nWHERE d.Document_Name = 'Data base';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show all document names using templates with template type code BK.",
      "gold_sql": "SELECT T2.document_name FROM Templates AS T1 JOIN Documents AS T2 ON T1.template_id  =  T2.template_id WHERE T1.template_type_code  =  \"BK\"",
      "predicted_sql": "SELECT d.Document_Name\nFROM Documents d\nJOIN Templates t ON d.Template_ID = t.Template_ID\nWHERE t.Template_Type_Code = 'BK';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the names of documents that use templates with the code BK?",
      "gold_sql": "SELECT T2.document_name FROM Templates AS T1 JOIN Documents AS T2 ON T1.template_id  =  T2.template_id WHERE T1.template_type_code  =  \"BK\"",
      "predicted_sql": "SELECT d.Document_Name\nFROM Documents d\nJOIN Templates t ON d.Template_ID = t.Template_ID\nWHERE t.Template_Type_Code = 'BK';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show all template type codes and the number of documents using each type.",
      "gold_sql": "SELECT T1.template_type_code ,  count(*) FROM Templates AS T1 JOIN Documents AS T2 ON T1.template_id  =  T2.template_id GROUP BY T1.template_type_code",
      "predicted_sql": "SELECT rtt.Template_Type_Code, COUNT(d.Document_ID) AS Document_Count\nFROM Ref_Template_Types rtt\nLEFT JOIN Templates t ON rtt.Template_Type_Code = t.Template_Type_Code\nLEFT JOIN Documents d ON t.Template_ID = d.Template_ID\nGROUP BY rtt.Template_Type_Code;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the different template type codes, and how many documents use each type?",
      "gold_sql": "SELECT T1.template_type_code ,  count(*) FROM Templates AS T1 JOIN Documents AS T2 ON T1.template_id  =  T2.template_id GROUP BY T1.template_type_code",
      "predicted_sql": "SELECT rtt.Template_Type_Code, COUNT(d.Document_ID) AS Document_Count\nFROM Ref_Template_Types rtt\nLEFT JOIN Templates t ON rtt.Template_Type_Code = t.Template_Type_Code\nLEFT JOIN Documents d ON t.Template_ID = d.Template_ID\nGROUP BY rtt.Template_Type_Code;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Which template type code is used by most number of documents?",
      "gold_sql": "SELECT T1.template_type_code FROM Templates AS T1 JOIN Documents AS T2 ON T1.template_id  =  T2.template_id GROUP BY T1.template_type_code ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT t.Template_Type_Code\nFROM Documents d\nJOIN Templates t ON d.Template_ID = t.Template_ID\nGROUP BY t.Template_Type_Code\nORDER BY COUNT(d.Document_ID) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the code of the template type that is most commonly used in documents.",
      "gold_sql": "SELECT T1.template_type_code FROM Templates AS T1 JOIN Documents AS T2 ON T1.template_id  =  T2.template_id GROUP BY T1.template_type_code ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT tt.Template_Type_Code\nFROM Ref_Template_Types tt\nJOIN Templates t ON tt.Template_Type_Code = t.Template_Type_Code\nJOIN Documents d ON t.Template_ID = d.Template_ID\nGROUP BY tt.Template_Type_Code\nORDER BY COUNT(d.Document_ID) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show all template type codes that are not used by any document.",
      "gold_sql": "SELECT template_type_code FROM Templates EXCEPT SELECT template_type_code FROM Templates AS T1 JOIN Documents AS T2 ON T1.template_id  =  T2.template_id",
      "predicted_sql": "SELECT rtt.Template_Type_Code\nFROM Ref_Template_Types rtt\nLEFT JOIN Templates t ON rtt.Template_Type_Code = t.Template_Type_Code\nLEFT JOIN Documents d ON t.Template_ID = d.Template_ID\nWHERE d.Document_ID IS NULL;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the codes of template types that are not used for any document?",
      "gold_sql": "SELECT template_type_code FROM Templates EXCEPT SELECT template_type_code FROM Templates AS T1 JOIN Documents AS T2 ON T1.template_id  =  T2.template_id",
      "predicted_sql": "SELECT rtt.Template_Type_Code\nFROM Ref_Template_Types rtt\nLEFT JOIN Templates t ON rtt.Template_Type_Code = t.Template_Type_Code\nLEFT JOIN Documents d ON t.Template_ID = d.Template_ID\nWHERE d.Document_ID IS NULL;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show all template type codes and descriptions.",
      "gold_sql": "SELECT template_type_code ,  template_type_description FROM Ref_template_types",
      "predicted_sql": "SELECT t.Template_Type_Code, t.Template_Type_Description\nFROM Ref_Template_Types AS t;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the type codes and descriptions for all template types?",
      "gold_sql": "SELECT template_type_code ,  template_type_description FROM Ref_template_types",
      "predicted_sql": "SELECT t.Template_Type_Code, t.Template_Type_Description\nFROM Ref_Template_Types AS t;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What is the template type descriptions for template type code \"AD\".",
      "gold_sql": "SELECT template_type_description FROM Ref_template_types WHERE template_type_code  =  \"AD\"",
      "predicted_sql": "SELECT rtt.Template_Type_Description\nFROM Ref_Template_Types rtt\nWHERE rtt.Template_Type_Code = 'AD';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the template type description of the template type with the code AD.",
      "gold_sql": "SELECT template_type_description FROM Ref_template_types WHERE template_type_code  =  \"AD\"",
      "predicted_sql": "SELECT rtt.Template_Type_Description\nFROM Ref_Template_Types rtt\nWHERE rtt.Template_Type_Code = 'AD';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What is the template type code for template type description \"Book\".",
      "gold_sql": "SELECT template_type_code FROM Ref_template_types WHERE template_type_description  =  \"Book\"",
      "predicted_sql": "SELECT rtt.Template_Type_Code\nFROM Ref_Template_Types rtt\nWHERE rtt.Template_Type_Description = 'Book';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the type code of the template type with the description \"Book\".",
      "gold_sql": "SELECT template_type_code FROM Ref_template_types WHERE template_type_description  =  \"Book\"",
      "predicted_sql": "SELECT rtt.Template_Type_Code\nFROM Ref_Template_Types rtt\nWHERE rtt.Template_Type_Description = 'Book';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the distinct template type descriptions for the templates ever used by any document?",
      "gold_sql": "SELECT DISTINCT T1.template_type_description FROM Ref_template_types AS T1 JOIN Templates AS T2 ON T1.template_type_code  = T2.template_type_code JOIN Documents AS T3 ON T2.Template_ID  =  T3.template_ID",
      "predicted_sql": "SELECT DISTINCT rtt.Template_Type_Description\nFROM Ref_Template_Types rtt\nJOIN Templates t ON rtt.Template_Type_Code = t.Template_Type_Code\nJOIN Documents d ON t.Template_ID = d.Template_ID;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the different descriptions for templates that have been used in a document.",
      "gold_sql": "SELECT DISTINCT T1.template_type_description FROM Ref_template_types AS T1 JOIN Templates AS T2 ON T1.template_type_code  = T2.template_type_code JOIN Documents AS T3 ON T2.Template_ID  =  T3.template_ID",
      "predicted_sql": "SELECT DISTINCT tt.Template_Type_Description\nFROM Templates t\nJOIN Documents d ON t.Template_ID = d.Template_ID\nJOIN Ref_Template_Types tt ON t.Template_Type_Code = tt.Template_Type_Code;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the template ids with template type description \"Presentation\".",
      "gold_sql": "SELECT T2.template_id FROM Ref_template_types AS T1 JOIN Templates AS T2 ON T1.template_type_code  = T2.template_type_code WHERE T1.template_type_description  =  \"Presentation\"",
      "predicted_sql": "SELECT t.Template_ID\nFROM Templates t\nJOIN Ref_Template_Types r ON t.Template_Type_Code = r.Template_Type_Code\nWHERE r.Template_Type_Description = 'Presentation';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the ids corresponding to templates with the description 'Presentation'.",
      "gold_sql": "SELECT T2.template_id FROM Ref_template_types AS T1 JOIN Templates AS T2 ON T1.template_type_code  = T2.template_type_code WHERE T1.template_type_description  =  \"Presentation\"",
      "predicted_sql": "SELECT t.Template_ID\nFROM Templates t\nJOIN Ref_Template_Types r ON t.Template_Type_Code = r.Template_Type_Code\nWHERE r.Template_Type_Description = 'Presentation';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "How many paragraphs in total?",
      "gold_sql": "SELECT count(*) FROM Paragraphs",
      "predicted_sql": "SELECT COUNT(*) AS Total_Paragraphs\nFROM Paragraphs;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Count the number of paragraphs.",
      "gold_sql": "SELECT count(*) FROM Paragraphs",
      "predicted_sql": "SELECT COUNT(*) AS Total_Paragraphs\nFROM Paragraphs;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "How many paragraphs for the document with name 'Summer Show'?",
      "gold_sql": "SELECT count(*) FROM Paragraphs AS T1 JOIN Documents AS T2 ON T1.document_ID  =  T2.document_ID WHERE T2.document_name  =  'Summer Show'",
      "predicted_sql": "SELECT COUNT(p.Paragraph_ID) AS Paragraph_Count\nFROM Documents d\nJOIN Paragraphs p ON d.Document_ID = p.Document_ID\nWHERE d.Document_Name = 'Summer Show';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Count the number of paragraphs in the document named 'Summer Show'.",
      "gold_sql": "SELECT count(*) FROM Paragraphs AS T1 JOIN Documents AS T2 ON T1.document_ID  =  T2.document_ID WHERE T2.document_name  =  'Summer Show'",
      "predicted_sql": "SELECT COUNT(p.Paragraph_ID) AS Paragraph_Count\nFROM Documents d\nJOIN Paragraphs p ON d.Document_ID = p.Document_ID\nWHERE d.Document_Name = 'Summer Show';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show paragraph details for paragraph with text 'Korea'.",
      "gold_sql": "SELECT Other_Details FROM Paragraphs WHERE paragraph_text  =  'Korea'",
      "predicted_sql": "SELECT p.Paragraph_ID, p.Paragraph_Text, p.Other_Details\nFROM Paragraphs p\nWHERE p.Paragraph_Text = 'Korea';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the details for the paragraph that includes the text 'Korea'?",
      "gold_sql": "SELECT Other_Details FROM Paragraphs WHERE paragraph_text  =  'Korea'",
      "predicted_sql": "SELECT p.Paragraph_ID, p.Paragraph_Text, p.Other_Details\nFROM Paragraphs p\nWHERE p.Paragraph_Text LIKE '%Korea%';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show all paragraph ids and texts for the document with name 'Welcome to NY'.",
      "gold_sql": "SELECT T1.paragraph_id ,   T1.paragraph_text FROM Paragraphs AS T1 JOIN Documents AS T2 ON T1.document_id  =  T2.document_id WHERE T2.Document_Name  =  'Welcome to NY'",
      "predicted_sql": "SELECT p.Paragraph_ID, p.Paragraph_Text\nFROM Paragraphs p\nJOIN Documents d ON p.Document_ID = d.Document_ID\nWHERE d.Document_Name = 'Welcome to NY';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the ids and texts of paragraphs in the document titled 'Welcome to NY'?",
      "gold_sql": "SELECT T1.paragraph_id ,   T1.paragraph_text FROM Paragraphs AS T1 JOIN Documents AS T2 ON T1.document_id  =  T2.document_id WHERE T2.Document_Name  =  'Welcome to NY'",
      "predicted_sql": "SELECT p.Paragraph_ID, p.Paragraph_Text\nFROM Paragraphs p\nJOIN Documents d ON p.Document_ID = d.Document_ID\nWHERE d.Document_Name = 'Welcome to NY';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show all paragraph texts for the document \"Customer reviews\".",
      "gold_sql": "SELECT T1.paragraph_text FROM Paragraphs AS T1 JOIN Documents AS T2 ON T1.document_id  =  T2.document_id WHERE T2.document_name  =  \"Customer reviews\"",
      "predicted_sql": "SELECT p.Paragraph_Text\nFROM Paragraphs p\nJOIN Documents d ON p.Document_ID = d.Document_ID\nWHERE d.Document_Name = 'Customer reviews';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the paragraph texts for the document with the name 'Customer reviews'?",
      "gold_sql": "SELECT T1.paragraph_text FROM Paragraphs AS T1 JOIN Documents AS T2 ON T1.document_id  =  T2.document_id WHERE T2.document_name  =  \"Customer reviews\"",
      "predicted_sql": "SELECT p.Paragraph_Text\nFROM Paragraphs p\nJOIN Documents d ON p.Document_ID = d.Document_ID\nWHERE d.Document_Name = 'Customer reviews';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show all document ids and the number of paragraphs in each document. Order by document id.",
      "gold_sql": "SELECT document_id ,  count(*) FROM Paragraphs GROUP BY document_id ORDER BY document_id",
      "predicted_sql": "SELECT d.Document_ID, COUNT(p.Paragraph_ID) AS Number_of_Paragraphs\nFROM Documents d\nLEFT JOIN Paragraphs p ON d.Document_ID = p.Document_ID\nGROUP BY d.Document_ID\nORDER BY d.Document_ID;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the different document ids along with the number of paragraphs corresponding to each, ordered by id.",
      "gold_sql": "SELECT document_id ,  count(*) FROM Paragraphs GROUP BY document_id ORDER BY document_id",
      "predicted_sql": "SELECT d.Document_ID, COUNT(p.Paragraph_ID) AS Number_of_Paragraphs\nFROM Documents d\nLEFT JOIN Paragraphs p ON d.Document_ID = p.Document_ID\nGROUP BY d.Document_ID\nORDER BY d.Document_ID;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show all document ids, names and the number of paragraphs in each document.",
      "gold_sql": "SELECT T1.document_id ,  T2.document_name ,  count(*) FROM Paragraphs AS T1 JOIN Documents AS T2 ON T1.document_id  =  T2.document_id GROUP BY T1.document_id",
      "predicted_sql": "SELECT d.Document_ID, d.Document_Name, COUNT(p.Paragraph_ID) AS Number_of_Paragraphs\nFROM Documents d\nLEFT JOIN Paragraphs p ON d.Document_ID = p.Document_ID\nGROUP BY d.Document_ID, d.Document_Name;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the ids and names of each document, as well as the number of paragraphs in each?",
      "gold_sql": "SELECT T1.document_id ,  T2.document_name ,  count(*) FROM Paragraphs AS T1 JOIN Documents AS T2 ON T1.document_id  =  T2.document_id GROUP BY T1.document_id",
      "predicted_sql": "SELECT d.Document_ID, d.Document_Name, COUNT(p.Paragraph_ID) AS Number_of_Paragraphs\nFROM Documents d\nLEFT JOIN Paragraphs p ON d.Document_ID = p.Document_ID\nGROUP BY d.Document_ID, d.Document_Name;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "List all document ids with at least two paragraphs.",
      "gold_sql": "SELECT document_id FROM Paragraphs GROUP BY document_id HAVING count(*)  >=  2",
      "predicted_sql": "SELECT d.Document_ID\nFROM Documents d\nJOIN Paragraphs p ON d.Document_ID = p.Document_ID\nGROUP BY d.Document_ID\nHAVING COUNT(p.Paragraph_ID) >= 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the ids of documents that have 2 or more paragraphs?",
      "gold_sql": "SELECT document_id FROM Paragraphs GROUP BY document_id HAVING count(*)  >=  2",
      "predicted_sql": "SELECT d.Document_ID\nFROM Documents d\nJOIN Paragraphs p ON d.Document_ID = p.Document_ID\nGROUP BY d.Document_ID\nHAVING COUNT(p.Paragraph_ID) >= 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What is the document id and name with greatest number of paragraphs?",
      "gold_sql": "SELECT T1.document_id ,  T2.document_name FROM Paragraphs AS T1 JOIN Documents AS T2 ON T1.document_id  =  T2.document_id GROUP BY T1.document_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT d.Document_ID, d.Document_Name\nFROM Documents d\nJOIN Paragraphs p ON d.Document_ID = p.Document_ID\nGROUP BY d.Document_ID, d.Document_Name\nORDER BY COUNT(p.Paragraph_ID) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the id and name of the document with the most paragraphs.",
      "gold_sql": "SELECT T1.document_id ,  T2.document_name FROM Paragraphs AS T1 JOIN Documents AS T2 ON T1.document_id  =  T2.document_id GROUP BY T1.document_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT d.Document_ID, d.Document_Name\nFROM Documents d\nJOIN Paragraphs p ON d.Document_ID = p.Document_ID\nGROUP BY d.Document_ID, d.Document_Name\nORDER BY COUNT(p.Paragraph_ID) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What is the document id with least number of paragraphs?",
      "gold_sql": "SELECT document_id FROM Paragraphs GROUP BY document_id ORDER BY count(*) ASC LIMIT 1",
      "predicted_sql": "SELECT d.Document_ID\nFROM Documents d\nLEFT JOIN Paragraphs p ON d.Document_ID = p.Document_ID\nGROUP BY d.Document_ID\nORDER BY COUNT(p.Paragraph_ID) ASC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Return the id of the document with the fewest paragraphs.",
      "gold_sql": "SELECT document_id FROM Paragraphs GROUP BY document_id ORDER BY count(*) ASC LIMIT 1",
      "predicted_sql": "SELECT d.Document_ID\nFROM Documents d\nLEFT JOIN Paragraphs p ON d.Document_ID = p.Document_ID\nGROUP BY d.Document_ID\nORDER BY COUNT(p.Paragraph_ID) ASC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What is the document id with 1 to 2 paragraphs?",
      "gold_sql": "SELECT document_id FROM Paragraphs GROUP BY document_id HAVING count(*) BETWEEN 1 AND 2",
      "predicted_sql": "SELECT d.Document_ID\nFROM Documents d\nJOIN Paragraphs p ON d.Document_ID = p.Document_ID\nGROUP BY d.Document_ID\nHAVING COUNT(p.Paragraph_ID) BETWEEN 1 AND 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Give the ids of documents that have between one and two paragraphs.",
      "gold_sql": "SELECT document_id FROM Paragraphs GROUP BY document_id HAVING count(*) BETWEEN 1 AND 2",
      "predicted_sql": "SELECT d.Document_ID\nFROM Documents d\nJOIN Paragraphs p ON d.Document_ID = p.Document_ID\nGROUP BY d.Document_ID\nHAVING COUNT(p.Paragraph_ID) BETWEEN 1 AND 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "Show the document id with paragraph text 'Brazil' and 'Ireland'.",
      "gold_sql": "SELECT document_id FROM Paragraphs WHERE paragraph_text  =  'Brazil' INTERSECT SELECT document_id FROM Paragraphs WHERE paragraph_text  =  'Ireland'",
      "predicted_sql": "SELECT DISTINCT p.Document_ID\nFROM Paragraphs p\nWHERE p.Paragraph_Text IN ('Brazil', 'Ireland');",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "cre_Doc_Template_Mgt",
      "question": "What are the ids of documents that contain the paragraph text 'Brazil' and 'Ireland'?",
      "gold_sql": "SELECT document_id FROM Paragraphs WHERE paragraph_text  =  'Brazil' INTERSECT SELECT document_id FROM Paragraphs WHERE paragraph_text  =  'Ireland'",
      "predicted_sql": "SELECT d.Document_ID\nFROM Documents d\nJOIN Paragraphs p ON d.Document_ID = p.Document_ID\nWHERE p.Paragraph_Text IN ('Brazil', 'Ireland')\nGROUP BY d.Document_ID\nHAVING COUNT(DISTINCT p.Paragraph_Text) = 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "How many teachers are there?",
      "gold_sql": "SELECT count(*) FROM teacher",
      "predicted_sql": "SELECT COUNT(*) AS Teacher_Count FROM teacher;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What is the total count of teachers?",
      "gold_sql": "SELECT count(*) FROM teacher",
      "predicted_sql": "SELECT COUNT(*) AS Total_Teachers FROM teacher;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "List the names of teachers in ascending order of age.",
      "gold_sql": "SELECT Name FROM teacher ORDER BY Age ASC",
      "predicted_sql": "SELECT Name \nFROM teacher \nORDER BY CAST(Age AS INT) ASC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What are the names of the teachers ordered by ascending age?",
      "gold_sql": "SELECT Name FROM teacher ORDER BY Age ASC",
      "predicted_sql": "SELECT t.Name\nFROM teacher t\nORDER BY CAST(t.Age AS INT) ASC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What are the age and hometown of teachers?",
      "gold_sql": "SELECT Age ,  Hometown FROM teacher",
      "predicted_sql": "SELECT t.Age, t.Hometown\nFROM teacher t;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What is the age and hometown of every teacher?",
      "gold_sql": "SELECT Age ,  Hometown FROM teacher",
      "predicted_sql": "SELECT t.Age, t.Hometown\nFROM teacher t;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "List the name of teachers whose hometown is not \"Little Lever Urban District\".",
      "gold_sql": "SELECT Name FROM teacher WHERE Hometown != \"Little Lever Urban Distric\"",
      "predicted_sql": "SELECT t.Name \nFROM teacher t \nWHERE t.Hometown IS NULL OR t.Hometown <> 'Little Lever Urban District';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What are the names of the teachers whose hometown is not \"Little Lever Urban District\"?",
      "gold_sql": "SELECT Name FROM teacher WHERE Hometown != \"Little Lever Urban Distric\"",
      "predicted_sql": "SELECT t.Name \nFROM teacher t \nWHERE t.Hometown IS NULL OR t.Hometown <> 'Little Lever Urban District';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "Show the name of teachers aged either 32 or 33?",
      "gold_sql": "SELECT Name FROM teacher WHERE Age  =  32 OR Age  =  33",
      "predicted_sql": "SELECT t.Name\nFROM teacher t\nWHERE CAST(t.Age AS INT) IN (32, 33);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What are the names of the teachers who are aged either 32 or 33?",
      "gold_sql": "SELECT Name FROM teacher WHERE Age  =  32 OR Age  =  33",
      "predicted_sql": "SELECT t.Name \nFROM teacher t \nWHERE t.Age IN ('32', '33');",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What is the hometown of the youngest teacher?",
      "gold_sql": "SELECT Hometown FROM teacher ORDER BY Age ASC LIMIT 1",
      "predicted_sql": "SELECT t.Hometown\nFROM teacher t\nWHERE t.Age = (SELECT MIN(Age) FROM teacher);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "Where is the youngest teacher from?",
      "gold_sql": "SELECT Hometown FROM teacher ORDER BY Age ASC LIMIT 1",
      "predicted_sql": "SELECT Hometown \nFROM teacher \nWHERE Age = (SELECT MIN(Age) FROM teacher);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "Show different hometown of teachers and the number of teachers from each hometown.",
      "gold_sql": "SELECT Hometown ,  COUNT(*) FROM teacher GROUP BY Hometown",
      "predicted_sql": "SELECT t.Hometown, COUNT(t.Teacher_ID) AS NumberOfTeachers\nFROM teacher t\nGROUP BY t.Hometown;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "For each hometown, how many teachers are there?",
      "gold_sql": "SELECT Hometown ,  COUNT(*) FROM teacher GROUP BY Hometown",
      "predicted_sql": "SELECT t.Hometown, COUNT(t.Teacher_ID) AS Teacher_Count\nFROM teacher t\nGROUP BY t.Hometown;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "List the most common hometown of teachers.",
      "gold_sql": "SELECT Hometown FROM teacher GROUP BY Hometown ORDER BY COUNT(*) DESC LIMIT 1",
      "predicted_sql": "SELECT Hometown, COUNT(*) AS Hometown_Count\nFROM teacher\nGROUP BY Hometown\nORDER BY Hometown_Count DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What is the most commmon hometowns for teachers?",
      "gold_sql": "SELECT Hometown FROM teacher GROUP BY Hometown ORDER BY COUNT(*) DESC LIMIT 1",
      "predicted_sql": "SELECT Hometown, COUNT(*) AS Hometown_Count\nFROM teacher\nGROUP BY Hometown\nORDER BY Hometown_Count DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "Show the hometowns shared by at least two teachers.",
      "gold_sql": "SELECT Hometown FROM teacher GROUP BY Hometown HAVING COUNT(*)  >=  2",
      "predicted_sql": "SELECT t.Hometown\nFROM teacher t\nGROUP BY t.Hometown\nHAVING COUNT(t.Teacher_ID) >= 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What are the towns from which at least two teachers come from?",
      "gold_sql": "SELECT Hometown FROM teacher GROUP BY Hometown HAVING COUNT(*)  >=  2",
      "predicted_sql": "SELECT Hometown\nFROM teacher\nGROUP BY Hometown\nHAVING COUNT(Teacher_ID) >= 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "Show names of teachers and the courses they are arranged to teach.",
      "gold_sql": "SELECT T3.Name ,  T2.Course FROM course_arrange AS T1 JOIN course AS T2 ON T1.Course_ID  =  T2.Course_ID JOIN teacher AS T3 ON T1.Teacher_ID  =  T3.Teacher_ID",
      "predicted_sql": "SELECT t.Name, c.Course\nFROM teacher t\nJOIN course_arrange ca ON t.Teacher_ID = ca.Teacher_ID\nJOIN course c ON ca.Course_ID = c.Course_ID;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What is the name of each teacher and what course they teach?",
      "gold_sql": "SELECT T3.Name ,  T2.Course FROM course_arrange AS T1 JOIN course AS T2 ON T1.Course_ID  =  T2.Course_ID JOIN teacher AS T3 ON T1.Teacher_ID  =  T3.Teacher_ID",
      "predicted_sql": "SELECT t.Name, c.Course\nFROM teacher t\nJOIN course_arrange ca ON t.Teacher_ID = ca.Teacher_ID\nJOIN course c ON ca.Course_ID = c.Course_ID;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "Show names of teachers and the courses they are arranged to teach in ascending alphabetical order of the teacher's name.",
      "gold_sql": "SELECT T3.Name ,  T2.Course FROM course_arrange AS T1 JOIN course AS T2 ON T1.Course_ID  =  T2.Course_ID JOIN teacher AS T3 ON T1.Teacher_ID  =  T3.Teacher_ID ORDER BY T3.Name",
      "predicted_sql": "SELECT t.Name, c.Course\nFROM teacher t\nJOIN course_arrange ca ON t.Teacher_ID = ca.Teacher_ID\nJOIN course c ON ca.Course_ID = c.Course_ID\nORDER BY t.Name ASC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What are the names of the teachers and the courses they teach in ascending alphabetical order by the name of the teacher?",
      "gold_sql": "SELECT T3.Name ,  T2.Course FROM course_arrange AS T1 JOIN course AS T2 ON T1.Course_ID  =  T2.Course_ID JOIN teacher AS T3 ON T1.Teacher_ID  =  T3.Teacher_ID ORDER BY T3.Name",
      "predicted_sql": "SELECT t.Name AS Teacher_Name, c.Course AS Course_Name\nFROM teacher t\nJOIN course_arrange ca ON t.Teacher_ID = ca.Teacher_ID\nJOIN course c ON ca.Course_ID = c.Course_ID\nORDER BY t.Name ASC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "Show the name of the teacher for the math course.",
      "gold_sql": "SELECT T3.Name FROM course_arrange AS T1 JOIN course AS T2 ON T1.Course_ID  =  T2.Course_ID JOIN teacher AS T3 ON T1.Teacher_ID  =  T3.Teacher_ID WHERE T2.Course  =  \"Math\"",
      "predicted_sql": "SELECT t.Name\nFROM teacher t\nJOIN course_arrange ca ON t.Teacher_ID = ca.Teacher_ID\nJOIN course c ON ca.Course_ID = c.Course_ID\nWHERE c.Course = 'math';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What are the names of the people who teach math courses?",
      "gold_sql": "SELECT T3.Name FROM course_arrange AS T1 JOIN course AS T2 ON T1.Course_ID  =  T2.Course_ID JOIN teacher AS T3 ON T1.Teacher_ID  =  T3.Teacher_ID WHERE T2.Course  =  \"Math\"",
      "predicted_sql": "SELECT DISTINCT t.Name\nFROM teacher t\nJOIN course_arrange ca ON t.Teacher_ID = ca.Teacher_ID\nJOIN course c ON ca.Course_ID = c.Course_ID\nWHERE c.Course = 'math';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "Show names of teachers and the number of courses they teach.",
      "gold_sql": "SELECT T2.Name ,  COUNT(*) FROM course_arrange AS T1 JOIN teacher AS T2 ON T1.Teacher_ID  =  T2.Teacher_ID GROUP BY T2.Name",
      "predicted_sql": "SELECT t.Name, COUNT(ca.Course_ID) AS NumberOfCourses\nFROM teacher t\nLEFT JOIN course_arrange ca ON t.Teacher_ID = ca.Teacher_ID\nGROUP BY t.Name;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What are the names of the teachers and how many courses do they teach?",
      "gold_sql": "SELECT T2.Name ,  COUNT(*) FROM course_arrange AS T1 JOIN teacher AS T2 ON T1.Teacher_ID  =  T2.Teacher_ID GROUP BY T2.Name",
      "predicted_sql": "SELECT t.Name, COUNT(ca.Course_ID) AS NumberOfCourses\nFROM teacher t\nLEFT JOIN course_arrange ca ON t.Teacher_ID = ca.Teacher_ID\nGROUP BY t.Name;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "Show names of teachers that teach at least two courses.",
      "gold_sql": "SELECT T2.Name FROM course_arrange AS T1 JOIN teacher AS T2 ON T1.Teacher_ID  =  T2.Teacher_ID GROUP BY T2.Name HAVING COUNT(*)  >=  2",
      "predicted_sql": "SELECT t.Name\nFROM teacher t\nJOIN course_arrange ca ON t.Teacher_ID = ca.Teacher_ID\nGROUP BY t.Teacher_ID, t.Name\nHAVING COUNT(DISTINCT ca.Course_ID) >= 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What are the names of the teachers who teach at least two courses?",
      "gold_sql": "SELECT T2.Name FROM course_arrange AS T1 JOIN teacher AS T2 ON T1.Teacher_ID  =  T2.Teacher_ID GROUP BY T2.Name HAVING COUNT(*)  >=  2",
      "predicted_sql": "SELECT t.Name\nFROM teacher t\nJOIN course_arrange ca ON t.Teacher_ID = ca.Teacher_ID\nGROUP BY t.Teacher_ID, t.Name\nHAVING COUNT(DISTINCT ca.Course_ID) >= 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "List the names of teachers who have not been arranged to teach courses.",
      "gold_sql": "SELECT Name FROM teacher WHERE Teacher_id NOT IN (SELECT Teacher_id FROM course_arrange)",
      "predicted_sql": "SELECT t.Name\nFROM teacher t\nLEFT JOIN course_arrange ca ON t.Teacher_ID = ca.Teacher_ID\nWHERE ca.Course_ID IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "course_teach",
      "question": "What are the names of the teachers whose courses have not been arranged?",
      "gold_sql": "SELECT Name FROM teacher WHERE Teacher_id NOT IN (SELECT Teacher_id FROM course_arrange)",
      "predicted_sql": "SELECT t.Name\nFROM teacher t\nLEFT JOIN course_arrange ca ON t.Teacher_ID = ca.Teacher_ID\nWHERE ca.Course_ID IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "How many visitors below age 30 are there?",
      "gold_sql": "SELECT count(*) FROM visitor WHERE age  <  30",
      "predicted_sql": "SELECT COUNT(*) AS Number_of_Visitors_Below_30\nFROM visitor\nWHERE Age < 30;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "Find the names of the visitors whose membership level is higher than 4, and order the results by the level from high to low.",
      "gold_sql": "SELECT name FROM visitor WHERE Level_of_membership  >  4 ORDER BY Level_of_membership DESC",
      "predicted_sql": "SELECT v.Name\nFROM visitor v\nWHERE v.Level_of_membership > 4\nORDER BY v.Level_of_membership DESC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "What is the average age of the visitors whose membership level is not higher than 4?",
      "gold_sql": "SELECT avg(age) FROM visitor WHERE Level_of_membership  <=  4",
      "predicted_sql": "SELECT AVG(Age) AS Average_Age\nFROM visitor\nWHERE Level_of_membership <= 4;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "Find the name and membership level of the visitors whose membership level is higher than 4, and sort by their age from old to young.",
      "gold_sql": "SELECT name ,  Level_of_membership FROM visitor WHERE Level_of_membership  >  4 ORDER BY age DESC",
      "predicted_sql": "SELECT v.Name, v.Level_of_membership\nFROM visitor v\nWHERE v.Level_of_membership > 4\nORDER BY v.Age DESC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "Find the id and name of the museum that has the most staff members?",
      "gold_sql": "SELECT museum_id ,  name FROM museum ORDER BY num_of_staff DESC LIMIT 1",
      "predicted_sql": "SELECT m.Museum_ID, m.Name\nFROM museum m\nWHERE m.Num_of_Staff = (SELECT MAX(Num_of_Staff) FROM museum);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "Find the average number of staff working for the museums that were open before 2009.",
      "gold_sql": "SELECT avg(num_of_staff) FROM museum WHERE open_year  <  2009",
      "predicted_sql": "SELECT AVG(m.Num_of_Staff) AS Average_Staff\nFROM museum m\nWHERE m.Open_Year < '2009';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "What are the opening year and staff number of the museum named Plaza Museum?",
      "gold_sql": "SELECT Num_of_Staff ,  Open_Year FROM museum WHERE name  =  'Plaza Museum'",
      "predicted_sql": "SELECT m.Open_Year, m.Num_of_Staff\nFROM museum m\nWHERE m.Name = 'Plaza Museum';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "find the names of museums which have more staff than the minimum staff number of all museums opened after 2010.",
      "gold_sql": "SELECT name FROM museum WHERE num_of_staff  >  (SELECT min(num_of_staff) FROM museum WHERE open_year  >  2010)",
      "predicted_sql": "SELECT m.Name\nFROM museum m\nWHERE m.Num_of_Staff > (SELECT MIN(Num_of_Staff) FROM museum WHERE Open_Year > '2010');",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "find the id, name and age for visitors who visited some museums more than once.",
      "gold_sql": "SELECT t1.id ,  t1.name ,  t1.age FROM visitor AS t1 JOIN visit AS t2 ON t1.id  =  t2.visitor_id GROUP BY t1.id HAVING count(*)  >  1",
      "predicted_sql": "SELECT v.ID, v.Name, v.Age\nFROM visitor v\nJOIN visit vi ON v.ID = vi.visitor_ID\nGROUP BY v.ID, v.Name, v.Age\nHAVING COUNT(vi.Museum_ID) > 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "What are the id, name and membership level of visitors who have spent the largest amount of money in total in all museum tickets?",
      "gold_sql": "SELECT t2.visitor_id ,  t1.name ,  t1.Level_of_membership FROM visitor AS t1 JOIN visit AS t2 ON t1.id  =  t2.visitor_id GROUP BY t2.visitor_id ORDER BY sum(t2.Total_spent) DESC LIMIT 1",
      "predicted_sql": "SELECT v.ID, v.Name, v.Level_of_membership\nFROM visitor v\nJOIN visit vi ON v.ID = vi.visitor_ID\nGROUP BY v.ID, v.Name, v.Level_of_membership\nORDER BY SUM(vi.Total_spent) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "What are the id and name of the museum visited most times?",
      "gold_sql": "SELECT t2.Museum_ID ,  t1.name FROM museum AS t1 JOIN visit AS t2 ON t1.Museum_ID  =  t2.Museum_ID GROUP BY t2.Museum_ID ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT m.Museum_ID, m.Name\nFROM museum m\nJOIN visit v ON m.Museum_ID = v.Museum_ID\nGROUP BY m.Museum_ID, m.Name\nORDER BY COUNT(v.visitor_ID) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "What is the name of the museum that had no visitor yet?",
      "gold_sql": "SELECT name FROM museum WHERE Museum_ID NOT IN (SELECT museum_id FROM visit)",
      "predicted_sql": "SELECT m.Name \nFROM museum m \nLEFT JOIN visit v ON m.Museum_ID = v.Museum_ID \nWHERE v.visitor_ID IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "Find the name and age of the visitor who bought the most tickets at once.",
      "gold_sql": "SELECT t1.name ,  t1.age FROM visitor AS t1 JOIN visit AS t2 ON t1.id  =  t2.visitor_id ORDER BY t2.num_of_ticket DESC LIMIT 1",
      "predicted_sql": "SELECT v.Name, v.Age\nFROM visitor v\nJOIN visit vi ON v.ID = vi.visitor_ID\nWHERE vi.Num_of_Ticket = (\n    SELECT MAX(Num_of_Ticket)\n    FROM visit\n)",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "What are the average and maximum number of tickets bought in all visits?",
      "gold_sql": "SELECT avg(num_of_ticket) ,  max(num_of_ticket) FROM visit",
      "predicted_sql": "SELECT AVG(Num_of_Ticket) AS Average_Tickets, MAX(Num_of_Ticket) AS Maximum_Tickets\nFROM visit;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "What is the total ticket expense of the visitors whose membership level is 1?",
      "gold_sql": "SELECT sum(t2.Total_spent) FROM visitor AS t1 JOIN visit AS t2 ON t1.id  =  t2.visitor_id WHERE t1.Level_of_membership  =  1",
      "predicted_sql": "SELECT COALESCE(SUM(v.Total_spent), 0) AS Total_Expense\nFROM visit v\nJOIN visitor vi ON v.visitor_ID = vi.ID\nWHERE vi.Level_of_membership = 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "What is the name of the visitor who visited both a museum opened before 2009 and a museum opened after 2011?",
      "gold_sql": "SELECT t1.name FROM visitor AS t1 JOIN visit AS t2 ON t1.id  =  t2.visitor_id JOIN museum AS t3 ON t3.Museum_ID  =  t2.Museum_ID WHERE t3.open_year  <  2009 INTERSECT SELECT t1.name FROM visitor AS t1 JOIN visit AS t2 ON t1.id  =  t2.visitor_id JOIN museum AS t3 ON t3.Museum_ID  =  t2.Museum_ID WHERE t3.open_year  >  2011",
      "predicted_sql": "SELECT DISTINCT v.Name\nFROM visitor v\nJOIN visit vi1 ON v.ID = vi1.visitor_ID\nJOIN museum m1 ON vi1.Museum_ID = m1.Museum_ID\nJOIN visit vi2 ON v.ID = vi2.visitor_ID\nJOIN museum m2 ON vi2.Museum_ID = m2.Museum_ID\nWHERE m1.Open_Year < '2009' AND m2.Open_Year > '2011';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "Find the number of visitors who did not visit any museum opened after 2010.",
      "gold_sql": "SELECT count(*) FROM visitor WHERE id NOT IN (SELECT t2.visitor_id FROM museum AS t1 JOIN visit AS t2 ON t1.Museum_ID  =  t2.Museum_ID WHERE t1.open_year  >  2010)",
      "predicted_sql": "SELECT COUNT(DISTINCT v.ID) AS Num_of_Visitors\nFROM visitor v\nWHERE v.ID NOT IN (\n    SELECT DISTINCT vi.visitor_ID\n    FROM visit vi\n    JOIN museum m ON vi.Museum_ID = m.Museum_ID\n    WHERE m.Open_Year > '2010'\n);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "museum_visit",
      "question": "How many museums were opened after 2013 or before 2008?",
      "gold_sql": "SELECT count(*) FROM museum WHERE open_year  >  2013 OR open_year  <  2008",
      "predicted_sql": "SELECT COUNT(*) AS Museum_Count\nFROM museum\nWHERE Open_Year > '2013' OR Open_Year < '2008';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the total number of players.",
      "gold_sql": "SELECT count(*) FROM players",
      "predicted_sql": "SELECT COUNT(*) AS total_players FROM players;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "How many players are there?",
      "gold_sql": "SELECT count(*) FROM players",
      "predicted_sql": "SELECT COUNT(*) AS total_players FROM players;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the total number of matches.",
      "gold_sql": "SELECT count(*) FROM matches",
      "predicted_sql": "SELECT COUNT(*) AS total_matches FROM matches;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Count the number of matches.",
      "gold_sql": "SELECT count(*) FROM matches",
      "predicted_sql": "SELECT COUNT(*) AS total_matches FROM matches;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "List the first name and birth date of all players from the country with code USA.",
      "gold_sql": "SELECT first_name ,  birth_date FROM players WHERE country_code  =  'USA'",
      "predicted_sql": "SELECT p.first_name, p.birth_date\nFROM players p\nWHERE p.country_code = 'USA';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What are the first names and birth dates of players from the USA?",
      "gold_sql": "SELECT first_name ,  birth_date FROM players WHERE country_code  =  'USA'",
      "predicted_sql": "SELECT p.first_name, p.birth_date\nFROM players p\nWHERE p.country_code = 'USA';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the average age of losers and winners of all matches.",
      "gold_sql": "SELECT avg(loser_age) ,  avg(winner_age) FROM matches",
      "predicted_sql": "SELECT \n    AVG(COALESCE(loser_age, 0)) AS average_loser_age,\n    AVG(COALESCE(winner_age, 0)) AS average_winner_age\nFROM matches;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What are the average ages of losers and winners across matches?",
      "gold_sql": "SELECT avg(loser_age) ,  avg(winner_age) FROM matches",
      "predicted_sql": "SELECT \n    AVG(loser_age) AS average_loser_age,\n    AVG(winner_age) AS average_winner_age\nFROM \n    matches;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the average rank of winners in all matches.",
      "gold_sql": "SELECT avg(winner_rank) FROM matches",
      "predicted_sql": "SELECT AVG(winner_rank) AS average_winner_rank\nFROM matches;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What is the average rank for winners in all matches?",
      "gold_sql": "SELECT avg(winner_rank) FROM matches",
      "predicted_sql": "SELECT AVG(m.winner_rank) AS average_winner_rank\nFROM matches m;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the highest rank of losers in all matches.",
      "gold_sql": "SELECT min(loser_rank) FROM matches",
      "predicted_sql": "SELECT MIN(m.loser_rank) AS highest_loser_rank\nFROM matches m;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What is the best rank of losers across all matches?",
      "gold_sql": "SELECT min(loser_rank) FROM matches",
      "predicted_sql": "SELECT MIN(loser_rank) AS best_loser_rank\nFROM matches\nWHERE loser_rank IS NOT NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "find the number of distinct country codes of all players.",
      "gold_sql": "SELECT count(DISTINCT country_code) FROM players",
      "predicted_sql": "SELECT COUNT(DISTINCT country_code) AS distinct_country_codes\nFROM players;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "How many distinct countries do players come from?",
      "gold_sql": "SELECT count(DISTINCT country_code) FROM players",
      "predicted_sql": "SELECT COUNT(DISTINCT country_code) AS distinct_country_count\nFROM players;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the number of distinct name of losers.",
      "gold_sql": "SELECT count(DISTINCT loser_name) FROM matches",
      "predicted_sql": "SELECT COUNT(DISTINCT loser_name) AS distinct_loser_names\nFROM matches;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "How many different loser names are there?",
      "gold_sql": "SELECT count(DISTINCT loser_name) FROM matches",
      "predicted_sql": "SELECT COUNT(DISTINCT loser_name) AS different_loser_names\nFROM matches;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the name of tourney that has more than 10 matches.",
      "gold_sql": "SELECT tourney_name FROM matches GROUP BY tourney_name HAVING count(*)  >  10",
      "predicted_sql": "SELECT m.tourney_name\nFROM matches m\nGROUP BY m.tourney_name\nHAVING COUNT(m.match_num) > 10;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What are the names of tournaments that have more than 10 matches?",
      "gold_sql": "SELECT tourney_name FROM matches GROUP BY tourney_name HAVING count(*)  >  10",
      "predicted_sql": "SELECT m.tourney_name\nFROM matches m\nGROUP BY m.tourney_name\nHAVING COUNT(m.match_num) > 10;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "List the names of all winners who played in both 2013 and 2016.",
      "gold_sql": "SELECT winner_name FROM matches WHERE YEAR  =  2013 INTERSECT SELECT winner_name FROM matches WHERE YEAR  =  2016",
      "predicted_sql": "SELECT DISTINCT m1.winner_name\nFROM matches m1\nJOIN matches m2 ON m1.winner_id = m2.winner_id\nWHERE m1.year = 2013 AND m2.year = 2016;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What are the names of players who won in both 2013 and 2016?",
      "gold_sql": "SELECT winner_name FROM matches WHERE YEAR  =  2013 INTERSECT SELECT winner_name FROM matches WHERE YEAR  =  2016",
      "predicted_sql": "SELECT p.first_name, p.last_name\nFROM players p\nJOIN matches m ON p.player_id = m.winner_id\nWHERE m.year IN (2013, 2016)\nGROUP BY p.player_id, p.first_name, p.last_name\nHAVING COUNT(DISTINCT m.year) = 2;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "List the number of all matches who played in years of 2013 or 2016.",
      "gold_sql": "SELECT count(*) FROM matches WHERE YEAR  =  2013 OR YEAR  =  2016",
      "predicted_sql": "SELECT COUNT(*) AS total_matches\nFROM matches\nWHERE year IN (2013, 2016);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "How many matches were played in 2013 or 2016?",
      "gold_sql": "SELECT count(*) FROM matches WHERE YEAR  =  2013 OR YEAR  =  2016",
      "predicted_sql": "SELECT COUNT(*) AS matches_played\nFROM matches\nWHERE year IN (2013, 2016);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What are the country code and first name of the players who won in both tourney WTA Championships and Australian Open?",
      "gold_sql": "SELECT T1.country_code ,  T1.first_name FROM players AS T1 JOIN matches AS T2 ON T1.player_id  =  T2.winner_id WHERE T2.tourney_name  =  'WTA Championships' INTERSECT SELECT T1.country_code ,  T1.first_name FROM players AS T1 JOIN matches AS T2 ON T1.player_id  =  T2.winner_id WHERE T2.tourney_name  =  'Australian Open'",
      "predicted_sql": "SELECT DISTINCT p.country_code, p.first_name\nFROM players p\nJOIN matches m1 ON p.player_id = m1.winner_id\nJOIN matches m2 ON p.player_id = m2.winner_id\nWHERE m1.tourney_name = 'WTA Championships' AND m2.tourney_name = 'Australian Open';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What are the first names and country codes for players who won both the WTA Championships and the Australian Open?",
      "gold_sql": "SELECT T1.country_code ,  T1.first_name FROM players AS T1 JOIN matches AS T2 ON T1.player_id  =  T2.winner_id WHERE T2.tourney_name  =  'WTA Championships' INTERSECT SELECT T1.country_code ,  T1.first_name FROM players AS T1 JOIN matches AS T2 ON T1.player_id  =  T2.winner_id WHERE T2.tourney_name  =  'Australian Open'",
      "predicted_sql": "SELECT DISTINCT p.first_name, p.country_code\nFROM players p\nJOIN matches m1 ON p.player_id = m1.winner_id AND m1.tourney_name = 'WTA Championships'\nJOIN matches m2 ON p.player_id = m2.winner_id AND m2.tourney_name = 'Australian Open';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the first name and country code of the oldest player.",
      "gold_sql": "SELECT first_name ,  country_code FROM players ORDER BY birth_date LIMIT 1",
      "predicted_sql": "SELECT p.first_name, p.country_code\nFROM players p\nWHERE p.birth_date = (SELECT MIN(birth_date) FROM players);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What is the first name and country code of the oldest player?",
      "gold_sql": "SELECT first_name ,  country_code FROM players ORDER BY birth_date LIMIT 1",
      "predicted_sql": "SELECT p.first_name, p.country_code\nFROM players p\nWHERE p.birth_date = (SELECT MIN(birth_date) FROM players);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "List the first and last name of all players in the order of birth date.",
      "gold_sql": "SELECT first_name ,  last_name FROM players ORDER BY birth_date",
      "predicted_sql": "SELECT p.first_name, p.last_name \nFROM players p \nORDER BY p.birth_date;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What are the full names of all players, sorted by birth date?",
      "gold_sql": "SELECT first_name ,  last_name FROM players ORDER BY birth_date",
      "predicted_sql": "SELECT CONCAT(p.first_name, ' ', p.last_name) AS full_name\nFROM players p\nORDER BY p.birth_date;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "List the first and last name of all players who are left / L hand in the order of birth date.",
      "gold_sql": "SELECT first_name ,  last_name FROM players WHERE hand  =  'L' ORDER BY birth_date",
      "predicted_sql": "SELECT p.first_name, p.last_name\nFROM players p\nWHERE p.hand = 'L'\nORDER BY p.birth_date;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What are the full names of all left handed players, in order of birth date?",
      "gold_sql": "SELECT first_name ,  last_name FROM players WHERE hand  =  'L' ORDER BY birth_date",
      "predicted_sql": "SELECT CONCAT(p.first_name, ' ', p.last_name) AS full_name\nFROM players p\nWHERE p.hand = 'left'\nORDER BY p.birth_date;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the first name and country code of the player who did the most number of tours.",
      "gold_sql": "SELECT T1.country_code ,  T1.first_name FROM players AS T1 JOIN rankings AS T2 ON T1.player_id  =  T2.player_id ORDER BY T2.tours DESC LIMIT 1",
      "predicted_sql": "SELECT p.first_name, p.country_code\nFROM players p\nJOIN (\n    SELECT player_id, COUNT(*) AS tour_count\n    FROM rankings\n    GROUP BY player_id\n) r ON p.player_id = r.player_id\nORDER BY r.tour_count DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What is the first name and country code of the player with the most tours?",
      "gold_sql": "SELECT T1.country_code ,  T1.first_name FROM players AS T1 JOIN rankings AS T2 ON T1.player_id  =  T2.player_id ORDER BY T2.tours DESC LIMIT 1",
      "predicted_sql": "SELECT p.first_name, p.country_code\nFROM players p\nJOIN rankings r ON p.player_id = r.player_id\nGROUP BY p.player_id, p.first_name, p.country_code\nORDER BY SUM(r.tours) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the year that has the most number of matches.",
      "gold_sql": "SELECT YEAR FROM matches GROUP BY YEAR ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT year\nFROM matches\nGROUP BY year\nORDER BY COUNT(*) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": true,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Which year had the most matches?",
      "gold_sql": "SELECT YEAR FROM matches GROUP BY YEAR ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT year, COUNT(*) AS match_count\nFROM matches\nGROUP BY year\nORDER BY match_count DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the name and rank points of the winner who won the most times.",
      "gold_sql": "SELECT winner_name ,  winner_rank_points FROM matches GROUP BY winner_name ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT m.winner_name, COUNT(*) AS win_count, p.player_id, r.ranking_points\nFROM matches m\nJOIN players p ON m.winner_id = p.player_id\nJOIN rankings r ON p.player_id = r.player_id\nGROUP BY m.winner_name, p.player_id, r.ranking_points\nORDER BY win_count DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What is the name of the winner who has won the most matches, and how many rank points does this player have?",
      "gold_sql": "SELECT winner_name ,  winner_rank_points FROM matches GROUP BY winner_name ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT p.first_name || ' ' || p.last_name AS winner_name, \n       r.ranking_points\nFROM matches m\nJOIN players p ON m.winner_id = p.player_id\nJOIN rankings r ON p.player_id = r.player_id\nWHERE r.ranking_date = (SELECT MAX(ranking_date) FROM rankings WHERE player_id = p.player_id)\nGROUP BY p.player_id, p.first_name, p.last_name, r.ranking_points\nORDER BY COUNT(m.match_num) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the name of the winner who has the highest rank points and participated in the Australian Open tourney.",
      "gold_sql": "SELECT winner_name FROM matches WHERE tourney_name  =  'Australian Open' ORDER BY winner_rank_points DESC LIMIT 1",
      "predicted_sql": "SELECT m.winner_name\nFROM matches m\nWHERE m.tourney_name = 'Australian Open'\nORDER BY m.winner_rank_points DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What is the name of the winner with the most rank points who participated in the Australian Open tournament?",
      "gold_sql": "SELECT winner_name FROM matches WHERE tourney_name  =  'Australian Open' ORDER BY winner_rank_points DESC LIMIT 1",
      "predicted_sql": "SELECT winner_name \nFROM matches \nWHERE tourney_name = 'Australian Open' \nORDER BY winner_rank_points DESC \nLIMIT 1;",
      "exec_match": true,
      "exact_match": true,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "find the names of loser and winner who played in the match with greatest number of minutes.",
      "gold_sql": "SELECT winner_name ,  loser_name FROM matches ORDER BY minutes DESC LIMIT 1",
      "predicted_sql": "SELECT m.winner_name, m.loser_name\nFROM matches m\nWHERE m.minutes = (SELECT MAX(minutes) FROM matches);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What are the names of the winner and loser who played in the longest match?",
      "gold_sql": "SELECT winner_name ,  loser_name FROM matches ORDER BY minutes DESC LIMIT 1",
      "predicted_sql": "SELECT m.winner_name, m.loser_name\nFROM matches m\nORDER BY m.minutes DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the average ranking for each player and their first name.",
      "gold_sql": "SELECT avg(ranking) ,  T1.first_name FROM players AS T1 JOIN rankings AS T2 ON T1.player_id  =  T2.player_id GROUP BY T1.first_name",
      "predicted_sql": "SELECT p.first_name, AVG(r.ranking) AS average_ranking\nFROM players p\nLEFT JOIN rankings r ON p.player_id = r.player_id\nGROUP BY p.player_id, p.first_name;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What are the first names of all players, and their average rankings?",
      "gold_sql": "SELECT avg(ranking) ,  T1.first_name FROM players AS T1 JOIN rankings AS T2 ON T1.player_id  =  T2.player_id GROUP BY T1.first_name",
      "predicted_sql": "SELECT p.first_name, AVG(r.ranking) AS average_ranking\nFROM players p\nLEFT JOIN rankings r ON p.player_id = r.player_id\nGROUP BY p.first_name;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the total ranking points for each player and their first name.",
      "gold_sql": "SELECT sum(ranking_points) ,  T1.first_name FROM players AS T1 JOIN rankings AS T2 ON T1.player_id  =  T2.player_id GROUP BY T1.first_name",
      "predicted_sql": "SELECT p.first_name, COALESCE(SUM(r.ranking_points), 0) AS total_ranking_points\nFROM players p\nLEFT JOIN rankings r ON p.player_id = r.player_id\nGROUP BY p.player_id, p.first_name;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What are the first names of all players, and their total ranking points?",
      "gold_sql": "SELECT sum(ranking_points) ,  T1.first_name FROM players AS T1 JOIN rankings AS T2 ON T1.player_id  =  T2.player_id GROUP BY T1.first_name",
      "predicted_sql": "SELECT p.first_name, COALESCE(SUM(r.ranking_points), 0) AS total_ranking_points\nFROM players p\nLEFT JOIN rankings r ON p.player_id = r.player_id\nGROUP BY p.player_id, p.first_name;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "find the number of players for each country.",
      "gold_sql": "SELECT count(*) ,  country_code FROM players GROUP BY country_code",
      "predicted_sql": "SELECT country_code, COUNT(player_id) AS player_count\nFROM players\nGROUP BY country_code;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "How many players are from each country?",
      "gold_sql": "SELECT count(*) ,  country_code FROM players GROUP BY country_code",
      "predicted_sql": "SELECT country_code, COUNT(*) AS player_count\nFROM players\nGROUP BY country_code;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "find the code of the country where has the greatest number of players.",
      "gold_sql": "SELECT country_code FROM players GROUP BY country_code ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT country_code\nFROM players\nGROUP BY country_code\nORDER BY COUNT(player_id) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What is the code of the country with the most players?",
      "gold_sql": "SELECT country_code FROM players GROUP BY country_code ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT country_code\nFROM players\nGROUP BY country_code\nORDER BY COUNT(player_id) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the codes of countries that have more than 50 players.",
      "gold_sql": "SELECT country_code FROM players GROUP BY country_code HAVING count(*)  >  50",
      "predicted_sql": "SELECT country_code\nFROM players\nGROUP BY country_code\nHAVING COUNT(player_id) > 50;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What are the codes of countries with more than 50 players?",
      "gold_sql": "SELECT country_code FROM players GROUP BY country_code HAVING count(*)  >  50",
      "predicted_sql": "SELECT p.country_code\nFROM players p\nGROUP BY p.country_code\nHAVING COUNT(p.player_id) > 50;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the total number of tours for each ranking date.",
      "gold_sql": "SELECT sum(tours) ,  ranking_date FROM rankings GROUP BY ranking_date",
      "predicted_sql": "SELECT r.ranking_date, SUM(r.tours) AS total_tours\nFROM rankings r\nGROUP BY r.ranking_date;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "How many total tours were there for each ranking date?",
      "gold_sql": "SELECT sum(tours) ,  ranking_date FROM rankings GROUP BY ranking_date",
      "predicted_sql": "SELECT r.ranking_date, SUM(r.tours) AS total_tours\nFROM rankings r\nGROUP BY r.ranking_date;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the number of matches happened in each year.",
      "gold_sql": "SELECT count(*) ,  YEAR FROM matches GROUP BY YEAR",
      "predicted_sql": "SELECT year, COUNT(*) AS match_count\nFROM matches\nGROUP BY year\nORDER BY year;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "How many matches were played in each year?",
      "gold_sql": "SELECT count(*) ,  YEAR FROM matches GROUP BY YEAR",
      "predicted_sql": "SELECT year, COUNT(*) AS matches_played\nFROM matches\nGROUP BY year\nORDER BY year;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the name and rank of the 3 youngest winners across all matches.",
      "gold_sql": "SELECT DISTINCT winner_name ,  winner_rank FROM matches ORDER BY winner_age LIMIT 3",
      "predicted_sql": "SELECT p.first_name || ' ' || p.last_name AS winner_name, m.winner_rank\nFROM matches m\nJOIN players p ON m.winner_id = p.player_id\nORDER BY p.birth_date DESC\nLIMIT 3;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What are the names and ranks of the three youngest winners across all matches?",
      "gold_sql": "SELECT DISTINCT winner_name ,  winner_rank FROM matches ORDER BY winner_age LIMIT 3",
      "predicted_sql": "SELECT p.first_name, p.last_name, m.winner_rank\nFROM matches m\nJOIN players p ON m.winner_id = p.player_id\nORDER BY (CURRENT_DATE - p.birth_date) ASC\nLIMIT 3;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "How many different winners both participated in the WTA Championships and were left handed?",
      "gold_sql": "SELECT count(DISTINCT winner_name) FROM matches WHERE tourney_name  =  'WTA Championships' AND winner_hand  =  'L'",
      "predicted_sql": "SELECT COUNT(DISTINCT m.winner_id) AS left_handed_winners\nFROM matches m\nJOIN players p ON m.winner_id = p.player_id\nWHERE m.tourney_name = 'WTA Championships' AND p.hand = 'left';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the number of left handed winners who participated in the WTA Championships.",
      "gold_sql": "SELECT count(DISTINCT winner_name) FROM matches WHERE tourney_name  =  'WTA Championships' AND winner_hand  =  'L'",
      "predicted_sql": "SELECT COUNT(DISTINCT m.winner_id) AS left_handed_winners\nFROM matches m\nWHERE m.winner_hand = 'left' AND m.tourney_name = 'WTA Championships';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the first name, country code and birth date of the winner who has the highest rank points in all matches.",
      "gold_sql": "SELECT T1.first_name ,  T1.country_code ,  T1.birth_date FROM players AS T1 JOIN matches AS T2 ON T1.player_id  =  T2.winner_id ORDER BY T2.winner_rank_points DESC LIMIT 1",
      "predicted_sql": "SELECT p.first_name, p.country_code, p.birth_date\nFROM players p\nJOIN matches m ON p.player_id = m.winner_id\nWHERE m.winner_rank_points = (\n    SELECT MAX(winner_rank_points)\n    FROM matches\n)\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "What is the first name, country code, and birth date of the player with the most winner rank points across all matches?",
      "gold_sql": "SELECT T1.first_name ,  T1.country_code ,  T1.birth_date FROM players AS T1 JOIN matches AS T2 ON T1.player_id  =  T2.winner_id ORDER BY T2.winner_rank_points DESC LIMIT 1",
      "predicted_sql": "SELECT p.first_name, p.country_code, p.birth_date\nFROM players p\nJOIN (\n    SELECT winner_id, SUM(winner_rank_points) AS total_rank_points\n    FROM matches\n    GROUP BY winner_id\n    ORDER BY total_rank_points DESC\n    LIMIT 1\n) AS top_winner ON p.player_id = top_winner.winner_id;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "Find the number of players for each hand type.",
      "gold_sql": "SELECT count(*) ,  hand FROM players GROUP BY hand",
      "predicted_sql": "SELECT p.hand, COUNT(*) AS player_count\nFROM players p\nGROUP BY p.hand;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "wta_1",
      "question": "How many players are there for each hand type?",
      "gold_sql": "SELECT count(*) ,  hand FROM players GROUP BY hand",
      "predicted_sql": "SELECT hand, COUNT(*) AS player_count\nFROM players\nGROUP BY hand;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "How many ships ended up being 'Captured'?",
      "gold_sql": "SELECT count(*) FROM ship WHERE disposition_of_ship  =  'Captured'",
      "predicted_sql": "SELECT COUNT(*) AS captured_ships_count\nFROM ship\nWHERE disposition_of_ship = 'Captured';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "List the name and tonnage ordered by in descending alphaetical order for the names.",
      "gold_sql": "SELECT name ,  tonnage FROM ship ORDER BY name DESC",
      "predicted_sql": "SELECT s.name, s.tonnage \nFROM ship s \nORDER BY s.name DESC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "List the name, date and result of each battle.",
      "gold_sql": "SELECT name ,  date FROM battle",
      "predicted_sql": "SELECT b.name, b.date, b.result\nFROM battle AS b;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "What is maximum and minimum death toll caused each time?",
      "gold_sql": "SELECT max(killed) ,  min(killed) FROM death",
      "predicted_sql": "SELECT \n    b.id AS battle_id,\n    b.name AS battle_name,\n    MAX(d.killed) AS max_deaths,\n    MIN(d.killed) AS min_deaths\nFROM \n    battle b\nLEFT JOIN \n    ship s ON s.lost_in_battle = b.id\nLEFT JOIN \n    death d ON d.caused_by_ship_id = s.id\nGROUP BY \n    b.id, b.name;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "What is the average number of injuries caused each time?",
      "gold_sql": "SELECT avg(injured) FROM death",
      "predicted_sql": "SELECT AVG(injured) AS average_injuries\nFROM death;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "What are the death and injury situations caused by the ship with tonnage 't'?",
      "gold_sql": "SELECT T1.killed ,  T1.injured FROM death AS T1 JOIN ship AS t2 ON T1.caused_by_ship_id  =  T2.id WHERE T2.tonnage  =  't'",
      "predicted_sql": "SELECT d.killed, d.injured\nFROM death d\nJOIN ship s ON d.caused_by_ship_id = s.id\nWHERE s.tonnage = 't';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "What are the name and results of the battles when the bulgarian commander is not 'Boril'",
      "gold_sql": "SELECT name ,  RESULT FROM battle WHERE bulgarian_commander != 'Boril'",
      "predicted_sql": "SELECT b.name, b.result\nFROM battle b\nWHERE b.bulgarian_commander IS NULL OR b.bulgarian_commander <> 'Boril';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "What are the different ids and names of the battles that lost any 'Brig' type shipes?",
      "gold_sql": "SELECT DISTINCT T1.id ,  T1.name FROM battle AS T1 JOIN ship AS T2 ON T1.id  =  T2.lost_in_battle WHERE T2.ship_type  =  'Brig'",
      "predicted_sql": "SELECT DISTINCT b.id, b.name\nFROM battle b\nJOIN ship s ON b.id = s.lost_in_battle\nWHERE s.ship_type = 'Brig';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "What are the ids and names of the battles that led to more than 10 people killed in total.",
      "gold_sql": "SELECT T1.id ,  T1.name FROM battle AS T1 JOIN ship AS T2 ON T1.id  =  T2.lost_in_battle JOIN death AS T3 ON T2.id  =  T3.caused_by_ship_id GROUP BY T1.id HAVING sum(T3.killed)  >  10",
      "predicted_sql": "SELECT b.id, b.name\nFROM battle b\nJOIN ship s ON b.id = s.lost_in_battle\nJOIN death d ON s.id = d.caused_by_ship_id\nGROUP BY b.id, b.name\nHAVING SUM(COALESCE(d.killed, 0)) > 10;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "What is the ship id and name that caused most total injuries?",
      "gold_sql": "SELECT T2.id ,  T2.name FROM death AS T1 JOIN ship AS t2 ON T1.caused_by_ship_id  =  T2.id GROUP BY T2.id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT d.caused_by_ship_id, s.name\nFROM death d\nJOIN ship s ON d.caused_by_ship_id = s.id\nGROUP BY d.caused_by_ship_id, s.name\nORDER BY SUM(d.injured) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "What are the distinct battle names which are between bulgarian commander 'Kaloyan' and latin commander 'Baldwin I'?",
      "gold_sql": "SELECT name FROM battle WHERE bulgarian_commander  =  'Kaloyan' AND latin_commander  =  'Baldwin I'",
      "predicted_sql": "SELECT DISTINCT b.name\nFROM battle b\nWHERE b.bulgarian_commander = 'Kaloyan' AND b.latin_commander = 'Baldwin I';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "How many different results are there for the battles?",
      "gold_sql": "SELECT count(DISTINCT RESULT) FROM battle",
      "predicted_sql": "SELECT COUNT(DISTINCT result) AS different_battle_results\nFROM battle;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "How many battles did not lose any ship with tonnage '225'?",
      "gold_sql": "SELECT count(*) FROM battle WHERE id NOT IN ( SELECT lost_in_battle FROM ship WHERE tonnage  =  '225' );",
      "predicted_sql": "SELECT COUNT(b.id) AS battles_without_lost_ships\nFROM battle b\nLEFT JOIN ship s ON s.lost_in_battle = b.id AND s.tonnage = '225'\nWHERE s.id IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "List the name and date the battle that has lost the ship named 'Lettice' and the ship named 'HMS Atalanta'",
      "gold_sql": "SELECT T1.name ,  T1.date FROM battle AS T1 JOIN ship AS T2 ON T1.id  =  T2.lost_in_battle WHERE T2.name  =  'Lettice' INTERSECT SELECT T1.name ,  T1.date FROM battle AS T1 JOIN ship AS T2 ON T1.id  =  T2.lost_in_battle WHERE T2.name  =  'HMS Atalanta'",
      "predicted_sql": "SELECT b.name, b.date\nFROM battle b\nJOIN ship s ON s.lost_in_battle = b.id\nWHERE s.name IN ('Lettice', 'HMS Atalanta')\nGROUP BY b.name, b.date\nHAVING COUNT(DISTINCT s.name) = 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "Show names, results and bulgarian commanders of the battles with no ships lost in the 'English Channel'.",
      "gold_sql": "SELECT name ,  RESULT ,  bulgarian_commander FROM battle EXCEPT SELECT T1.name ,  T1.result ,  T1.bulgarian_commander FROM battle AS T1 JOIN ship AS T2 ON T1.id  =  T2.lost_in_battle WHERE T2.location  =  'English Channel'",
      "predicted_sql": "SELECT b.name, b.result, b.bulgarian_commander\nFROM battle b\nLEFT JOIN ship s ON b.id = s.lost_in_battle\nWHERE s.location IS NULL OR s.location <> 'English Channel';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "battle_death",
      "question": "What are the notes of the death events which has substring 'East'?",
      "gold_sql": "SELECT note FROM death WHERE note LIKE '%East%'",
      "predicted_sql": "SELECT d.note \nFROM death d \nWHERE d.note LIKE '%East%';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "what are all the addresses including line 1 and line 2?",
      "gold_sql": "SELECT line_1 ,  line_2 FROM addresses",
      "predicted_sql": "SELECT a.line_1, a.line_2 \nFROM Addresses a;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the first and second line for all addresses?",
      "gold_sql": "SELECT line_1 ,  line_2 FROM addresses",
      "predicted_sql": "SELECT a.line_1, a.line_2\nFROM Addresses a;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "How many courses in total are listed?",
      "gold_sql": "SELECT count(*) FROM Courses",
      "predicted_sql": "SELECT COUNT(*) AS total_courses FROM Courses;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "How many courses are there?",
      "gold_sql": "SELECT count(*) FROM Courses",
      "predicted_sql": "SELECT COUNT(*) AS total_courses FROM Courses;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "How is the math course described?",
      "gold_sql": "SELECT course_description FROM Courses WHERE course_name  =  'math'",
      "predicted_sql": "SELECT course_description \nFROM Courses \nWHERE course_name = 'math';",
      "exec_match": true,
      "exact_match": true,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What are the descriptions for all the math courses?",
      "gold_sql": "SELECT course_description FROM Courses WHERE course_name  =  'math'",
      "predicted_sql": "SELECT c.course_description \nFROM Courses c \nWHERE c.course_name LIKE '%math%';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the zip code of the address in the city Port Chelsea?",
      "gold_sql": "SELECT zip_postcode FROM Addresses WHERE city  =  'Port Chelsea'",
      "predicted_sql": "SELECT zip_postcode \nFROM Addresses AS a \nWHERE a.city = 'Port Chelsea';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the zip code for Port Chelsea?",
      "gold_sql": "SELECT zip_postcode FROM Addresses WHERE city  =  'Port Chelsea'",
      "predicted_sql": "SELECT zip_postcode \nFROM Addresses \nWHERE city = 'Port Chelsea';",
      "exec_match": true,
      "exact_match": true,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Which department offers the most number of degrees? List department name and id.",
      "gold_sql": "SELECT T2.department_name ,  T1.department_id FROM Degree_Programs AS T1 JOIN Departments AS T2 ON T1.department_id  =  T2.department_id GROUP BY T1.department_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT d.department_id, d.department_name\nFROM Departments d\nJOIN Degree_Programs dp ON d.department_id = dp.department_id\nGROUP BY d.department_id, d.department_name\nORDER BY COUNT(dp.degree_program_id) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "For each department id, what is the name of the department with the most number of degrees?",
      "gold_sql": "SELECT T2.department_name ,  T1.department_id FROM Degree_Programs AS T1 JOIN Departments AS T2 ON T1.department_id  =  T2.department_id GROUP BY T1.department_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT d.department_id, d.department_name\nFROM Departments d\nJOIN Degree_Programs dp ON d.department_id = dp.department_id\nGROUP BY d.department_id, d.department_name\nORDER BY COUNT(dp.degree_program_id) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "How many departments offer any degree?",
      "gold_sql": "SELECT count(DISTINCT department_id) FROM Degree_Programs",
      "predicted_sql": "SELECT COUNT(DISTINCT d.department_id) AS department_count\nFROM Departments d\nJOIN Degree_Programs dp ON d.department_id = dp.department_id;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "How many different departments offer degrees?",
      "gold_sql": "SELECT count(DISTINCT department_id) FROM Degree_Programs",
      "predicted_sql": "SELECT COUNT(DISTINCT d.department_id) AS number_of_departments\nFROM Departments d\nJOIN Degree_Programs dp ON d.department_id = dp.department_id;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "How many different degree names are offered?",
      "gold_sql": "SELECT count(DISTINCT degree_summary_name) FROM Degree_Programs",
      "predicted_sql": "SELECT COUNT(DISTINCT degree_summary_name) AS different_degree_names\nFROM Degree_Programs;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "How many different degrees are offered?",
      "gold_sql": "SELECT count(DISTINCT degree_summary_name) FROM Degree_Programs",
      "predicted_sql": "SELECT COUNT(DISTINCT degree_program_id) AS total_degrees\nFROM Degree_Programs;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "How many degrees does the engineering department offer?",
      "gold_sql": "SELECT count(*) FROM Departments AS T1 JOIN Degree_Programs AS T2 ON T1.department_id  =  T2.department_id WHERE T1.department_name  =  'engineer'",
      "predicted_sql": "SELECT COUNT(*) AS degree_count\nFROM Degree_Programs dp\nJOIN Departments d ON dp.department_id = d.department_id\nWHERE d.department_name = 'Engineering';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "How many degrees does the engineering department have?",
      "gold_sql": "SELECT count(*) FROM Departments AS T1 JOIN Degree_Programs AS T2 ON T1.department_id  =  T2.department_id WHERE T1.department_name  =  'engineer'",
      "predicted_sql": "SELECT COUNT(*) AS degree_count\nFROM Degree_Programs dp\nJOIN Departments d ON dp.department_id = d.department_id\nWHERE d.department_name = 'Engineering';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What are the names and descriptions of all the sections?",
      "gold_sql": "SELECT section_name ,  section_description FROM Sections",
      "predicted_sql": "SELECT s.section_name, s.section_description \nFROM Sections s;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What are the names and descriptions for all the sections?",
      "gold_sql": "SELECT section_name ,  section_description FROM Sections",
      "predicted_sql": "SELECT s.section_name, s.section_description\nFROM Sections s;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What are the names and id of courses having at most 2 sections?",
      "gold_sql": "SELECT T1.course_name ,  T1.course_id FROM Courses AS T1 JOIN Sections AS T2 ON T1.course_id  =  T2.course_id GROUP BY T1.course_id HAVING count(*)  <=  2",
      "predicted_sql": "SELECT c.course_id, c.course_name\nFROM Courses c\nJOIN Sections s ON c.course_id = s.course_id\nGROUP BY c.course_id, c.course_name\nHAVING COUNT(s.section_id) <= 2;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What are the names and ids of every course with less than 2 sections?",
      "gold_sql": "SELECT T1.course_name ,  T1.course_id FROM Courses AS T1 JOIN Sections AS T2 ON T1.course_id  =  T2.course_id GROUP BY T1.course_id HAVING count(*)  <=  2",
      "predicted_sql": "SELECT c.course_id, c.course_name\nFROM Courses c\nLEFT JOIN Sections s ON c.course_id = s.course_id\nGROUP BY c.course_id, c.course_name\nHAVING COUNT(s.section_id) < 2;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "List the section_name in reversed lexicographical order.",
      "gold_sql": "SELECT section_name FROM Sections ORDER BY section_name DESC",
      "predicted_sql": "SELECT section_name \nFROM Sections \nORDER BY section_name DESC;",
      "exec_match": true,
      "exact_match": true,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What are the names of the sections in reverse alphabetical order?",
      "gold_sql": "SELECT section_name FROM Sections ORDER BY section_name DESC",
      "predicted_sql": "SELECT section_name \nFROM Sections \nORDER BY section_name DESC;",
      "exec_match": true,
      "exact_match": true,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the semester which most student registered in? Show both the name and the id.",
      "gold_sql": "SELECT T1.semester_name ,  T1.semester_id FROM Semesters AS T1 JOIN Student_Enrolment AS T2 ON T1.semester_id  =  T2.semester_id GROUP BY T1.semester_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT s.semester_id, s.semester_name\nFROM Student_Enrolment se\nJOIN Semesters s ON se.semester_id = s.semester_id\nGROUP BY s.semester_id, s.semester_name\nORDER BY COUNT(se.student_enrolment_id) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "For each semester, what is the name and id of the one with the most students registered?",
      "gold_sql": "SELECT T1.semester_name ,  T1.semester_id FROM Semesters AS T1 JOIN Student_Enrolment AS T2 ON T1.semester_id  =  T2.semester_id GROUP BY T1.semester_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT s.semester_id, s.semester_name\nFROM Semesters s\nJOIN Student_Enrolment se ON s.semester_id = se.semester_id\nGROUP BY s.semester_id, s.semester_name\nORDER BY COUNT(se.student_enrolment_id) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the description of the department whose name has the substring the computer?",
      "gold_sql": "SELECT department_description FROM Departments WHERE department_name LIKE '%computer%'",
      "predicted_sql": "SELECT d.department_description \nFROM Departments d \nWHERE d.department_name LIKE '%the computer%';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the department description for the one whose name has the word computer?",
      "gold_sql": "SELECT department_description FROM Departments WHERE department_name LIKE '%computer%'",
      "predicted_sql": "SELECT d.department_description \nFROM Departments d \nWHERE d.department_name LIKE '%computer%';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Who are enrolled in 2 degree programs in one semester? List the first name, middle name and last name and the id.",
      "gold_sql": "SELECT T1.first_name ,  T1.middle_name ,  T1.last_name ,  T1.student_id FROM Students AS T1 JOIN Student_Enrolment AS T2 ON T1.student_id  =  T2.student_id GROUP BY T1.student_id HAVING count(*)  =  2",
      "predicted_sql": "SELECT s.student_id, s.first_name, s.middle_name, s.last_name\nFROM Students s\nJOIN Student_Enrolment se ON s.student_id = se.student_id\nWHERE se.semester_id IN (\n    SELECT semester_id\n    FROM Student_Enrolment\n    GROUP BY student_id, semester_id\n    HAVING COUNT(DISTINCT degree_program_id) = 2\n);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What are the first, middle, and last names, along with the ids, of all students who enrolled in 2 degree programs in one semester?",
      "gold_sql": "SELECT T1.first_name ,  T1.middle_name ,  T1.last_name ,  T1.student_id FROM Students AS T1 JOIN Student_Enrolment AS T2 ON T1.student_id  =  T2.student_id GROUP BY T1.student_id HAVING count(*)  =  2",
      "predicted_sql": "SELECT s.first_name, s.middle_name, s.last_name, s.student_id\nFROM Students s\nJOIN Student_Enrolment se ON s.student_id = se.student_id\nWHERE se.student_enrolment_id IN (\n    SELECT se1.student_enrolment_id\n    FROM Student_Enrolment se1\n    GROUP BY se1.student_id, se1.semester_id\n    HAVING COUNT(DISTINCT se1.degree_program_id) = 2\n);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Who is enrolled in a Bachelor degree program? List the first name, middle name, last name.",
      "gold_sql": "SELECT DISTINCT T1.first_name ,  T1.middle_name ,  T1.last_name FROM Students AS T1 JOIN Student_Enrolment AS T2 ON T1.student_id  =  T2.student_id JOIN Degree_Programs AS T3 ON T2.degree_program_id  =  T3.degree_program_id WHERE T3.degree_summary_name  =  'Bachelor'",
      "predicted_sql": "SELECT s.first_name, s.middle_name, s.last_name\nFROM Students s\nJOIN Student_Enrolment se ON s.student_id = se.student_id\nJOIN Degree_Programs dp ON se.degree_program_id = dp.degree_program_id\nWHERE dp.degree_summary_name LIKE '%Bachelor%';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What are the first, middle, and last names for everybody enrolled in a Bachelors program?",
      "gold_sql": "SELECT DISTINCT T1.first_name ,  T1.middle_name ,  T1.last_name FROM Students AS T1 JOIN Student_Enrolment AS T2 ON T1.student_id  =  T2.student_id JOIN Degree_Programs AS T3 ON T2.degree_program_id  =  T3.degree_program_id WHERE T3.degree_summary_name  =  'Bachelor'",
      "predicted_sql": "SELECT s.first_name, s.middle_name, s.last_name\nFROM Students s\nJOIN Student_Enrolment se ON s.student_id = se.student_id\nJOIN Degree_Programs dp ON se.degree_program_id = dp.degree_program_id\nWHERE dp.degree_summary_name LIKE '%Bachelors%';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Find the kind of program which most number of students are enrolled in?",
      "gold_sql": "SELECT T1.degree_summary_name FROM Degree_Programs AS T1 JOIN Student_Enrolment AS T2 ON T1.degree_program_id  =  T2.degree_program_id GROUP BY T1.degree_summary_name ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT dp.degree_summary_name, COUNT(se.student_id) AS student_count\nFROM Degree_Programs dp\nJOIN Student_Enrolment se ON dp.degree_program_id = se.degree_program_id\nGROUP BY dp.degree_summary_name\nORDER BY student_count DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the degree summary name that has the most number of students enrolled?",
      "gold_sql": "SELECT T1.degree_summary_name FROM Degree_Programs AS T1 JOIN Student_Enrolment AS T2 ON T1.degree_program_id  =  T2.degree_program_id GROUP BY T1.degree_summary_name ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT dp.degree_summary_name\nFROM Degree_Programs dp\nJOIN Student_Enrolment se ON dp.degree_program_id = se.degree_program_id\nGROUP BY dp.degree_summary_name\nORDER BY COUNT(se.student_enrolment_id) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Find the program which most number of students are enrolled in. List both the id and the summary.",
      "gold_sql": "SELECT T1.degree_program_id ,  T1.degree_summary_name FROM Degree_Programs AS T1 JOIN Student_Enrolment AS T2 ON T1.degree_program_id  =  T2.degree_program_id GROUP BY T1.degree_program_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT se.degree_program_id, dp.degree_summary_name\nFROM Student_Enrolment se\nJOIN Degree_Programs dp ON se.degree_program_id = dp.degree_program_id\nGROUP BY se.degree_program_id, dp.degree_summary_name\nORDER BY COUNT(se.student_id) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the program id and the summary of the degree that has the most students enrolled?",
      "gold_sql": "SELECT T1.degree_program_id ,  T1.degree_summary_name FROM Degree_Programs AS T1 JOIN Student_Enrolment AS T2 ON T1.degree_program_id  =  T2.degree_program_id GROUP BY T1.degree_program_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT dp.degree_program_id, dp.degree_summary_name\nFROM Degree_Programs dp\nJOIN Student_Enrolment se ON dp.degree_program_id = se.degree_program_id\nGROUP BY dp.degree_program_id, dp.degree_summary_name\nORDER BY COUNT(se.student_enrolment_id) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Which student has enrolled for the most times in any program? List the id, first name, middle name, last name, the number of enrollments and student id.",
      "gold_sql": "SELECT T1.student_id ,  T1.first_name ,  T1.middle_name ,  T1.last_name ,  count(*) ,  T1.student_id FROM Students AS T1 JOIN Student_Enrolment AS T2 ON T1.student_id  =  T2.student_id GROUP BY T1.student_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT \n    s.student_id, \n    s.first_name, \n    s.middle_name, \n    s.last_name, \n    COUNT(se.student_enrolment_id) AS number_of_enrollments\nFROM \n    Students s\nJOIN \n    Student_Enrolment se ON s.student_id = se.student_id\nGROUP BY \n    s.student_id, s.first_name, s.middle_name, s.last_name\nORDER BY \n    number_of_enrollments DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the first, middle, and last name, along with the id and number of enrollments, for the student who enrolled the most in any program?",
      "gold_sql": "SELECT T1.student_id ,  T1.first_name ,  T1.middle_name ,  T1.last_name ,  count(*) ,  T1.student_id FROM Students AS T1 JOIN Student_Enrolment AS T2 ON T1.student_id  =  T2.student_id GROUP BY T1.student_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT s.first_name, s.middle_name, s.last_name, s.student_id, COUNT(se.student_enrolment_id) AS number_of_enrollments\nFROM Students s\nJOIN Student_Enrolment se ON s.student_id = se.student_id\nGROUP BY s.student_id, s.first_name, s.middle_name, s.last_name\nORDER BY number_of_enrollments DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Which semesters do not have any student enrolled? List the semester name.",
      "gold_sql": "SELECT semester_name FROM Semesters WHERE semester_id NOT IN( SELECT semester_id FROM Student_Enrolment )",
      "predicted_sql": "SELECT s.semester_name\nFROM Semesters s\nLEFT JOIN Student_Enrolment se ON s.semester_id = se.semester_id\nWHERE se.student_enrolment_id IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the name of the semester with no students enrolled?",
      "gold_sql": "SELECT semester_name FROM Semesters WHERE semester_id NOT IN( SELECT semester_id FROM Student_Enrolment )",
      "predicted_sql": "SELECT s.semester_name \nFROM Semesters s \nLEFT JOIN Student_Enrolment se ON s.semester_id = se.semester_id \nWHERE se.student_enrolment_id IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What are all the course names of the courses which ever have students enrolled in?",
      "gold_sql": "SELECT DISTINCT T1.course_name FROM Courses AS T1 JOIN Student_Enrolment_Courses AS T2 ON T1.course_id  =  T2.course_id",
      "predicted_sql": "SELECT DISTINCT c.course_name\nFROM Courses c\nJOIN Student_Enrolment_Courses sec ON c.course_id = sec.course_id;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What are the names of all courses that have some students enrolled?",
      "gold_sql": "SELECT DISTINCT T1.course_name FROM Courses AS T1 JOIN Student_Enrolment_Courses AS T2 ON T1.course_id  =  T2.course_id",
      "predicted_sql": "SELECT DISTINCT c.course_name\nFROM Courses c\nJOIN Student_Enrolment_Courses sec ON c.course_id = sec.course_id;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What's the name of the course with most number of enrollments?",
      "gold_sql": "SELECT  T1.course_name FROM Courses AS T1 JOIN Student_Enrolment_Courses AS T2 ON T1.course_id  =  T2.course_id GROUP BY T1.course_name ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT c.course_name\nFROM Courses c\nJOIN Student_Enrolment_Courses sec ON c.course_id = sec.course_id\nGROUP BY c.course_id, c.course_name\nORDER BY COUNT(sec.student_course_id) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the name of the course with the most students enrolled?",
      "gold_sql": "SELECT  T1.course_name FROM Courses AS T1 JOIN Student_Enrolment_Courses AS T2 ON T1.course_id  =  T2.course_id GROUP BY T1.course_name ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT c.course_name\nFROM Courses c\nJOIN Student_Enrolment_Courses sec ON c.course_id = sec.course_id\nGROUP BY c.course_id, c.course_name\nORDER BY COUNT(sec.student_course_id) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Find the last name of the students who currently live in the state of North Carolina but have not registered in any degree program.",
      "gold_sql": "SELECT T1.last_name FROM Students AS T1 JOIN Addresses AS T2 ON T1.current_address_id  =  T2.address_id WHERE T2.state_province_county  =  'NorthCarolina' EXCEPT SELECT DISTINCT T3.last_name FROM Students AS T3 JOIN Student_Enrolment AS T4 ON T3.student_id  =  T4.student_id",
      "predicted_sql": "SELECT s.last_name\nFROM Students s\nWHERE s.current_address_id IN (\n    SELECT a.address_id\n    FROM Addresses a\n    WHERE a.state_province_county = 'North Carolina'\n) AND s.student_id NOT IN (\n    SELECT se.student_id\n    FROM Student_Enrolment se\n);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What are the last name of the students who live in North Carolina but have not registered in any degree programs?",
      "gold_sql": "SELECT T1.last_name FROM Students AS T1 JOIN Addresses AS T2 ON T1.current_address_id  =  T2.address_id WHERE T2.state_province_county  =  'NorthCarolina' EXCEPT SELECT DISTINCT T3.last_name FROM Students AS T3 JOIN Student_Enrolment AS T4 ON T3.student_id  =  T4.student_id",
      "predicted_sql": "SELECT s.last_name\nFROM Students s\nJOIN Addresses a ON s.current_address_id = a.address_id\nLEFT JOIN Student_Enrolment se ON s.student_id = se.student_id\nWHERE a.state_province_county = 'North Carolina' AND se.student_enrolment_id IS NULL;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Show the date and id of the transcript with at least 2 course results.",
      "gold_sql": "SELECT T2.transcript_date ,  T1.transcript_id FROM Transcript_Contents AS T1 JOIN Transcripts AS T2 ON T1.transcript_id  =  T2.transcript_id GROUP BY T1.transcript_id HAVING count(*)  >=  2",
      "predicted_sql": "SELECT t.transcript_id, t.transcript_date\nFROM Transcripts t\nJOIN Transcript_Contents tc ON t.transcript_id = tc.transcript_id\nGROUP BY t.transcript_id, t.transcript_date\nHAVING COUNT(tc.student_course_id) >= 2;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the date and id of the transcript with at least 2 courses listed?",
      "gold_sql": "SELECT T2.transcript_date ,  T1.transcript_id FROM Transcript_Contents AS T1 JOIN Transcripts AS T2 ON T1.transcript_id  =  T2.transcript_id GROUP BY T1.transcript_id HAVING count(*)  >=  2",
      "predicted_sql": "SELECT t.transcript_id, t.transcript_date\nFROM Transcripts t\nJOIN Transcript_Contents tc ON t.transcript_id = tc.transcript_id\nGROUP BY t.transcript_id, t.transcript_date\nHAVING COUNT(tc.student_course_id) >= 2;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the phone number of the man with the first name Timmothy and the last name Ward?",
      "gold_sql": "SELECT cell_mobile_number FROM Students WHERE first_name  =  'Timmothy' AND last_name  =  'Ward'",
      "predicted_sql": "SELECT s.cell_mobile_number \nFROM Students s \nWHERE s.first_name = 'Timmothy' AND s.last_name = 'Ward';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the mobile phone number of the student named Timothy Ward?",
      "gold_sql": "SELECT cell_mobile_number FROM Students WHERE first_name  =  'Timmothy' AND last_name  =  'Ward'",
      "predicted_sql": "SELECT s.cell_mobile_number \nFROM Students s \nWHERE s.first_name = 'Timothy' AND s.last_name = 'Ward';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Who is the first student to register? List the first name, middle name and last name.",
      "gold_sql": "SELECT first_name ,  middle_name ,  last_name FROM Students ORDER BY date_first_registered ASC LIMIT 1",
      "predicted_sql": "SELECT s.first_name, s.middle_name, s.last_name\nFROM Students s\nWHERE s.date_first_registered = (SELECT MIN(date_first_registered) FROM Students);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the first, middle, and last name of the first student to register?",
      "gold_sql": "SELECT first_name ,  middle_name ,  last_name FROM Students ORDER BY date_first_registered ASC LIMIT 1",
      "predicted_sql": "SELECT first_name, middle_name, last_name\nFROM Students\nORDER BY date_first_registered ASC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Who is the earliest graduate of the school? List the first name, middle name and last name.",
      "gold_sql": "SELECT first_name ,  middle_name ,  last_name FROM Students ORDER BY date_left ASC LIMIT 1",
      "predicted_sql": "SELECT s.first_name, s.middle_name, s.last_name\nFROM Students s\nWHERE s.date_left IS NOT NULL\nORDER BY s.date_left ASC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the first, middle, and last name of the earliest school graduate?",
      "gold_sql": "SELECT first_name ,  middle_name ,  last_name FROM Students ORDER BY date_left ASC LIMIT 1",
      "predicted_sql": "SELECT s.first_name, s.middle_name, s.last_name\nFROM Students s\nWHERE s.date_left IS NOT NULL\nORDER BY s.date_left ASC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Whose permanent address is different from his or her current address? List his or her first name.",
      "gold_sql": "SELECT first_name FROM Students WHERE current_address_id != permanent_address_id",
      "predicted_sql": "SELECT s.first_name\nFROM Students s\nWHERE s.current_address_id <> s.permanent_address_id;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the first name of the student whose permanent address is different from his or her current one?",
      "gold_sql": "SELECT first_name FROM Students WHERE current_address_id != permanent_address_id",
      "predicted_sql": "SELECT s.first_name\nFROM Students s\nWHERE s.current_address_id <> s.permanent_address_id;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Which address holds the most number of students currently? List the address id and all lines.",
      "gold_sql": "SELECT T1.address_id ,  T1.line_1 ,  T1.line_2 FROM Addresses AS T1 JOIN Students AS T2 ON T1.address_id  =  T2.current_address_id GROUP BY T1.address_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT a.address_id, a.line_1, a.line_2, a.line_3\nFROM Addresses a\nJOIN Students s ON a.address_id = s.current_address_id\nGROUP BY a.address_id, a.line_1, a.line_2, a.line_3\nORDER BY COUNT(s.student_id) DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the id, line 1, and line 2 of the address with the most students?",
      "gold_sql": "SELECT T1.address_id ,  T1.line_1 ,  T1.line_2 FROM Addresses AS T1 JOIN Students AS T2 ON T1.address_id  =  T2.current_address_id GROUP BY T1.address_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT a.address_id, a.line_1, a.line_2\nFROM Addresses a\nJOIN Students s ON a.address_id = s.current_address_id OR a.address_id = s.permanent_address_id\nGROUP BY a.address_id, a.line_1, a.line_2\nORDER BY COUNT(s.student_id) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "On average, when were the transcripts printed?",
      "gold_sql": "SELECT avg(transcript_date) FROM Transcripts",
      "predicted_sql": "SELECT DATEADD(SECOND, AVG(DATEDIFF(SECOND, '1970-01-01', t.transcript_date)), '1970-01-01') AS average_transcript_printed_date\nFROM Transcripts t\nWHERE t.transcript_date IS NOT NULL;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the average transcript date?",
      "gold_sql": "SELECT avg(transcript_date) FROM Transcripts",
      "predicted_sql": "SELECT DATEADD(SECOND, AVG(DATEDIFF(SECOND, '1970-01-01', transcript_date)), '1970-01-01') AS average_transcript_date\nFROM Transcripts;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "When is the first transcript released? List the date and details.",
      "gold_sql": "SELECT transcript_date ,  other_details FROM Transcripts ORDER BY transcript_date ASC LIMIT 1",
      "predicted_sql": "SELECT MIN(t.transcript_date) AS first_transcript_date, \n       MAX(t.other_details) AS details\nFROM Transcripts t;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the earliest date of a transcript release, and what details can you tell me?",
      "gold_sql": "SELECT transcript_date ,  other_details FROM Transcripts ORDER BY transcript_date ASC LIMIT 1",
      "predicted_sql": "SELECT t.transcript_date, t.other_details\nFROM Transcripts t\nWHERE t.transcript_date = (SELECT MIN(transcript_date) FROM Transcripts);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "How many transcripts are released?",
      "gold_sql": "SELECT count(*) FROM Transcripts",
      "predicted_sql": "SELECT COUNT(*) AS total_transcripts\nFROM Transcripts;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "How many transcripts are listed?",
      "gold_sql": "SELECT count(*) FROM Transcripts",
      "predicted_sql": "SELECT COUNT(*) AS total_transcripts\nFROM Transcripts;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the last transcript release date?",
      "gold_sql": "SELECT transcript_date FROM Transcripts ORDER BY transcript_date DESC LIMIT 1",
      "predicted_sql": "SELECT MAX(transcript_date) AS last_transcript_release_date\nFROM Transcripts;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "When was the last transcript released?",
      "gold_sql": "SELECT transcript_date FROM Transcripts ORDER BY transcript_date DESC LIMIT 1",
      "predicted_sql": "SELECT MAX(transcript_date) AS last_transcript_release\nFROM Transcripts;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "How many times at most can a course enrollment result show in different transcripts? Also show the course enrollment id.",
      "gold_sql": "SELECT count(*) ,  student_course_id FROM Transcript_Contents GROUP BY student_course_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT sec.student_course_id, COUNT(tc.transcript_id) AS transcript_count\nFROM Student_Enrolment_Courses sec\nLEFT JOIN Transcript_Contents tc ON sec.student_course_id = tc.student_course_id\nGROUP BY sec.student_course_id\nORDER BY transcript_count DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the maximum number of times that a course shows up in different transcripts and what is that course's enrollment id?",
      "gold_sql": "SELECT count(*) ,  student_course_id FROM Transcript_Contents GROUP BY student_course_id ORDER BY count(*) DESC LIMIT 1",
      "predicted_sql": "SELECT sec.student_course_id, COUNT(tc.transcript_id) AS course_count\nFROM Student_Enrolment_Courses sec\nJOIN Transcript_Contents tc ON sec.student_course_id = tc.student_course_id\nGROUP BY sec.student_course_id\nORDER BY course_count DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Show the date of the transcript which shows the least number of results, also list the id.",
      "gold_sql": "SELECT T2.transcript_date ,  T1.transcript_id FROM Transcript_Contents AS T1 JOIN Transcripts AS T2 ON T1.transcript_id  =  T2.transcript_id GROUP BY T1.transcript_id ORDER BY count(*) ASC LIMIT 1",
      "predicted_sql": "SELECT t.transcript_id, t.transcript_date\nFROM Transcripts t\nJOIN Transcript_Contents tc ON t.transcript_id = tc.transcript_id\nGROUP BY t.transcript_id, t.transcript_date\nORDER BY COUNT(tc.student_course_id) ASC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the date and id of the transcript with the least number of results?",
      "gold_sql": "SELECT T2.transcript_date ,  T1.transcript_id FROM Transcript_Contents AS T1 JOIN Transcripts AS T2 ON T1.transcript_id  =  T2.transcript_id GROUP BY T1.transcript_id ORDER BY count(*) ASC LIMIT 1",
      "predicted_sql": "SELECT t.transcript_id, t.transcript_date\nFROM Transcripts t\nJOIN Transcript_Contents tc ON t.transcript_id = tc.transcript_id\nGROUP BY t.transcript_id, t.transcript_date\nORDER BY COUNT(tc.student_course_id) ASC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Find the semester when both Master students and Bachelor students got enrolled in.",
      "gold_sql": "SELECT DISTINCT T2.semester_id FROM Degree_Programs AS T1 JOIN Student_Enrolment AS T2 ON T1.degree_program_id  =  T2.degree_program_id WHERE degree_summary_name  =  'Master' INTERSECT SELECT DISTINCT T2.semester_id FROM Degree_Programs AS T1 JOIN Student_Enrolment AS T2 ON T1.degree_program_id  =  T2.degree_program_id WHERE degree_summary_name  =  'Bachelor'",
      "predicted_sql": "SELECT se.semester_id\nFROM Student_Enrolment se\nJOIN Degree_Programs dp ON se.degree_program_id = dp.degree_program_id\nWHERE dp.degree_program_id IN (SELECT degree_program_id FROM Degree_Programs WHERE degree_program_name IN ('Master', 'Bachelor'))\nGROUP BY se.semester_id\nHAVING COUNT(DISTINCT dp.degree_program_id) = 2;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the id of the semester that had both Masters and Bachelors students enrolled?",
      "gold_sql": "SELECT DISTINCT T2.semester_id FROM Degree_Programs AS T1 JOIN Student_Enrolment AS T2 ON T1.degree_program_id  =  T2.degree_program_id WHERE degree_summary_name  =  'Master' INTERSECT SELECT DISTINCT T2.semester_id FROM Degree_Programs AS T1 JOIN Student_Enrolment AS T2 ON T1.degree_program_id  =  T2.degree_program_id WHERE degree_summary_name  =  'Bachelor'",
      "predicted_sql": "SELECT se.semester_id\nFROM Student_Enrolment se\nJOIN Degree_Programs dp ON se.degree_program_id = dp.degree_program_id\nWHERE dp.degree_program_id IN (SELECT degree_program_id FROM Degree_Programs WHERE degree_program_name IN ('Masters', 'Bachelors'))\nGROUP BY se.semester_id\nHAVING COUNT(DISTINCT dp.degree_program_id) = 2;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "How many different addresses do the students currently live?",
      "gold_sql": "SELECT count(DISTINCT current_address_id) FROM Students",
      "predicted_sql": "SELECT COUNT(DISTINCT a.address_id) AS different_current_addresses\nFROM Students s\nJOIN Addresses a ON s.current_address_id = a.address_id;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What are the different addresses that have students living there?",
      "gold_sql": "SELECT count(DISTINCT current_address_id) FROM Students",
      "predicted_sql": "SELECT DISTINCT a.*\nFROM Addresses a\nJOIN Students s ON a.address_id = s.current_address_id OR a.address_id = s.permanent_address_id;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "List all the student details in reversed lexicographical order.",
      "gold_sql": "SELECT other_student_details FROM Students ORDER BY other_student_details DESC",
      "predicted_sql": "SELECT s.student_id, s.first_name, s.middle_name, s.last_name, s.cell_mobile_number, s.email_address, s.ssn, s.date_first_registered, s.date_left, s.other_student_details\nFROM Students s\nORDER BY s.last_name DESC, s.first_name DESC, s.middle_name DESC;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What other details can you tell me about students in reverse alphabetical order?",
      "gold_sql": "SELECT other_student_details FROM Students ORDER BY other_student_details DESC",
      "predicted_sql": "SELECT s.other_student_details \nFROM Students s \nORDER BY s.other_student_details DESC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Describe the section h.",
      "gold_sql": "SELECT section_description FROM Sections WHERE section_name  =  'h'",
      "predicted_sql": "SELECT \n    s.section_id, \n    s.course_id, \n    s.section_name, \n    s.section_description, \n    s.other_details \nFROM \n    Sections s \nWHERE \n    s.section_id = 'h';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What is the description for the section named h?",
      "gold_sql": "SELECT section_description FROM Sections WHERE section_name  =  'h'",
      "predicted_sql": "SELECT s.section_description \nFROM Sections s \nWHERE s.section_name = 'h';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "Find the first name of the students who permanently live in the country Haiti or have the cell phone number 09700166582.",
      "gold_sql": "SELECT T1.first_name FROM Students AS T1 JOIN Addresses AS T2 ON T1.permanent_address_id  =  T2.address_id WHERE T2.country  =  'Haiti' UNION SELECT first_name FROM Students WHERE cell_mobile_number  =  '09700166582'",
      "predicted_sql": "SELECT s.first_name \nFROM Students s \nWHERE s.permanent_address_id IN (\n    SELECT a.address_id \n    FROM Addresses a \n    WHERE a.country = 'Haiti'\n) OR s.cell_mobile_number = '09700166582';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "student_transcripts_tracking",
      "question": "What are the first names of the students who live in Haiti permanently or have the cell phone number 09700166582?",
      "gold_sql": "SELECT T1.first_name FROM Students AS T1 JOIN Addresses AS T2 ON T1.permanent_address_id  =  T2.address_id WHERE T2.country  =  'Haiti' UNION SELECT first_name FROM Students WHERE cell_mobile_number  =  '09700166582'",
      "predicted_sql": "SELECT DISTINCT s.first_name\nFROM Students s\nJOIN Addresses a ON s.permanent_address_id = a.address_id\nWHERE a.country = 'Haiti' OR s.cell_mobile_number = '09700166582';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "List the title of all cartoons in alphabetical order.",
      "gold_sql": "SELECT Title FROM Cartoon ORDER BY title",
      "predicted_sql": "SELECT Title FROM Cartoon ORDER BY Title ASC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What are the titles of the cartoons sorted alphabetically?",
      "gold_sql": "SELECT Title FROM Cartoon ORDER BY title",
      "predicted_sql": "SELECT Title FROM Cartoon ORDER BY Title ASC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "List all cartoon directed by \"Ben Jones\".",
      "gold_sql": "SELECT Title FROM Cartoon WHERE Directed_by = \"Ben Jones\";",
      "predicted_sql": "SELECT c.Title, c.Directed_by, c.Original_air_date\nFROM Cartoon AS c\nWHERE c.Directed_by = 'Ben Jones';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What are the names of all cartoons directed by Ben Jones?",
      "gold_sql": "SELECT Title FROM Cartoon WHERE Directed_by = \"Ben Jones\";",
      "predicted_sql": "SELECT c.Title\nFROM Cartoon c\nWHERE c.Directed_by = 'Ben Jones';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "How many cartoons were written by \"Joseph Kuhr\"?",
      "gold_sql": "SELECT count(*) FROM Cartoon WHERE Written_by = \"Joseph Kuhr\";",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfCartoons\nFROM Cartoon\nWHERE Written_by = 'Joseph Kuhr';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the number of cartoones written by Joseph Kuhr?",
      "gold_sql": "SELECT count(*) FROM Cartoon WHERE Written_by = \"Joseph Kuhr\";",
      "predicted_sql": "SELECT COUNT(*) AS Number_of_Cartoons\nFROM Cartoon AS c\nWHERE c.Written_by = 'Joseph Kuhr';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "list all cartoon titles and their directors ordered by their air date",
      "gold_sql": "SELECT title ,  Directed_by FROM Cartoon ORDER BY Original_air_date",
      "predicted_sql": "SELECT c.Title, c.Directed_by\nFROM Cartoon c\nORDER BY c.Original_air_date;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the name and directors of all the cartoons that are ordered by air date?",
      "gold_sql": "SELECT title ,  Directed_by FROM Cartoon ORDER BY Original_air_date",
      "predicted_sql": "SELECT c.Title, c.Directed_by\nFROM Cartoon c\nORDER BY c.Original_air_date;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "List the title of all cartoon directed by \"Ben Jones\" or \"Brandon Vietti\".",
      "gold_sql": "SELECT Title FROM Cartoon WHERE Directed_by = \"Ben Jones\" OR Directed_by = \"Brandon Vietti\";",
      "predicted_sql": "SELECT c.Title \nFROM Cartoon c \nWHERE c.Directed_by IN ('Ben Jones', 'Brandon Vietti');",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What are the titles of all cartoons directed by Ben Jones or Brandon Vietti?",
      "gold_sql": "SELECT Title FROM Cartoon WHERE Directed_by = \"Ben Jones\" OR Directed_by = \"Brandon Vietti\";",
      "predicted_sql": "SELECT c.Title\nFROM Cartoon c\nWHERE c.Directed_by IN ('Ben Jones', 'Brandon Vietti');",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "Which country has the most of TV Channels? List the country and number of TV Channels it has.",
      "gold_sql": "SELECT Country ,  count(*) FROM TV_Channel GROUP BY Country ORDER BY count(*) DESC LIMIT 1;",
      "predicted_sql": "SELECT Country, COUNT(*) AS Number_of_TV_Channels\nFROM TV_Channel\nGROUP BY Country\nORDER BY Number_of_TV_Channels DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the country with the most number of TV Channels and how many does it have?",
      "gold_sql": "SELECT Country ,  count(*) FROM TV_Channel GROUP BY Country ORDER BY count(*) DESC LIMIT 1;",
      "predicted_sql": "SELECT Country, COUNT(*) AS Channel_Count\nFROM TV_Channel\nGROUP BY Country\nORDER BY Channel_Count DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "List the number of different series names and contents in the TV Channel table.",
      "gold_sql": "SELECT count(DISTINCT series_name) ,  count(DISTINCT content) FROM TV_Channel;",
      "predicted_sql": "SELECT COUNT(DISTINCT series_name) AS different_series_names, COUNT(DISTINCT Content) AS different_contents\nFROM TV_Channel;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "How many different series and contents are listed in the TV Channel table?",
      "gold_sql": "SELECT count(DISTINCT series_name) ,  count(DISTINCT content) FROM TV_Channel;",
      "predicted_sql": "SELECT COUNT(DISTINCT series_name) AS different_series, COUNT(DISTINCT Content) AS different_contents\nFROM TV_Channel;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the content of TV Channel with serial name \"Sky Radio\"?",
      "gold_sql": "SELECT Content FROM TV_Channel WHERE series_name = \"Sky Radio\";",
      "predicted_sql": "SELECT Content \nFROM TV_Channel AS tc \nWHERE tc.series_name = 'Sky Radio';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the content of the series Sky Radio?",
      "gold_sql": "SELECT Content FROM TV_Channel WHERE series_name = \"Sky Radio\";",
      "predicted_sql": "SELECT TC.Content \nFROM TV_Channel TC \nWHERE TC.series_name = 'Sky Radio';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the Package Option of TV Channel with serial name \"Sky Radio\"?",
      "gold_sql": "SELECT Package_Option FROM TV_Channel WHERE series_name = \"Sky Radio\";",
      "predicted_sql": "SELECT tc.Package_Option \nFROM TV_Channel tc \nWHERE tc.series_name = 'Sky Radio';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What are the Package Options of the TV Channels whose series names are Sky Radio?",
      "gold_sql": "SELECT Package_Option FROM TV_Channel WHERE series_name = \"Sky Radio\";",
      "predicted_sql": "SELECT DISTINCT tc.Package_Option\nFROM TV_Channel tc\nWHERE tc.series_name = 'Sky Radio';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "How many TV Channel using language English?",
      "gold_sql": "SELECT count(*) FROM TV_Channel WHERE LANGUAGE = \"English\";",
      "predicted_sql": "SELECT COUNT(*) AS English_Channel_Count\nFROM TV_Channel\nWHERE Language = 'English';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "How many TV Channels use the English language?",
      "gold_sql": "SELECT count(*) FROM TV_Channel WHERE LANGUAGE = \"English\";",
      "predicted_sql": "SELECT COUNT(*) AS English_Channel_Count\nFROM TV_Channel\nWHERE Language = 'English';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "List the language used least number of TV Channel. List language and number of TV Channel.",
      "gold_sql": "SELECT LANGUAGE ,  count(*) FROM TV_Channel GROUP BY LANGUAGE ORDER BY count(*) ASC LIMIT 1;",
      "predicted_sql": "SELECT Language, COUNT(*) AS Number_of_TV_Channels\nFROM TV_Channel\nGROUP BY Language\nORDER BY Number_of_TV_Channels ASC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What are the languages used by the least number of TV Channels and how many channels use it?",
      "gold_sql": "SELECT LANGUAGE ,  count(*) FROM TV_Channel GROUP BY LANGUAGE ORDER BY count(*) ASC LIMIT 1;",
      "predicted_sql": "SELECT Language, COUNT(*) AS Channel_Count\nFROM TV_Channel\nGROUP BY Language\nHAVING COUNT(*) = (\n    SELECT MIN(Channel_Count)\n    FROM (\n        SELECT COUNT(*) AS Channel_Count\n        FROM TV_Channel\n        GROUP BY Language\n    ) AS Subquery\n);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "List each language and the number of TV Channels using it.",
      "gold_sql": "SELECT LANGUAGE ,  count(*) FROM TV_Channel GROUP BY LANGUAGE",
      "predicted_sql": "SELECT tc.Language, COUNT(*) AS Channel_Count\nFROM TV_Channel tc\nGROUP BY tc.Language;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "For each language, list the number of TV Channels that use it.",
      "gold_sql": "SELECT LANGUAGE ,  count(*) FROM TV_Channel GROUP BY LANGUAGE",
      "predicted_sql": "SELECT Language, COUNT(*) AS Channel_Count\nFROM TV_Channel\nGROUP BY Language;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the TV Channel that shows the cartoon \"The Rise of the Blue Beetle!\"? List the TV Channel's series name.",
      "gold_sql": "SELECT T1.series_name FROM TV_Channel AS T1 JOIN Cartoon AS T2 ON T1.id = T2.Channel WHERE T2.Title = \"The Rise of the Blue Beetle!\";",
      "predicted_sql": "SELECT tc.series_name\nFROM TV_Channel tc\nJOIN Cartoon c ON tc.id = c.Channel\nWHERE c.Title = 'The Rise of the Blue Beetle!';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the series name of the TV Channel that shows the cartoon \"The Rise of the Blue Beetle\"?",
      "gold_sql": "SELECT T1.series_name FROM TV_Channel AS T1 JOIN Cartoon AS T2 ON T1.id = T2.Channel WHERE T2.Title = \"The Rise of the Blue Beetle!\";",
      "predicted_sql": "SELECT tc.series_name \nFROM TV_Channel tc\nJOIN Cartoon c ON tc.id = c.Channel\nWHERE c.Title = 'The Rise of the Blue Beetle';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "List the title of all  Cartoons showed on TV Channel with series name \"Sky Radio\".",
      "gold_sql": "SELECT T2.Title FROM TV_Channel AS T1 JOIN Cartoon AS T2 ON T1.id = T2.Channel WHERE T1.series_name = \"Sky Radio\";",
      "predicted_sql": "SELECT c.Title\nFROM Cartoon c\nJOIN TV_Channel tc ON c.Channel = tc.id\nWHERE tc.series_name = 'Sky Radio';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the title of all the cartools that are on the TV Channel with the series name \"Sky Radio\"?",
      "gold_sql": "SELECT T2.Title FROM TV_Channel AS T1 JOIN Cartoon AS T2 ON T1.id = T2.Channel WHERE T1.series_name = \"Sky Radio\";",
      "predicted_sql": "SELECT c.Title\nFROM Cartoon c\nJOIN TV_Channel tc ON c.Channel = tc.id\nWHERE tc.series_name = 'Sky Radio';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "List the Episode of all TV series sorted by rating.",
      "gold_sql": "SELECT Episode FROM TV_series ORDER BY rating",
      "predicted_sql": "SELECT ts.Episode, ts.Rating \nFROM TV_series ts \nORDER BY ts.Rating;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What are all of the episodes ordered by ratings?",
      "gold_sql": "SELECT Episode FROM TV_series ORDER BY rating",
      "predicted_sql": "SELECT ts.Episode, ts.Rating\nFROM TV_series ts\nORDER BY ts.Rating DESC;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "List top 3 highest Rating  TV series. List the TV series's Episode and Rating.",
      "gold_sql": "SELECT Episode ,  Rating FROM TV_series ORDER BY Rating DESC LIMIT 3;",
      "predicted_sql": "SELECT ts.Episode, ts.Rating\nFROM TV_series ts\nORDER BY ts.Rating DESC\nLIMIT 3;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What are 3 most highly rated episodes in the TV series table and what were those ratings?",
      "gold_sql": "SELECT Episode ,  Rating FROM TV_series ORDER BY Rating DESC LIMIT 3;",
      "predicted_sql": "SELECT Episode, Rating \nFROM TV_series \nORDER BY Rating DESC \nLIMIT 3;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is minimum and maximum share of TV series?",
      "gold_sql": "SELECT max(SHARE) , min(SHARE) FROM TV_series;",
      "predicted_sql": "SELECT MIN(Share) AS Min_Share, MAX(Share) AS Max_Share FROM TV_series;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the maximum and minimum share for the TV series?",
      "gold_sql": "SELECT max(SHARE) , min(SHARE) FROM TV_series;",
      "predicted_sql": "SELECT MAX(Share) AS Max_Share, MIN(Share) AS Min_Share FROM TV_series;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the air date of TV series with Episode \"A Love of a Lifetime\"?",
      "gold_sql": "SELECT Air_Date FROM TV_series WHERE Episode = \"A Love of a Lifetime\";",
      "predicted_sql": "SELECT ts.Air_Date\nFROM TV_series ts\nWHERE ts.Episode = 'A Love of a Lifetime';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "When did the episode \"A Love of a Lifetime\" air?",
      "gold_sql": "SELECT Air_Date FROM TV_series WHERE Episode = \"A Love of a Lifetime\";",
      "predicted_sql": "SELECT Air_Date \nFROM TV_series \nWHERE Episode = 'A Love of a Lifetime';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is Weekly Rank of TV series with Episode \"A Love of a Lifetime\"?",
      "gold_sql": "SELECT Weekly_Rank FROM TV_series WHERE Episode = \"A Love of a Lifetime\";",
      "predicted_sql": "SELECT ts.Weekly_Rank\nFROM TV_series ts\nWHERE ts.Episode = 'A Love of a Lifetime';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the weekly rank for the episode \"A Love of a Lifetime\"?",
      "gold_sql": "SELECT Weekly_Rank FROM TV_series WHERE Episode = \"A Love of a Lifetime\";",
      "predicted_sql": "SELECT ts.Weekly_Rank\nFROM TV_series ts\nWHERE ts.Episode = 'A Love of a Lifetime';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the TV Channel of TV series with Episode \"A Love of a Lifetime\"? List the TV Channel's series name.",
      "gold_sql": "SELECT T1.series_name FROM TV_Channel AS T1 JOIN TV_series AS T2 ON T1.id = T2.Channel WHERE T2.Episode = \"A Love of a Lifetime\";",
      "predicted_sql": "SELECT c.series_name \nFROM TV_series AS s\nJOIN TV_Channel AS c ON s.Channel = c.id\nWHERE s.Episode = 'A Love of a Lifetime';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the name of the series that has the episode \"A Love of a Lifetime\"?",
      "gold_sql": "SELECT T1.series_name FROM TV_Channel AS T1 JOIN TV_series AS T2 ON T1.id = T2.Channel WHERE T2.Episode = \"A Love of a Lifetime\";",
      "predicted_sql": "SELECT c.series_name\nFROM TV_series AS ts\nJOIN TV_Channel AS c ON ts.Channel = c.id\nWHERE ts.Episode = 'A Love of a Lifetime';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "List the Episode of all  TV series showed on TV Channel with series name \"Sky Radio\".",
      "gold_sql": "SELECT T2.Episode FROM TV_Channel AS T1 JOIN TV_series AS T2 ON T1.id = T2.Channel WHERE T1.series_name = \"Sky Radio\";",
      "predicted_sql": "SELECT ts.Episode\nFROM TV_series ts\nJOIN TV_Channel tc ON ts.Channel = tc.id\nWHERE tc.series_name = 'Sky Radio';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the episode for the TV series named \"Sky Radio\"?",
      "gold_sql": "SELECT T2.Episode FROM TV_Channel AS T1 JOIN TV_series AS T2 ON T1.id = T2.Channel WHERE T1.series_name = \"Sky Radio\";",
      "predicted_sql": "SELECT ts.Episode \nFROM TV_series ts \nJOIN TV_Channel tc ON ts.Channel = tc.id \nWHERE tc.series_name = 'Sky Radio';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "Find the number of cartoons directed by each of the listed directors.",
      "gold_sql": "SELECT count(*) ,  Directed_by FROM cartoon GROUP BY Directed_by",
      "predicted_sql": "SELECT Directed_by, COUNT(*) AS Number_of_Cartoons\nFROM Cartoon\nGROUP BY Directed_by;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "How many cartoons did each director create?",
      "gold_sql": "SELECT count(*) ,  Directed_by FROM cartoon GROUP BY Directed_by",
      "predicted_sql": "SELECT Directed_by, COUNT(*) AS Cartoon_Count\nFROM Cartoon\nGROUP BY Directed_by;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "Find the production code and channel of the most recently aired cartoon.",
      "gold_sql": "SELECT production_code ,  channel FROM cartoon ORDER BY original_air_date LIMIT 1",
      "predicted_sql": "SELECT c.Production_code, c.Channel\nFROM Cartoon c\nORDER BY c.Original_air_date DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the produdction code and channel of the most recent cartoon?",
      "gold_sql": "SELECT production_code ,  channel FROM cartoon ORDER BY original_air_date LIMIT 1",
      "predicted_sql": "SELECT c.Production_code, c.Channel\nFROM Cartoon AS c\nORDER BY c.Original_air_date DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "Find the package choice and series name of the TV channel that has high definition TV.",
      "gold_sql": "SELECT package_option ,  series_name FROM TV_Channel WHERE hight_definition_TV  =  \"yes\"",
      "predicted_sql": "SELECT tc.Package_Option, tc.series_name\nFROM TV_Channel tc\nWHERE tc.Hight_definition_TV = 'Yes';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What are the package options and the name of the series for the TV Channel that supports high definition TV?",
      "gold_sql": "SELECT package_option ,  series_name FROM TV_Channel WHERE hight_definition_TV  =  \"yes\"",
      "predicted_sql": "SELECT tc.Package_Option, tc.series_name \nFROM TV_Channel tc \nWHERE tc.Hight_definition_TV = 'Yes';",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "which countries' tv channels are playing some cartoon written by Todd Casey?",
      "gold_sql": "SELECT T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.written_by  =  'Todd Casey'",
      "predicted_sql": "SELECT DISTINCT tc.Country\nFROM TV_Channel tc\nJOIN Cartoon c ON tc.id = c.Channel\nWHERE c.Written_by = 'Todd Casey';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What are the countries that have cartoons on TV that were written by Todd Casey?",
      "gold_sql": "SELECT T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.written_by  =  'Todd Casey'",
      "predicted_sql": "SELECT DISTINCT tc.Country\nFROM TV_Channel tc\nJOIN Cartoon c ON tc.id = c.Channel\nWHERE c.Written_by = 'Todd Casey';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "which countries' tv channels are not playing any cartoon written by Todd Casey?",
      "gold_sql": "SELECT country FROM TV_Channel EXCEPT SELECT T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.written_by  =  'Todd Casey'",
      "predicted_sql": "SELECT DISTINCT tc.Country\nFROM TV_Channel tc\nWHERE tc.id NOT IN (\n    SELECT c.Channel\n    FROM Cartoon c\n    WHERE c.Written_by = 'Todd Casey'\n);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What are the countries that are not playing cartoons written by Todd Casey?",
      "gold_sql": "SELECT country FROM TV_Channel EXCEPT SELECT T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.written_by  =  'Todd Casey'",
      "predicted_sql": "SELECT DISTINCT tc.Country\nFROM TV_Channel tc\nWHERE tc.id NOT IN (\n    SELECT c.Channel\n    FROM Cartoon c\n    WHERE c.Written_by = 'Todd Casey'\n);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "Find the series name and country of the tv channel that is playing some cartoons directed by Ben Jones and Michael Chang?",
      "gold_sql": "SELECT T1.series_name ,  T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.directed_by  =  'Michael Chang' INTERSECT SELECT T1.series_name ,  T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.directed_by  =  'Ben Jones'",
      "predicted_sql": "SELECT DISTINCT tc.series_name, tc.Country\nFROM TV_Channel tc\nJOIN Cartoon c ON tc.id = c.Channel\nWHERE c.Directed_by IN ('Ben Jones', 'Michael Chang');",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the series name and country of all TV channels that are playing cartoons directed by Ben Jones and cartoons directed by Michael Chang?",
      "gold_sql": "SELECT T1.series_name ,  T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.directed_by  =  'Michael Chang' INTERSECT SELECT T1.series_name ,  T1.country FROM TV_Channel AS T1 JOIN cartoon AS T2 ON T1.id = T2.Channel WHERE T2.directed_by  =  'Ben Jones'",
      "predicted_sql": "SELECT DISTINCT tc.series_name, tc.Country\nFROM TV_Channel tc\nJOIN Cartoon c ON tc.id = c.Channel\nWHERE c.Directed_by IN ('Ben Jones', 'Michael Chang');",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "find the pixel aspect ratio and nation of the tv channels that do not use English.",
      "gold_sql": "SELECT Pixel_aspect_ratio_PAR ,  country FROM tv_channel WHERE LANGUAGE != 'English'",
      "predicted_sql": "SELECT tc.Pixel_aspect_ratio_PAR, tc.Country\nFROM TV_Channel tc\nWHERE tc.Language IS NULL OR tc.Language <> 'English';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What is the pixel aspect ratio and country of origin for all TV channels that do not use English?",
      "gold_sql": "SELECT Pixel_aspect_ratio_PAR ,  country FROM tv_channel WHERE LANGUAGE != 'English'",
      "predicted_sql": "SELECT tc.Pixel_aspect_ratio_PAR, tc.Country\nFROM TV_Channel tc\nWHERE tc.Language IS NULL OR tc.Language <> 'English';",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "find id of the tv channels that from the countries where have more than two tv channels.",
      "gold_sql": "SELECT id FROM tv_channel GROUP BY country HAVING count(*)  >  2",
      "predicted_sql": "SELECT DISTINCT tc.id\nFROM TV_Channel tc\nWHERE tc.Country IN (\n    SELECT Country\n    FROM TV_Channel\n    GROUP BY Country\n    HAVING COUNT(*) > 2\n);",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What are the ids of all tv channels that have more than 2 TV channels?",
      "gold_sql": "SELECT id FROM tv_channel GROUP BY country HAVING count(*)  >  2",
      "predicted_sql": "SELECT c.id\nFROM TV_Channel c\nJOIN TV_series s ON c.id = s.Channel\nGROUP BY c.id\nHAVING COUNT(s.id) > 2;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "find the id of tv channels that do not play any cartoon directed by Ben Jones.",
      "gold_sql": "SELECT id FROM TV_Channel EXCEPT SELECT channel FROM cartoon WHERE directed_by  =  'Ben Jones'",
      "predicted_sql": "SELECT c.id\nFROM TV_Channel c\nLEFT JOIN Cartoon ca ON c.id = ca.Channel AND ca.Directed_by = 'Ben Jones'\nWHERE ca.id IS NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What are the ids of the TV channels that do not have any cartoons directed by Ben Jones?",
      "gold_sql": "SELECT id FROM TV_Channel EXCEPT SELECT channel FROM cartoon WHERE directed_by  =  'Ben Jones'",
      "predicted_sql": "SELECT c.id\nFROM TV_Channel c\nWHERE NOT EXISTS (\n    SELECT 1\n    FROM Cartoon ca\n    WHERE ca.Channel = c.id AND ca.Directed_by = 'Ben Jones'\n);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "find the package option of the tv channel that do not have any cartoon directed by Ben Jones.",
      "gold_sql": "SELECT package_option FROM TV_Channel WHERE id NOT IN (SELECT channel FROM cartoon WHERE directed_by  =  'Ben Jones')",
      "predicted_sql": "SELECT DISTINCT tc.Package_Option\nFROM TV_Channel tc\nWHERE tc.id NOT IN (\n    SELECT c.Channel\n    FROM Cartoon c\n    WHERE c.Directed_by = 'Ben Jones'\n);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "tvshow",
      "question": "What are the package options of all tv channels that are not playing any cartoons directed by Ben Jones?",
      "gold_sql": "SELECT package_option FROM TV_Channel WHERE id NOT IN (SELECT channel FROM cartoon WHERE directed_by  =  'Ben Jones')",
      "predicted_sql": "SELECT DISTINCT tc.Package_Option\nFROM TV_Channel tc\nWHERE tc.id NOT IN (\n    SELECT c.Channel\n    FROM Cartoon c\n    WHERE c.Directed_by = 'Ben Jones'\n);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "How many poker players are there?",
      "gold_sql": "SELECT count(*) FROM poker_player",
      "predicted_sql": "SELECT COUNT(*) AS Total_Poker_Players\nFROM poker_player;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "Count the number of poker players.",
      "gold_sql": "SELECT count(*) FROM poker_player",
      "predicted_sql": "SELECT COUNT(*) AS NumberOfPokerPlayers\nFROM poker_player;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "List the earnings of poker players in descending order.",
      "gold_sql": "SELECT Earnings FROM poker_player ORDER BY Earnings DESC",
      "predicted_sql": "SELECT pp.Earnings\nFROM poker_player pp\nORDER BY pp.Earnings DESC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What are the earnings of poker players, ordered descending by value?",
      "gold_sql": "SELECT Earnings FROM poker_player ORDER BY Earnings DESC",
      "predicted_sql": "SELECT pp.Earnings\nFROM poker_player pp\nORDER BY pp.Earnings DESC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "List the final tables made and the best finishes of poker players.",
      "gold_sql": "SELECT Final_Table_Made ,  Best_Finish FROM poker_player",
      "predicted_sql": "SELECT pp.Final_Table_Made, pp.Best_Finish\nFROM poker_player pp;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What are the final tables made and best finishes for all poker players?",
      "gold_sql": "SELECT Final_Table_Made ,  Best_Finish FROM poker_player",
      "predicted_sql": "SELECT pp.Final_Table_Made, pp.Best_Finish\nFROM poker_player pp;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What is the average earnings of poker players?",
      "gold_sql": "SELECT avg(Earnings) FROM poker_player",
      "predicted_sql": "SELECT AVG(pp.Earnings) AS Average_Earnings\nFROM poker_player pp\nWHERE pp.Earnings IS NOT NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "Return the average earnings across all poker players.",
      "gold_sql": "SELECT avg(Earnings) FROM poker_player",
      "predicted_sql": "SELECT AVG(p.Earnings) AS Average_Earnings\nFROM poker_player p\nWHERE p.Earnings IS NOT NULL;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What is the money rank of the poker player with the highest earnings?",
      "gold_sql": "SELECT Money_Rank FROM poker_player ORDER BY Earnings DESC LIMIT 1",
      "predicted_sql": "SELECT pp.Money_Rank\nFROM poker_player pp\nWHERE pp.Earnings = (SELECT MAX(Earnings) FROM poker_player);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "Return the money rank of the player with the greatest earnings.",
      "gold_sql": "SELECT Money_Rank FROM poker_player ORDER BY Earnings DESC LIMIT 1",
      "predicted_sql": "SELECT Money_Rank \nFROM poker_player \nWHERE Earnings = (SELECT MAX(Earnings) FROM poker_player);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What is the maximum number of final tables made among poker players with earnings less than 200000?",
      "gold_sql": "SELECT max(Final_Table_Made) FROM poker_player WHERE Earnings  <  200000",
      "predicted_sql": "SELECT MAX(pp.Final_Table_Made) AS Max_Final_Tables\nFROM poker_player pp\nWHERE pp.Earnings < 200000;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "Return the maximum final tables made across all poker players who have earnings below 200000.",
      "gold_sql": "SELECT max(Final_Table_Made) FROM poker_player WHERE Earnings  <  200000",
      "predicted_sql": "SELECT MAX(pp.Final_Table_Made) AS Max_Final_Tables\nFROM poker_player pp\nWHERE pp.Earnings < 200000;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What are the names of poker players?",
      "gold_sql": "SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID",
      "predicted_sql": "SELECT p.Name\nFROM people p\nJOIN poker_player pp ON p.People_ID = pp.People_ID;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "Return the names of all the poker players.",
      "gold_sql": "SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID",
      "predicted_sql": "SELECT p.Name\nFROM people p\nJOIN poker_player pp ON p.People_ID = pp.People_ID;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What are the names of poker players whose earnings is higher than 300000?",
      "gold_sql": "SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID WHERE T2.Earnings  >  300000",
      "predicted_sql": "SELECT p.Name\nFROM people p\nJOIN poker_player pp ON p.People_ID = pp.People_ID\nWHERE pp.Earnings > 300000;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "Give the names of poker players who have earnings above 300000.",
      "gold_sql": "SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID WHERE T2.Earnings  >  300000",
      "predicted_sql": "SELECT p.Name\nFROM people p\nJOIN poker_player pp ON p.People_ID = pp.People_ID\nWHERE pp.Earnings > 300000;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "List the names of poker players ordered by the final tables made in ascending order.",
      "gold_sql": "SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Final_Table_Made",
      "predicted_sql": "SELECT p.Name\nFROM people p\nJOIN poker_player pp ON p.People_ID = pp.People_ID\nORDER BY pp.Final_Table_Made ASC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What are the names of poker players, ordered ascending by the number of final tables they have made?",
      "gold_sql": "SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Final_Table_Made",
      "predicted_sql": "SELECT p.Name\nFROM people p\nJOIN poker_player pp ON p.People_ID = pp.People_ID\nGROUP BY p.Name\nORDER BY COUNT(pp.Final_Table_Made) ASC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What is the birth date of the poker player with the lowest earnings?",
      "gold_sql": "SELECT T1.Birth_Date FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Earnings ASC LIMIT 1",
      "predicted_sql": "SELECT p.Birth_Date\nFROM people p\nJOIN poker_player pp ON p.People_ID = pp.People_ID\nORDER BY pp.Earnings ASC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "Return the birth date of the poker player with the lowest earnings.",
      "gold_sql": "SELECT T1.Birth_Date FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Earnings ASC LIMIT 1",
      "predicted_sql": "SELECT p.Birth_Date\nFROM people p\nJOIN poker_player pp ON p.People_ID = pp.People_ID\nORDER BY pp.Earnings ASC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What is the money rank of the tallest poker player?",
      "gold_sql": "SELECT T2.Money_Rank FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T1.Height DESC LIMIT 1",
      "predicted_sql": "SELECT pp.Money_Rank\nFROM poker_player pp\nJOIN people p ON pp.People_ID = p.People_ID\nWHERE p.Height = (SELECT MAX(Height) FROM people);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "Return the money rank of the poker player with the greatest height.",
      "gold_sql": "SELECT T2.Money_Rank FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T1.Height DESC LIMIT 1",
      "predicted_sql": "SELECT pp.Money_Rank\nFROM poker_player pp\nJOIN people p ON pp.People_ID = p.People_ID\nWHERE p.Height = (SELECT MAX(Height) FROM people);",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What is the average earnings of poker players with height higher than 200?",
      "gold_sql": "SELECT avg(T2.Earnings) FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID WHERE T1.Height  >  200",
      "predicted_sql": "SELECT AVG(pp.Earnings) AS Average_Earnings\nFROM poker_player pp\nJOIN people p ON pp.People_ID = p.People_ID\nWHERE p.Height > 200;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "Give average earnings of poker players who are taller than 200.",
      "gold_sql": "SELECT avg(T2.Earnings) FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID WHERE T1.Height  >  200",
      "predicted_sql": "SELECT AVG(pp.Earnings) AS Average_Earnings\nFROM poker_player pp\nJOIN people p ON pp.People_ID = p.People_ID\nWHERE p.Height > 200;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What are the names of poker players in descending order of earnings?",
      "gold_sql": "SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Earnings DESC",
      "predicted_sql": "SELECT p.Name\nFROM people p\nJOIN poker_player pp ON p.People_ID = pp.People_ID\nORDER BY pp.Earnings DESC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "Return the names of poker players sorted by their earnings descending.",
      "gold_sql": "SELECT T1.Name FROM people AS T1 JOIN poker_player AS T2 ON T1.People_ID  =  T2.People_ID ORDER BY T2.Earnings DESC",
      "predicted_sql": "SELECT p.Name\nFROM poker_player pp\nJOIN people p ON pp.People_ID = p.People_ID\nORDER BY pp.Earnings DESC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What are different nationalities of people and the corresponding number of people from each nation?",
      "gold_sql": "SELECT Nationality ,  COUNT(*) FROM people GROUP BY Nationality",
      "predicted_sql": "SELECT p.Nationality, COUNT(p.People_ID) AS NumberOfPeople\nFROM people p\nGROUP BY p.Nationality;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "How many people are there of each nationality?",
      "gold_sql": "SELECT Nationality ,  COUNT(*) FROM people GROUP BY Nationality",
      "predicted_sql": "SELECT Nationality, COUNT(*) AS People_Count\nFROM people\nGROUP BY Nationality;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What is the most common nationality of people?",
      "gold_sql": "SELECT Nationality FROM people GROUP BY Nationality ORDER BY COUNT(*) DESC LIMIT 1",
      "predicted_sql": "SELECT Nationality, COUNT(*) AS Nationality_Count\nFROM people\nGROUP BY Nationality\nORDER BY Nationality_Count DESC\nLIMIT 1;",
      "exec_match": false,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "Give the nationality that is most common across all people.",
      "gold_sql": "SELECT Nationality FROM people GROUP BY Nationality ORDER BY COUNT(*) DESC LIMIT 1",
      "predicted_sql": "SELECT Nationality\nFROM people\nGROUP BY Nationality\nORDER BY COUNT(*) DESC\nLIMIT 1;",
      "exec_match": true,
      "exact_match": true,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What are the nationalities that are shared by at least two people?",
      "gold_sql": "SELECT Nationality FROM people GROUP BY Nationality HAVING COUNT(*)  >=  2",
      "predicted_sql": "SELECT p.Nationality\nFROM people p\nGROUP BY p.Nationality\nHAVING COUNT(p.People_ID) >= 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "Return the nationalities for which there are two or more people.",
      "gold_sql": "SELECT Nationality FROM people GROUP BY Nationality HAVING COUNT(*)  >=  2",
      "predicted_sql": "SELECT p.Nationality\nFROM people p\nGROUP BY p.Nationality\nHAVING COUNT(p.People_ID) >= 2;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "List the names and birth dates of people in ascending alphabetical order of name.",
      "gold_sql": "SELECT Name ,  Birth_Date FROM people ORDER BY Name ASC",
      "predicted_sql": "SELECT p.Name, p.Birth_Date\nFROM people p\nORDER BY p.Name ASC;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    },
    {
      "db_id": "poker_player",
      "question": "What are the names and birth dates of people, ordered by their names in alphabetical order?",
      "gold_sql": "SELECT Name ,  Birth_Date FROM people ORDER BY Name ASC",
      "predicted_sql": "SELECT p.Name, p.Birth_Date\nFROM people p\nORDER BY p.Name;",
      "exec_match": true,
      "exact_match": false,
      "error": null
    }
  ]
}