QIAN-ME/bird_schema_data huggingface dataset:
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    Calculate the percentage of high-level undergraduate course. high-level undergraduate course refers to courseLevel = 'Level_400'; percentage = divide(count(course.course_id) when courseLevel = 'Level_400', count(course.course_id)) * 100%

    【Evidence】
    high-level undergraduate course refers to courseLevel = 'Level_400'; percentage = divide(count(course.course_id) when courseLevel = 'Level_400', count(course.course_id)) * 100%

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT CAST(SUM(CASE  WHEN courseLevel = 'Level_400' THEN 1 ELSE 0 END) AS REAL) * 100 / COUNT(*) AS per FROM course
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    List down all the person IDs who taught course ID of 18. person IDs refers to taughtBy.p_id; course ID of 18  refers to taughtBy.course_id = 18

    【Evidence】
    person IDs refers to taughtBy.p_id; course ID of 18  refers to taughtBy.course_id = 18

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT p_id FROM taughtBy WHERE course_id = 18
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    Provide the position status and IDs of professor who advised student ID "303". position status refers to hasPosition; IDs of professor refers to p_id_dummy; student ID "303" refers to advisedBy.p_id = 303

    【Evidence】
    position status refers to hasPosition; IDs of professor refers to p_id_dummy; student ID "303" refers to advisedBy.p_id = 303

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T2.hasPosition, T1.p_id_dummy FROM advisedBy AS T1 INNER JOIN person AS T2 ON T1.p_id_dummy = T2.p_id WHERE T1.p_id = 303
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    List the person IDs and course levels of the affiliated professors in faculty. person IDs refers to person.p_id; affiliated professors in faculty refers to professor = 1 and hasPosition = 'Faculty_aff'

    【Evidence】
    person IDs refers to person.p_id; affiliated professors in faculty refers to professor = 1 and hasPosition = 'Faculty_aff'

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T1.p_id, T3.courseLevel FROM person AS T1 INNER JOIN taughtBy AS T2 ON T1.p_id = T2.p_id INNER JOIN course AS T3 ON T3.course_id = T2.course_id WHERE T1.hasPosition = 'Faculty_aff'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    Describe the year in program and in phase status for the student with most number in advisor. student refers to advisedBy.p_id; most number in advisor refers to max(count(p_id_dummy))

    【Evidence】
    student refers to advisedBy.p_id; most number in advisor refers to max(count(p_id_dummy))

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T2.yearsInProgram, T2.inPhase FROM advisedBy AS T1 INNER JOIN person AS T2 ON T1.p_id = T2.p_id GROUP BY T1.p_id ORDER BY COUNT(*) DESC LIMIT 1
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    List down the advised student IDs and IDs of employing professor in faculty. advised student IDs refers to person.p_id; IDs of employing professor in faculty refers to p_id_dummy and hasPosition = 'Faculty_eme'

    【Evidence】
    advised student IDs refers to person.p_id; IDs of employing professor in faculty refers to p_id_dummy and hasPosition = 'Faculty_eme'

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T1.p_id, T2.p_id FROM advisedBy AS T1 INNER JOIN person AS T2 ON T1.p_id_dummy = T2.p_id WHERE hasPosition = 'Faculty_eme'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    List the course IDs and levels of person IDs from 40 to 50. course IDs and levels refers to course.course_id and courseLevel; person IDs from 40 to 50 refers to taughtBy.p_id between 40 and 50

    【Evidence】
    course IDs and levels refers to course.course_id and courseLevel; person IDs from 40 to 50 refers to taughtBy.p_id between 40 and 50

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T1.course_id, T1.courseLevel FROM course AS T1 INNER JOIN taughtBy AS T2 ON T1.course_id = T2.course_id WHERE T2.p_id BETWEEN 40 AND 50
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    Describe the course level and list of person IDs who taught course ID of 147. person IDs refers to taughtBy.p_id; course ID of 147 refers to course.course_id = 147

    【Evidence】
    person IDs refers to taughtBy.p_id; course ID of 147 refers to course.course_id = 147

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T1.courseLevel, T1.course_id FROM course AS T1 INNER JOIN taughtBy AS T2 ON T1.course_id = T2.course_id WHERE T2.p_id = 141
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    Mention the person ID of faculty professor who taught course ID 104 and the course level. person ID refers to person.p_id; faculty professor refers to professor = 1 and hasPosition ! = 0

    【Evidence】
    person ID refers to person.p_id; faculty professor refers to professor = 1 and hasPosition ! = 0

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T1.p_id, T3.courseLevel FROM person AS T1 INNER JOIN taughtBy AS T2 ON T1.p_id = T2.p_id INNER JOIN course AS T3 ON T3.course_id = T2.course_id WHERE T3.course_id = 104 AND T1.hasPosition <> 0
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    Find the professor ID and position in faculty who taught high-level undergraduate course of less than 10 in ID. professor ID refers to person.p_id when professor = 1; position in faculty refers to hasPosition; high-level undergraduate course refers to courseLevel = 'Level_400'; less than 10 in ID refers to course.course_id < 10

    【Evidence】
    professor ID refers to person.p_id when professor = 1; position in faculty refers to hasPosition; high-level undergraduate course refers to courseLevel = 'Level_400'; less than 10 in ID refers to course.course_id < 10

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T1.p_id, T1.hasPosition FROM person AS T1 INNER JOIN taughtBy AS T2 ON T1.p_id = T2.p_id INNER JOIN course AS T3 ON T3.course_id = T2.course_id WHERE T3.courseLevel = 'Level_400' AND T2.course_id < 10
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    List the professor ID who taught the course ID from 121 to 130 of basic undergraduate courses. professor ID refers to taughtBy.p_id; course ID from 121 to 130 of basic undergraduate courses refers to courseLevel = 'Level_300' and course.course_id between 121 and 130

    【Evidence】
    professor ID refers to taughtBy.p_id; course ID from 121 to 130 of basic undergraduate courses refers to courseLevel = 'Level_300' and course.course_id between 121 and 130

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T2.p_id FROM course AS T1 INNER JOIN taughtBy AS T2 ON T1.course_id = T2.course_id WHERE T1.courseLevel = 'Level_300' AND T1.course_id > 121 AND T1.course_id < 130
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    List the advisor IDs for students with eighth year of program and position status in faculty of those professors. advisor IDs refers to p_id_dummy and person.p_id where professor = 1; eighth year of program refers to yearsInprogram = 'Year_8'; position status in faculty of those professors refers to hasPosition

    【Evidence】
    advisor IDs refers to p_id_dummy and person.p_id where professor = 1; eighth year of program refers to yearsInprogram = 'Year_8'; position status in faculty of those professors refers to hasPosition

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T1.p_id_dummy, T2.hasPosition FROM advisedBy AS T1 INNER JOIN person AS T2 ON T1.p_id = T2.p_id WHERE T2.yearsInProgram = 'Year_8'
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    List any five of course IDs with professor IDs who taught master courses. professor IDs refers to taughtBy.p_id; master course refers to courseLevel = 'Level_500'

    【Evidence】
    professor IDs refers to taughtBy.p_id; master course refers to courseLevel = 'Level_500'

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT T1.course_id, T2.p_id FROM course AS T1 INNER JOIN taughtBy AS T2 ON T1.course_id = T2.course_id WHERE T1.courseLevel = 'Level_500' LIMIT 5
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    How many students are under advisor 415? advisor 415 refers to p_id_dummy = 415

    【Evidence】
    advisor 415 refers to p_id_dummy = 415

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT COUNT(*) FROM advisedBy WHERE p_id_dummy = 415
You are now a sqlite data analyst, and you are given a database schema as follows:

    【Schema】
    【DB_ID】 computer_student
