MySQL数据库

一、创建如下表，并创建相关约束

二、操作表

　　1、自行创建测试数据；

　　2、查询学生总人数；

　　3、查询“生物”课程和“物理”课程成绩都及格的学生id和姓名；

　　4、查询每个年级的班级数，取出班级数最多的前三个年级；

　　5、查询平均成绩最高和最低的学生的id和姓名以及平均成绩；

　　6、查询每个年级的学生人数；

　　7、查询每位学生的学号，姓名，选课数，平均成绩；

　　8、查询学生编号为“2”的学生的姓名、该学生成绩最高的课程名、成绩最低的课程名及分数；

　　9、查询姓“李”的老师的个数和所带班级数；

　　10、查询班级数小于5的年级id和年级名；

　　11、查询班级信息，包括班级id、班级名称、年级、年级级别(12为低年级，34为中年级，56为高年级)，示例结果如下；

　　

　　12、查询学过“张三”老师2门课以上的同学的学号、姓名；

　　13、查询教授课程超过2门的老师的id和姓名；

　　14、查询学过编号“1”课程和编号“2”课程的同学的学号、姓名；

　　15、查询没有带过高年级的老师id和姓名；

　　16、查询学过“张三”老师所教的所有课的同学的学号、姓名；

　　17、查询带过超过2个班级的老师的id和姓名；

　　18、查询课程编号“2”的成绩比课程编号“1”课程低的所有同学的学号、姓名；

　　19、查询所带班级数最多的老师id和姓名；

　　20、查询有课程成绩小于60分的同学的学号、姓名；

　　21、查询没有学全所有课的同学的学号、姓名；

　　22、查询至少有一门课与学号为“1”的同学所学相同的同学的学号和姓名；

　　23、查询至少学过学号为“1”同学所选课程中任意一门课的其他同学学号和姓名；

　　24、查询和“2”号同学学习的课程完全相同的其他同学的学号和姓名；

　　25、删除学习“张三”老师课的score表记录；

　　26、向score表中插入一些记录，这些记录要求符合以下条件：①没有上过编号“2”课程的同学学号；②插入“2”号课程的平均成绩；

　　27、按平均成绩从低到高显示所有学生的“语文”、“数学”、“英语”三门的课程成绩，按如下形式显示： 学生ID,语文,数学,英语,有效课程数,有效平均分；

　　28、查询各科成绩最高和最低的分：以如下形式显示：课程ID，最高分，最低分；

　　29、按各科平均成绩从低到高和及格率的百分数从高到低顺序；

　　30、课程平均分从高到低显示（现实任课老师）；

　　31、查询各科成绩前三名的记录(不考虑成绩并列情况)

　　32、查询每门课程被选修的学生数；

　　33、查询选修了2门以上课程的全部学生的学号和姓名；

　　34、查询男生、女生的人数，按倒序排列；

　　35、查询姓“张”的学生名单；

　　36、查询同名同姓学生名单，并统计同名人数；

　　37、查询每门课程的平均成绩，结果按平均成绩升序排列，平均成绩相同时，按课程号降序排列；

　　38、查询课程名称为“数学”，且分数低于60的学生姓名和分数；

　　39、查询课程编号为“3”且课程成绩在80分以上的学生的学号和姓名；

　　40、求选修了课程的学生人数

　　41、查询选修“王五”老师所授课程的学生中，成绩最高和最低的学生姓名及其成绩；

　　42、查询各个课程及相应的选修人数；

　　43、查询不同课程但成绩相同的学生的学号、课程号、学生成绩；

　　44、查询每门课程成绩最好的前两名学生id和姓名；

　　45、检索至少选修两门课程的学生学号；

　　46、查询没有学生选修的课程的课程号和课程名；

　　47、查询没带过任何班级的老师id和姓名；

　　48、查询有两门以上课程超过80分的学生id及其平均成绩；

　　49、检索“3”课程分数小于60，按分数降序排列的同学学号；

　　50、删除编号为“2”的同学的“1”课程的成绩；

　　51、查询同时选修了物理课和生物课的学生id和姓名；

此处是求知的分割线

--------------------------------------------------------------------------------------------------------------------------------------------

test_1

