MMTU-benchmark/MMTU huggingface dataset:
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Player          | Position   | School                            | Hometown             | MLB Draft                                         |
|:----------------|:-----------|:----------------------------------|:---------------------|:--------------------------------------------------|
| clayton kershaw | pitcher    | highland park high school         | dallas, tx           | 1st round - 7th pick of 2006 draft ( dodgers )    |
| hank conger     | catcher    | huntington beach high school      | huntington beach, ca | 1st round - 25th pick of 2006 draft ( angels )    |
| chris marrero   | infielder  | monsignor pace high school        | opa-locka, fl        | 1st round - 15th pick of 2006 draft ( nationals ) |
| billy rowell    | infielder  | bishop eustace preparatory school | pennsauken, nj       | 1st round - 9th pick of 2006 draft ( orioles )    |
| chris parmelee  | outfielder | chino hills high school           | chino hills, ca      | 1st round - 20th pick of 2006 draft ( twins )     |
| jason place     | outfielder | wren high school                  | piedmont, sc         | 1st round - 27th pick of 2006 draft ( red sox )   |
| travis snider   | outfielder | jackson high school               | mill creek, wa       | 1st round - 14th pick of 2006 draft ( blue jays ) |

Question: How many players have the hometown Pennsauken, NJ?

table_id: 1-11677100-12
label: SELECT COUNT("Player") FROM "table" WHERE "Hometown" = "Pennsauken, NJ"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   Year | Competition                          | Venue                          | Position   | Notes                         |
|-------:|:-------------------------------------|:-------------------------------|:-----------|:------------------------------|
|   2003 | european cross country championships | edinburgh , scotland           | 67th       | junior men individual 6.595km |
|   2004 | european cross country championships | heringsdorf , germany          | 70th       | junior men individual 5.64km  |
|   2004 | world cross country championships    | brussels , belgium             | 85th       | junior race men 8km           |
|   2005 | european u23 championships           | erfurt , germany               | 15th       | 10,000 m                      |
|   2005 | european cross country championships | tilburg , the netherlands      | 65th       | men individual 9.84km         |
|   2006 | european cross country championships | san giorgio su legnano , italy | 15th       | men u23 individual 8.03km     |
|   2007 | european u23 championships           | debrecen , hungary             | 2nd        | 10,000 m                      |
|   2007 | european cross country championships | toro , spain                   | 16th       | men u23 individual 8.2km      |
|   2008 | european cross country championships | brussels , belgium             | 9th        | men individual 10 km          |

Question: What venue hsoted the european cross country championships with a notes of junior men individual 6.595km?

table_id: 2-15205143-1
label: SELECT "Venue" FROM "table" WHERE "Competition" = "european cross country championships" AND "Notes" = "junior men individual 6.595km"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Tournament      | 2009            | 2010            | 2011            | 2012            | Win %           |
|:----------------|:----------------|:----------------|:----------------|:----------------|:----------------|
| women's singles | women's singles | women's singles | women's singles | women's singles | women's singles |
| australian open | a               | q2              | a               | 1r              | 50%             |
| french open     | a               | a               | a               | 1r              | 0%              |
| wimbledon       | 1r              | 1r              | 2r              | 1r              | 44%             |
| us open         | q3              | q3              | 2r              | 4r              | 67%             |
| women's doubles | women's doubles | women's doubles | women's doubles | women's doubles | women's doubles |
| australian open | a               | qf              | a               | 1r              | 50%             |
| french open     | a               | a               | a               | a               | 0%              |
| wimbledon       | 2r              | 1r              | 1r              | 1r              | 29%             |
| us open         | a               | a               | a               | 1r              | 0%              |

Question: What is the winning % for the 2010 QF?

