brief_instruction stringlengths 16 224 | instruction stringlengths 687 8.77k | output stringlengths 18 577 |
|---|---|---|
Find the titles of items whose rating is higher than the average review rating of all items. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the titles of items whose rating is higher than the average review rating of all items.` to a syntactically-correct PostgreSQL query.
| SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id WHERE T2.rating > (SELECT avg(rating) FROM review) |
Find the titles of items that received any rating below 5. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the titles of items that received any rating below 5.` to a syntactically-correct PostgreSQL query.
| SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id WHERE T2.rating < 5 |
Find the titles of items that received both a rating higher than 8 and a rating below 5. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the titles of items that received both a rating higher than 8 and a rating below 5.` to a syntactically-correct PostgreSQL query.
| SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id WHERE T2.rating > 8 INTERSECT SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id WHERE T2.rating < 5 |
Find the names of items whose rank is higher than 3 and whose average rating is above 5. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the names of items whose rank is higher than 3 and whose average rating is above 5.` to a syntactically-correct PostgreSQL query.
| SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id WHERE T2.rank > 3 INTERSECT SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id GROUP BY T2.i_id HAVING avg(T2.rating) > 5 |
Find the name of the item with the lowest average rating. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the name of the item with the lowest average rating.` to a syntactically-correct PostgreSQL query.
| SELECT T1.title FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id GROUP BY T2.i_id ORDER BY avg(T2.rating) LIMIT 1 |
List the titles of all items in alphabetic order . |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List the titles of all items in alphabetic order .` to a syntactically-correct PostgreSQL query.
| SELECT title FROM item ORDER BY title |
Find the name of the user who gives the most reviews. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the name of the user who gives the most reviews.` to a syntactically-correct PostgreSQL query.
| SELECT T1.name FROM useracct AS T1 JOIN review AS T2 ON T1.u_id = T2.u_id GROUP BY T2.u_id ORDER BY count(*) DESC LIMIT 1 |
Find the name and id of the item with the highest average rating. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the name and id of the item with the highest average rating.` to a syntactically-correct PostgreSQL query.
| SELECT T1.title , T1.i_id FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id GROUP BY T2.i_id ORDER BY avg(T2.rating) DESC LIMIT 1 |
Find the name and id of the good with the highest average rank. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the name and id of the good with the highest average rank.` to a syntactically-correct PostgreSQL query.
| SELECT T1.title , T1.i_id FROM item AS T1 JOIN review AS T2 ON T1.i_id = T2.i_id GROUP BY T2.i_id ORDER BY avg(T2.rank) DESC LIMIT 1 |
For each user, return the name and the average rating of reviews given by them. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `For each user, return the name and the average rating of reviews given by them.` to a syntactically-correct PostgreSQL query.
| SELECT T1.name , avg(T2.rating) FROM useracct AS T1 JOIN review AS T2 ON T1.u_id = T2.u_id GROUP BY T2.u_id |
For each user, find their name and the number of reviews written by them. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `For each user, find their name and the number of reviews written by them.` to a syntactically-correct PostgreSQL query.
| SELECT T1.name , count(*) FROM useracct AS T1 JOIN review AS T2 ON T1.u_id = T2.u_id GROUP BY T2.u_id |
Find the name of the user who gave the highest rating. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the name of the user who gave the highest rating.` to a syntactically-correct PostgreSQL query.
| SELECT T1.name FROM useracct AS T1 JOIN review AS T2 ON T1.u_id = T2.u_id ORDER BY T2.rating DESC LIMIT 1 |
Find the name of the source user with the highest average trust score. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the name of the source user with the highest average trust score.` to a syntactically-correct PostgreSQL query.
| SELECT T1.name FROM useracct AS T1 JOIN trust AS T2 ON T1.u_id = T2.source_u_id GROUP BY T2.source_u_id ORDER BY avg(trust) DESC LIMIT 1 |
Find each target user's name and average trust score. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find each target user's name and average trust score.` to a syntactically-correct PostgreSQL query.
| SELECT T1.name , avg(trust) FROM useracct AS T1 JOIN trust AS T2 ON T1.u_id = T2.target_u_id GROUP BY T2.target_u_id |
Find the name of the target user with the lowest trust score. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the name of the target user with the lowest trust score.` to a syntactically-correct PostgreSQL query.
| SELECT T1.name FROM useracct AS T1 JOIN trust AS T2 ON T1.u_id = T2.target_u_id ORDER BY trust LIMIT 1 |
Find the names of the items that did not receive any review. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the names of the items that did not receive any review.` to a syntactically-correct PostgreSQL query.
| SELECT title FROM item WHERE i_id NOT IN (SELECT i_id FROM review) |
Find the names of users who did not leave any review. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the names of users who did not leave any review.` to a syntactically-correct PostgreSQL query.
| SELECT name FROM useracct WHERE u_id NOT IN (SELECT u_id FROM review) |
Find the number of users who did not write any review. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the number of users who did not write any review.` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM useracct WHERE u_id NOT IN (SELECT u_id FROM review) |
Find the number of items without any review. |
-- Language PostgreSQL
-- Tables:
-- Table: item
columns : [['item id', 'number'], ['title', 'text']]
-- Table: review
columns : [['a id', 'number'], ['user id', 'number'], ['item id', 'number'], ['rating', 'number'], ['rank', 'number']]
-- Table: useracct
columns : [['user id', 'number'], ['name', 'text']]
-- Table: trust
columns : [['source user id', 'number'], ['target user id', 'number'], ['trust', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the number of items without any review.` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM item WHERE i_id NOT IN (SELECT i_id FROM review) |
How many players are there? |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many players are there?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM player |
List the names of players in ascending order of votes. |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List the names of players in ascending order of votes.` to a syntactically-correct PostgreSQL query.
| SELECT Player_name FROM player ORDER BY Votes ASC |
What are the gender and occupation of players? |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the gender and occupation of players?` to a syntactically-correct PostgreSQL query.
| SELECT Gender , Occupation FROM player |
List the name and residence for players whose occupation is not "Researcher". |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List the name and residence for players whose occupation is not "Researcher".` to a syntactically-correct PostgreSQL query.
| SELECT Player_name , residence FROM player WHERE Occupation != "Researcher" |
Show the names of sponsors of players whose residence is either "Brandon" or "Birtle". |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the names of sponsors of players whose residence is either "Brandon" or "Birtle".` to a syntactically-correct PostgreSQL query.
| SELECT Sponsor_name FROM player WHERE Residence = "Brandon" OR Residence = "Birtle" |
What is the name of the player with the largest number of votes? |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the name of the player with the largest number of votes?` to a syntactically-correct PostgreSQL query.
| SELECT Player_name FROM player ORDER BY Votes DESC LIMIT 1 |
Show different occupations along with the number of players in each occupation. |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show different occupations along with the number of players in each occupation.` to a syntactically-correct PostgreSQL query.
| SELECT Occupation , COUNT(*) FROM player GROUP BY Occupation |
Please show the most common occupation of players. |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Please show the most common occupation of players.` to a syntactically-correct PostgreSQL query.
| SELECT Occupation FROM player GROUP BY Occupation ORDER BY COUNT(*) DESC LIMIT 1 |
Show the residences that have at least two players. |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the residences that have at least two players.` to a syntactically-correct PostgreSQL query.
| SELECT Residence FROM player GROUP BY Residence HAVING COUNT(*) >= 2 |
Show the names of players and names of their coaches. |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the names of players and names of their coaches.` to a syntactically-correct PostgreSQL query.
| SELECT T3.Player_name , T2.coach_name FROM player_coach AS T1 JOIN coach AS T2 ON T1.Coach_ID = T2.Coach_ID JOIN player AS T3 ON T1.Player_ID = T3.Player_ID |
Show the names of players coached by the rank 1 coach. |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the names of players coached by the rank 1 coach.` to a syntactically-correct PostgreSQL query.
| SELECT T3.Player_name FROM player_coach AS T1 JOIN coach AS T2 ON T1.Coach_ID = T2.Coach_ID JOIN player AS T3 ON T1.Player_ID = T3.Player_ID WHERE T2.Rank = 1 |
Show the names and genders of players with a coach starting after 2011. |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the names and genders of players with a coach starting after 2011.` to a syntactically-correct PostgreSQL query.
| SELECT T3.Player_name , T3.gender FROM player_coach AS T1 JOIN coach AS T2 ON T1.Coach_ID = T2.Coach_ID JOIN player AS T3 ON T1.Player_ID = T3.Player_ID WHERE T1.Starting_year > 2011 |
Show the names of players and names of their coaches in descending order of the votes of players. |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the names of players and names of their coaches in descending order of the votes of players.` to a syntactically-correct PostgreSQL query.
| SELECT T3.Player_name , T2.coach_name FROM player_coach AS T1 JOIN coach AS T2 ON T1.Coach_ID = T2.Coach_ID JOIN player AS T3 ON T1.Player_ID = T3.Player_ID ORDER BY T3.Votes DESC |
List the names of players that do not have coaches. |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List the names of players that do not have coaches.` to a syntactically-correct PostgreSQL query.
| SELECT Player_name FROM player WHERE Player_ID NOT IN (SELECT Player_ID FROM player_coach) |
Show the residences that have both a player of gender "M" and a player of gender "F". |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the residences that have both a player of gender "M" and a player of gender "F".` to a syntactically-correct PostgreSQL query.
| SELECT Residence FROM player WHERE gender = "M" INTERSECT SELECT Residence FROM player WHERE gender = "F" |
How many coaches does each club has? List the club id, name and the number of coaches. |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many coaches does each club has? List the club id, name and the number of coaches.` to a syntactically-correct PostgreSQL query.
| SELECT T1.club_id , T1.club_name, count(*) FROM club AS T1 JOIN coach AS T2 ON T1.club_id = T2.club_id GROUP BY T1.club_id |
How many gold medals has the club with the most coaches won? |
-- Language PostgreSQL
-- Tables:
-- Table: player
columns : [['player id', 'number'], ['sponsor name', 'text'], ['player name', 'text'], ['gender', 'text'], ['residence', 'text'], ['occupation', 'text'], ['votes', 'number'], ['rank', 'text']]
-- Table: club
columns : [['club id', 'number'], ['club name', 'text'], ['region', 'text'], ['start year', 'number']]
-- Table: coach
columns : [['coach id', 'number'], ['player name', 'text'], ['gender', 'text'], ['club id', 'number'], ['rank', 'number']]
-- Table: player coach
columns : [['player id', 'number'], ['coach id', 'number'], ['starting year', 'number']]
-- Table: match result
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['big silver', 'number'], ['small silver', 'number'], ['bronze', 'number'], ['points', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many gold medals has the club with the most coaches won?` to a syntactically-correct PostgreSQL query.
| SELECT T1.club_id , T1.gold FROM match_result AS T1 JOIN coach AS T2 ON T1.club_id = T2.club_id GROUP BY T1.club_id ORDER BY count(*) DESC LIMIT 1 |
How many gymnasts are there? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many gymnasts are there?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM gymnast |
Count the number of gymnasts. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Count the number of gymnasts.` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM gymnast |
List the total points of gymnasts in descending order. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List the total points of gymnasts in descending order.` to a syntactically-correct PostgreSQL query.
| SELECT Total_Points FROM gymnast ORDER BY Total_Points DESC |
What are the total points for all gymnasts, ordered by total points descending? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the total points for all gymnasts, ordered by total points descending?` to a syntactically-correct PostgreSQL query.
| SELECT Total_Points FROM gymnast ORDER BY Total_Points DESC |
List the total points of gymnasts in descending order of floor exercise points. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List the total points of gymnasts in descending order of floor exercise points.` to a syntactically-correct PostgreSQL query.
| SELECT Total_Points FROM gymnast ORDER BY Floor_Exercise_Points DESC |
What are the total points of gymnasts, ordered by their floor exercise points descending? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the total points of gymnasts, ordered by their floor exercise points descending?` to a syntactically-correct PostgreSQL query.
| SELECT Total_Points FROM gymnast ORDER BY Floor_Exercise_Points DESC |
What is the average horizontal bar points for all gymnasts? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the average horizontal bar points for all gymnasts?` to a syntactically-correct PostgreSQL query.
| SELECT avg(Horizontal_Bar_Points) FROM gymnast |
Return the average horizontal bar points across all gymnasts. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Return the average horizontal bar points across all gymnasts.` to a syntactically-correct PostgreSQL query.
| SELECT avg(Horizontal_Bar_Points) FROM gymnast |
What are the names of people in ascending alphabetical order? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the names of people in ascending alphabetical order?` to a syntactically-correct PostgreSQL query.
| SELECT Name FROM People ORDER BY Name ASC |
Return the names of people, ordered alphabetically. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Return the names of people, ordered alphabetically.` to a syntactically-correct PostgreSQL query.
| SELECT Name FROM People ORDER BY Name ASC |
What are the names of gymnasts? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the names of gymnasts?` to a syntactically-correct PostgreSQL query.
| SELECT T2.Name FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID |
Return the names of the gymnasts. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Return the names of the gymnasts.` to a syntactically-correct PostgreSQL query.
| SELECT T2.Name FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID |
What are the names of gymnasts whose hometown is not "Santo Domingo"? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the names of gymnasts whose hometown is not "Santo Domingo"?` to a syntactically-correct PostgreSQL query.
| SELECT T2.Name FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID WHERE T2.Hometown != "Santo Domingo" |
Return the names of gymnasts who did not grow up in Santo Domingo. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Return the names of gymnasts who did not grow up in Santo Domingo.` to a syntactically-correct PostgreSQL query.
| SELECT T2.Name FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID WHERE T2.Hometown != "Santo Domingo" |
What is the age of the tallest person? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the age of the tallest person?` to a syntactically-correct PostgreSQL query.
| SELECT Age FROM people ORDER BY Height DESC LIMIT 1 |
Return the age of the person with the greatest height. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Return the age of the person with the greatest height.` to a syntactically-correct PostgreSQL query.
| SELECT Age FROM people ORDER BY Height DESC LIMIT 1 |
List the names of the top 5 oldest people. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List the names of the top 5 oldest people.` to a syntactically-correct PostgreSQL query.
| SELECT Name FROM People ORDER BY Age DESC LIMIT 5 |
What are the names of the five oldest people? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the names of the five oldest people?` to a syntactically-correct PostgreSQL query.
| SELECT Name FROM People ORDER BY Age DESC LIMIT 5 |
What is the total point count of the youngest gymnast? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the total point count of the youngest gymnast?` to a syntactically-correct PostgreSQL query.
| SELECT T1.Total_Points FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID ORDER BY T2.Age ASC LIMIT 1 |
Return the total points of the gymnast with the lowest age. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Return the total points of the gymnast with the lowest age.` to a syntactically-correct PostgreSQL query.
| SELECT T1.Total_Points FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID ORDER BY T2.Age ASC LIMIT 1 |
What is the average age of all gymnasts? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the average age of all gymnasts?` to a syntactically-correct PostgreSQL query.
| SELECT avg(T2.Age) FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID |
Return the average age across all gymnasts. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Return the average age across all gymnasts.` to a syntactically-correct PostgreSQL query.
| SELECT avg(T2.Age) FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID |
What are the distinct hometowns of gymnasts with total points more than 57.5? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the distinct hometowns of gymnasts with total points more than 57.5?` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT T2.Hometown FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID WHERE T1.Total_Points > 57.5 |
Give the different hometowns of gymnasts that have a total point score of above 57.5. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Give the different hometowns of gymnasts that have a total point score of above 57.5.` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT T2.Hometown FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID WHERE T1.Total_Points > 57.5 |
What are the hometowns of gymnasts and the corresponding number of gymnasts? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the hometowns of gymnasts and the corresponding number of gymnasts?` to a syntactically-correct PostgreSQL query.
| SELECT T2.Hometown , COUNT(*) FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID GROUP BY T2.Hometown |
How many gymnasts are from each hometown? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many gymnasts are from each hometown?` to a syntactically-correct PostgreSQL query.
| SELECT T2.Hometown , COUNT(*) FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID GROUP BY T2.Hometown |
What is the most common hometown of gymnasts? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the most common hometown of gymnasts?` to a syntactically-correct PostgreSQL query.
| SELECT T2.Hometown FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID GROUP BY T2.Hometown ORDER BY COUNT(*) DESC LIMIT 1 |
Return the hometown that is most common among gymnasts. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Return the hometown that is most common among gymnasts.` to a syntactically-correct PostgreSQL query.
| SELECT T2.Hometown FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID GROUP BY T2.Hometown ORDER BY COUNT(*) DESC LIMIT 1 |
What are the hometowns that are shared by at least two gymnasts? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the hometowns that are shared by at least two gymnasts?` to a syntactically-correct PostgreSQL query.
| SELECT T2.Hometown FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID GROUP BY T2.Hometown HAVING COUNT(*) >= 2 |
Give the hometowns from which two or more gymnasts are from. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Give the hometowns from which two or more gymnasts are from.` to a syntactically-correct PostgreSQL query.
| SELECT T2.Hometown FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID GROUP BY T2.Hometown HAVING COUNT(*) >= 2 |
List the names of gymnasts in ascending order by their heights. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List the names of gymnasts in ascending order by their heights.` to a syntactically-correct PostgreSQL query.
| SELECT T2.Name FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID ORDER BY T2.Height ASC |
What are the names of gymnasts, ordered by their heights ascending? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the names of gymnasts, ordered by their heights ascending?` to a syntactically-correct PostgreSQL query.
| SELECT T2.Name FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID ORDER BY T2.Height ASC |
List the distinct hometowns that are not associated with any gymnast. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List the distinct hometowns that are not associated with any gymnast.` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT Hometown FROM people EXCEPT SELECT DISTINCT T2.Hometown FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID |
From which hometowns did no gymnasts come from? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `From which hometowns did no gymnasts come from?` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT Hometown FROM people EXCEPT SELECT DISTINCT T2.Hometown FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID |
Show the hometowns shared by people older than 23 and younger than 20. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the hometowns shared by people older than 23 and younger than 20.` to a syntactically-correct PostgreSQL query.
| SELECT Hometown FROM people WHERE Age > 23 INTERSECT SELECT Hometown FROM people WHERE Age < 20 |
From which hometowns did both people older than 23 and younger than 20 come from? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `From which hometowns did both people older than 23 and younger than 20 come from?` to a syntactically-correct PostgreSQL query.
| SELECT Hometown FROM people WHERE Age > 23 INTERSECT SELECT Hometown FROM people WHERE Age < 20 |
How many distinct hometowns did these people have? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many distinct hometowns did these people have?` to a syntactically-correct PostgreSQL query.
| SELECT count(DISTINCT Hometown) FROM people |
Count the number of different hometowns of these people. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Count the number of different hometowns of these people.` to a syntactically-correct PostgreSQL query.
| SELECT count(DISTINCT Hometown) FROM people |
Show the ages of gymnasts in descending order of total points. |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Show the ages of gymnasts in descending order of total points.` to a syntactically-correct PostgreSQL query.
| SELECT T2.Age FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID ORDER BY T1.Total_Points DESC |
What are the ages of the gymnasts, ordered descending by their total points? |
-- Language PostgreSQL
-- Tables:
-- Table: gymnast
columns : [['gymnast id', 'number'], ['floor exercise points', 'number'], ['pommel horse points', 'number'], ['rings points', 'number'], ['vault points', 'number'], ['parallel bars points', 'number'], ['horizontal bar points', 'number'], ['total points', 'number']]
-- Table: people
columns : [['people id', 'number'], ['name', 'text'], ['age', 'number'], ['height', 'number'], ['hometown', 'text']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the ages of the gymnasts, ordered descending by their total points?` to a syntactically-correct PostgreSQL query.
| SELECT T2.Age FROM gymnast AS T1 JOIN people AS T2 ON T1.Gymnast_ID = T2.People_ID ORDER BY T1.Total_Points DESC |
Find the total savings balance of all accounts except the account with name ‘Brown’. |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the total savings balance of all accounts except the account with name ‘Brown’.` to a syntactically-correct PostgreSQL query.
| SELECT sum(T2.balance) FROM accounts AS T1 JOIN savings AS T2 ON T1.custid = T2.custid WHERE T1.name != 'Brown' |
What is the total balance of savings accounts not belonging to someone with the name Brown? |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the total balance of savings accounts not belonging to someone with the name Brown?` to a syntactically-correct PostgreSQL query.
| SELECT sum(T2.balance) FROM accounts AS T1 JOIN savings AS T2 ON T1.custid = T2.custid WHERE T1.name != 'Brown' |
How many accounts are there in total? |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many accounts are there in total?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM accounts |
Count the number of accounts. |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Count the number of accounts.` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM accounts |
What is the total checking balance in all accounts? |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the total checking balance in all accounts?` to a syntactically-correct PostgreSQL query.
| SELECT sum(balance) FROM checking |
Find the total balance across checking accounts. |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the total balance across checking accounts.` to a syntactically-correct PostgreSQL query.
| SELECT sum(balance) FROM checking |
Find the average checking balance. |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the average checking balance.` to a syntactically-correct PostgreSQL query.
| SELECT avg(balance) FROM checking |
What is the average balance in checking accounts? |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the average balance in checking accounts?` to a syntactically-correct PostgreSQL query.
| SELECT avg(balance) FROM checking |
How many accounts have a savings balance above the average savings balance? |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `How many accounts have a savings balance above the average savings balance?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM savings WHERE balance > (SELECT avg(balance) FROM savings) |
Find the number of accounts with a savings balance that is higher than the average savings balance. |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the number of accounts with a savings balance that is higher than the average savings balance.` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM savings WHERE balance > (SELECT avg(balance) FROM savings) |
Find the name and id of accounts whose checking balance is below the maximum checking balance. |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the name and id of accounts whose checking balance is below the maximum checking balance.` to a syntactically-correct PostgreSQL query.
| SELECT T1.custid , T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid WHERE T2.balance < (SELECT max(balance) FROM checking) |
What are the customer id and name corresponding to accounts with a checking balance less than the largest checking balance? |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the customer id and name corresponding to accounts with a checking balance less than the largest checking balance?` to a syntactically-correct PostgreSQL query.
| SELECT T1.custid , T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid WHERE T2.balance < (SELECT max(balance) FROM checking) |
What is the checking balance of the account whose owner’s name contains the substring ‘ee’? |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the checking balance of the account whose owner’s name contains the substring ‘ee’?` to a syntactically-correct PostgreSQL query.
| SELECT T2.balance FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid WHERE T1.name LIKE '%ee%' |
Find the balance of the checking account belonging to an owner whose name contains 'ee'. |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the balance of the checking account belonging to an owner whose name contains 'ee'.` to a syntactically-correct PostgreSQL query.
| SELECT T2.balance FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid WHERE T1.name LIKE '%ee%' |
Find the checking balance and saving balance in the Brown’s account. |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the checking balance and saving balance in the Brown’s account.` to a syntactically-correct PostgreSQL query.
| SELECT T2.balance , T3.balance FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid JOIN savings AS T3 ON T1.custid = T3.custid WHERE T1.name = 'Brown' |
What are the checking and savings balances in accounts belonging to Brown? |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the checking and savings balances in accounts belonging to Brown?` to a syntactically-correct PostgreSQL query.
| SELECT T2.balance , T3.balance FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid JOIN savings AS T3 ON T1.custid = T3.custid WHERE T1.name = 'Brown' |
Find the names of accounts whose checking balance is above the average checking balance, but savings balance is below the average savings balance. |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the names of accounts whose checking balance is above the average checking balance, but savings balance is below the average savings balance.` to a syntactically-correct PostgreSQL query.
| SELECT T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid WHERE T2.balance > (SELECT avg(balance) FROM checking) INTERSECT SELECT T1.name FROM accounts AS T1 JOIN savings AS T2 ON T1.custid = T2.custid WHERE T2.balance < (SELECT avg(balance) FROM savings) |
What are the names of accounts with checking balances greater than the average checking balance and savings balances below the average savings balance? |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the names of accounts with checking balances greater than the average checking balance and savings balances below the average savings balance?` to a syntactically-correct PostgreSQL query.
| SELECT T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid WHERE T2.balance > (SELECT avg(balance) FROM checking) INTERSECT SELECT T1.name FROM accounts AS T1 JOIN savings AS T2 ON T1.custid = T2.custid WHERE T2.balance < (SELECT avg(balance) FROM savings) |
Find the checking balance of the accounts whose savings balance is higher than the average savings balance. |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the checking balance of the accounts whose savings balance is higher than the average savings balance.` to a syntactically-correct PostgreSQL query.
| SELECT T2.balance FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid WHERE T1.name IN (SELECT T1.name FROM accounts AS T1 JOIN savings AS T2 ON T1.custid = T2.custid WHERE T2.balance > (SELECT avg(balance) FROM savings)) |
What are the balances of checking accounts belonging to people with savings balances greater than the average savings balance? |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the balances of checking accounts belonging to people with savings balances greater than the average savings balance?` to a syntactically-correct PostgreSQL query.
| SELECT T2.balance FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid WHERE T1.name IN (SELECT T1.name FROM accounts AS T1 JOIN savings AS T2 ON T1.custid = T2.custid WHERE T2.balance > (SELECT avg(balance) FROM savings)) |
List all customers’ names in the alphabetical order. |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `List all customers’ names in the alphabetical order.` to a syntactically-correct PostgreSQL query.
| SELECT name FROM accounts ORDER BY name |
What are the names of all the customers in alphabetical order? |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What are the names of all the customers in alphabetical order?` to a syntactically-correct PostgreSQL query.
| SELECT name FROM accounts ORDER BY name |
Find the name of account that has the lowest total checking and saving balance. |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `Find the name of account that has the lowest total checking and saving balance.` to a syntactically-correct PostgreSQL query.
| SELECT T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid JOIN savings AS T3 ON T1.custid = T3.custid ORDER BY T2.balance + T3.balance LIMIT 1 |
What is the name corresponding to the accoung with the lowest sum of checking and savings balances? |
-- Language PostgreSQL
-- Tables:
-- Table: accounts
columns : [['customer id', 'number'], ['name', 'text']]
-- Table: savings
columns : [['customer id', 'number'], ['balance', 'number']]
-- Table: checking
columns : [['customer id', 'number'], ['balance', 'number']]
You are a SQL code translator. You have been given the Table data above. Your role is to translate natural language to PostgreSQL.
You should not select columns that are not part of the tables provided to you. Think step by step.
Your only output should be SQL code. Do not include any other text. Only SQL code.
Translate `What is the name corresponding to the accoung with the lowest sum of checking and savings balances?` to a syntactically-correct PostgreSQL query.
| SELECT T1.name FROM accounts AS T1 JOIN checking AS T2 ON T1.custid = T2.custid JOIN savings AS T3 ON T1.custid = T3.custid ORDER BY T2.balance + T3.balance LIMIT 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.