建库建表
            # 作业库 
                create database mysql_work; 
            # 年级表
                create table class_grade(
                -> gid int not null auto_increment,
                -> gname varchar(20) not null unique,
                -> primary key(gid)
                -> );
            # 班级表
                create table class(
                -> cid int not null primary key auto_increment,
                -> caption varchar(20) not null,
                -> grade_id int not null,
                -> foreign key(grade_id) references class_grade(gid)
                -> );
            # 学生表
                create table student(
                -> sid int not null primary key auto_increment,
                -> gender enum('男','女') not null,
                -> class_id int not null,
                -> foreign key(class_id) references class(cid)
                -> );
            # 老师表
                create table teacher(
                -> tid int not null primary key auto_increment,
                -> tname varchar(20) not null
                -> );
            # 课程表
                create table course(
                -> cid int not null primary key auto_increment,
                -> cname varchar(20) not null,
                -> teacher_id int not null ,
                -> foreign key(teacher_id) references teacher(tid)
                -> );
            # 成绩表
                create table score(
                -> sid int not null unique auto_increment,
                -> student_id int not null,
                -> course_id int not null,
                -> score int not null,
                -> primary key(student_id,course_id),
                -> foreign key(student_id) references student(sid)
                -> on delete cascade
                -> on update cascade,
                -> foreign key(course_id) references course(cid)
                -> on delete cascade
                -> on update cascade
                -> );
            # 班级任职表
                create table teach2cls(
                -> tcid int not null unique auto_increment,
                -> tid int not null,
                -> cid int not null,
                -> primary key(tid,cid),
                -> foreign key(tid) references teacher(tid)
                -> on delete cascade
                -> on update cascade,
                -> foreign key(cid) references course(cid)
                -> on delete cascade
                -> on update cascade
                -> );
                
        插入数据
            insert into class_grade(gname) values    # 4个年级
            ('一年级'),
            ('二年级'),
            ('三年级'),
            ('四年级');
            +-----+-----------+
            | gid | gname     |
            +-----+-----------+
            |   1 | 一年级    |
            |   3 | 三年级    |
            |   2 | 二年级    |
            |   4 | 四年级    |
            +-----+-----------+
            
            insert into class(caption,grade_id) values  # 9个班级
            ('一年一班',1),
            ('一年二班',1),
            ('一年三班',1),
            ('二年一班',2),
            ('二年二班',2),
            ('三年一班',3),
            ('三年二班',3),
            ('四年一班',4),
            ('四年二班',4);
            +-----+--------------+----------+
            | cid | caption      | grade_id |
            +-----+--------------+----------+
            |   1 | 一年一班     |        1 |
            |   2 | 一年二班     |        1 |
            |   3 | 一年三班     |        1 |
            |   4 | 二年一班     |        2 |
            |   5 | 二年二班     |        2 |
            |   6 | 三年一班     |        3 |
            |   7 | 三年二班     |        3 |
            |   8 | 四年一班     |        4 |
            |   9 | 四年二班     |        4 |
            +-----+--------------+----------+
            
            insert into student(sname,gender,class_id) values  # 12个学生
            ('Jane','女',1),
            ('Rose','女',1),
            ('Jack','男',2),
            ('Alice','女',2),
            ('Alex','男',3),
            ('Drigon','男',4),
            ('Lily','女',5),
            ('Lucy','女',6),
            ('Jone','男',6),
            ('紫霞','女',7),
            ('张尊宝','男',8),
            ('高圆圆','女',9);
            +-----+--------+----------+-----------+
            | sid | gender | class_id | sname     |
            +-----+--------+----------+-----------+
            |   1 | 女     |        1 | Jane      |
            |   2 | 女     |        1 | Rose      |
            |   3 | 男     |        2 | Jack      |
            |   4 | 女     |        2 | Alice     |
            |   5 | 男     |        3 | Alex      |
            |   6 | 男     |        4 | Drigon    |
            |   7 | 女     |        5 | Lily      |
            |   8 | 女     |        6 | Lucy      |
            |   9 | 男     |        6 | Jone      |
            |  10 | 女     |        7 | 紫霞      |
            |  11 | 男     |        8 | 张尊宝    |
            |  12 | 女     |        9 | 高圆圆    |
            +-----+--------+----------+-----------+
            
            insert into teacher(tname) values   # 4个老师
            ('曹显'),
            ('王浩'),
            ('王五'),
            ('赵坤');
            +-----+--------+
            | tid | tname  |
            +-----+--------+
            |   1 | 曹显   |
            |   2 | 王浩   |
            |   3 | 王五   |
            |   4 | 赵坤   |
            +-----+--------+
            
            insert into course(cname,teacher_id) values  # 6门课程
            ('生物',1),
            ('物理',2),
            ('化学',3),
            ('语文',3),
            ('数学',4),
            ('地理',2);
            +-----+--------+------------+
            | cid | cname  | teacher_id |
            +-----+--------+------------+
            |   1 | 生物   |          1 |
            |   2 | 物理   |          2 |
            |   3 | 化学   |          3 |
            |   4 | 语文   |          3 |
            |   5 | 数学   |          4 |
            |   6 | 地理   |          2 |
            +-----+--------+------------+
            
            insert into score(student_id,course_id,score) values # 12个学生，6门课程   
            (1,1,60),
            (1,2,59),
            (2,4,60),
            (2,5,59),
            (2,6,33),
            (3,1,59),
            (3,5,28),
            (4,4,100),
            (4,6,90),
            (5,4,88),
            (6,5,100),
            (6,6,60),
            (7,3,57),
            (7,5,60),
            (8,2,61),
            (8,4,59),
            (9,1,60),
            (9,2,61),
            (9,3,21),
            (10,5,68),
            (11,1,89),
            (12,3,100);
            +-----+------------+-----------+-------+
            | sid | student_id | course_id | score |
            +-----+------------+-----------+-------+
            |   1 |          1 |         1 |    60 |
            |   2 |          1 |         2 |    59 |
            |   3 |          2 |         4 |    60 |
            |   4 |          2 |         5 |    59 |
            |   5 |          2 |         6 |    33 |
            |   6 |          3 |         1 |    59 |
            |   7 |          3 |         5 |    28 |
            |   8 |          4 |         4 |   100 |
            |   9 |          4 |         6 |    90 |
            |  10 |          5 |         4 |    88 |
            |  11 |          6 |         5 |   100 |
            |  12 |          6 |         6 |    60 |
            |  13 |          7 |         3 |    57 |
            |  14 |          7 |         5 |    60 |
            |  15 |          8 |         2 |    61 |
            |  16 |          8 |         4 |    59 |
            |  17 |          9 |         1 |    60 |
            |  18 |          9 |         2 |    61 |
            |  19 |          9 |         3 |    21 |
            |  20 |         10 |         5 |    68 |
            |  21 |         11 |         1 |    89 |
            |  22 |         12 |         3 |   100 |
            +-----+------------+-----------+-------+ 
            
            insert into teach2cls(tid,cid) values # 4个老师 9个班级 
            (1,1),
            (1,2),
            (1,3),
            (1,7),
            (2,4),
            (2,8),
            (2,7),
            (2,5),
            (3,9),
            (3,3),
            (3,5),
            (3,2),
            (4,8),
            (4,4),
            (4,6),
            (4,1);
            +------+-----+-----+
            | tcid | tid | cid |
            +------+-----+-----+
            |    1 |   1 |   1 |
            |    2 |   1 |   2 |
            |    3 |   1 |   3 |
            |    4 |   1 |   7 |
            |    5 |   2 |   4 |
            |    6 |   2 |   8 |
            |    7 |   2 |   7 |
            |    8 |   2 |   5 |
            |    9 |   3 |   9 |
            |   10 |   3 |   3 |
            |   11 |   3 |   5 |
            |   12 |   3 |   2 |
            |   13 |   4 |   8 |
            |   14 |   4 |   4 |
            |   15 |   4 |   6 |
            |   16 |   4 |   1 |
            +------+-----+-----+