table_id: 2-18288707-2
label: SELECT "Win %" FROM "table" WHERE "2010" = "qf"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   Heat |   Lane | Name                       | Country        | Mark     |
|-------:|-------:|:---------------------------|:---------------|:---------|
|      1 |      5 | olesya zykina              | russia         | 51.75    |
|      1 |      3 | antonina yefremova         | ukraine        | 51.79 pb |
|      1 |      6 | moushaumi robinson         | united states  | 51.85 pb |
|      1 |      1 | racheal nachula            | zambia         | 53.30 nr |
|      1 |      2 | makelesi batimala          | fiji           | 54.23    |
|      1 |      4 | christy ekpukhon ihunaeqbo | nigeria        | dns      |
|      2 |      6 | natalya nazarova           | russia         | 51.62    |
|      2 |      3 | shareese woods             | united states  | 51.87 pb |
|      2 |      4 | angela morosanu            | romania        | 52.83 sb |
|      2 |      2 | zuzana hejnová             | czech republic | 53.16    |
|      2 |      5 | amantle montsho            | botswana       | 53.21    |
|      2 |      1 | nataliya pyhyda            | ukraine        | 53.33    |

Question: What is the average lane racheal nachula has when the heat is less than 2?

table_id: 2-16196238-3
label: SELECT AVG("Lane") FROM "table" WHERE "Heat" < 2 AND "Name" = "racheal nachula"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Place   | Player             | Country          | Score     | To par   |
|:--------|:-------------------|:-----------------|:----------|:---------|
| 1       | chad campbell      | united states    | 71-67=138 | –6       |
| t2      | fred couples       | united states    | 71-70=141 | –3       |
| t2      | rocco mediate      | united states    | 68-73=141 | –3       |
| t2      | vijay singh        | fiji             | 67-74=141 | –3       |
| t5      | tim clark          | south africa     | 70-72=142 | –2       |
| t5      | darren clarke      | northern ireland | 72-70=142 | –2       |
| t5      | ernie els          | south africa     | 71-71=142 | –2       |
| t5      | david howell       | england          | 71-71=142 | –2       |
| t5      | phil mickelson     | united states    | 70-72=142 | –2       |
| t10     | olin browne        | united states    | 74-69=143 | –1       |
| t10     | ben crenshaw       | united states    | 71-72=143 | –1       |
| t10     | retief goosen      | south africa     | 70-73=143 | –1       |
| t10     | pádraig harrington | ireland          | 73-70=143 | –1       |
| t10     | billy mayfair      | united states    | 71-72=143 | –1       |
| t10     | nick o'hern        | australia        | 71-72=143 | –1       |
| t10     | tiger woods        | united states    | 72-71=143 | –1       |

Question: Name the To par for t10 place and score of 72-71=143

table_id: 2-12626983-5
label: SELECT "To par" FROM "table" WHERE "Place" = "t10" AND "Score" = "72-71=143"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Name                            | Tenure    | Courtesy title           | Court Rank           | Revenues    | Lineage                           |
|:--------------------------------|:----------|:-------------------------|:---------------------|:------------|:----------------------------------|
| ōoka tadasuke (大岡忠相)        | 1748–1751 | echizen-no-kami (越前守) | lower 5th (従五位下) | 10,000 koku | 4th son of hatamoto ōoka tadataka |
| ōoka tadayoshi (大岡忠宜)       | 1755–1766 | echizen-no-kami (越前守) | lower 5th (従五位下) | 10,000 koku | 2nd son of tadasuke               |
| ōoka tadatsune (大岡忠恒)       | 1766–1784 | echizen-no-kami (越前守) | lower 5th (従五位下) | 10,000 koku | 2nd son of tadayoshi              |
| ōoka tadatomo (大岡忠與)        | 1784–1786 | echizen-no-kami (越前守) | lower 5th (従五位下) | 13,000 koku | 3rd son of ogasawara nagamichi    |
| ōoka tadayori (大岡忠移)        | 1786–1828 | echizen-no-kami (越前守) | lower 5th (従五位下) | 10,000 koku | 3rd son of tadatsune              |
| ōoka tadayoshi (2nd) (大岡忠愛) | 1828–1857 | echizen-no-kami (越前守) | lower 5th (従五位下) | 10,000 koku | son of tadayori                   |
| ōoka tadataka (大岡忠敬)        | 1857–1871 | echizen-no-kami (越前守) | lower 5th (従五位下) | 10,000 koku | 5th son of tadayori               |

