brief_instruction stringlengths 16 224 | instruction stringlengths 687 8.77k | output stringlengths 18 577 |
|---|---|---|
What is the name of the department with the student that has the lowest GPA? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 department with the student that has the lowest GPA?` to a syntactically-correct PostgreSQL query.
| SELECT T2.dept_name FROM student AS T1 JOIN department AS T2 ON T1.dept_code = T2.dept_code ORDER BY stu_gpa LIMIT 1 |
Find the first name and gpa of the students whose gpa is lower than the average gpa of all students. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first name and gpa of the students whose gpa is lower than the average gpa of all students.` to a syntactically-correct PostgreSQL query.
| SELECT stu_fname , stu_gpa FROM student WHERE stu_gpa < (SELECT avg(stu_gpa) FROM student) |
What is the first name and GPA of every student that has a GPA lower than average? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first name and GPA of every student that has a GPA lower than average?` to a syntactically-correct PostgreSQL query.
| SELECT stu_fname , stu_gpa FROM student WHERE stu_gpa < (SELECT avg(stu_gpa) FROM student) |
Find the name and address of the department that has the highest number of students. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 address of the department that has the highest number of students.` to a syntactically-correct PostgreSQL query.
| SELECT T2.dept_name , T2.dept_address FROM student AS T1 JOIN department AS T2 ON T1.dept_code = T2.dept_code GROUP BY T1.dept_code ORDER BY count(*) DESC LIMIT 1 |
What is the name and address of the department with the most students? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 and address of the department with the most students?` to a syntactically-correct PostgreSQL query.
| SELECT T2.dept_name , T2.dept_address FROM student AS T1 JOIN department AS T2 ON T1.dept_code = T2.dept_code GROUP BY T1.dept_code ORDER BY count(*) DESC LIMIT 1 |
Find the name, address, number of students in the departments that have the top 3 highest number of students. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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, address, number of students in the departments that have the top 3 highest number of students.` to a syntactically-correct PostgreSQL query.
| SELECT T2.dept_name , T2.dept_address , count(*) FROM student AS T1 JOIN department AS T2 ON T1.dept_code = T2.dept_code GROUP BY T1.dept_code ORDER BY count(*) DESC LIMIT 3 |
What is the name, address, and number of students in the departments that have the 3 most students? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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, address, and number of students in the departments that have the 3 most students?` to a syntactically-correct PostgreSQL query.
| SELECT T2.dept_name , T2.dept_address , count(*) FROM student AS T1 JOIN department AS T2 ON T1.dept_code = T2.dept_code GROUP BY T1.dept_code ORDER BY count(*) DESC LIMIT 3 |
Find the first name and office of the professor who is in the history department and has a Ph.D. degree. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first name and office of the professor who is in the history department and has a Ph.D. degree.` to a syntactically-correct PostgreSQL query.
| SELECT T1.emp_fname , T2.prof_office FROM employee AS T1 JOIN professor AS T2 ON T1.emp_num = T2.emp_num JOIN department AS T3 ON T3.dept_code = T2.dept_code WHERE T3.dept_name = 'History' AND T2.prof_high_degree = 'Ph.D.' |
What are the first names and office of the professors who are in the history department and have a Ph.D? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names and office of the professors who are in the history department and have a Ph.D?` to a syntactically-correct PostgreSQL query.
| SELECT T1.emp_fname , T2.prof_office FROM employee AS T1 JOIN professor AS T2 ON T1.emp_num = T2.emp_num JOIN department AS T3 ON T3.dept_code = T2.dept_code WHERE T3.dept_name = 'History' AND T2.prof_high_degree = 'Ph.D.' |
Find the first names of all instructors who have taught some course and the course code. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names of all instructors who have taught some course and the course code.` to a syntactically-correct PostgreSQL query.
| SELECT T2.emp_fname , T1.crs_code FROM CLASS AS T1 JOIN employee AS T2 ON T1.prof_num = T2.emp_num |
What are the first names of all teachers who have taught a course and the corresponding course codes? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names of all teachers who have taught a course and the corresponding course codes?` to a syntactically-correct PostgreSQL query.
| SELECT T2.emp_fname , T1.crs_code FROM CLASS AS T1 JOIN employee AS T2 ON T1.prof_num = T2.emp_num |
Find the first names of all instructors who have taught some course and the course description. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names of all instructors who have taught some course and the course description.` to a syntactically-correct PostgreSQL query.
| SELECT T2.emp_fname , T3.crs_description FROM CLASS AS T1 JOIN employee AS T2 ON T1.prof_num = T2.emp_num JOIN course AS T3 ON T1.crs_code = T3.crs_code |
What are the first names of all teachers who have taught a course and the corresponding descriptions? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names of all teachers who have taught a course and the corresponding descriptions?` to a syntactically-correct PostgreSQL query.
| SELECT T2.emp_fname , T3.crs_description FROM CLASS AS T1 JOIN employee AS T2 ON T1.prof_num = T2.emp_num JOIN course AS T3 ON T1.crs_code = T3.crs_code |
Find the first names and offices of all instructors who have taught some course and also find the course description. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names and offices of all instructors who have taught some course and also find the course description.` to a syntactically-correct PostgreSQL query.
| SELECT T2.emp_fname , T4.prof_office , T3.crs_description FROM CLASS AS T1 JOIN employee AS T2 ON T1.prof_num = T2.emp_num JOIN course AS T3 ON T1.crs_code = T3.crs_code JOIN professor AS T4 ON T2.emp_num = T4.emp_num |
What are the first names, office locations of all lecturers who have taught some course? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names, office locations of all lecturers who have taught some course?` to a syntactically-correct PostgreSQL query.
| SELECT T2.emp_fname , T4.prof_office , T3.crs_description FROM CLASS AS T1 JOIN employee AS T2 ON T1.prof_num = T2.emp_num JOIN course AS T3 ON T1.crs_code = T3.crs_code JOIN professor AS T4 ON T2.emp_num = T4.emp_num |
Find the first names and offices of all instructors who have taught some course and the course description and the department name. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names and offices of all instructors who have taught some course and the course description and the department name.` to a syntactically-correct PostgreSQL query.
| SELECT T2.emp_fname , T4.prof_office , T3.crs_description , T5.dept_name FROM CLASS AS T1 JOIN employee AS T2 ON T1.prof_num = T2.emp_num JOIN course AS T3 ON T1.crs_code = T3.crs_code JOIN professor AS T4 ON T2.emp_num = T4.emp_num JOIN department AS T5 ON T4.dept_code = T5.dept_code |
What are the first names, office locations, and departments of all instructors, and also what are the descriptions of the courses they teach? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names, office locations, and departments of all instructors, and also what are the descriptions of the courses they teach?` to a syntactically-correct PostgreSQL query.
| SELECT T2.emp_fname , T4.prof_office , T3.crs_description , T5.dept_name FROM CLASS AS T1 JOIN employee AS T2 ON T1.prof_num = T2.emp_num JOIN course AS T3 ON T1.crs_code = T3.crs_code JOIN professor AS T4 ON T2.emp_num = T4.emp_num JOIN department AS T5 ON T4.dept_code = T5.dept_code |
Find names of all students who took some course and the course description. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 names of all students who took some course and the course description.` to a syntactically-correct PostgreSQL query.
| SELECT T1.stu_fname , T1.stu_lname , T4.crs_description FROM student AS T1 JOIN enroll AS T2 ON T1.stu_num = T2.stu_num JOIN CLASS AS T3 ON T2.class_code = T3.class_code JOIN course AS T4 ON T3.crs_code = T4.crs_code |
What are the names of all students who took a class and the corresponding course descriptions? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 students who took a class and the corresponding course descriptions?` to a syntactically-correct PostgreSQL query.
| SELECT T1.stu_fname , T1.stu_lname , T4.crs_description FROM student AS T1 JOIN enroll AS T2 ON T1.stu_num = T2.stu_num JOIN CLASS AS T3 ON T2.class_code = T3.class_code JOIN course AS T4 ON T3.crs_code = T4.crs_code |
Find names of all students who took some course and got A or C. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 names of all students who took some course and got A or C.` to a syntactically-correct PostgreSQL query.
| SELECT T1.stu_fname , T1.stu_lname FROM student AS T1 JOIN enroll AS T2 ON T1.stu_num = T2.stu_num WHERE T2.enroll_grade = 'C' OR T2.enroll_grade = 'A' |
What are the names of all students taking a course who received an A or C? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 students taking a course who received an A or C?` to a syntactically-correct PostgreSQL query.
| SELECT T1.stu_fname , T1.stu_lname FROM student AS T1 JOIN enroll AS T2 ON T1.stu_num = T2.stu_num WHERE T2.enroll_grade = 'C' OR T2.enroll_grade = 'A' |
Find the first names of all professors in the Accounting department who is teaching some course and the class room. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names of all professors in the Accounting department who is teaching some course and the class room.` to a syntactically-correct PostgreSQL query.
| SELECT T2.emp_fname , T1.class_room FROM CLASS AS T1 JOIN employee AS T2 ON T1.prof_num = T2.emp_num JOIN professor AS T3 ON T2.emp_num = T3.emp_num JOIN department AS T4 ON T4.dept_code = T3.dept_code WHERE T4.dept_name = 'Accounting' |
What are the first names of all Accounting professors who teach and what are the classrooms of the courses they teach? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names of all Accounting professors who teach and what are the classrooms of the courses they teach?` to a syntactically-correct PostgreSQL query.
| SELECT T2.emp_fname , T1.class_room FROM CLASS AS T1 JOIN employee AS T2 ON T1.prof_num = T2.emp_num JOIN professor AS T3 ON T2.emp_num = T3.emp_num JOIN department AS T4 ON T4.dept_code = T3.dept_code WHERE T4.dept_name = 'Accounting' |
Find the first names and degree of all professors who are teaching some class in Computer Info. Systems department. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names and degree of all professors who are teaching some class in Computer Info. Systems department.` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT T2.emp_fname , T3.prof_high_degree FROM CLASS AS T1 JOIN employee AS T2 ON T1.prof_num = T2.emp_num JOIN professor AS T3 ON T2.emp_num = T3.emp_num JOIN department AS T4 ON T4.dept_code = T3.dept_code WHERE T4.dept_name = 'Computer Info. Systems' |
What are the different first names and highest degree attained for professors teaching in the Computer Information Systems department? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 different first names and highest degree attained for professors teaching in the Computer Information Systems department?` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT T2.emp_fname , T3.prof_high_degree FROM CLASS AS T1 JOIN employee AS T2 ON T1.prof_num = T2.emp_num JOIN professor AS T3 ON T2.emp_num = T3.emp_num JOIN department AS T4 ON T4.dept_code = T3.dept_code WHERE T4.dept_name = 'Computer Info. Systems' |
What is the last name of the student who got a grade A in the class with code 10018. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 last name of the student who got a grade A in the class with code 10018.` to a syntactically-correct PostgreSQL query.
| SELECT T1.stu_lname FROM student AS T1 JOIN enroll AS T2 ON T1.stu_num = T2.stu_num WHERE T2.enroll_grade = 'A' AND T2.class_code = 10018 |
What is the last name of the student who received an A in the class with the code 10018? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 last name of the student who received an A in the class with the code 10018?` to a syntactically-correct PostgreSQL query.
| SELECT T1.stu_lname FROM student AS T1 JOIN enroll AS T2 ON T1.stu_num = T2.stu_num WHERE T2.enroll_grade = 'A' AND T2.class_code = 10018 |
Find the first name and office of history professor who did not get a Ph.D. degree. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first name and office of history professor who did not get a Ph.D. degree.` to a syntactically-correct PostgreSQL query.
| SELECT T2.emp_fname , T1.prof_office FROM professor AS T1 JOIN employee AS T2 ON T1.emp_num = T2.emp_num JOIN department AS T3 ON T1.dept_code = T3.dept_code WHERE T3.dept_name = 'History' AND T1.prof_high_degree != 'Ph.D.' |
What are the first names and offices of history professors who don't have Ph.D.s? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names and offices of history professors who don't have Ph.D.s?` to a syntactically-correct PostgreSQL query.
| SELECT T2.emp_fname , T1.prof_office FROM professor AS T1 JOIN employee AS T2 ON T1.emp_num = T2.emp_num JOIN department AS T3 ON T1.dept_code = T3.dept_code WHERE T3.dept_name = 'History' AND T1.prof_high_degree != 'Ph.D.' |
Find the first names of professors who are teaching more than one class. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names of professors who are teaching more than one class.` to a syntactically-correct PostgreSQL query.
| SELECT T2.emp_fname FROM CLASS AS T1 JOIN employee AS T2 ON T1.prof_num = T2.emp_num GROUP BY T1.prof_num HAVING count(*) > 1 |
What are the first names of all professors who teach more than one class? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names of all professors who teach more than one class?` to a syntactically-correct PostgreSQL query.
| SELECT T2.emp_fname FROM CLASS AS T1 JOIN employee AS T2 ON T1.prof_num = T2.emp_num GROUP BY T1.prof_num HAVING count(*) > 1 |
Find the first names of students who took exactly one class. |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names of students who took exactly one class.` to a syntactically-correct PostgreSQL query.
| SELECT T1.stu_fname FROM student AS T1 JOIN enroll AS T2 ON T1.stu_num = T2.stu_num GROUP BY T2.stu_num HAVING count(*) = 1 |
What are the first names of student who only took one course? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first names of student who only took one course?` to a syntactically-correct PostgreSQL query.
| SELECT T1.stu_fname FROM student AS T1 JOIN enroll AS T2 ON T1.stu_num = T2.stu_num GROUP BY T2.stu_num HAVING count(*) = 1 |
Find the name of department that offers the class whose description has the word "Statistics". |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 department that offers the class whose description has the word "Statistics".` to a syntactically-correct PostgreSQL query.
| SELECT T2.dept_name FROM course AS T1 JOIN department AS T2 ON T1.dept_code = T2.dept_code WHERE T1.crs_description LIKE '%Statistics%' |
What is the name of the department that offers a course that has a description including the word "Statistics"? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 department that offers a course that has a description including the word "Statistics"?` to a syntactically-correct PostgreSQL query.
| SELECT T2.dept_name FROM course AS T1 JOIN department AS T2 ON T1.dept_code = T2.dept_code WHERE T1.crs_description LIKE '%Statistics%' |
What is the first name of the student whose last name starting with the letter S and is taking ACCT-211 class? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first name of the student whose last name starting with the letter S and is taking ACCT-211 class?` to a syntactically-correct PostgreSQL query.
| SELECT T1.stu_fname FROM student AS T1 JOIN enroll AS T2 ON T1.stu_num = T2.stu_num JOIN CLASS AS T3 ON T2.class_code = T3.class_code WHERE T3.crs_code = 'ACCT-211' AND T1.stu_lname LIKE 'S%' |
What is the first name of the student whose last name starts with the letter S and is taking ACCT-211? |
-- Language PostgreSQL
-- Tables:
-- Table: class
columns : [['class code', 'text'], ['course code', 'text'], ['class section', 'text'], ['class time', 'text'], ['class room', 'text'], ['professor employee number', 'number']]
-- Table: course
columns : [['course code', 'text'], ['department code', 'text'], ['course description', 'text'], ['course credit', 'number']]
-- Table: department
columns : [['department code', 'text'], ['department name', 'text'], ['school code', 'text'], ['employee number', 'number'], ['department address', 'text'], ['department extension', 'text']]
-- Table: employee
columns : [['employee number', 'number'], ['employee last name', 'text'], ['employee first name', 'text'], ['employee initial', 'text'], ['employee job code', 'text'], ['employee hire date', 'time'], ['employee date of birth', 'time']]
-- Table: enroll
columns : [['class code', 'text'], ['student number', 'number'], ['enroll grade', 'text']]
-- Table: professor
columns : [['employee number', 'number'], ['department code', 'text'], ['professor office', 'text'], ['professor extension', 'text'], ['professor high degree', 'text']]
-- Table: student
columns : [['student num', 'number'], ['student last name', 'text'], ['student first name', 'text'], ['student init', 'text'], ['student date of birth', 'time'], ['student class hours took', 'number'], ['student class', 'text'], ['student gpa', 'number'], ['student transfer', 'number'], ['department code', 'text'], ['student phone', 'text'], ['professor number', '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 first name of the student whose last name starts with the letter S and is taking ACCT-211?` to a syntactically-correct PostgreSQL query.
| SELECT T1.stu_fname FROM student AS T1 JOIN enroll AS T2 ON T1.stu_num = T2.stu_num JOIN CLASS AS T3 ON T2.class_code = T3.class_code WHERE T3.crs_code = 'ACCT-211' AND T1.stu_lname LIKE 'S%' |
How many clubs are there? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 clubs are there?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM club |
What is the total number of clubs? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 number of clubs?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM club |
List the distinct region of clubs in ascending alphabetical order. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 region of clubs in ascending alphabetical order.` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT Region FROM club ORDER BY Region ASC |
What are the different regions of clubs in ascending alphabetical order? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 different regions of clubs in ascending alphabetical order?` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT Region FROM club ORDER BY Region ASC |
What is the average number of gold medals for clubs? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 number of gold medals for clubs?` to a syntactically-correct PostgreSQL query.
| SELECT avg(Gold) FROM club_rank |
What is the average number of gold medals for a club? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 number of gold medals for a club?` to a syntactically-correct PostgreSQL query.
| SELECT avg(Gold) FROM club_rank |
What are the types and countries of competitions? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 types and countries of competitions?` to a syntactically-correct PostgreSQL query.
| SELECT Competition_type , Country FROM competition |
What are the types of every competition and in which countries are they located? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 types of every competition and in which countries are they located?` to a syntactically-correct PostgreSQL query.
| SELECT Competition_type , Country FROM competition |
What are the distinct years in which the competitions type is not "Tournament"? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 years in which the competitions type is not "Tournament"?` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT YEAR FROM competition WHERE Competition_type != "Tournament" |
What are the different years for all competitions that are not of type equal to tournament? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 different years for all competitions that are not of type equal to tournament?` to a syntactically-correct PostgreSQL query.
| SELECT DISTINCT YEAR FROM competition WHERE Competition_type != "Tournament" |
What are the maximum and minimum number of silver medals for clubs. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 maximum and minimum number of silver medals for clubs.` to a syntactically-correct PostgreSQL query.
| SELECT max(Silver) , min(Silver) FROM club_rank |
What are the maximum and minimum number of silver medals for all the clubs? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 maximum and minimum number of silver medals for all the clubs?` to a syntactically-correct PostgreSQL query.
| SELECT max(Silver) , min(Silver) FROM club_rank |
How many clubs have total medals less than 10? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 clubs have total medals less than 10?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM club_rank WHERE Total < 10 |
What is the total number of clubs that have less than 10 medals in total? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 number of clubs that have less than 10 medals in total?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) FROM club_rank WHERE Total < 10 |
List all club names in ascending order of start year. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 all club names in ascending order of start year.` to a syntactically-correct PostgreSQL query.
| SELECT name FROM club ORDER BY Start_year ASC |
What are the names of all the clubs starting with the oldest? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 all the clubs starting with the oldest?` to a syntactically-correct PostgreSQL query.
| SELECT name FROM club ORDER BY Start_year ASC |
List all club names in descending alphabetical order. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 all club names in descending alphabetical order.` to a syntactically-correct PostgreSQL query.
| SELECT name FROM club ORDER BY name DESC |
What are the names of all the clubs ordered in descending alphabetical order? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 all the clubs ordered in descending alphabetical order?` to a syntactically-correct PostgreSQL query.
| SELECT name FROM club ORDER BY name DESC |
Please show the names and the players of clubs. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 `Please show the names and the players of clubs.` to a syntactically-correct PostgreSQL query.
| SELECT T1.name , T2.Player_id FROM club AS T1 JOIN player AS T2 ON T1.Club_ID = T2.Club_ID |
What are the names and players of all the clubs? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 and players of all the clubs?` to a syntactically-correct PostgreSQL query.
| SELECT T1.name , T2.Player_id FROM club AS T1 JOIN player AS T2 ON T1.Club_ID = T2.Club_ID |
Show the names of clubs that have players with position "Right Wing". |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 names of clubs that have players with position "Right Wing".` to a syntactically-correct PostgreSQL query.
| SELECT T1.name FROM club AS T1 JOIN player AS T2 ON T1.Club_ID = T2.Club_ID WHERE T2.Position = "Right Wing" |
What are the names of the clubs that have players in the position of "Right Wing"? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 clubs that have players in the position of "Right Wing"?` to a syntactically-correct PostgreSQL query.
| SELECT T1.name FROM club AS T1 JOIN player AS T2 ON T1.Club_ID = T2.Club_ID WHERE T2.Position = "Right Wing" |
What is the average points of players from club with name "AIB". |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 points of players from club with name "AIB".` to a syntactically-correct PostgreSQL query.
| SELECT avg(T2.Points) FROM club AS T1 JOIN player AS T2 ON T1.Club_ID = T2.Club_ID WHERE T1.name = "AIB" |
What is the average number of points for players from the "AIB" club? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 number of points for players from the "AIB" club?` to a syntactically-correct PostgreSQL query.
| SELECT avg(T2.Points) FROM club AS T1 JOIN player AS T2 ON T1.Club_ID = T2.Club_ID WHERE T1.name = "AIB" |
List the position of players and the average number of points of players of each position. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 position of players and the average number of points of players of each position.` to a syntactically-correct PostgreSQL query.
| SELECT POSITION , avg(Points) FROM player GROUP BY POSITION |
For each position, what is the average number of points for players in that position? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 `For each position, what is the average number of points for players in that position?` to a syntactically-correct PostgreSQL query.
| SELECT POSITION , avg(Points) FROM player GROUP BY POSITION |
List the position of players with average number of points scored by players of that position bigger than 20. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 position of players with average number of points scored by players of that position bigger than 20.` to a syntactically-correct PostgreSQL query.
| SELECT POSITION FROM player GROUP BY name HAVING avg(Points) >= 20 |
What are the positions of players whose average number of points scored by that position is larger than 20? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 positions of players whose average number of points scored by that position is larger than 20?` to a syntactically-correct PostgreSQL query.
| SELECT POSITION FROM player GROUP BY name HAVING avg(Points) >= 20 |
List the types of competition and the number of competitions of each type. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 types of competition and the number of competitions of each type.` to a syntactically-correct PostgreSQL query.
| SELECT Competition_type , COUNT(*) FROM competition GROUP BY Competition_type |
What are the types of competition and number of competitions for that type? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 types of competition and number of competitions for that type?` to a syntactically-correct PostgreSQL query.
| SELECT Competition_type , COUNT(*) FROM competition GROUP BY Competition_type |
List the most common type of competition. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 most common type of competition.` to a syntactically-correct PostgreSQL query.
| SELECT Competition_type FROM competition GROUP BY Competition_type ORDER BY COUNT(*) DESC LIMIT 1 |
What is the most common competition type? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 competition type?` to a syntactically-correct PostgreSQL query.
| SELECT Competition_type FROM competition GROUP BY Competition_type ORDER BY COUNT(*) DESC LIMIT 1 |
List the types of competition that have at most five competitions of that type. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 types of competition that have at most five competitions of that type.` to a syntactically-correct PostgreSQL query.
| SELECT Competition_type FROM competition GROUP BY Competition_type HAVING COUNT(*) <= 5 |
What are the types of competition that have most 5 competitions for that type? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 types of competition that have most 5 competitions for that type?` to a syntactically-correct PostgreSQL query.
| SELECT Competition_type FROM competition GROUP BY Competition_type HAVING COUNT(*) <= 5 |
List the names of clubs that do not have any players. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 clubs that do not have any players.` to a syntactically-correct PostgreSQL query.
| SELECT name FROM CLub WHERE Club_ID NOT IN (SELECT Club_ID FROM player) |
What are the names of all clubs that do not have any players? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 all clubs that do not have any players?` to a syntactically-correct PostgreSQL query.
| SELECT name FROM CLub WHERE Club_ID NOT IN (SELECT Club_ID FROM player) |
What are the positions with both players having more than 20 points and less than 10 points. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 positions with both players having more than 20 points and less than 10 points.` to a syntactically-correct PostgreSQL query.
| SELECT POSITION FROM player WHERE Points > 20 INTERSECT SELECT POSITION FROM player WHERE Points < 10 |
What are the positions of both players that have more than 20 20 points and less than 10 points? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 positions of both players that have more than 20 20 points and less than 10 points?` to a syntactically-correct PostgreSQL query.
| SELECT POSITION FROM player WHERE Points > 20 INTERSECT SELECT POSITION FROM player WHERE Points < 10 |
Show total points of all players. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 total points of all players.` to a syntactically-correct PostgreSQL query.
| SELECT sum(Points) FROM player |
What is the total number of points for all players? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 number of points for all players?` to a syntactically-correct PostgreSQL query.
| SELECT sum(Points) FROM player |
how many different positions are there? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 different positions are there?` to a syntactically-correct PostgreSQL query.
| SELECT count(DISTINCT POSITION) FROM player |
How many different position for players are listed? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 different position for players are listed?` to a syntactically-correct PostgreSQL query.
| SELECT count(DISTINCT POSITION) FROM player |
what are the name of players who get more than the average points. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 name of players who get more than the average points.` to a syntactically-correct PostgreSQL query.
| SELECT name FROM player WHERE points > (SELECT avg(points) FROM player) |
What are the names of all players that got more than the average number of points? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 all players that got more than the average number of points?` to a syntactically-correct PostgreSQL query.
| SELECT name FROM player WHERE points > (SELECT avg(points) FROM player) |
find the number of players whose points are lower than 30 in each position. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 `find the number of players whose points are lower than 30 in each position.` to a syntactically-correct PostgreSQL query.
| SELECT count(*) , POSITION FROM player WHERE points < 30 GROUP BY POSITION |
What is the number of players who have points less than 30 for each position? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 number of players who have points less than 30 for each position?` to a syntactically-correct PostgreSQL query.
| SELECT count(*) , POSITION FROM player WHERE points < 30 GROUP BY POSITION |
which country did participated in the most number of Tournament competitions? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 `which country did participated in the most number of Tournament competitions?` to a syntactically-correct PostgreSQL query.
| SELECT country FROM competition WHERE competition_type = 'Tournament' GROUP BY country ORDER BY count(*) DESC LIMIT 1 |
what is the name of the country that participated in the most tournament competitions? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 name of the country that participated in the most tournament competitions?` to a syntactically-correct PostgreSQL query.
| SELECT country FROM competition WHERE competition_type = 'Tournament' GROUP BY country ORDER BY count(*) DESC LIMIT 1 |
which countries did participated in both Friendly and Tournament type competitions. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 `which countries did participated in both Friendly and Tournament type competitions.` to a syntactically-correct PostgreSQL query.
| SELECT country FROM competition WHERE competition_type = 'Friendly' INTERSECT SELECT country FROM competition WHERE competition_type = 'Tournament' |
What are the countries that participated in both friendly and tournament type competitions? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 countries that participated in both friendly and tournament type competitions?` to a syntactically-correct PostgreSQL query.
| SELECT country FROM competition WHERE competition_type = 'Friendly' INTERSECT SELECT country FROM competition WHERE competition_type = 'Tournament' |
Find the countries that have never participated in any competition with Friendly type. |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 `Find the countries that have never participated in any competition with Friendly type.` to a syntactically-correct PostgreSQL query.
| SELECT country FROM competition EXCEPT SELECT country FROM competition WHERE competition_type = 'Friendly' |
What are the countries that have never participated in any friendly-type competitions? |
-- Language PostgreSQL
-- Tables:
-- Table: club
columns : [['club id', 'number'], ['name', 'text'], ['region', 'text'], ['start year', 'text']]
-- Table: club rank
columns : [['rank', 'number'], ['club id', 'number'], ['gold', 'number'], ['silver', 'number'], ['bronze', 'number'], ['total', 'number']]
-- Table: player
columns : [['player id', 'number'], ['name', 'text'], ['position', 'text'], ['club id', 'number'], ['apps', 'number'], ['tries', 'number'], ['goals', 'text'], ['points', 'number']]
-- Table: competition
columns : [['competition id', 'number'], ['year', 'number'], ['competition type', 'text'], ['country', 'text']]
-- Table: competition result
columns : [['competition id', 'number'], ['club id 1', 'number'], ['club id 2', 'number'], ['score', '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 countries that have never participated in any friendly-type competitions?` to a syntactically-correct PostgreSQL query.
| SELECT country FROM competition EXCEPT SELECT country FROM competition WHERE competition_type = 'Friendly' |
How many furniture components are there in total? |
-- Language PostgreSQL
-- Tables:
-- Table: manufacturer
columns : [['manufacturer id', 'number'], ['open year', 'number'], ['name', 'text'], ['num of factories', 'number'], ['num of shops', 'number']]
-- Table: furniture
columns : [['furniture id', 'number'], ['name', 'text'], ['num of component', 'number'], ['market rate', 'number']]
-- Table: furniture manufacte
columns : [['manufacturer id', 'number'], ['furniture id', 'number'], ['price in dollar', '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 furniture components are there in total?` to a syntactically-correct PostgreSQL query.
| SELECT sum(num_of_component) FROM furniture |
Return the name and id of the furniture with the highest market rate. |
-- Language PostgreSQL
-- Tables:
-- Table: manufacturer
columns : [['manufacturer id', 'number'], ['open year', 'number'], ['name', 'text'], ['num of factories', 'number'], ['num of shops', 'number']]
-- Table: furniture
columns : [['furniture id', 'number'], ['name', 'text'], ['num of component', 'number'], ['market rate', 'number']]
-- Table: furniture manufacte
columns : [['manufacturer id', 'number'], ['furniture id', 'number'], ['price in dollar', '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 `Return the name and id of the furniture with the highest market rate.` to a syntactically-correct PostgreSQL query.
| SELECT name , furniture_id FROM furniture ORDER BY market_rate DESC LIMIT 1 |
find the total market rate of the furnitures that have the top 2 market shares. |
-- Language PostgreSQL
-- Tables:
-- Table: manufacturer
columns : [['manufacturer id', 'number'], ['open year', 'number'], ['name', 'text'], ['num of factories', 'number'], ['num of shops', 'number']]
-- Table: furniture
columns : [['furniture id', 'number'], ['name', 'text'], ['num of component', 'number'], ['market rate', 'number']]
-- Table: furniture manufacte
columns : [['manufacturer id', 'number'], ['furniture id', 'number'], ['price in dollar', '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 market rate of the furnitures that have the top 2 market shares.` to a syntactically-correct PostgreSQL query.
| SELECT sum(market_rate) FROM furniture ORDER BY market_rate DESC LIMIT 2 |
Find the component amounts and names of all furnitures that have more than 10 components. |
-- Language PostgreSQL
-- Tables:
-- Table: manufacturer
columns : [['manufacturer id', 'number'], ['open year', 'number'], ['name', 'text'], ['num of factories', 'number'], ['num of shops', 'number']]
-- Table: furniture
columns : [['furniture id', 'number'], ['name', 'text'], ['num of component', 'number'], ['market rate', 'number']]
-- Table: furniture manufacte
columns : [['manufacturer id', 'number'], ['furniture id', 'number'], ['price in dollar', '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 component amounts and names of all furnitures that have more than 10 components.` to a syntactically-correct PostgreSQL query.
| SELECT Num_of_Component , name FROM furniture WHERE Num_of_Component > 10 |
Find the name and component amount of the least popular furniture. |
-- Language PostgreSQL
-- Tables:
-- Table: manufacturer
columns : [['manufacturer id', 'number'], ['open year', 'number'], ['name', 'text'], ['num of factories', 'number'], ['num of shops', 'number']]
-- Table: furniture
columns : [['furniture id', 'number'], ['name', 'text'], ['num of component', 'number'], ['market rate', 'number']]
-- Table: furniture manufacte
columns : [['manufacturer id', 'number'], ['furniture id', 'number'], ['price in dollar', '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 component amount of the least popular furniture.` to a syntactically-correct PostgreSQL query.
| SELECT name , Num_of_Component FROM furniture ORDER BY market_rate LIMIT 1 |
Find the names of furnitures whose prices are lower than the highest price. |
-- Language PostgreSQL
-- Tables:
-- Table: manufacturer
columns : [['manufacturer id', 'number'], ['open year', 'number'], ['name', 'text'], ['num of factories', 'number'], ['num of shops', 'number']]
-- Table: furniture
columns : [['furniture id', 'number'], ['name', 'text'], ['num of component', 'number'], ['market rate', 'number']]
-- Table: furniture manufacte
columns : [['manufacturer id', 'number'], ['furniture id', 'number'], ['price in dollar', '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 furnitures whose prices are lower than the highest price.` to a syntactically-correct PostgreSQL query.
| SELECT t1.name FROM furniture AS t1 JOIN furniture_manufacte AS t2 ON t1.Furniture_ID = t2.Furniture_ID WHERE t2.Price_in_Dollar < (SELECT max(Price_in_Dollar) FROM furniture_manufacte) |
Which manufacturer has the most number of shops? List its name and year of opening. |
-- Language PostgreSQL
-- Tables:
-- Table: manufacturer
columns : [['manufacturer id', 'number'], ['open year', 'number'], ['name', 'text'], ['num of factories', 'number'], ['num of shops', 'number']]
-- Table: furniture
columns : [['furniture id', 'number'], ['name', 'text'], ['num of component', 'number'], ['market rate', 'number']]
-- Table: furniture manufacte
columns : [['manufacturer id', 'number'], ['furniture id', 'number'], ['price in dollar', '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 `Which manufacturer has the most number of shops? List its name and year of opening.` to a syntactically-correct PostgreSQL query.
| SELECT open_year , name FROM manufacturer ORDER BY num_of_shops DESC LIMIT 1 |
Find the average number of factories for the manufacturers that have more than 20 shops. |
-- Language PostgreSQL
-- Tables:
-- Table: manufacturer
columns : [['manufacturer id', 'number'], ['open year', 'number'], ['name', 'text'], ['num of factories', 'number'], ['num of shops', 'number']]
-- Table: furniture
columns : [['furniture id', 'number'], ['name', 'text'], ['num of component', 'number'], ['market rate', 'number']]
-- Table: furniture manufacte
columns : [['manufacturer id', 'number'], ['furniture id', 'number'], ['price in dollar', '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 number of factories for the manufacturers that have more than 20 shops.` to a syntactically-correct PostgreSQL query.
| SELECT avg(Num_of_Factories) FROM manufacturer WHERE num_of_shops > 20 |
List all manufacturer names and ids ordered by their opening year. |
-- Language PostgreSQL
-- Tables:
-- Table: manufacturer
columns : [['manufacturer id', 'number'], ['open year', 'number'], ['name', 'text'], ['num of factories', 'number'], ['num of shops', 'number']]
-- Table: furniture
columns : [['furniture id', 'number'], ['name', 'text'], ['num of component', 'number'], ['market rate', 'number']]
-- Table: furniture manufacte
columns : [['manufacturer id', 'number'], ['furniture id', 'number'], ['price in dollar', '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 manufacturer names and ids ordered by their opening year.` to a syntactically-correct PostgreSQL query.
| SELECT name , manufacturer_id FROM manufacturer ORDER BY open_year |
Give me the name and year of opening of the manufacturers that have either less than 10 factories or more than 10 shops. |
-- Language PostgreSQL
-- Tables:
-- Table: manufacturer
columns : [['manufacturer id', 'number'], ['open year', 'number'], ['name', 'text'], ['num of factories', 'number'], ['num of shops', 'number']]
-- Table: furniture
columns : [['furniture id', 'number'], ['name', 'text'], ['num of component', 'number'], ['market rate', 'number']]
-- Table: furniture manufacte
columns : [['manufacturer id', 'number'], ['furniture id', 'number'], ['price in dollar', '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 `Give me the name and year of opening of the manufacturers that have either less than 10 factories or more than 10 shops.` to a syntactically-correct PostgreSQL query.
| SELECT name , open_year FROM manufacturer WHERE num_of_shops > 10 OR Num_of_Factories < 10 |
what is the average number of factories and maximum number of shops for manufacturers that opened before 1990. |
-- Language PostgreSQL
-- Tables:
-- Table: manufacturer
columns : [['manufacturer id', 'number'], ['open year', 'number'], ['name', 'text'], ['num of factories', 'number'], ['num of shops', 'number']]
-- Table: furniture
columns : [['furniture id', 'number'], ['name', 'text'], ['num of component', 'number'], ['market rate', 'number']]
-- Table: furniture manufacte
columns : [['manufacturer id', 'number'], ['furniture id', 'number'], ['price in dollar', '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 number of factories and maximum number of shops for manufacturers that opened before 1990.` to a syntactically-correct PostgreSQL query.
| SELECT max(num_of_shops) , avg(Num_of_Factories) FROM manufacturer WHERE open_year < 1990 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.