test_2

查询学生总人数；
            select count(sid) as count_student from student;
            +---------------+
            | count_student |
            +---------------+
            |            12 |
            +---------------+

test_3

查询“生物”课程和“物理”课程成绩都及格的学生id和姓名；
            select sid,sname from student where sid in(
                select score.student_id from score inner join course on score.course_id=course.cid
                where course.cname in(
                    "生物",
                    "物理")
                    and score.score >= 60 
                    group by score.student_id
                    having count(course_id) = 2
                    );
            +-----+-------+
            | sid | sname |
            +-----+-------+
            |   9 | Jone  |
            +-----+-------+

test_4

查询每个年级的班级数，取出班级数最多的前三个年级；
            select class_grade.gname from class_grade inner join 
                (select grade_id,count(cid) as count_course 
                from class 
                group by grade_id 
                order by count_course desc limit 3)
                as t1 
                on class_grade.gid = t1.grade_id;
            +-----------+
            | gname     |
            +-----------+
            | 一年级    |
            | 三年级    |
            | 二年级    |
            +-----------+

test_5

查询平均成绩最高和最低的学生的id和姓名以及平均成绩；
            select student.sid,student.sname,t1.avg_score 
                from student 
                    inner join (
                    select 
                        student_id,avg(score) as avg_score 
                    from 
                        score 
                    group by 
                        student_id
                    having avg(score) in
                    (
                        (
                        select avg(score) as max_avg_score
                        from score
                        group by student_id
                        order by avg(score) desc
                        limit 1
                        ),
                        (
                        select avg(score) as min_avg_score
                        from score
                        group by student_id
                        order by avg(score) asc
                        limit 1
                        )
                    )
                )as t1 on student.sid = t1.student_id;
            +-----+-----------+-----------+
            | sid | sname     | avg_score |
            +-----+-----------+-----------+
            |   3 | Jack      |   43.5000 |
            |  12 | 高圆圆    |  100.0000 |
            +-----+-----------+-----------+

test_6

查询每个年级的学生人数；
            select t1.grade_id,count(t1.sid) as count_student
            from (
                    select student.sid,class.grade_id
                    from 
                        student,
                        class
                    where
                        student.class_id = class.cid
                )as t1
            group by 
                    t1.grade_id;
            +----------+---------------+
            | grade_id | count_student |
            +----------+---------------+
            |        1 |             5 |
            |        2 |             2 |
            |        3 |             3 |
            |        4 |             2 |
            +----------+---------------+

test_7

查询每位学生的学号，姓名，选课数，平均成绩；
            select student.sid,student.sname,t1.count_course,t1.avg_score
                from student 
                    left join(
                        select 
                            student_id,
                            count(course_id) as count_course,
                            avg(score) as avg_score
                        from
                            score
                        group by    
                            student_id
                        )as t1 on student.sid=t1.student_id;
            +-----+-----------+--------------+-----------+
            | sid | sname     | count_course | avg_score |
            +-----+-----------+--------------+-----------+
            |   1 | Jane      |            2 |   59.5000 |
            |   2 | Rose      |            3 |   50.6667 |
            |   3 | Jack      |            2 |   43.5000 |
            |   4 | Alice     |            2 |   95.0000 |
            |   5 | Alex      |            1 |   88.0000 |
            |   6 | Drigon    |            2 |   80.0000 |
            |   7 | Lily      |            2 |   58.5000 |
            |   8 | Lucy      |            2 |   60.0000 |
            |   9 | Jone      |            3 |   47.3333 |
            |  10 | 紫霞      |            1 |   68.0000 |
            |  11 | 张尊宝    |            1 |   89.0000 |
            |  12 | 高圆圆    |            1 |  100.0000 |
            +-----+-----------+--------------+-----------+

test_8

查询学生编号为“2”的学生的姓名、该学生成绩最高的课程名、成绩最低的课程名及分数；
            select student.sname,course.cname,t1.score
                from(
                    select
                        student_id,
                        course_id,
                        t1.score
                    from
                        score
                    where    
                        student_id=2 and score in
                            (
                            select    
                                max(score)
                            from
                                score
                            where
                                student_id=2
                                ),
                            (
                            select
                                min(score)
                            from
                                score
                            where
                                student_id=2
                            )
                        )as t1
                    inner join student on t1.student_id=student.sid
                    inner join course on t1.course_id=course.cid;
                    +-------+--------+-------+
                    | sname | cname  | score |
                    +-------+--------+-------+
                    | Rose  | 语文   |    60 |
                    | Rose  | 地理   |    33 |
                    +-------+--------+-------+

test_9