Question: What's the court ranking of 5th son of tadayori and has revenues of 10,000 koku?

table_id: 2-12803263-1
label: SELECT "Court Rank" FROM "table" WHERE "Revenues" = "10,000 koku" AND "Lineage" = "5th son of tadayori"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Year   | Start   | Qual    | Rank   | Finish   |   Laps |
|:-------|:--------|:--------|:-------|:---------|-------:|
| 1982   | 11      | 197.705 | 13     | 15       |    147 |
| 1983   | 16      | 197.608 | 24     | 8        |    195 |
| 1984   | 22      | 201.612 | 28     | 28       |     61 |
| 1985   | 25      | 206.104 | 25     | 22       |    121 |
| 1986   | 26      | 207.590 | 31     | 29       |     70 |
| totals | totals  | totals  | totals | totals   |    594 |

Question: Which Laps have a Finish of 15?

table_id: 2-1882094-2
label: SELECT "Laps" FROM "table" WHERE "Finish" = "15"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Opposition            | Span      |   Lost |   Tied | Success Rate   |
|:----------------------|:----------|-------:|-------:|:---------------|
| chennai super kings   | 2008–2013 |      8 |      0 | 35.71%         |
| deccan chargers       | 2008–2012 |      6 |      0 | 44.44%         |
| delhi daredevils      | 2008–2013 |      5 |      0 | 50.00%         |
| kings xi punjab       | 2008–2013 |      6 |      0 | 45.45%         |
| kochi tuskers kerala  | 2011–2011 |      0 |      0 | 100.00%        |
| kolkata knight riders | 2008–2013 |      5 |      0 | 54.54%         |
| mumbai indians        | 2008–2013 |      7 |      0 | 46.15%         |
| pune warriors india   | 2011–2013 |      0 |      0 | 100.00%        |
| rajasthan royals      | 2008–2011 |      5 |      0 | 50.00%         |
| sunrisers hyderabad   | 2013      |      1 |      0 | 50.00%         |
| total                 | 2008–2013 |     43 |      0 | 50.55%         |

Question: What is the average number of losses when there are more than 0 ties?

table_id: 2-15861688-5
label: SELECT AVG("Lost") FROM "table" WHERE "Tied" > 0
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Name                  | Bullet        | Length        | Base         | Shoulder     | Neck         |
|:----------------------|:--------------|:--------------|:-------------|:-------------|:-------------|
| .25-20 winchester     | 6.55 (.258)   | 33.78 (1.33)  | 8.86 (.349)  | 8.46 (.333)  | 6.96 (.274)  |
| .25-35 winchester     | 6.55 (.258)   | 51.89 (2.043) | 10.73 (.422) | 9.26 (.365)  | 7.15 (.282)  |
| .250-3000 savage      | 6.553 (.258)  | 48.46 (1.912) | 11.91 (.469) | 10.51 (.414) | 7.26 (.286)  |
| .257 roberts          | 6.553 (.258)  | 56.72 (2.233) | 11.99 (.427) | 10.92 (.430) | 7.36 (.290)  |
| .25-06 remington      | 6.541 (.2575) | 63.35 (2.494) | 11.94 (.470) | 11.20 (.441) | 7.37 (.290)  |
| .257 weatherby magnum | 6.5 (.257)    | 65.0 (2.560)  | 13.1 (.514)  | 12.6 (.496)  | 7.3 (.288)   |
| .256 win magnum       | 6.528 (.257)  | 32.54 (1.281) | 9.677 (.381) | 9.347 (.368) | 6.528 (.257) |

Question: Which length has a Bullet of 6.5 (.257)?