【Schema】
# Table: taughtBy
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(p_id:INTEGER, Primary Key, Examples: [40, 180, 279])
]
# Table: person
[
(p_id:INTEGER, Primary Key, Examples: [3, 4, 5]),
(professor:INTEGER, Examples: [0, 1]),
(student:INTEGER, Examples: [1, 0]),
(hasPosition:TEXT, Examples: [0, Faculty, Faculty_adj]),
(inPhase:TEXT, Examples: [0, Post_Quals, Post_Generals]),
(yearsInProgram:TEXT, Examples: [0, Year_2, Year_5])
]
# Table: course
[
(course_id:INTEGER, Primary Key, Examples: [0, 1, 2]),
(courseLevel:TEXT, Examples: [Level_500, Level_300, Level_400])
]
# Table: advisedBy
[
(p_id:INTEGER, Primary Key, Examples: [6, 9, 13]),
(p_id_dummy:INTEGER, Primary Key, Examples: [5, 7, 29])
]
【Foreign keys】
taughtBy.p_id=person.p_id
taughtBy.course_id=course.course_id
advisedBy.p_id=person.p_id
advisedBy.p_id_dummy=person.p_id

    【Question】
    How many professional or master/graduate courses are there? professional or master/graduate courses refers to courseLevel = 'Level_500'

    【Evidence】
    professional or master/graduate courses refers to courseLevel = 'Level_500'

    Please read and understand the database schema carefully, and generate an executable SQL based on the user's question and evidence. 

SQL: SELECT COUNT(*) FROM course WHERE courseLevel = 'Level_500'