查询班级数小于5的年级id和年级名；
            方法1：
            select 
                gid,gname,count(cid) as count_cid 
            from class_grade 
                inner join class on gid=grade_id
            group 
                by gid 
            having 
                count(cid)<5;
            
            方法2：
            select
                gid,
                gname
            from
                class_grade
            where gid in (
                select
                    grade_id
                from
                    class
                group by
                    grade_id
                having
                    count(caption) < 5
            );
            +-----+-----------+-----------+
            | gid | gname     | count_cid |
            +-----+-----------+-----------+
            |   1 | 一年级    |         3 |
            |   2 | 二年级    |         2 |
            |   3 | 三年级    |         2 |
            |   4 | 四年级    |         2 |
            +-----+-----------+-----------+    

test_10

查询班级数小于5的年级id和年级名；
            方法1：
            select 
                gid,gname,count(cid) as count_cid 
            from class_grade 
                inner join class on gid=grade_id
            group 
                by gid 
            having 
                count(cid)<5;
            
            方法2：
            select
                gid,
                gname
            from
                class_grade
            where gid in (
                select
                    grade_id
                from
                    class
                group by
                    grade_id
                having
                    count(caption) < 5
            );
            +-----+-----------+-----------+
            | gid | gname     | count_cid |
            +-----+-----------+-----------+
            |   1 | 一年级    |         3 |
            |   2 | 二年级    |         2 |
            |   3 | 三年级    |         2 |
            |   4 | 四年级    |         2 |
            +-----+-----------+-----------+    

test_11

查询班级信息，包括班级id、班级名称、年级、年级级别
            select 
                class.cid,class.caption,class_grade.gid,
                case 
                    when class_grade.gid between 1 and 2 then '低'
                    when class_grade.gid between 3 and 4 then '中'
                    when class_grade.gid between 5 and 6 then '高' else 0 end as '年级级别'
            from 
                class,
                class_grade
            where
                class.grade_id=class_grade.gid;
            +-----+--------------+-----+--------------+
            | cid | caption      | gid | 年级级别     |
            +-----+--------------+-----+--------------+
            |   1 | 一年一班     |   1 | 低           |
            |   2 | 一年二班     |   1 | 低           |
            |   3 | 一年三班     |   1 | 低           |
            |   6 | 三年一班     |   3 | 中           |
            |   7 | 三年二班     |   3 | 中           |
            |   4 | 二年一班     |   2 | 低           |
            |   5 | 二年二班     |   2 | 低           |
            |   8 | 四年一班     |   4 | 中           |
            |   9 | 四年二班     |   4 | 中           |
            +-----+--------------+-----+--------------+

test_12

查询学过“张三”老师2门课以上的同学的学号、姓名；
            select 
                student.sid,student.sname
            from 
                student
            where 
                sid in(
                    select 
                        student_id
                    from 
                        score
                    where
                        course_id in(
                            select    
                                course.cid
                            from
                                teacher,
                                course
                            where 
                                teacher.tid=course.teacher_id
                                and teacher.tname='张三'
                            )
                    group by
                        student_id
                    having
                        count(course_id) >2
                );
                
            # Empty set (0.00 sec) 记录为空

test_13

查询教授课程超过2门的老师的id和姓名；
            select 
                teacher.tid,teacher.tname 
            from teacher
                where
                    tid in(
                        select 
                            teacher_id
                        from course
                        group by
                            teacher_id
                        having
                            count(cid)>2
                        );
            # Empty set (0.00 sec) 无记录

test_14

查询学过编号“1”课程和编号“2”课程的同学的学号、姓名；
            select
                sid,
                sname
            from
                student
            where
                sid in (
                    select distinct
                        student_id
                    from
                        score
                    where
                        course_id in (
                            1,
                            2
                        )
                );
            +-----+-----------+
            | sid | sname     |
            +-----+-----------+
            |   1 | Jane      |
            |   3 | Jack      |
            |   8 | Lucy      |
            |   9 | Jone      |
            |  11 | 张尊宝    |
            +-----+-----------+        

test_15

查询没有带过高年级的老师id和姓名；
            select tid,tname 
                from teacher
            where 
                tid not in(
                select 
                    tid 
                from 
                    teach2cls
                where 
                    cid in(
                        select
                            t1.cid
                            from(
                                select
                                    class.cid,
                                    class.caption,
                                    class_grade.gname,
                                    case
                                    when class_grade.gid between 1 and 2 then '低'
                                    when class_grade.gid between 3 and 4 then '中'
                                    when class_grade.gid between 5 and 6 then '高' else 0 end as grade_layer
                                from
                                    class,
                                    class_grade
                                where
                                    class.grade_id=class_grade.gid
                                )as t1
                            where    
                                t1.grade_layer='高'
                        )
                    );
            +-----+--------+
            | tid | tname  |
            +-----+--------+
            |   1 | 曹显   |
            |   2 | 王浩   |
            |   3 | 王五   |
            |   4 | 赵坤   |
            +-----+--------+

test_16

查询学过“张三”老师所教的所有课的同学的学号、姓名；
            select sid,sname from student
                where sid in (
                    select student_id from score
                        where course_id in(
                            select cid from course
                            inner join teacher on course.teacher_id=teacher.tid
                            where teacher.tname = '张三'
                            )
                    );
                        
            Empty set (0.00 sec)    记录为空

test_17

查询带过超过2个班级的老师的id和姓名；
            select tid,tname from teacher
                where tid in(
                    select tid from teach2cls
                        group by tid 
                        having count(cid)>2
                        );
            +-----+--------+
            | tid | tname  |
            +-----+--------+
            |   1 | 曹显   |
            |   2 | 王浩   |
            |   3 | 王五   |
            |   4 | 赵坤   |
            +-----+--------+    

test_18