table_id: 2-1058122-3
label: SELECT "Length" FROM "table" WHERE "Bullet" = "6.5 (.257)"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Player                             | No.(s)   | Height in Ft.   | Position      | Years with Spurs   | School/Previous Club Team/Country   |
|:-----------------------------------|:---------|:----------------|:--------------|:-------------------|:------------------------------------|
| ahearn, blake blake ahearn         | 18       | 6-2             | guard         | 2008-09            | missouri state                      |
| alexander, cory cory alexander     | 1        | 6-1             | guard         | 1995-98            | virginia                            |
| anderson, derek derek anderson     | 1        | 6-5             | guard         | 2000-01            | kentucky                            |
| anderson, greg greg anderson       | 33       | 6-10            | forward       | 1987-89, 1996-97   | houston                             |
| anderson, james james anderson     | 11, 25   | 6-6             | guard         | 2010-13            | oklahoma state                      |
| anderson, michael michael anderson | 10       | 5-11            | guard         | 1988-89            | drexel                              |
| anderson, willie willie anderson   | 40       | 6-7             | guard/forward | 1988-95            | georgia                             |
| averitt, bird bird averitt         | 10       | 6-1             | guard         | 1973-74            | pepperdine                          |

Question: What is Player, when Years With Spurs is 1988-95?

table_id: 2-16669584-1
label: SELECT "Player" FROM "table" WHERE "Years with Spurs" = "1988-95"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Home team       | Home team score   | Away team       | Away team score   | Venue         |   Crowd | Date          |
|:----------------|:------------------|:----------------|:------------------|:--------------|--------:|:--------------|
| melbourne       | 11.13 (79)        | richmond        | 6.15 (51)         | mcg           |   41634 | 21 april 1962 |
| footscray       | 12.8 (80)         | hawthorn        | 6.11 (47)         | western oval  |   30752 | 21 april 1962 |
| carlton         | 13.10 (88)        | geelong         | 19.13 (127)       | princes park  |   41846 | 21 april 1962 |
| essendon        | 12.13 (85)        | fitzroy         | 7.6 (48)          | windy hill    |   29200 | 23 april 1962 |
| collingwood     | 5.8 (38)          | st kilda        | 9.9 (63)          | victoria park |   42170 | 23 april 1962 |
| south melbourne | 14.13 (97)        | north melbourne | 13.13 (91)        | lake oval     |   22340 | 23 april 1962 |

Question: Where did Collingwood play as the home team?

table_id: 2-10776868-1
label: SELECT "Venue" FROM "table" WHERE "Home team" = "collingwood"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Team 1              | Agg.          | Team 2            | 1st leg   | 2nd leg   |
|:--------------------|:--------------|:------------------|:----------|:----------|
| etoile du sahel     | 2–0           | espérance         | 2–0       | 0–0       |
| club africain       | 0–0 (5–3 pk ) | djoliba           | 0–0       | 0–0       |
| platinum stars      | 2–4           | cs sfaxien        | 2–2       | 0–2       |
| js kabylie          | 2–1           | les astres fc     | 1–1       | 1–0       |
| mamelodi sundowns   | 1–2           | haras el hodood   | 1–0       | 0–2       |
| olympique khouribga | 2–2( a )      | al-merrikh        | 2–2       | 0–0       |
| inter luanda        | 3–2           | mount cameroon fc | 2–1       | 1–1       |
| al ittihad tripolil | 3–4           | asante kotoko     | 2–1       | 1–3       |

Question: What is the 1st leg of cs sfaxien?

table_id: 2-14835821-4
label: SELECT "1st leg" FROM "table" WHERE "Team 2" = "cs sfaxien"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   Game | Date         | Opponent                 | Score      | Location                 | Record   |
|-------:|:-------------|:-------------------------|:-----------|:-------------------------|:---------|
|     46 | fri. feb. 1  | minnesota timberwolves   | 95-98 (ot) | fleetcenter              | 26-20    |
|     47 | sun. feb. 3  | los angeles clippers     | 104-91     | fleetcenter              | 27-20    |
|     48 | tue. feb. 5  | @ charlotte hornets      | 82-79      | charlotte coliseum       | 28-20    |
|     49 | wed. feb. 6  | sacramento kings         | 85-102     | fleetcenter              | 28-21    |
|     50 | tue. feb. 12 | @ denver nuggets         | 110-93     | pepsi center             | 29-21    |
|     51 | wed. feb. 13 | @ golden state warriors  | 75-92      | the arena in oakland     | 29-22    |
|     52 | fri. feb. 15 | @ portland trail blazers | 107-104    | rose garden              | 30-22    |
|     53 | sat. feb. 16 | @ seattle supersonics    | 79-99      | keyarena                 | 30-23    |
|     54 | tue. feb. 19 | @ los angeles lakers     | 109-108    | staples center           | 31-23    |
|     55 | thu. feb. 21 | @ dallas mavericks       | 92-98      | american airlines center | 31-24    |
|     56 | sat. feb. 23 | @ houston rockets        | 89-99      | compaq center            | 31-25    |
|     57 | wed. feb. 27 | milwaukee bucks          | 92-95      | fleetcenter              | 31-26    |