查询课程编号“2”的成绩比课程编号“1”课程低的所有同学的学号、姓名；
            select sid,sname from student
                where sid in(
                    select t1.student_id from 
                        (select student_id,score from score
                            where 
                                course_id=2
                            group by
                                student_id
                        ) as t1,
                        (select student_id,score from score
                            where    
                                course_id=1
                            group by
                                student_id
                        ) as t2
                    where 
                        t1.student_id = t2.student_id
                        and t1.score < t2.score
                    );
                    
            +-----+-------+
            | sid | sname |
            +-----+-------+
            |   1 | Jane  |
            +-----+-------+    

test_19

查询所带班级数最多的老师id和姓名；
            select tid,tname from teacher
                where tid in(
                    select tid from teach2cls
                        group by tid
                        having count(cid)=(
                            select count(cid) from teach2cls
                                group by tid
                                order by count(cid) desc
                                limit 1
                            )
                );
            +-----+--------+
            | tid | tname  |
            +-----+--------+
            |   1 | 曹显   |
            |   2 | 王浩   |
            |   3 | 王五   |
            |   4 | 赵坤   |
            +-----+--------+

test_20

查询有课程成绩小于60分的同学的学号、姓名；
            select sid,sname from student
                where sid in (
                    select distinct student_id from score
                        where score<60
                );
            +-----+-------+
            | sid | sname |
            +-----+-------+
            |   1 | Jane  |
            |   2 | Rose  |
            |   3 | Jack  |
            |   7 | Lily  |
            |   8 | Lucy  |
            |   9 | Jone  |
            +-----+-------+        

test_21

查询没有学全所有课的同学的学号、姓名；
            select sid,sname from student
                where sid not in(
                    select student_id from score
                        group by student_id
                        having count(course_id) = (
                            select count(cid) from course)
                        );
            +-----+-----------+
            | sid | sname     |
            +-----+-----------+
            |   1 | Jane      |
            |   2 | Rose      |
            |   3 | Jack      |
            |   4 | Alice     |
            |   5 | Alex      |
            |   6 | Drigon    |
            |   7 | Lily      |
            |   8 | Lucy      |
            |   9 | Jone      |
            |  10 | 紫霞      |
            |  11 | 张尊宝    |
            |  12 | 高圆圆    |
            +-----+-----------+    

test_22

查询至少有一门课与学号为“1”的同学所学相同的同学的学号和姓名；
            select sid,sname from student 
                where sid in(
                    select student_id from score
                    where course_id in (
                        select course_id from score
                        where student_id = 1                    
                    )
                    group by student_id
                );
            +-----+-----------+
            | sid | sname     |
            +-----+-----------+
            |   1 | Jane      |
            |   3 | Jack      |
            |   8 | Lucy      |
            |   9 | Jone      |
            |  11 | 张尊宝    |
            +-----+-----------+    

test_23

查询至少学过学号为“1”同学所选课程中任意一门课的其他同学学号和姓名；
            select sid,sname from student
                where sid in(
                    select student_id from score
                    where course_id in(
                            select course_id from score
                            where student_id = 1
                            )
                        group by student_id
                        )
                        and sid!=1;
            +-----+-----------+
            | sid | sname     |
            +-----+-----------+
            |   3 | Jack      |
            |   9 | Jone      |
            |  11 | 张尊宝    |
            |   8 | Lucy      |
            +-----+-----------+    

test_24

查询和“2”号同学学习的课程完全相同的其他同学的学号和姓名；
                 select sid,sname from student where sid in (
                    select
                        score.student_id
                    from
                        score,
                        (
                            select course_id from score where student_id = 2
                        ) as t1
                    where
                        score.course_id = t1.course_id
                        and score.student_id != 2
                    group by
                        score.student_id
                    having
                        count(score.course_id) = (
                            select
                                count(course_id)
                            from
                                score
                            where
                                student_id = 2
                        )
                );    

test_25

删除学习“张三”老师课的score表记录；                
            delete from  score where course_id in(
                select course.cid from course,teacher
                    where course.teacher_id = teacher.tid
                        and teacher.tname = '张三');
            
            Query OK, 0 rows affected (0.08 sec) 无数据受到影响

test_26

向score表中插入一些记录，这些记录要求符合以下条件：①没有上过编号“2”课程的同学学号；②插入“2”号课程的平均成绩；
            insert into score(student_id,course_id,score)
                select t1.sid,2,t2.avg_score from (
                    select sid from student 
                        where sid not in (
                            select student_id from score 
                                where course_id=2
                                )
                        ) as t1,
                        (
                            select avg(score) as avg_score from score
                                where  course_id=2
                        ) as t2;
            
            Query OK, 9 rows affected (0.14 sec)  # 添加了9行记录
            Records: 9  Duplicates: 0  Warnings: 0

test_27

按平均成绩从低到高显示所有学生的“语文”、“数学”、“物理”三门的课程成绩，按如下形式显示：
            select 
                sc.student_id,
                (select 
                    score.score from score left join course on score.course_id=course.cid where course.cname='语文'
                        and score.student_id = sc.student_id 
                )as Chinese,
                (select 
                    score.score from score left join course on score.course_id = course.cid where course.cname='数学'
                        and score.student_id=sc.student_id
                )as math,
                (select    
                    score.score from score left join course on score.course_id = course.cid where course.cname='物理'
                        and score.student_id=sc.student_id
                )as physics,
                    count(sc.course_id),
                    avg(sc.score)
                from score as sc
                group by
                    sc.student_id
                order by
                    avg(sc.score) asc;
            
            +------------+---------+------+---------+---------------------+---------------+
            | student_id | Chinese | math | physics | count(sc.course_id) | avg(sc.score) |
            +------------+---------+------+---------+---------------------+---------------+
            |          9 |    NULL | NULL |      61 |                   3 |       47.3333 |
            |          3 |    NULL |   28 |      60 |                   3 |       49.0000 |
            |          2 |      60 |   59 |      60 |                   4 |       53.0000 |
            |          7 |    NULL |   60 |      60 |                   3 |       59.0000 |
            |          1 |    NULL | NULL |      59 |                   2 |       59.5000 |
            |          8 |      59 | NULL |      61 |                   2 |       60.0000 |
            |         10 |    NULL |   68 |      60 |                   2 |       64.0000 |
            |          6 |    NULL |  100 |      60 |                   3 |       73.3333 |
            |          5 |      88 | NULL |      60 |                   2 |       74.0000 |
            |         11 |    NULL | NULL |      60 |                   2 |       74.5000 |
            |         12 |    NULL | NULL |      60 |                   2 |       80.0000 |
            |          4 |     100 | NULL |      60 |                   3 |       83.3333 |
            +------------+---------+------+---------+---------------------+---------------+
            12 rows in set (0.00 sec)