Question: What game was the final score 82-79?

table_id: 2-17622423-7
label: SELECT "Game" FROM "table" WHERE "Score" = "82-79"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   Round |   Pick | Player         | Nationality   | College                 |
|--------:|-------:|:---------------|:--------------|:------------------------|
|       1 |     22 | reggie lewis   | united states | northeastern            |
|       2 |     45 | brad lohaus    | united states | iowa                    |
|       4 |     70 | tom sheehey    | united states | virginia                |
|       4 |     91 | darryl kennedy | united states | oklahoma                |
|       5 |    114 | david butler   | united states | california              |
|       6 |    137 | tim naegeli    | united states | wisconsin–stevens point |
|       7 |    160 | jerry corcoran | united states | northeastern            |

Question: What is the nationality of the round 4 draft selection who played college ball at oklahoma?

table_id: 2-17344644-1
label: SELECT "Nationality" FROM "table" WHERE "Round" = 4 AND "College" = "oklahoma"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| Home team       | Home team score   | Away team       | Away team score   | Venue             |   Crowd | Date             |
|:----------------|:------------------|:----------------|:------------------|:------------------|--------:|:-----------------|
| north melbourne | 16.15 (111)       | south melbourne | 12.15 (87)        | arden street oval |   15607 | 2 september 1978 |
| geelong         | 13.22 (100)       | fitzroy         | 5.8 (38)          | kardinia park     |   22842 | 2 september 1978 |
| hawthorn        | 17.16 (118)       | essendon        | 16.13 (109)       | princes park      |   14534 | 2 september 1978 |
| melbourne       | 19.11 (125)       | collingwood     | 24.12 (156)       | mcg               |   40267 | 2 september 1978 |
| st kilda        | 16.10 (106)       | carlton         | 9.12 (66)         | moorabbin oval    |   35850 | 2 september 1978 |
| richmond        | 19.20 (134)       | footscray       | 11.15 (81)        | vfl park          |   17768 | 2 september 1978 |

Question: Where was the game played when the crowd was more than 14,534 and the home team scored 13.22 (100)?

table_id: 2-10887680-22
label: SELECT "Venue" FROM "table" WHERE "Crowd" > 14534 AND "Home team score" = "13.22 (100)"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   Lane | Name               | Nationality   |   50m split | Time      |
|-------:|:-------------------|:--------------|------------:|:----------|
|      5 | brendan hansen     | usa           |       27.67 | 00: 59.80 |
|      4 | kosuke kitajima    | japan         |       27.79 | 00: 59.96 |
|      6 | brenton rickard    | australia     |       28.15 | 1:00.58   |
|      2 | valeriy dymo       | ukraine       |       28.18 | 1:00.60   |
|      7 | oleg lisogor       | ukraine       |       28.07 | 1:00.83   |
|      1 | mihail alexandrov  | bulgaria      |       28.09 | 1:01.17   |
|      8 | dmitry komornikov  | russia        |       28.58 | 1:01.24   |
|      3 | alexander dale oen | norway        |       27.93 | 1:01.67   |

Question: What is the time for a 50m split less than 28.58 and a lane of 2?