test_28

查询各科成绩最高和最低的分：以如下形式显示：课程ID，最高分，最低分；
            select course.cid,max(score.score) as max_score,min(score.score) as min_score
                from course left join score on course.cid=score.course_id
                group by score.course_id;
            +-----+-----------+-----------+
            | cid | max_score | min_score |
            +-----+-----------+-----------+
            |   1 |        89 |        59 |
            |   2 |        61 |        59 |
            |   3 |       100 |        21 |
            |   4 |       100 |        59 |
            |   5 |       100 |        28 |
            |   6 |        90 |        33 |
            +-----+-----------+-----------+
            6 rows in set (2.43 sec)

test_29

按各科平均成绩从低到高和及格率的百分数从高到低顺序；
            select course_id,avg(score) as avg_score,
                sum(case when score.score>60 then 1 else 0 end)/count(1)*100 as percent
                from
                    score
                group by
                    course_id
                order by
                    avg(score) asc,
                    percent desc;

test_30

课程平均分从高到低显示（显示任课老师）；
            select t1.course_id,t1.avg_score,teacher.tname from course,teacher,
                (
                select course_id,avg(score) as avg_score from score
                group by course_id
                order by avg_score desc
                ) as t1
            where 
                course.cid = t1.course_id
                and course.teacher_id = teacher.tid
            order by
                t1.avg_score desc;
                
            +-----------+-----------+--------+
            | course_id | avg_score | tname  |
            +-----------+-----------+--------+
            |         4 |   76.7500 | 王五   |
            |         1 |   67.0000 | 曹显   |
            |         5 |   63.0000 | 赵坤   |
            |         6 |   61.0000 | 王浩   |
            |         2 |   60.0833 | 王浩   |
            |         3 |   59.3333 | 王五   |
            +-----------+-----------+--------+
            6 rows in set (0.05 sec)

test_31

查询各科成绩前三名的记录
            select 
                score.sid,
                score.student_id,
                score.course_id,
                score.score,
                t1.first_score,
                t1.second_score,
                t1.third_score
            from score inner join(
                select
                    s1.sid,
                    (select score from score as s2 where s1.course_id=s2.course_id order by score  desc limit 0,1) as first_score,
                    (select score from score as s3 where s1.course_id=s3.course_id order by score  desc limit 1,1) as second_score,
                    (select score from score as s4 where s1.course_id=s4.course_id order by score  desc limit 2,1) as third_score
                    
                from score as s1
                ) as t1 on score.sid = t1.sid
                where score.score in(
                    t1.first_score,
                    t1.second_score,
                    t1.third_score
                    
                );
            +-----+------------+-----------+-------+-------------+--------------+-------------+
            | sid | student_id | course_id | score | first_score | second_score | third_score |
            +-----+------------+-----------+-------+-------------+--------------+-------------+
            |   1 |          1 |         1 |    60 |          89 |           60 |          60 |
            |   3 |          2 |         4 |    60 |         100 |           88 |          60 |
            |   5 |          2 |         6 |    33 |          90 |           60 |          33 |
            |   8 |          4 |         4 |   100 |         100 |           88 |          60 |
            |   9 |          4 |         6 |    90 |          90 |           60 |          33 |
            |  10 |          5 |         4 |    88 |         100 |           88 |          60 |
            |  11 |          6 |         5 |   100 |         100 |           68 |          60 |
            |  12 |          6 |         6 |    60 |          90 |           60 |          33 |
            |  13 |          7 |         3 |    57 |         100 |           57 |          21 |
            |  14 |          7 |         5 |    60 |         100 |           68 |          60 |
            |  15 |          8 |         2 |    61 |          61 |           61 |          60 |
            |  17 |          9 |         1 |    60 |          89 |           60 |          60 |
            |  18 |          9 |         2 |    61 |          61 |           61 |          60 |
            |  19 |          9 |         3 |    21 |         100 |           57 |          21 |
            |  20 |         10 |         5 |    68 |         100 |           68 |          60 |
            |  21 |         11 |         1 |    89 |          89 |           60 |          60 |
            |  22 |         12 |         3 |   100 |         100 |           57 |          21 |
            |  23 |          2 |         2 |    60 |          61 |           61 |          60 |
            |  24 |          3 |         2 |    60 |          61 |           61 |          60 |
            |  25 |          4 |         2 |    60 |          61 |           61 |          60 |
            |  26 |          5 |         2 |    60 |          61 |           61 |          60 |
            |  27 |          6 |         2 |    60 |          61 |           61 |          60 |
            |  28 |          7 |         2 |    60 |          61 |           61 |          60 |
            |  29 |         10 |         2 |    60 |          61 |           61 |          60 |
            |  30 |         11 |         2 |    60 |          61 |           61 |          60 |
            |  31 |         12 |         2 |    60 |          61 |           61 |          60 |
            +-----+------------+-----------+-------+-------------+--------------+-------------+
            26 rows in set (0.00 sec)

test_32

查询每门课程被选修的学生数；
            select course.cid,ifnull(t1.count_students,0) as count_student 
                from course left join (
                    select course_id,count(student_id) as count_students
                    from score 
                    group by
                        course_id
                    ) as t1 on course.cid = t1.course_id;
            +-----+---------------+
            | cid | count_student |
            +-----+---------------+
            |   1 |             4 |
            |   2 |            12 |
            |   6 |             3 |
            |   3 |             3 |
            |   4 |             4 |
            |   5 |             5 |
            +-----+---------------+
            6 rows in set (0.06 sec)

test_33

查询选修了2门以上课程的全部学生的学号和姓名；
            select sid,sname from student
                where sid in(
                    select student_id from score
                    group by
                        student_id
                    having
                        count(course_id)>2
                    );
            +-----+--------+
            | sid | sname  |
            +-----+--------+
            |   2 | Rose   |
            |   3 | Jack   |
            |   4 | Alice  |
            |   6 | Drigon |
            |   7 | Lily   |
            |   9 | Jone   |
            +-----+--------+
            6 rows in set (0.06 sec)

test_34

查询男生、女生的人数，按倒序排列；
            select gender,count(sid) as count_student
                from student
                group by gender
                order by count_student desc;
            +--------+---------------+
            | gender | count_student |
            +--------+---------------+
            | 女     |             7 |
            | 男     |             5 |
            +--------+---------------+
            2 rows in set (0.02 sec)    

test_35

查询姓“张”的学生名单；
            select sid,sname,gender,class.caption 
                from student inner join class on student.class_id = class.cid
                where sname like '张%';
            +-----+-----------+--------+--------------+
            | sid | sname     | gender | caption      |
            +-----+-----------+--------+--------------+
            |  11 | 张尊宝    | 男     | 四年一班     |
            +-----+-----------+--------+--------------+
            1 row in set (0.06 sec)
        

test_36

查询同名同姓学生名单，并统计同名人数；
            select sid,sname,count(sname) as count_sname 
                from student
                group by sname
                having count(sname)>1;
                
            Empty set (0.00 sec)

test_37

查询每门课程的平均成绩，结果按平均成绩升序排列，平均成绩相同时，按课程号降序排列；
            select cid,cname,avg(score.score) as avg_score from course 
                inner join score on course.cid = score.course_id
                group by cid
                having avg(score.score)
                order by avg(score.score),
                course_id desc;
            +-----+--------+-----------+
            | cid | cname  | avg_score |
            +-----+--------+-----------+
            |   3 | 化学   |   59.3333 |
            |   2 | 物理   |   60.0833 |
            |   6 | 地理   |   61.0000 |
            |   5 | 数学   |   63.0000 |
            |   1 | 生物   |   67.0000 |
            |   4 | 语文   |   76.7500 |
            +-----+--------+-----------+
            6 rows in set (0.00 sec)

test_38

查询课程名称为“数学”，且分数低于60的学生姓名和分数；
            select student.sid,student.sname,t1.score from student
                        inner join (
                            select score.student_id,score.score from score
                            inner join course on score.course_id=course.cid
                        where cname='数学' 
                              and score.score<60
                        )as t1 on student.sid=t1.student_id;
            +-----+-------+-------+
            | sid | sname | score |
            +-----+-------+-------+
            |   2 | Rose  |    59 |
            |   3 | Jack  |    28 |
            +-----+-------+-------+
            2 rows in set (0.00 sec)

test_39

查询课程编号为“3”且课程成绩在80分以上的学生的学号和姓名；
            select student.sid,student.sname,t1.score from student
                inner join(
                    select score.student_id,score.score from score
                    inner join course on score.course_id=course.cid
                where cid=3
                    and score.score>80
                )as t1 on student.sid = t1.student_id;
            
            +-----+-----------+-------+
            | sid | sname     | score |
            +-----+-----------+-------+
            |  12 | 高圆圆    |   100 |
            +-----+-----------+-------+
            1 row in set (0.00 sec)    

test_40

求选修了课程的学生人数
            select course_id,count(student_id) as count_student 
                from score
                group by course_id;
        
        +-----------+---------------+
        | course_id | count_student |
        +-----------+---------------+
        |         1 |             4 |
        |         2 |            12 |
        |         3 |             3 |
        |         4 |             4 |
        |         5 |             5 |
        |         6 |             3 |
        +-----------+---------------+
        6 rows in set (0.00 sec)

test_41

查询选修“王五”老师所授课程的学生中，成绩最高和最低的学生姓名及其成绩；
            select student.sid,student.sname,t2.course_id,t2.score,t2.max_score,t2.min_score from student
                inner join (
                    select score.student_id,score.course_id,score.score,t1.max_score,t1.min_score
                        from score,
                        (
                        select course_id,max(score) as max_score,min(score) as min_score
                        from score
                        where course_id in (
                            select cid from course
                            inner join teacher on course.teacher_id = teacher.tid
                        where teacher.tname = '王五'
                        )
                    group by course_id
                    ) as t1
                where score.course_id = t1.course_id
                    and score.score in(
                        max_score,
                        min_score
                    )
                    
                )as t2 on student.sid  = t2.student_id;
        +-----+-----------+-----------+-------+-----------+-----------+
        | sid | sname     | course_id | score | max_score | min_score |
        +-----+-----------+-----------+-------+-----------+-----------+
        |   4 | Alice     |         4 |   100 |       100 |        59 |
        |   8 | Lucy      |         4 |    59 |       100 |        59 |
        |   9 | Jone      |         3 |    21 |       100 |        21 |
        |  12 | 高圆圆    |         3 |   100 |       100 |        21 |
        +-----+-----------+-----------+-------+-----------+-----------+
        4 rows in set (0.00 sec)
        