table_id: 2-10325152-1
label: SELECT "Time" FROM "table" WHERE "50m split" < 28.58 AND "Lane" = 2
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
| School                  | Location   | Mascot    | IHSAA Class   | County        | Year Joined   | Year Left   | Conference Joined         |
|:------------------------|:-----------|:----------|:--------------|:--------------|:--------------|:------------|:--------------------------|
| bethany christian       | goshen     | bruins    | n/a           | 20 elkhart    | 1971 1987     | 1981 1988   | independent               |
| divine heart            | donaldson  | chargers  | n/a           | 50 marshall   | 1971          | 1972        | independent (closed 1979) |
| fort wayne canterbury   | fort wayne | cavaliers | a             | 2 allen       | 1985          | 2002        | independent               |
| huntington catholic     | huntington | ramblers  | n/a           | 35 huntington | 1971 1984     | 1981 1985   | independent closed 1985   |
| kewanna                 | kewanna    | indians   | n/a           | 25 fulton     | 1971          | 1981        | merged into caston        |
| lakewood park christian | auburn     | panthers  | a             | 17 dekalb     | 2000          | 2009        | independent               |
| marion bennett          | marion     | trojans   | n/a           | 27 grant      | 1973 1984     | 1981 1993   | independent closed 1993   |
| wawassee prep           | syracuse   | lakers    | n/a           | 50 marshall   | 1971          | 1975        | closed 1975               |

Question: Which county has the mascot of Bruins?

table_id: 2-18737756-2
label: SELECT "County" FROM "table" WHERE "Mascot" = "bruins"
Task: NL2SQL (source dataset: WikiSQL)

Natural language to SQL, also known as NL2SQL, is the problem of generating a SQL query that can be executed on a input table, for a given natural language question.

You will be given an input table called "table" in the markdown format, as well as a question. Your task is to generate an SQL query that can be executed on the input table to answer the question.

Please ensure that the generated SQL only return relevant columns being specifically asked in the question (e.g., in SQL please don't return more than one columns in SELECT if only one column is needed to answer the given question, and similarly please refrain from using SELECT * unless the entire row is needed to answer the question).
 
When generating SQL code, please use the SQLite syntax to ensure that your SQL is executable on SQLite3. Use only columns that are present in the table, always use quotes around your column and table names (some column names have punctuation or special characters), and refer to the columns using the column-names exactly as they appear in the table, do not add or remove punctuation (underscore, slash, etc.)

No explanation, return the code only with the following markdown codeblock format : ```sql<SQL CODE>```. For example, ```sql
SELECT * FROM "table"
``` is a valid format.

Table:
|   Week | Date         | Opponent       | Location           | Final Score   |   Attendance | Record   |
|-------:|:-------------|:---------------|:-------------------|:--------------|-------------:|:---------|
|      1 | august 14    | blue bombers   | exhibition stadium | l 14–13       |        27189 | 0–1–0    |
|      2 | august 20    | tiger-cats     | exhibition stadium | l 28–24       |        27809 | 0–2–0    |
|      3 | august 25    | @ alouettes    | molson stadium     | w 15–10       |        18522 | 1–2–0    |
|      4 | september 4  | @ tiger-cats   | civic stadium      | l 21–19       |        26533 | 1–3–0    |
|      5 | september 10 | roughriders    | exhibition stadium | w 27–7        |        24047 | 2–3–0    |
|      6 | september 16 | @ eskimos      | clarke stadium     | t 8–8         |        21510 | 2–3–1    |
|      6 | september 18 | @ lions        | empire stadium     | w 15–7        |        24428 | 3–3–1    |
|      7 | september 24 | rough riders   | exhibition stadium | l 29–10       |        30648 | 3–4–1    |
|      8 | september 29 | stampeders     | exhibition stadium | w 22–19       |        23546 | 4–4–1    |
|      9 | october 7    | @ alouettes    | molson stadium     | w 33–27       |        19075 | 5–4–1    |
|     10 | october 15   | tiger-cats     | exhibition stadium | l 37–10       |        29553 | 5–5–1    |
|     11 | october 21   | @ rough riders | landsdowne park    | w 21–7        |        18821 | 6–5–1    |
|     12 | october 29   | alouettes      | exhibition stadium | w 15–9        |        23316 | 7–5–1    |

Question: If the opponent is the Stampeders, what is the record?

table_id: 1-23916539-3
label: SELECT "Record" FROM "table" WHERE "Opponent" = "Stampeders"