test_42

查询各个课程及相应的选修人数；
            select course.cid,course.cname,count(student_id) as count_student from course
                inner join score on course.cid = score.course_id
                group by course.cid
                having count(student_id);                        
            -+--------+---------------+
            | cid | cname  | count_student |
            +-----+--------+---------------+
            |   1 | 生物   |             4 |
            |   2 | 物理   |            12 |
            |   3 | 化学   |             3 |
            |   4 | 语文   |             4 |
            |   5 | 数学   |             5 |
            |   6 | 地理   |             3 |
            +-----+--------+---------------+
            6 rows in set (0.00 sec)    

test_43

查询不同课程但成绩相同的学生的学号、课程号、学生成绩；
            select distinct s1.student_id,s2.student_id,
                s1.course_id as s1_course_id,
                s2.course_id as s2_course_id,
                s1.score,s2.score
            from 
                score as s1,
                score as s2
            where s1.student_id = s2.student_id
            and s1.course_id != s2.course_id
            and s1.score = s2.score;
            +------------+------------+--------------+--------------+-------+-------+
            | student_id | student_id | s1_course_id | s2_course_id | score | score |
            +------------+------------+--------------+--------------+-------+-------+
            |          2 |          2 |            2 |            4 |    60 |    60 |
            |          2 |          2 |            4 |            2 |    60 |    60 |
            |          6 |          6 |            2 |            6 |    60 |    60 |
            |          6 |          6 |            6 |            2 |    60 |    60 |
            |          7 |          7 |            2 |            5 |    60 |    60 |
            |          7 |          7 |            5 |            2 |    60 |    60 |
            +------------+------------+--------------+--------------+-------+-------+
            6 rows in set (0.00 sec)

test_44

查询每门课程成绩最好的前两名学生id和姓名；
            select
                student.sid,
                student.sname,
                t2.course_id,
                t2.score,
                t2.first_score,
                t2.second_score
            from
                student
            inner join (                    
                select
                    score.student_id,
                    score.course_id,
                    score.score,
                    t1.first_score,
                    t1.second_score
                from
                    score
                inner join (
                    select
                        s1.sid,
                        (select s2.score from score as s2 where s1.course_id = s2.course_id order by s2.score desc limit 0,1) as first_score,
                        (select s3.score from score as s3 where s1.course_id = s3.course_id order by s3.score desc limit 1,1) as second_score
                    from
                        score as s1
                ) as t1 on score.sid = t1.sid
                where
                    score.score in (           
                        t1.first_score,
                        t1.second_score
                    )
            ) as t2 on student.sid = t2.student_id;

test_45

检索至少选修两门课程的学生学号；
            select student_id,student.sname from score inner join student on score.student_id = student.sid
            group by student_id
            having count(course_id)>=2;
            +------------+-----------+
            | student_id | sname     |
            +------------+-----------+
            |          1 | Jane      |
            |          2 | Rose      |
            |          3 | Jack      |
            |          4 | Alice     |
            |          5 | Alex      |
            |          6 | Drigon    |
            |          7 | Lily      |
            |          8 | Lucy      |
            |          9 | Jone      |
            |         10 | 紫霞      |
            |         11 | 张尊宝    |
            |         12 | 高圆圆    |
            +------------+-----------+
            12 rows in set (0.00 sec)

test_46

查询没有学生选修的课程的课程号和课程名；
            select course.cid,course.cname from course
                where course.cid not in (
                    select course_id from score 
                    group by course_id
                    );
                        
            Empty set (0.00 sec)    无数据受到影响

test_47

查询没带过任何班级的老师id和姓名；
            select teacher.tid,teacher.tname from teacher
                where teacher.tid not in(
                    select tid from teach2cls
                    group by tid
                );
                
                Empty set (0.05 sec) 无数据受到影响

test_48

查询有两门以上课程超过80分的学生id及其平均成绩；
            select score.student_id,avg(score) as avg_score from score
                where student_id in (
                    select student_id from score
                    where score>80
                    group by student_id
                    having count(score.course_id)>2
                    )
                group by student_id;
                
            Empty set (0.00 sec)   无数据受到影响

test_49

检索“3”课程分数小于60，按分数降序排列的同学学号；
            select score.student_id,score.score from score
                    where score<60
                        and course_id = 3
                order by score.score desc;
                
            +------------+-------+
            | student_id | score |
            +------------+-------+
            |          7 |    57 |
            |          9 |    21 |
            +------------+-------+
            2 rows in set (0.00 sec)

test_50

删除编号为“2”的同学的“1”课程的成绩；
            方法一：
                delete score from score where student_id=2 and course_id=1;
                
            方法二：
                delete from score where sid=(
                    select t1.sid from (
                        select sid from score 
                            where  student_id = 2 and course_id = 1
                    )as  t1
                    );
            Query OK, 0 rows affected (0.00 sec) 无数据受到影响

test_51

查询同时选修了物理课和生物课的学生id和姓名；
            select sid,sname from student
                where sid in(
                    select student_id from score
                    where course_id in(
                        select cid from course
                        where  course.cname in(
                            '物理',
                            '生物')
                    )        
                group by student_id
                having count(course_id)=2
            );
            +-----+-----------+
            | sid | sname     |
            +-----+-----------+
            |   1 | Jane      |
            |   3 | Jack      |
            |   9 | Jone      |
            |  11 | 张尊宝    |
            +-----+-----------+
            4 rows in set (0.00 sec)