精华内容
下载资源
问答
  • 创新思维结作业19媒创2019创新思维结展示2019.12.27媒烦恼创造营出品本周五,媒创班历时五个星期的专业创新思维训练结!!啦!每一个组的同学都非常认真非常用心地制作了结作业,每一份作业都给人满满的...

    创新思维

    结课作业 

    988cee13c6855b7c4362c0f58348e218.png

    19媒创

    2019

    创新思维结课展示

    2019.12.27 媒烦恼创造营出品

    本周五,媒创班历时五个星期的专业课

    创新思维训练

    结!课!啦!

    每一个组的同学都非常认真非常用心地制作了结课作业,每一份作业都给人满满的惊喜,让人连连夸赞。同学们不禁怀疑自己:“我竟然和这么多大佬在同一个班级上课吗?oh我不配。”接下来让我们一起欣赏一下他们的作品吧——

    01

    短视频组

    创建奥莱德公司

    以娱乐新闻报道形式制作视频

    奥莱德公司出品

    短视频

    3a70709cd89679984bd7d9feed3a5a5d.png

    新闻报道与小片制作

    前期策划:李颖

    中期表演:范志谦 邬萧祎 沈昊千

    后期制作:吴秋玮 洪子轩

    低成本大制作,人数少事情多,技术差要求高,但希望各位看的开心。

    本片奥莱德娱乐文化传媒有限责任公司独家出品,盗版必究。

    02

    影视组

    用心选角掏心策划熬夜加班疯狂爆肝

    打造年度ip巨作

    影视剪辑与策划

    男女主角在大学时期通过游戏相识,相知,相爱。但由于男主出国问题导致两人感情破裂。七年后出车祸整容后的男主回国 遇到了刚刚离婚的女主,两人历经波折终于解开了误会,但女主有与闺蜜因婚礼开始了一场新娘大作战......

    新娘何以很倾城

     本剧励志为大家提供

     最经典的狗血剧

     最渣男女主

     最墨迹虐恋大戏

     最莫名奇妙的喜剧混剪

    7e7f6f3c9c1419fdb9901c630102c9b1.png866b2d3ae9293e6497e38c8e68b7d5c2.png692fc117e585d2b3cbd2be91a2f47b0b.png

    03

    动漫组

    以土木水三元素组成超能工程队

    用爱与肝激情创作动画漫画

    LEGEND OF MC ISLAND

    2.以丰富的与媒创班互动情节,吸引本班同学,以期得到媒创班同学关注与支持,从而进一步扩宽业务范围,拓展素材来源。

    制作动画视频与推广

    1.以高质量同人(基于动漫原作上的二次创作)画面,展现团队高超专业技能,以期得到技术层面的认可。

    3.提高业务水平后生产更加优质的动漫产品,拓宽受众面,扩大影响力

    04

    游戏组

    成立TBC工作室

    用全新的模式制作推广像素风格游戏

    制作游戏与预告视频

    杨明坤:艾子哥牛逼!泽子哥牛逼!

    张政华:我觉得这款游戏真的带给我身临其境的体验,气氛渲染的很好,真的有把我吓到。

    温宇明:剧情设置巧妙,前后呼应,伏笔埋的很好。

    经泽丰:我们艾坤不仅仅会Ctrl,还会Shift和Alt。TBC牛逼!

    彭宇:内容充实主题明确音乐优美意韵深远世间不可多见的佳作

    杨天艾:整挺好!

    FIONA游戏

    6181abdb6035ee65248be49bb0a78728.png

    05

    广告组

    以人文关怀消释商业气息

    给予这个寒冬最浓郁的温暖

    “茶说”广告

    采用视频的形式,通过真实的采访,展现三种不同类型的大学生的内心世界和他们与茶说奶茶的渊源,赋予其打动人心的内涵,引发广告受众的共鸣和代入感。

    视频广告与策划

    采访对象分别是一位单身女孩、一个热恋中的女孩和一个有些特别的男孩。通过受访者讲出自己对恋爱和生活的真实感受,坚守品牌独特的标识,给无数独特的人带去抚慰和惬意,给予人满满元气,世间美好都与你环环相扣。

    06

    文创组

    创办女某文创无限不负责任公司

    设计“国风圣诞”系列产品及活动并宣传推广

    当西方圣诞与东方元素相遇,会碰撞出怎样的火花?

    圣诞老人VS财神爷?

    凤凰VS麋鹿?

    财大气粗的女某文创无限不负责任公司推出“国风圣诞”系列产品

    只有你想不到 没有女某做不到

    想说的话:

    女某一出手 创意全都有

    到底谁更秀 媒创就是牛

    国风圣诞产品设计

    792abe2f532faacea42c3a7307704c8c.pngcf986cbe9d83a70dd97f6e9e013ab652.png44344c567a149e237d4028e67fefc16c.png1e086a72d1dfe2bc99fc837d70f07602.pngc9a00c7f2a76b1715781bedf02f58262.png050797dce5219b493ac2fd6862dd9feb.png

    “我们开设这门课,可以和其他专业区分开,我们是创意人。”

    以上只是媒创班的小小创意,相信我们无穷的潜力,未来我们将会给大家更多的惊喜!

    咱们2020见!

    文案 | 胡佳妮

    排版 | 邬萧祎

    头图 | 于欣

    审核 | 邬萧祎

    指导老师 | 詹骞

    特别鸣谢 | 宫承波 孙宇

    创意制作 | 19媒创全体成员

    展开全文
  • 程序员的思维训练-开发认知潜能的九堂-azw3格式 ,电子书可调节字体
  • 高级程序员必修--sql思维举重训练

    出处:http://blog.csdn.net/lk_blog/article/details/7585540


     写sql是程序员基本功课,找工作面试一般必有sql题,实际工作中对sql的需求更是千变万化,所以掌握好sql对于一个程序员来说是件非常重要的事情.本文通过一个简单易懂的关系(学生/课程/成绩关系)尽量构造出各种各样的需求来提高我们写sql的功底,其中有些sql还是有一些难度的,大多数sql我都给出了思考思路,希望本人N天的劳动成果对您有所帮助.

        限于本人水平有限,有些地方的sql写的并不完美,希望大家不吝赐教.最后提一点小小的要求,希望大家对本文积极进行评论,大家的评论是我改进和提高的动力,我希望在和大家的交流中得到提高.

    表关系:



    建表和初始化sql(本例子使用oralce数据库):

    1. --创建表  
    2. create table T_STUDENT(sno NUMBER not null,  sname VARCHAR2(30),  sdree VARCHAR2(50),  sage  NUMBER,  ssex  CHAR(2));  
    3. alter table T_STUDENT add primary key (SNO);  
    4. create table T_SCORE(sno   NUMBER,  cno   NUMBER,  grade NUMBER(4,1), tno NUMBER,  id NUMBER not null);  
    5. alter table T_SCORE add primary key (ID);  
    6. create table T_COURSE(cno NUMBER not null,  cname VARCHAR2(30));  
    7. alter table T_COURSE add primary key (CNO);  
    8.   
    9. --初始化学生表  
    10. insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (1, '李坤''天融信', 26, '男');  
    11. insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (2, '曹贵生''中银', 26, '男');  
    12. insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (3, '柳波''淘宝', 27, '男');  
    13. insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (4, '纪争光''IBM', 23, '男');  
    14. insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (5, '李学宇''微软', 25, '女');  
    15. insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (6, '李雪琪''文思', 25, '女');  
    16. insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (7, '陈绪''百度', 26, '男');  
    17. insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (8, '韩正阳''中海油', 24, '男');  
    18. insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (9, '陈伟东''腾讯', 24, '男');  
    19. insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (10, '刘兵''华为', 24, '男');  
    20. insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (11, '丁成云''联想', 25, '女');  
    21. insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (12, '王鹏''中兴', 25, '男');  
    22. commit;  
    23.   
    24. --初始化课程表  
    25. insert into T_COURSE (CNO, CNAME) values (1, 'JAVA程序设计');  
    26. insert into T_COURSE (CNO, CNAME) values (2, 'ORACLE开发');  
    27. insert into T_COURSE (CNO, CNAME) values (3, 'C++程序设计');  
    28. insert into T_COURSE (CNO, CNAME) values (4, 'C#程序设计');  
    29. insert into T_COURSE (CNO, CNAME) values (5, 'Windows实战');  
    30. insert into T_COURSE (CNO, CNAME) values (6, 'Center OS教程');  
    31. insert into T_COURSE (CNO, CNAME) values (7, 'Jsp/Servlet开发');  
    32. insert into T_COURSE (CNO, CNAME) values (8, 'J2EE从入门到精通');  
    33. insert into T_COURSE (CNO, CNAME) values (9, 'EJB及设计模式');  
    34. insert into T_COURSE (CNO, CNAME) values (10, 'Javascript/jQuery实战');  
    35. insert into T_COURSE (CNO, CNAME) values (11, 'Flash设计');  
    36. insert into T_COURSE (CNO, CNAME) values (12, 'HTML/CSS/JAVASCRIPT实战');  
    37. insert into T_COURSE (CNO, CNAME) values (13, '精通ASP.NET');  
    38. insert into T_COURSE (CNO, CNAME) values (14, 'JBoss入门');  
    39. insert into T_COURSE (CNO, CNAME) values (15, 'Spring开发');  
    40. commit;  
    41.   
    42. --初始化成绩表  
    43. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (1, 2, 90.0, 2, 1);  
    44. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (1, 3, 80.0, 3, 2);  
    45. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (1, 4, 90.0, 4, 3);  
    46. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 2, 70.0, 2, 4);  
    47. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (2, 11, 66.0, 11, 5);  
    48. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (2, 15, 77.0, 15, 6);  
    49. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (2, 8, 87.0, 8, 7);  
    50. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (2, 6, 96.0, 6, 8);  
    51. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (3, 2, 89.0, 2, 9);  
    52. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (3, 1, 91.0, 1, 10);  
    53. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (4, 2, 83.0, 2, 11);  
    54. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (5, 4, 73.0, 4, 12);  
    55. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (5, 1, 60.0, 1, 13);  
    56. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (5, 8, 82.0, 8, 14);  
    57. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (6, 8, 90.5, 10, 15);  
    58. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (8, 2, 58.0, 2, 16);  
    59. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 3, 80.0, 3, 17);  
    60. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (9, 11, 65.0, 11, 18);  
    61. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (9, 12, 67.0, 12, 19);  
    62. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (9, 15, 95.0, 15, 20);  
    63. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (9, 13, 59.0, 13, 21);  
    64. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (10, 4, 98.0, 4, 22);  
    65. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (10, 6, 97.0, 6, 23);  
    66. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (10, 7, 96.0, 7, 24);  
    67. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 7, 95.0, 7, 25);  
    68. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (12, 8, 69.0, 8, 26);  
    69. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (12, 9, 85.0, 9, 27);  
    70. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (10, 14, 100.0, 14, 28);  
    71. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (6, 9, 100.0, 9, 29);  
    72. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 1, 59.0, 1, 30);  
    73. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 4, 90.0, 4, 31);  
    74. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 5, 91.0, 5, 32);  
    75. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 6, 58.0, 6, 33);  
    76. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 8, 93.0, 8, 34);  
    77. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 9, 57.0, 9, 35);  
    78. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 10, 95.0, 10, 36);  
    79. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 11, 96.0, 11, 37);  
    80. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 12, 97.0, 12, 38);  
    81. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 13, 98.0, 13, 39);  
    82. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 14, 99.0, 14, 40);  
    83. insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 15, 89.0, 15, 41);  
    84. commit;  
    在思维举重前,先来一个热身运动吧:
    1. --(一)查询选修课程名称为'JAVA程序设计'的学员学号和姓名   
    2. --方法一:  
    3. --1.查询'JAVA程序设计'这门课程的课程号  
    4. --2.在成绩表中查询课程号为步骤1的课程号的成绩信息..  
    5. --3.在学生表中查询学号为步骤2结果的学生信息  
    6. select st.sno, st.sname  
    7.   from student st  
    8.  where st.sno in  
    9.        (select sno  
    10.           from score sc  
    11.          where sc.cno =  
    12.                (select co.cno from course co where co.cname = 'JAVA程序设计'));  
    13.   
    14. --方法二:  
    15. --1.查询'JAVA程序设计'这门课程的课程号  
    16. --2.在成绩表和学生表关联结果中查询课程号等于步骤1的课程号的成绩信息.  
    17. --sql86  
    18. select st.sno, st.sname  
    19.   from student st, score sc  
    20.  where st.sno = sc.sno  
    21.    and sc.cno =  
    22.        (select co.cno from course co where co.cname = 'JAVA程序设计');  
    23.          
    24. --sql92  
    25. select st.sno, st.sname  
    26.   from student st  
    27.   join score sc  
    28.     on st.sno = sc.sno  
    29.  where sc.cno =  
    30.        (select co.cno from course co where co.cname = 'JAVA程序设计');  
    31.          
    32. --方法三:  
    33. --1.在成绩表和课程表关联结果中查询选修了'JAVA程序设计'这门课的学生的学号  
    34. --2.在学生表中查询步骤1中的学号的学生的详细信息.  
    35. --sql86  
    36. select st.sno, st.sname  
    37.   from student st  
    38.  where st.sno in (select sc.sno  
    39.                          from score sc, course co  
    40.                         where sc.cno = co.cno  
    41.                           and co.cname = 'JAVA程序设计');  
    42.    
    43. --sql92   
    44.  select st.sno, st.sname  
    45.    from student st  
    46.   where st.sno in (select sc.sno  
    47.                           from score sc  
    48.                           join course co  
    49.                             on sc.cno = co.cno    
    50.                       where co.cname = 'JAVA程序设计');  
    51.                         
    52.  --方法四:                       
    53.  --在成绩表和课程表和学生表三表关联的结果中过滤得到选修了 'JAVA程序设计'的学生基本信息     
    54.  --sql86  
    55.   select st.sno, st.sname  
    56.    from student st, score sc, course co  
    57.   where st.sno = sc.sno  
    58.     and co.cno = sc.cno  
    59.     and co.cname = 'JAVA程序设计';  
    60.                
    61.  --sql92(1) 用where过滤  
    62.  select st.sno, st.sname  
    63.   from student st  
    64.   join score sc  
    65.     on st.sno = sc.sno  
    66.   join course co  
    67.     on co.cno = sc.cno  
    68.  where co.cname = 'JAVA程序设计';  
    69.   
    70. --sql92(2) 在关联条件中过滤  
    71.  select st.sno, st.sname  
    72.    from student st  
    73.    join score sc  
    74.      on st.sno = sc.sno  
    75.    join course co  
    76.      on co.cno = sc.cno  
    77.     and co.cname = 'JAVA程序设计';  
    78.    
    79. 注: 1.对于sql86 和sql92的区别见这篇文章: http://blog.csdn.net/lk_blog/article/details/7580300  
    80.     2.如果您在看的过程中觉得不熟悉的地方很多,建议您先看此文: http://blog.csdn.net/lk_blog/article/details/7585501  

    进入正文:

    1. --(一)查询不选修课程编号为'1'的学员姓名和所属单位   
    2. --1.在成绩表中查询课程号为'1'的所有学生学号  
    3. --2.在学生表中查询学号不在步骤1中的学生的基本信息.  
    4. select st.sname, st.sdree  
    5.   from t_student st  
    6.  where st.sno not in (select sc.sno from t_score sc where sc.cno = '1');  
    7.    
    8.    
    9.  --(二)查询平均成绩大于85的所有学生的学号、姓名和平均成绩?  
    10. select sc.sno, st.sname  
    11.    from t_score sc  
    12.    join t_student st  
    13.      on sc.sno = st.sno  
    14.   group by sc.sno, st.sname  
    15.  having avg(sc.grade) > 85;  
    16.    
    17.    
    18.  --(三)查询课程名称为"JAVA程序设计",且分数低于60的学生姓名和分数  
    19. select *  
    20.   from t_score sc  
    21.   join t_course co  
    22.     on sc.cno = co.cno  
    23.  where sc.grade < 60  
    24.    and co.cname = 'JAVA程序设计'  
    25.      
    26.  select *  
    27.    from t_score sc  
    28.    join t_course co  
    29.      on sc.cno = co.cno  
    30.     and sc.grade < 60  
    31.     and co.cname = 'JAVA程序设计'  
    32.   
    33. --(四)查询任何一门课程成绩全部都在70分以上的姓名、课程名称和分数?  
    34. --1.查询出成绩小于70分的学生的学号.  
    35. --2.将学生,成绩,课程三张表作关联.  
    36. --3.在关联表中过滤出不在步骤1查询结果中的学生信息.  
    37. select st.sname, co.cname, sc.grade  
    38.   from t_student st  
    39.   join t_score sc  
    40.     on st.sno = sc.sno  
    41.   join t_course co  
    42.     on sc.cno = co.cno  
    43.  where st.sno not in (select sc1.cno from t_score sc1 where sc1.grade < 70);  
    44.    
    45.    
    46. --(五)查询出选了课的学生的人数.  
    47. select count(distinct(sc.sno)) from t_score sc;  
    48.   
    49.   
    50. --(六)查询每门课程被选课的学生数  
    51. select sc.cno, count(distinct(sc.sno)) from t_score sc group by sc.cno;  
    52.   
    53.                
    54. --(七)查询选了全部课程的学员姓名和所属单位  
    55. --1.在课程表中查询出所有课程的数量  
    56. --2.在成绩表中查询出学生选课数等于步骤1中总选课数的学生的学号,注意要用distinct,having中可以使用count,where中不能使用count.  
    57. --3.在学生表中查出步骤2中学生的基本信息.  
    58. select st.sname, st.sdree  
    59.   from t_student st  
    60.  where st.sno in  
    61.        (select sc.sno  
    62.           from t_score sc  
    63.          group by sc.sno  
    64.         having count(distinct sc.cno) = (select count(distinct sc1.cno)  
    65.                                           from t_course sc1));  
    66.                                             
    67.                                                                                          
    68. --(八) 查询没有学全所有课的同学的学号、姓名  
    69. select st.sname, st.sdree  
    70.   from t_student st  
    71.  where st.sno in  
    72.        (select sc.sno  
    73.           from t_score sc  
    74.          group by sc.sno  
    75.         having count(distinct sc.cno) != (select count(*) from t_course));  
    76.    
    77.           
    78. --(九)查询选修课程超过5门的学员学号和所属单位   
    79. --1.在成绩表中查询出选课程超过5门的学生学号.  
    80. --2.在学生表中查询步骤1中学号的学生的基本信息.  
    81. select st.sname, st.sdree  
    82.   from t_student st  
    83.  where st.sno in (select sc.sno  
    84.                          from t_score sc  
    85.                         group by sc.sno  
    86.                        having count(distinct sc.cno) > 5);  
    87.                                                
    88.                                                                                   
    89. --(十)查询出没有选课的学生基本信息  
    90. --1.在成绩表中查询出所有选过课的学生的学号.  
    91. --2.在学生表中查询出步骤1中学生的基本信息.  
    92. select *  
    93.   from t_student st  
    94.  where st.sno not in (select sc.sno from t_score sc);  
    95.   
    96. --下面的两个sql等价,在成绩表中数据量很大时使用下面的sql  
    97. select *  
    98.   from t_student st  
    99.  where st.sno not in (select distinct (sc.sno) from t_score sc);  
    100.    
    101. select *  
    102.   from t_student st  
    103.  where st.sno not in (select sc.sno from t_score sc group by sc.sno);  
    104.   
    105.                                                   
    106. --(十一) 列出有二门以上不及格课程的学生姓名及其平均成绩   
    107. --方法一  
    108. --1.在成绩表中查询出2门不及格学生的学号,结果记作t1  
    109. --2.将学生表和t1和成绩表三表作关联得到关联表,在关联表中取学生基本信息和平均成绩.  
    110. --sql92     
    111. select st.sno, st.sname, avg(sc.grade)  
    112.   from t_student st  
    113.   join (select sc.sno  
    114.           from t_score sc  
    115.          where sc.grade < 60  
    116.          group by sc.sno  
    117.         having count(distinct sc.cno) > 2) t1  
    118.     on st.sno = t1.sno  
    119.   join t_score sc  
    120.     on sc.sno = t1.sno  
    121.  group by st.sno, st.sname;  
    122.    
    123.  --sql86  
    124. select st.sno, st.sname, avg(sc.grade)  
    125.   from t_student st,  
    126.        t_score sc,  
    127.        (select sc.sno  
    128.           from t_score sc  
    129.          where sc.grade < 60  
    130.          group by sc.sno  
    131.         having count(distinct sc.cno) > 2) t1  
    132.  where st.sno = t1.sno  
    133.    and sc.sno = t1.sno  
    134.  group by st.sno, st.sname;  
    135.   
    136. --方法二:  
    137. --1.在成绩表中查询出2门不及格学生的学号  
    138. --2.将学生表和成绩表通过学号作关联并根据步骤1中的结果作过滤,在关联结果中取出学生基本信息和平均成绩                       
    139. select st.sno, st.sname, avg(sc.grade)  
    140.   from t_student st  
    141.   join t_score sc  
    142.     on st.sno = sc.sno  
    143.  where st.sno in (select sc.sno  
    144.                     from t_score sc  
    145.                    where sc.grade < 60  
    146.                    group by sc.sno  
    147.                   having count(distinct sc.cno) > 2)  
    148.  group by st.sno, st.sname;  
    149.   
    150.    
    151.  --(十二) 查询平均成绩大于60分的同学的学号和平均成绩  
    152. --学生表和课程表关联,在having子句中过滤平均成绩大于60分.  
    153. select st.sno, avg(sc.grade)  
    154.   from t_student st, t_score sc  
    155.  where st.sno = sc.sno  
    156.  group by st.sno  
    157. having avg(sc.grade) > 60;  
    158.   
    159. --1.学生表和课程表关联,将关联的结果记作t1  
    160. --2.在t1中过滤平均成绩大于60的学生学号.  
    161. select t1.sno, t1.avg_grade  
    162.   from (select st.sno, avg(sc.grade) avg_grade  
    163.           from t_student st, t_score sc  
    164.          where st.sno = sc.sno  
    165.          group by st.sno) t1  
    166.  where t1.avg_grade > 60;  
    167.    
    168.    
    169. --(十三)查询出只选修了一门课程的全部学生的学号和姓名  
    170.  --方法一:  
    171.  --1.将学生表和成绩表作关联,在分组函数中使用having子句过滤出只选了一门课程的学生基本信息.  
    172.  select sc.sno, st.sname  
    173.    from t_score sc  
    174.    join t_student st  
    175.      on sc.sno = st.sno  
    176.   group by sc.sno, st.sname  
    177.  having count(distinct sc.cno) = 1;  
    178.    
    179.  --方法二:  
    180.  --1.在成绩表中查找学号,分组函数的过滤条件判断只选择了一门课程的学生.  
    181.  --2.在学生表中查找学号在步骤1中的值的学生的基本信息  
    182. select st.sno,st.sname  
    183.   from t_student st  
    184.  where st.sno in (select sc.sno  
    185.                     from t_score sc  
    186.                    group by sc.sno  
    187.                   having count(distinct sc.cno) = 1);  
    188.                     
    189.    
    190.                     
    191.  --(十四)查询至少有一门课与学号为"1"的同学所学相同的同学的学号和姓名  
    192. select st.sno, st.sname  
    193.   from t_student st  
    194.   join t_score sc1  
    195.     on st.sno = sc1.sno  
    196.  where sc1.cno in (select sc.cno from t_score sc where sc.sno = '1')  
    197.  group by st.sno, st.sname;  
    198.   
    199.   
    200.   
    201. --(十五)列出既学过"1"号课程,又学过"2"号课程的所有学生姓名  
    202. --1.将成绩表和课程表作关联,在关联条件中作过滤查询出既选过课程'1'又选过课程'2'的学生的学号,注意看 co.cno in ('1', '2')和having count(distinct sc.cno) = 2 的位置.  
    203. --2.在学生表中根据步骤1的结果作过滤查询出学生的基本信息.  
    204. --方法一:  
    205. --sql86  
    206. select st.sno, st.sname  
    207.   from t_student st,  
    208.        (select sc.sno  
    209.           from t_score sc, t_course co  
    210.          where sc.cno = co.cno  
    211.            and co.cno in ('1''2')  
    212.          group by sc.sno  
    213.         having count(distinct sc.cno) = 2) t1  
    214.  where st.sno = t1.sno;  
    215.    
    216.  --sql92  
    217.  select st.sno, st.sname  
    218.   from t_student st join   
    219.        (select sc.sno  
    220.           from t_score sc join t_course co  
    221.          on sc.cno = co.cno  
    222.            and co.cno in ('1''2')  
    223.          group by sc.sno  
    224.         having count(distinct sc.cno) = 2) t1  
    225.  on st.sno = t1.sno;  
    226.    
    227.  --方法二:  
    228.  --sql86  
    229.  select st.sno, st.sname  
    230.    from t_student st  
    231.   where st.sno in (select sc.sno  
    232.                      from t_score sc, t_course co  
    233.                     where sc.cno = co.cno  
    234.                       and co.cno in ('1''2')  
    235.                     group by sc.sno  
    236.                    having count(distinct sc.cno) = 2);  
    237.    
    238. --sql92   
    239.   select st.sno, st.sname  
    240.     from t_student st  
    241.    where st.sno in (select sc.sno  
    242.                       from t_score sc  
    243.                       join t_course co  
    244.                         on sc.cno = co.cno  
    245.                        and co.cno in ('1''2')  
    246.                      group by sc.sno  
    247.                     having count(distinct sc.cno) = 2);  
    248.    
    249.    
    250.    
    251.  --(十六)查询至少学过学号为"1"的同学所有门课的同学学号和姓名  
    252.  --1.查询出'1'号同学学习的全部课程.  
    253.  --2.查询出'1'号同学学习全部课程的数量.  
    254.  --3.将课程表和成绩表做关联,在关联表中查询出学生的学号,关联条件中加入过滤条件[课程号在步骤1查询结果范围内],过滤条件中加入数量等级步骤2中得到的数量.  
    255.  --4.在学生表中查询步骤3中的学号的学生的基本信息.  
    256. select st.sno, st.sname  
    257.   from t_student st  
    258.  where st.sno in  
    259.        (select sc.sno  
    260.           from t_score sc  
    261.           join t_course co  
    262.             on sc.cno = co.cno  
    263.            and co.cno in (select sc.cno from t_score sc where sc.sno = '1')  
    264.          group by sc.sno  
    265.         having count(distinct sc.cno) = (select count(distinct sc.cno)  
    266.                                           from t_score sc  
    267.                                          where sc.sno = '1'))  
    268.                                            
    269.     
    270.                                            
    271.  --(十七)查询和"6"号同学学习的课程完全相同的同学的学号和姓名  
    272.  --分析:要查询与6号同学完全相同的课程的学生信息,等价于学过6号同学的学过的所有课程并且选课数量与6同学选课数量相等.  
    273.  --方法一:   
    274.  --1.查询出'1'号同学学习的全部课程.  
    275.  --2.查询出'1'号同学学习全部课程的数量.  
    276.  --3.将课程表和成绩表做关联,在关联表中查询出学生的学号和选课数量,记作 t2,关联条件中加入过滤条件[课程号在步骤1查询结果范围内],过滤条件中加入数量等级步骤2中得到的数量.  
    277.  --4.在成绩表中查询出学号和每个学生选课数量.得到结果记作: t1  
    278.  --5.将步骤3中的t2和步骤4中的t1通过学生学号关联,添加过滤条件,t1中的选课数量等于t2中的选课数量.  
    279.  --6.在学生表中查询不步骤5的学生学号的基本信息.  
    280.  select st.sno, st.sname  
    281.    from t_student st  
    282.   where st.sno in  
    283.         (select t1.sno  
    284.            from (select sc_a.sno, count(distinct sc_a.cno) num_outer  
    285.                    from t_score sc_a  
    286.                   group by sc_a.sno) t1  
    287.            join (select sc.sno, count(distinct sc.cno) num_inner  
    288.                   from t_score sc  
    289.                   join t_course co  
    290.                     on sc.cno = co.cno  
    291.                    and co.cno in  
    292.                        (select sc.cno from t_score sc where sc.sno = '6')  
    293.                  group by sc.sno  
    294.                 having count(distinct sc.cno) = (select count(distinct sc.cno)  
    295.                                                   from t_score sc  
    296.                                                  where sc.sno = '6')) t2  
    297.              on t1.sno = t2.sno  
    298.           where t1.num_outer = t2.num_inner);  
    299.             
    300.     
    301.             
    302.  --(十八)列出"1"号课成绩比"2"号课成绩高的所有学生的学号及其"1"号课和"2"号课的成绩  
    303.  --1.将学生表和课程表作两次关联,一次关联用于取该学生课程'1'的成绩,另一次关联用于取该学生课程'2'的成绩.  
    304.  --sql86  
    305. select st.sno, st.sname, sc_a.grade, sc_b.grade  
    306.   from t_student st, t_score sc_a, t_score sc_b  
    307.  where sc_a.cno = '1'  
    308.    and sc_b.cno = '2'  
    309.    and st.sno = sc_a.sno  
    310.    and st.sno = sc_b.sno  
    311.    and sc_a.grade > sc_b.grade  
    312.      
    313.  --sql92  
    314. select st.sno, st.sname, sc_a.grade, sc_b.grade  
    315.   from t_student st  
    316.   join t_score sc_a  
    317.     on st.sno = sc_a.sno  
    318.   join t_score sc_b  
    319.     on st.sno = sc_b.sno  
    320.  where sc_a.cno = '1'  
    321.    and sc_b.cno = '2'  
    322.    and sc_a.grade > sc_b.grade  
    323.      
    324.   
    325.   
    326. --(十九)查询所有同学的学号、姓名、选课数、总成绩  
    327. select st.sno, st.sname, count(sc.cno), sum(sc.grade)  
    328.   from t_student st, t_score sc  
    329.  where st.sno = sc.sno  
    330.  group by st.sno, st.sname;  
    331.   
    332.   
    333.   
    334. --(二十)查询课程成绩小于60分的同学的学号,姓名,课程名,成绩  
    335. --下面两条sql虽然结果相同,但意义不同,注意理解一下哦.  
    336. --1.将学生表,课程表,成绩表作关联  
    337. --2.对关联后的结果作过滤,过滤出成绩小于60的学生基本信息.  
    338. select st.sno, st.sname, co.cname, sc.grade  
    339.   from t_score sc  
    340.   join t_student st  
    341.     on sc.sno = st.sno  
    342.   join t_course co  
    343.     on sc.cno = co.cno  
    344.  where sc.grade < 60  
    345.   
    346. --1.将学生表,课程表,成绩表作关联,在关联条件中过滤成绩小于60.  
    347.  select st.sno, st.sname, co.cname, sc.grade  
    348.   from t_score sc  
    349.   join t_student st  
    350.     on sc.sno = st.sno  
    351.   join t_course co  
    352.     on sc.cno = co.cno  
    353. and sc.grade <60  
    354.   
    355.   
    356.   
    357. --(二十一)按平均成绩从到低显示所有学生的"JAVA程序设计"、"J2EE从入门到精通"、"EJB及设计模式"三门的课程成绩,  
    358. --并按如下形式显示: 学生ID,姓名,JAVA程序设计,J2EE从入门到精通,EJB及设计模式,有效课程数,有效课程平均分  
    359. --1.将成绩表和课程表关联得到结果记作: t1, 关联时的条件选择只统计以上三门课程.  
    360. --2.按题目中的要求组织统计结果.  
    361. select st.sno,  
    362.        st.sname,  
    363.        sum(decode(t1.cname, 'JAVA程序设计', t1.grade)) JAVA程序设计,  
    364.        sum(decode(t1.cname, 'J2EE从入门到精通', t1.grade)) J2EE从入门到精通,  
    365.        sum(decode(t1.cname, 'EJB及设计模式', t1.grade)) EJB及设计模式,  
    366.        count(distinct t1.grade) 有效课程数,  
    367.        avg(t1.grade) 有效课程平均分  
    368.   from t_student st  
    369.   join (select *  
    370.           from t_score sc  
    371.           join t_course co  
    372.             on sc.cno = co.cno  
    373.            and co.cname in  
    374.                ('JAVA程序设计''J2EE从入门到精通''EJB及设计模式')) t1  
    375.     on st.sno = t1.sno  
    376.  group by st.sno, st.sname  
    377.      
    378.  --将decode可以换成case when 第一种形式  
    379.  select st.sno,  
    380.         st.sname,  
    381.         sum(case t1.cname  
    382.               when 'JAVA程序设计' then  
    383.                t1.grade  
    384.             end) JAVA程序设计,  
    385.          sum(case t1.cname  
    386.               when 'J2EE从入门到精通' then  
    387.                t1.grade  
    388.             end) J2EE从入门到精通,  
    389.              sum(case t1.cname  
    390.               when 'EJB及设计模式' then  
    391.                t1.grade  
    392.             end) EJB及设计模式,  
    393.         count(distinct t1.grade) 有效课程数,  
    394.         avg(t1.grade) 有效课程平均分  
    395.    from t_student st  
    396.    join (select *  
    397.            from t_score sc  
    398.            join t_course co  
    399.              on sc.cno = co.cno  
    400.             and co.cname in  
    401.                 ('JAVA程序设计''J2EE从入门到精通''EJB及设计模式')) t1  
    402.      on st.sno = t1.sno  
    403.   group by st.sno, st.sname  
    404.     
    405.     
    406.  --将decode可以换成case when 第二种形式  
    407.   select st.sno,  
    408.          st.sname,  
    409.          sum(case  
    410.                when t1.cname = 'JAVA程序设计' then  
    411.                 t1.grade  
    412.              end) JAVA程序设计,  
    413.          sum(case  
    414.                when t1.cname = 'J2EE从入门到精通' then  
    415.                 t1.grade  
    416.              end) J2EE从入门到精通,  
    417.          sum(case  
    418.                when t1.cname = 'EJB及设计模式' then  
    419.                 t1.grade  
    420.              end) EJB及设计模式,  
    421.          count(distinct t1.grade) 有效课程数,  
    422.          avg(t1.grade) 有效课程平均分  
    423.     from t_student st  
    424.     join (select *  
    425.             from t_score sc  
    426.             join t_course co  
    427.               on sc.cno = co.cno  
    428.              and co.cname in  
    429.                  ('JAVA程序设计''J2EE从入门到精通''EJB及设计模式')) t1  
    430.       on st.sno = t1.sno  
    431.    group by st.sno, st.sname  
    432.    
    433.    
    434. --(二十二)查询各科成绩最高和最低的分:以如下形式显示:课程ID,课程名,最高分,最低分  
    435. select sc.cno, co.cname, max(grade), min(grade)  
    436.   from t_score sc  
    437.   join t_course co  
    438.     on sc.cno = co.cno  
    439.  group by sc.cno, co.cname  
    440.   
    441.   
    442. --(二十三)按各科平均成绩从低到高和及格率的百分数从高到低顺序   
    443. --1.在成绩表中查出课程号,平均成绩,课程人数,记作 : t1  
    444. --2.在成绩表中查出课程号,及格的课程人数,记作 : t2  
    445. --3.将步骤1中的成绩和步骤2中的课程2关联,查出所要的结果并排序.  
    446. select t1.cno, t1.avg_num 平均成绩, (count_num1 / count_num) * 100 及格率  
    447.   from (select sc.cno, avg(grade) avg_num, count(distinct sc.sno) count_num  
    448.           from t_score sc  
    449.          group by sc.cno) t1  
    450.   join (select sc1.cno, count(distinct sc1.sno) count_num1  
    451.           from t_score sc1  
    452.          where sc1.grade > 60  
    453.          group by sc1.cno) t2  
    454.     on t1.cno = t2.cno  
    455.  order by t1.avg_num asc, 及格率 desc  
    456.    
    457.    
    458. --(二十四)统计各科成绩,各分数段人数:课程ID,课程名称,[100-90]优,[90-80]良,[80-70]中,[70-60]一般,[<60]不及格  
    459. --1.在成绩表中根据成绩值分段  
    460. --2.将步骤1中的结果与课程表关联.  
    461. select sc.cno,co.cname,  
    462.        sum(case  
    463.              when sc.grade > 90 then  
    464.               1  
    465.            end) 优,  
    466.        sum(case  
    467.              when sc.grade > 80 and sc.grade < 90 then  
    468.               1  
    469.            end) 良,  
    470.        sum(case  
    471.              when sc.grade > 70 and sc.grade < 80 then  
    472.               1  
    473.            end) 中,  
    474.        sum(case  
    475.              when sc.grade > 60 and sc.grade < 70 then  
    476.               1  
    477.            end) 一般,  
    478.        sum(case  
    479.              when sc.grade < 60 then  
    480.               1  
    481.            end) 不及格  
    482.   from t_score sc join t_course co on sc.cno = co.cno  
    483.  group by sc.cno,co.cname  
    484.   
    485. --(二十五)查询学生平均成绩及其名次  
    486. select st.sno, st.sname, avg(sc.grade) avg_num  
    487.   from t_score sc  
    488.   join t_student st  
    489.     on sc.sno = st.sno  
    490.  group by st.sno, st.sname  
    491.  order by avg_num desc  
    492.   
    493.   
    494.   
    495. --(二十六)查询课程号分别为1,2,3的课程,成绩前三名的学生基本信息:(不考虑成绩并列情况)  
    496. --方法一:  
    497. --1.分别查出1,2,3各自的前3名的学生的学号,并用union all将结果集关联.  
    498. --2.在学生表中查询步骤1中查到的id的学生的基本信息.  
    499. select *  
    500.   from t_student  
    501.  where sno in (select t1.sno  
    502.                  from (select sc1.*  
    503.                          from t_score sc1  
    504.                         where sc1.cno = 1  
    505.                         order by sc1.grade desc) t1  
    506.                 where rownum < 4  
    507.                union all  
    508.                select t1.sno  
    509.                  from (select sc1.*  
    510.                          from t_score sc1  
    511.                         where sc1.cno = 2  
    512.                         order by sc1.grade desc) t1  
    513.                 where rownum < 4  
    514.                union all  
    515.                select t1.sno  
    516.                  from (select sc1.*  
    517.                          from t_score sc1  
    518.                         where sc1.cno = 3  
    519.                         order by sc1.grade desc) t1  
    520.                 where rownum < 4)  
    521.   
    522. --方法二:  
    523.  --rank() over(Partition .. order by ...) 是按照某个字段的值进行分组并编号  
    524. select t1.cno, t1.sno, t1.grade, r  
    525.   from (select sc.sno,  
    526.                sc.cno,  
    527.                sc.grade,  
    528.                rank() over(partition by sc.cno order by grade desc) r  
    529.           from t_score sc) t1  
    530.  where r < 4  
    531.    and t1.cno in (1, 2, 3)  
    532.  order by t1.cno, t1.sno, r;  
    533.   
    534.   
    535.  --(二十七)查询各科成绩前三名的记录(不考虑成绩并列情况)  
    536.  --rank() over(Partition .. order by ...) 是按照某个字段的值进行分组并编号  
    537. select t1.cno, t1.sno, t1.grade, r  
    538.   from (select sc.sno,  
    539.                sc.cno,  
    540.                sc.grade,  
    541.                rank() over(partition by sc.cno order by grade desc) r  
    542.           from t_score sc) t1  
    543.  where r < 4  
    544.  order by t1.cno, t1.sno, r;  
    展开全文
  • 程序员的思维训练

    千次阅读 2016-03-30 14:26:36
    程序员的思维训练本文内容为阅读Andy Hunt 《程序员的思维修炼:开发认知潜能的九堂》的笔记与心得感悟。约定:本文以引用的方式来记录原书的内容,其余内容为个人的看法与认知程序员的思维训练 从新手到专家的...

    程序员的思维训练

    本文内容为阅读Andy Hunt 《程序员的思维修炼:开发认知潜能的九堂课》的笔记与心得感悟。

    约定:本文以引用的方式来记录原书的内容,其余内容为个人的看法与认知


    从新手到专家的历程

    理论知识

    德雷福斯技能获取模型(Dreyfus model of skill acquisition),概括了从新手到专家必须经历的5个阶段:
    1. 新手(Novice)
    2. 高级新手(Advanced beginner)
    3. 胜任者(Competent)
    4. 精通者(Proficient)
    5. 专家(Expert)

    新手使用规则,专家使用直觉。

    所以,当作为新手,要去学习一项新的技能时候,第一阶段就应该是从机械地遵从规则开始!对于一个迫切想要了解某项新知识的人来说,踏出最纯正的第一步,至关重要。
    我曾经不止一次地被询问:我想要学习好算法和数据结构,请问该如何入门?于是,我总会热心地为他们推荐适合的编程语言,适合基础入门的网站与进阶的网站学习资料与实践场景。但是,我发现,很少甚至几乎没有人成功地按照了我说的入了门。由此也引发了我对一项新的技能入门第一步的思考,其实,也许我只要说:
    1. 下载一个C++ IDE:Code::Blocks
    2. 新建一个Console工程,打开里面的main.cpp源代码文件
    3. 阅读这样一个问题第K极值
    4. 了解快速排序相关知识
    5. Google优秀的快速排序写法,并背诵记忆下来!
    6. 写出实现这个问题的源代码,并提交
    7. 到此为止,你走出了第一步,于是接下来的路再继续发布给你一系列的任务

    所以你应该明白了我想要表达的意思,与其一开始就去做诸如:“分析与比较大量的编程语言,然后选出合适的入门语言;提供相关的资源网站,教他查询API;提示他写程序不要局限于IDE”这些看似更利于今后发展的行为,反不如上来就给出一系列“狭隘”的规则与指令,让他去按部就班。
    因为,成长是阶段性的。当你对一件事物的看法随着时间与经验的积累,达到一定量之后,必然会产生质变:从而由最初按部就班的混沌中产生意识,学会思考,从而进阶到下一阶段!阶段是不可跨越的,因此并不需要在入门新手阶段,过多地灌注超越当前眼界的事情!

    有效地使用

    R&D精神(Rip off and Duplicate,偷师学艺),三个阶段:
    1. 模仿
    2. 吸收
    3. 创新

    警惕工具陷阱,规则无法告诉你在某种情况下应该采取的最合适行为或者正确路线。他们充其量也就是“自行车的辅助轮”——可以帮助启动,但是却限制并大大妨碍了以后的表现。通常有如下需要注意的点:
    - 混淆模型和现实
    - 低估不能形式化的特性
    - 规定违背个人自主性的行为
    - 偏袒新手,从而疏远了经验丰富的员工
    - 阐明太多细节
    - 把复杂局势过于简单化
    - 追求过度一致
    - 忽视情境的细微差别

    不知道同样的问题是否也曾经困惑过你:当模仿别人时候,总怕被人说自己没有创意,没有想法
    现在,恍然大悟,这并非是真正缺乏创意的表现,而却正是最为纯正的学习方法。因为,没有这样的天才,在第一次做事情就能和专家达到相同的水平。因此,模仿是踏出第一步的关键。而所谓创新,是真正衡量你是否已自成体系的最终环节!所以,不要因为没有能够在第一步就自创而妄自菲薄。

    要获取专业技能,需要做到如下几项:
    - 培养更多的直觉
    - 认识到情境和观察情境模式的重要性
    - 更好地利用我们自己的经验

    在近日的谷歌AlphaGo与韩国围棋九段李世石的世纪大战1中,我关注到一个细节:场外的专家解说,如中国的古力九段,往往会用诸如:“这一手的杀气不够”、“这一步有点坏味道”,来形容某些失误的落子。
    专家懂得去寻找至关重要的细节,忽视无关紧要的细节。这是怎样做到的?这样的直觉又是如何获取的?
    这需要在阶段进阶中始终注意一个关键点:
    如何从关注规则中蜕变出来,反思自己,关注情境,把自己化为情境系统的一部分。

    认识你的大脑

    形象的比喻

    大脑
    双CPU模式:1号CPU负责线性、逻辑思维和语言处理,简称为L模式;2号CPU则采用异步、综合处理风格,简称为R模式

    R模式是不可预测的,你需要为此做好准备。答案和灵感会独立于你的意识活动出现,而且不是总在恰当的时候。这意味着你需要24x7随时准备记录任何灵感和想法

    L模式是令人信服的思考方式,当我们采用L模式去处理问题的时候,内心将涌出来自于类似自然科学客观规律的力量源泉。而R模式却常常被我们忽略或者轻视,因为你无法从讲道理的角度来阐述你通过R模式所带来的收益之处。也因此,忽视R模式,说不上来有什么坏处,却也的的确确因之丧失了很多其它方面的能力。
    我本人是一个R模式的青睐者,也希望以此感染所有阅读本文的读者们。即便现实很残酷,我也坚信着世界很美好,坚信着努力可以克服一切困难障碍,可以划破漆黑的天空,找到属于你自己的光芒!

    吸引力更有效:一些研究都表明具有吸引力的用户界面要比不具吸引力的界面更易于使用。

    颇为赞同这一点,因为记录下这段话的此时此刻,我正在使用一款名为马克飞象的Markdown编辑器,与之类似的是我前段时间经常用的MarkdownPad,下面来比较两者的操作界面:
    比较
    我们可以看出,同样的文本同样的编辑器,两者的区别仅仅在于编辑界面的“炫酷”程度,但是这却让我大大加深了对后者的喜爱,并毫不犹豫地购买了1年的VIP使用权(前者则是免费版)。

    展开全文
  • 程序员必修--sql思维举重训练

    万次阅读 多人点赞 2012-05-20 13:57:52
    思维举重前,先来一个热身运动吧: --(一)查询选修课程名称为'JAVA程序设计'的学员学号和姓名 --方法一: --1.查询'JAVA程序设计'这门课程的课程号 --2.在成绩表中查询课程号为步骤1的课程号的成绩信息.. --3.在...

        写sql是程序员基本功课,找工作面试一般必有sql题,实际工作中对sql的需求更是千变万化,所以掌握好sql对于一个程序员来说是件非常重要的事情.本文通过一个简单易懂的关系(学生/课程/成绩关系)尽量构造出各种各样的需求来提高我们写sql的功底,其中有些sql还是有一些难度的,大多数sql我都给出了思考思路,希望本人N天的劳动成果对您有所帮助.

        限于本人水平有限,有些地方的sql写的并不完美,希望大家不吝赐教.最后提一点小小的要求,希望大家对本文积极进行评论,大家的评论是我改进和提高的动力,我希望在和大家的交流中得到提高.

    表关系:



    建表和初始化sql(本例子使用oralce数据库):

    --创建表
    create table T_STUDENT(sno NUMBER not null,  sname VARCHAR2(30),  sdree VARCHAR2(50),  sage  NUMBER,  ssex  CHAR(2));
    alter table T_STUDENT add primary key (SNO);
    create table T_SCORE(sno   NUMBER,  cno   NUMBER,  grade NUMBER(4,1), tno NUMBER,  id NUMBER not null);
    alter table T_SCORE add primary key (ID);
    create table T_COURSE(cno NUMBER not null,  cname VARCHAR2(30));
    alter table T_COURSE add primary key (CNO);
    
    --初始化学生表
    insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (1, '李坤', '天融信', 26, '男');
    insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (2, '曹贵生', '中银', 26, '男');
    insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (3, '柳波', '买卖宝', 27, '男');
    insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (4, '纪争光', 'IBM', 23, '男');
    insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (5, '李学宇', '微软', 25, '女');
    insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (6, '李雪琪', '文思创新', 25, '女');
    insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (7, '陈绪', '中海油', 26, '男');
    insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (8, '韩正阳', '中海油', 24, '男');
    insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (9, '陈伟东', '中核', 24, '男');
    insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (10, '刘兵', '优酷', 24, '男');
    insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (11, '丁成云', '联想', 25, '女');
    insert into T_STUDENT (SNO, SNAME, SDREE, SAGE, SSEX) values (12, '王鹏', '中兴', 25, '男');
    commit;
    
    --初始化课程表
    insert into T_COURSE (CNO, CNAME) values (1, 'JAVA程序设计');
    insert into T_COURSE (CNO, CNAME) values (2, 'ORACLE开发');
    insert into T_COURSE (CNO, CNAME) values (3, 'C++程序设计');
    insert into T_COURSE (CNO, CNAME) values (4, 'C#程序设计');
    insert into T_COURSE (CNO, CNAME) values (5, 'Windows实战');
    insert into T_COURSE (CNO, CNAME) values (6, 'Center OS教程');
    insert into T_COURSE (CNO, CNAME) values (7, 'Jsp/Servlet开发');
    insert into T_COURSE (CNO, CNAME) values (8, 'J2EE从入门到精通');
    insert into T_COURSE (CNO, CNAME) values (9, 'EJB及设计模式');
    insert into T_COURSE (CNO, CNAME) values (10, 'Javascript/jQuery实战');
    insert into T_COURSE (CNO, CNAME) values (11, 'Flash设计');
    insert into T_COURSE (CNO, CNAME) values (12, 'HTML/CSS/JAVASCRIPT实战');
    insert into T_COURSE (CNO, CNAME) values (13, '精通ASP.NET');
    insert into T_COURSE (CNO, CNAME) values (14, 'JBoss入门');
    insert into T_COURSE (CNO, CNAME) values (15, 'Spring开发');
    commit;
    
    --初始化成绩表
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (1, 2, 90.0, 2, 1);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (1, 3, 80.0, 3, 2);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (1, 4, 90.0, 4, 3);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 2, 70.0, 2, 4);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (2, 11, 66.0, 11, 5);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (2, 15, 77.0, 15, 6);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (2, 8, 87.0, 8, 7);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (2, 6, 96.0, 6, 8);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (3, 2, 89.0, 2, 9);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (3, 1, 91.0, 1, 10);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (4, 2, 83.0, 2, 11);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (5, 4, 73.0, 4, 12);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (5, 1, 60.0, 1, 13);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (5, 8, 82.0, 8, 14);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (6, 8, 90.5, 10, 15);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (8, 2, 58.0, 2, 16);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 3, 80.0, 3, 17);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (9, 11, 65.0, 11, 18);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (9, 12, 67.0, 12, 19);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (9, 15, 95.0, 15, 20);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (9, 13, 59.0, 13, 21);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (10, 4, 98.0, 4, 22);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (10, 6, 97.0, 6, 23);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (10, 7, 96.0, 7, 24);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 7, 95.0, 7, 25);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (12, 8, 69.0, 8, 26);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (12, 9, 85.0, 9, 27);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (10, 14, 100.0, 14, 28);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (6, 9, 100.0, 9, 29);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 1, 59.0, 1, 30);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 4, 90.0, 4, 31);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 5, 91.0, 5, 32);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 6, 58.0, 6, 33);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 8, 93.0, 8, 34);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 9, 57.0, 9, 35);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 10, 95.0, 10, 36);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 11, 96.0, 11, 37);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 12, 97.0, 12, 38);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 13, 98.0, 13, 39);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 14, 99.0, 14, 40);
    insert into T_SCORE (SNO, CNO, GRADE, TNO, ID) values (11, 15, 89.0, 15, 41);
    commit;
    
    
    在思维举重前,先来一个热身运动吧:
    --(一)查询选修课程名称为'JAVA程序设计'的学员学号和姓名 
    --方法一:
    --1.查询'JAVA程序设计'这门课程的课程号
    --2.在成绩表中查询课程号为步骤1的课程号的成绩信息..
    --3.在学生表中查询学号为步骤2结果的学生信息
    select st.sno, st.sname
      from student st
     where st.sno in
           (select sno
              from score sc
             where sc.cno =
                   (select co.cno from course co where co.cname = 'JAVA程序设计'));
    
    --方法二:
    --1.查询'JAVA程序设计'这门课程的课程号
    --2.在成绩表和学生表关联结果中查询课程号等于步骤1的课程号的成绩信息.
    --sql86
    select st.sno, st.sname
      from student st, score sc
     where st.sno = sc.sno
       and sc.cno =
           (select co.cno from course co where co.cname = 'JAVA程序设计');
           
    --sql92
    select st.sno, st.sname
      from student st
      join score sc
        on st.sno = sc.sno
     where sc.cno =
           (select co.cno from course co where co.cname = 'JAVA程序设计');
           
    --方法三:
    --1.在成绩表和课程表关联结果中查询选修了'JAVA程序设计'这门课的学生的学号
    --2.在学生表中查询步骤1中的学号的学生的详细信息.
    --sql86
    select st.sno, st.sname
      from student st
     where st.sno in (select sc.sno
                             from score sc, course co
                            where sc.cno = co.cno
                              and co.cname = 'JAVA程序设计');
     
    --sql92 
     select st.sno, st.sname
       from student st
      where st.sno in (select sc.sno
                              from score sc
                              join course co
                                on sc.cno = co.cno  
                          where co.cname = 'JAVA程序设计');
                          
     --方法四:                     
     --在成绩表和课程表和学生表三表关联的结果中过滤得到选修了 'JAVA程序设计'的学生基本信息   
     --sql86
      select st.sno, st.sname
       from student st, score sc, course co
      where st.sno = sc.sno
        and co.cno = sc.cno
        and co.cname = 'JAVA程序设计';
                 
     --sql92(1) 用where过滤
     select st.sno, st.sname
      from student st
      join score sc
        on st.sno = sc.sno
      join course co
        on co.cno = sc.cno
     where co.cname = 'JAVA程序设计';
    
    --sql92(2) 在关联条件中过滤
     select st.sno, st.sname
       from student st
       join score sc
         on st.sno = sc.sno
       join course co
         on co.cno = sc.cno
        and co.cname = 'JAVA程序设计';
     
    注: 1.对于sql86 和sql92的区别见这篇文章: http://blog.csdn.net/lk_blog/article/details/7580300
        2.如果您在看的过程中觉得不熟悉的地方很多,建议您先看此文: http://blog.csdn.net/lk_blog/article/details/7585501

    进入正文:

    --(一)查询不选修课程编号为'1'的学员姓名和所属单位 
    --1.在成绩表中查询课程号为'1'的所有学生学号
    --2.在学生表中查询学号不在步骤1中的学生的基本信息.
    select st.sname, st.sdree
      from t_student st
     where st.sno not in (select sc.sno from t_score sc where sc.cno = '1');
     
     
     --(二)查询平均成绩大于85的所有学生的学号、姓名和平均成绩?
     select sc.sno, st.sname, avg(sc.grade)
       from t_score sc
       join t_student st
         on sc.sno = st.sno
      group by sc.sno, st.sname
     having avg(sc.grade) > 85; 
     
     --(三)查询课程名称为"JAVA程序设计",且分数低于60的学生姓名和分数
    select st.sname, sc.grade
      from t_score sc
      join t_student st
        on sc.sno = st.sno
      join t_course co
        on sc.cno = co.cno
     where sc.grade < 60
       and co.cname = 'JAVA程序设计';
        
     select st.sname, sc.grade
       from t_score sc
       join t_student st
         on sc.sno = st.sno
       join t_course co
         on sc.cno = co.cno
        and sc.grade < 60
        and co.cname = 'JAVA程序设计' ;
         
    select st.sname, sc.grade
      from t_score sc
      join t_student st
        on sc.sno = st.sno
     where sc.cno = (select cno from t_course where cname = 'JAVA程序设计')
       and sc.grade < 60
       
    
    --(四)查询任何一门课程成绩全部都在70分以上的姓名、课程名称和分数?
    --1.查询出成绩小于70分的学生的学号.
    --2.将学生,成绩,课程三张表作关联.
    --3.在关联表中过滤出不在步骤1查询结果中的学生信息.
    select st.sname, co.cname, sc.grade
      from t_student st
      join t_score sc
        on st.sno = sc.sno
      join t_course co
        on sc.cno = co.cno
     where st.sno not in (select sc1.sno from t_score sc1 where sc1.grade < 70);
     
     
    --(五)查询出选了课的学生的人数.
    select count(distinct(sc.sno)) from t_score sc;
    
    
    --(六)查询每门课程被选课的学生数
    select sc.cno, count(distinct(sc.sno)) from t_score sc group by sc.cno;
    
                 
    --(七)查询选了全部课程的学员姓名和所属单位
    --1.在课程表中查询出所有课程的数量
    --2.在成绩表中查询出学生选课数等于步骤1中总选课数的学生的学号,注意要用distinct,having中可以使用count,where中不能使用count.
    --3.在学生表中查出步骤2中学生的基本信息.
    select st.sname, st.sdree
      from t_student st
     where st.sno in
           (select sc.sno
              from t_score sc
             group by sc.sno
            having count(distinct sc.cno) = (select count(distinct sc1.cno)
                                              from t_course sc1));
                                              
                                                                                           
    --(八) 查询没有学全所有课的同学的学号、姓名
    select st.sname, st.sdree
      from t_student st
     where st.sno in
           (select sc.sno
              from t_score sc
             group by sc.sno
            having count(distinct sc.cno) != (select count(*) from t_course));
     
            
    --(九)查询选修课程超过5门的学员学号和所属单位 
    --1.在成绩表中查询出选课程超过5门的学生学号.
    --2.在学生表中查询步骤1中学号的学生的基本信息.
    select st.sname, st.sdree
      from t_student st
     where st.sno in (select sc.sno
                             from t_score sc
                            group by sc.sno
                           having count(distinct sc.cno) > 5);
                                                 
                                                                                    
    --(十)查询出没有选课的学生基本信息
    --1.在成绩表中查询出所有选过课的学生的学号.
    --2.在学生表中查询出步骤1中学生的基本信息.
    select *
      from t_student st
     where st.sno not in (select sc.sno from t_score sc);
    
    --下面的两个sql等价,在成绩表中数据量很大时使用下面的sql
    select *
      from t_student st
     where st.sno not in (select distinct (sc.sno) from t_score sc);
     
    select *
      from t_student st
     where st.sno not in (select sc.sno from t_score sc group by sc.sno);
    
                                                    
    --(十一) 列出有二门以上不及格课程的学生姓名及其平均成绩 
    --方法一
    --1.在成绩表中查询出2门不及格学生的学号,结果记作t1
    --2.将学生表和t1和成绩表三表作关联得到关联表,在关联表中取学生基本信息和平均成绩.
    --sql92   
    select st.sno, st.sname, avg(sc.grade)
      from t_student st
      join (select sc.sno
              from t_score sc
             where sc.grade < 60
             group by sc.sno
            having count(distinct sc.cno) > 2) t1
        on st.sno = t1.sno
      join t_score sc
        on sc.sno = t1.sno
     group by st.sno, st.sname;
     
     --sql86
    select st.sno, st.sname, avg(sc.grade)
      from t_student st,
           t_score sc,
           (select sc.sno
              from t_score sc
             where sc.grade < 60
             group by sc.sno
            having count(distinct sc.cno) > 2) t1
     where st.sno = t1.sno
       and sc.sno = t1.sno
     group by st.sno, st.sname;
    
    --方法二:
    --1.在成绩表中查询出2门不及格学生的学号
    --2.将学生表和成绩表通过学号作关联并根据步骤1中的结果作过滤,在关联结果中取出学生基本信息和平均成绩                     
    select st.sno, st.sname, avg(sc.grade)
      from t_student st
      join t_score sc
        on st.sno = sc.sno
     where st.sno in (select sc.sno
                        from t_score sc
                       where sc.grade < 60
                       group by sc.sno
                      having count(distinct sc.cno) > 2)
     group by st.sno, st.sname;
    
     
     --(十二) 查询平均成绩大于60分的同学的学号和平均成绩
    --学生表和课程表关联,在having子句中过滤平均成绩大于60分.
    select st.sno, avg(sc.grade)
      from t_student st, t_score sc
     where st.sno = sc.sno
     group by st.sno
    having avg(sc.grade) > 60;
    
    --1.学生表和课程表关联,将关联的结果记作t1
    --2.在t1中过滤平均成绩大于60的学生学号.
    select t1.sno, t1.avg_grade
      from (select st.sno, avg(sc.grade) avg_grade
              from t_student st, t_score sc
             where st.sno = sc.sno
             group by st.sno) t1
     where t1.avg_grade > 60;
     
     
    --(十三)查询出只选修了一门课程的全部学生的学号和姓名
     --方法一:
     --1.将学生表和成绩表作关联,在分组函数中使用having子句过滤出只选了一门课程的学生基本信息.
     select sc.sno, st.sname
       from t_score sc
       join t_student st
         on sc.sno = st.sno
      group by sc.sno, st.sname
     having count(distinct sc.cno) = 1;
     
     --方法二:
     --1.在成绩表中查找学号,分组函数的过滤条件判断只选择了一门课程的学生.
     --2.在学生表中查找学号在步骤1中的值的学生的基本信息
    select st.sno,st.sname
      from t_student st
     where st.sno in (select sc.sno
                        from t_score sc
                       group by sc.sno
                      having count(distinct sc.cno) = 1);
                      
     
                      
     --(十四)查询至少有一门课与学号为"1"的同学所学相同的同学的学号和姓名
    select st.sno, st.sname
      from t_student st
      join t_score sc1
        on st.sno = sc1.sno
     where sc1.cno in (select sc.cno from t_score sc where sc.sno = '1')
     group by st.sno, st.sname;
    
    
    
    --(十五)列出既学过"1"号课程,又学过"2"号课程的所有学生姓名
    --1.将成绩表和课程表作关联,在关联条件中作过滤查询出既选过课程'1'又选过课程'2'的学生的学号,注意看 co.cno in ('1', '2')和having count(distinct sc.cno) = 2 的位置.
    --2.在学生表中根据步骤1的结果作过滤查询出学生的基本信息.
    --方法一:
    --sql86
    select st.sno, st.sname
      from t_student st,
           (select sc.sno
              from t_score sc, t_course co
             where sc.cno = co.cno
               and co.cno in ('1', '2')
             group by sc.sno
            having count(distinct sc.cno) = 2) t1
     where st.sno = t1.sno;
     
     --sql92
     select st.sno, st.sname
      from t_student st join 
           (select sc.sno
              from t_score sc join t_course co
             on sc.cno = co.cno
               and co.cno in ('1', '2')
             group by sc.sno
            having count(distinct sc.cno) = 2) t1
     on st.sno = t1.sno;
     
     --方法二:
     --sql86
     select st.sno, st.sname
       from t_student st
      where st.sno in (select sc.sno
                         from t_score sc, t_course co
                        where sc.cno = co.cno
                          and co.cno in ('1', '2')
                        group by sc.sno
                       having count(distinct sc.cno) = 2);
     
    --sql92 
      select st.sno, st.sname
        from t_student st
       where st.sno in (select sc.sno
                          from t_score sc
                          join t_course co
                            on sc.cno = co.cno
                           and co.cno in ('1', '2')
                         group by sc.sno
                        having count(distinct sc.cno) = 2);
     
     
     
     --(十六)查询至少学过学号为"1"的同学所有门课的同学学号和姓名
     --1.查询出'1'号同学学习的全部课程.
     --2.查询出'1'号同学学习全部课程的数量.
     --3.将课程表和成绩表做关联,在关联表中查询出学生的学号,关联条件中加入过滤条件[课程号在步骤1查询结果范围内],过滤条件中加入数量等级步骤2中得到的数量.
     --4.在学生表中查询步骤3中的学号的学生的基本信息.
    select st.sno, st.sname
      from t_student st
     where st.sno in
           (select sc.sno
              from t_score sc
              join t_course co
                on sc.cno = co.cno
               and co.cno in (select sc.cno from t_score sc where sc.sno = '1')
             group by sc.sno
            having count(distinct sc.cno) = (select count(distinct sc.cno)
                                              from t_score sc
                                             where sc.sno = '1'))
                                             
      
                                             
     --(十七)查询和"6"号同学学习的课程完全相同的同学的学号和姓名
     --分析:要查询与6号同学完全相同的课程的学生信息,等价于学过6号同学的学过的所有课程并且选课数量与6同学选课数量相等.
     --方法一: 
     --1.查询出'1'号同学学习的全部课程.
     --2.查询出'1'号同学学习全部课程的数量.
     --3.将课程表和成绩表做关联,在关联表中查询出学生的学号和选课数量,记作 t2,关联条件中加入过滤条件[课程号在步骤1查询结果范围内],过滤条件中加入数量等级步骤2中得到的数量.
     --4.在成绩表中查询出学号和每个学生选课数量.得到结果记作: t1
     --5.将步骤3中的t2和步骤4中的t1通过学生学号关联,添加过滤条件,t1中的选课数量等于t2中的选课数量.
     --6.在学生表中查询不步骤5的学生学号的基本信息.
     select st.sno, st.sname
       from t_student st
      where st.sno in
            (select t1.sno
               from (select sc_a.sno, count(distinct sc_a.cno) num_outer
                       from t_score sc_a
                      group by sc_a.sno) t1
               join (select sc.sno, count(distinct sc.cno) num_inner
                      from t_score sc
                      join t_course co
                        on sc.cno = co.cno
                       and co.cno in
                           (select sc.cno from t_score sc where sc.sno = '6')
                     group by sc.sno
                    having count(distinct sc.cno) = (select count(distinct sc.cno)
                                                      from t_score sc
                                                     where sc.sno = '6')) t2
                 on t1.sno = t2.sno
              where t1.num_outer = t2.num_inner);
              
      
              
     --(十八)列出"1"号课成绩比"2"号课成绩高的所有学生的学号及其"1"号课和"2"号课的成绩
     --1.将学生表和课程表作两次关联,一次关联用于取该学生课程'1'的成绩,另一次关联用于取该学生课程'2'的成绩.
     --sql86
    select st.sno, st.sname, sc_a.grade, sc_b.grade
      from t_student st, t_score sc_a, t_score sc_b
     where sc_a.cno = '1'
       and sc_b.cno = '2'
       and st.sno = sc_a.sno
       and st.sno = sc_b.sno
       and sc_a.grade > sc_b.grade
       
     --sql92
    select st.sno, st.sname, sc_a.grade, sc_b.grade
      from t_student st
      join t_score sc_a
        on st.sno = sc_a.sno
      join t_score sc_b
        on st.sno = sc_b.sno
     where sc_a.cno = '1'
       and sc_b.cno = '2'
       and sc_a.grade > sc_b.grade
       
    
    
    --(十九)查询所有同学的学号、姓名、选课数、总成绩
    select st.sno, st.sname, count(sc.cno), sum(sc.grade)
      from t_student st, t_score sc
     where st.sno = sc.sno
     group by st.sno, st.sname;
    
    
    
    --(二十)查询课程成绩小于60分的同学的学号,姓名,课程名,成绩
    --下面两条sql虽然结果相同,但意义不同,注意理解一下哦.
    --1.将学生表,课程表,成绩表作关联
    --2.对关联后的结果作过滤,过滤出成绩小于60的学生基本信息.
    select st.sno, st.sname, co.cname, sc.grade
      from t_score sc
      join t_student st
        on sc.sno = st.sno
      join t_course co
        on sc.cno = co.cno
     where sc.grade < 60
    
    --1.将学生表,课程表,成绩表作关联,在关联条件中过滤成绩小于60.
     select st.sno, st.sname, co.cname, sc.grade
      from t_score sc
      join t_student st
        on sc.sno = st.sno
      join t_course co
        on sc.cno = co.cno
    and sc.grade <60
    
    
    
    --(二十一)按平均成绩从到低显示所有学生的"JAVA程序设计"、"J2EE从入门到精通"、"EJB及设计模式"三门的课程成绩,
    --并按如下形式显示: 学生ID,姓名,JAVA程序设计,J2EE从入门到精通,EJB及设计模式,有效课程数,有效课程平均分
    --1.将成绩表和课程表关联得到结果记作: t1, 关联时的条件选择只统计以上三门课程.
    --2.按题目中的要求组织统计结果.
    select st.sno,
           st.sname,
           sum(decode(t1.cname, 'JAVA程序设计', t1.grade)) JAVA程序设计,
           sum(decode(t1.cname, 'J2EE从入门到精通', t1.grade)) J2EE从入门到精通,
           sum(decode(t1.cname, 'EJB及设计模式', t1.grade)) EJB及设计模式,
           count(distinct t1.grade) 有效课程数,
           avg(t1.grade) 有效课程平均分
      from t_student st
      join (select *
              from t_score sc
              join t_course co
                on sc.cno = co.cno
               and co.cname in
                   ('JAVA程序设计', 'J2EE从入门到精通', 'EJB及设计模式')) t1
        on st.sno = t1.sno
     group by st.sno, st.sname
       
     --将decode可以换成case when 第一种形式
     select st.sno,
            st.sname,
            sum(case t1.cname
                  when 'JAVA程序设计' then
                   t1.grade
                end) JAVA程序设计,
             sum(case t1.cname
                  when 'J2EE从入门到精通' then
                   t1.grade
                end) J2EE从入门到精通,
                 sum(case t1.cname
                  when 'EJB及设计模式' then
                   t1.grade
                end) EJB及设计模式,
            count(distinct t1.grade) 有效课程数,
            avg(t1.grade) 有效课程平均分
       from t_student st
       join (select *
               from t_score sc
               join t_course co
                 on sc.cno = co.cno
                and co.cname in
                    ('JAVA程序设计', 'J2EE从入门到精通', 'EJB及设计模式')) t1
         on st.sno = t1.sno
      group by st.sno, st.sname
      
      
     --将decode可以换成case when 第二种形式
      select st.sno,
             st.sname,
             sum(case
                   when t1.cname = 'JAVA程序设计' then
                    t1.grade
                 end) JAVA程序设计,
             sum(case
                   when t1.cname = 'J2EE从入门到精通' then
                    t1.grade
                 end) J2EE从入门到精通,
             sum(case
                   when t1.cname = 'EJB及设计模式' then
                    t1.grade
                 end) EJB及设计模式,
             count(distinct t1.grade) 有效课程数,
             avg(t1.grade) 有效课程平均分
        from t_student st
        join (select *
                from t_score sc
                join t_course co
                  on sc.cno = co.cno
                 and co.cname in
                     ('JAVA程序设计', 'J2EE从入门到精通', 'EJB及设计模式')) t1
          on st.sno = t1.sno
       group by st.sno, st.sname
     
     
    --(二十二)查询各科成绩最高和最低的分:以如下形式显示:课程ID,课程名,最高分,最低分
    select sc.cno, co.cname, max(grade), min(grade)
      from t_score sc
      join t_course co
        on sc.cno = co.cno
     group by sc.cno, co.cname
    
    
    --(二十三)按各科平均成绩从低到高和及格率的百分数从高到低顺序 
    --1.在成绩表中查出课程号,平均成绩,课程人数,记作 : t1
    --2.在成绩表中查出课程号,及格的课程人数,记作 : t2
    --3.将步骤1中的成绩和步骤2中的课程2关联,查出所要的结果并排序.
    select t1.cno, t1.avg_num 平均成绩, (count_num1 / count_num) * 100 及格率
      from (select sc.cno, avg(grade) avg_num, count(distinct sc.sno) count_num
              from t_score sc
             group by sc.cno) t1
      join (select sc1.cno, count(distinct sc1.sno) count_num1
              from t_score sc1
             where sc1.grade > 60
             group by sc1.cno) t2
        on t1.cno = t2.cno
     order by t1.avg_num asc, 及格率 desc
     
     
    --(二十四)统计各科成绩,各分数段人数:课程ID,课程名称,[100-90]优,[90-80]良,[80-70]中,[70-60]一般,[<60]不及格
    --1.在成绩表中根据成绩值分段
    --2.将步骤1中的结果与课程表关联.
    select sc.cno,co.cname,
           sum(case
                 when sc.grade > 90 then
                  1
               end) 优,
           sum(case
                 when sc.grade > 80 and sc.grade < 90 then
                  1
               end) 良,
           sum(case
                 when sc.grade > 70 and sc.grade < 80 then
                  1
               end) 中,
           sum(case
                 when sc.grade > 60 and sc.grade < 70 then
                  1
               end) 一般,
           sum(case
                 when sc.grade < 60 then
                  1
               end) 不及格
      from t_score sc join t_course co on sc.cno = co.cno
     group by sc.cno,co.cname
    
    --(二十五)查询学生平均成绩及其名次
    select st.sno, st.sname, avg(sc.grade) avg_num
      from t_score sc
      join t_student st
        on sc.sno = st.sno
     group by st.sno, st.sname
     order by avg_num desc
    
    
    
    --(二十六)查询课程号分别为1,2,3的课程,成绩前三名的学生基本信息:(不考虑成绩并列情况)
    --方法一:
    --1.分别查出1,2,3各自的前3名的学生的学号,并用union all将结果集关联.
    --2.在学生表中查询步骤1中查到的id的学生的基本信息.
    select *
      from t_student
     where sno in (select t1.sno
                     from (select sc1.*
                             from t_score sc1
                            where sc1.cno = 1
                            order by sc1.grade desc) t1
                    where rownum < 4
                   union all
                   select t1.sno
                     from (select sc1.*
                             from t_score sc1
                            where sc1.cno = 2
                            order by sc1.grade desc) t1
                    where rownum < 4
                   union all
                   select t1.sno
                     from (select sc1.*
                             from t_score sc1
                            where sc1.cno = 3
                            order by sc1.grade desc) t1
                    where rownum < 4)
    
    --方法二:
     --rank() over(Partition .. order by ...) 是按照某个字段的值进行分组并编号
    select t1.cno, t1.sno, t1.grade, r
      from (select sc.sno,
                   sc.cno,
                   sc.grade,
                   rank() over(partition by sc.cno order by grade desc) r
              from t_score sc) t1
     where r < 4
       and t1.cno in (1, 2, 3)
     order by t1.cno, t1.sno, r;
    
    
     --(二十七)查询各科成绩前三名的记录(不考虑成绩并列情况)
     --rank() over(Partition .. order by ...) 是按照某个字段的值进行分组并编号
    select t1.cno, t1.sno, t1.grade, r
      from (select sc.sno,
                   sc.cno,
                   sc.grade,
                   rank() over(partition by sc.cno order by grade desc) r
              from t_score sc) t1
     where r < 4
     order by t1.cno, t1.sno, r;
      
    


     

     

    展开全文
  • 大家好,我们每周一次的数独又来了。本期,我们会介绍唯余解法:唯余解法的原理十分简单,但是在实际的解题中,非常不容易辨认。由于唯余解非常不容易辨认,所以一般的报章杂志及较大众化的数独网站,通常会将需要...
  • 讲师:邱岳 1. 运营是做什么的 运转·经营. 产品经理经常拆房子、盖新房子。经营是要持续经营一个产品。 CEO、COO(Apple 的Tim Cook以前就是)、CTO、CFO、CIO… 运营其实是个容量很大的工种 运营不是【打杂的】,但...
  • 高清好分享:思维导图训练营 30天重构思维模型(有需要的找我,你就可以低价拥有这个课程)我有这个课程,如果你也有需要,欢迎联系我,一起学习一起进步。更有海量学习资源与你分享!每周更新100多门课程,全网精品...
  • 创造思维方法训练

    2018-11-10 09:42:49
    《创造思维方法训练(第2版)》不同于普通的教科书...为了改变这种状况,作者尝试做了一项教学改革试验,在一所学校开设创造思维方法,结果收到了意想不到的效果,而《创造思维方法训练》就是创造思维方法课程的结晶。
  • 写sql是程序员基本功课,找工作面试一般必有sql题,实际工作中对sql的需求更是千变万化,所以掌握好sql对于一个程序员来说是件非常重要的事情.本文通过一个简单易懂的关系(学生/课程/成绩关系)尽量构造出各种各样的需求...
  • 材料力学课程是工科土木、机械类专业重要的技术基础,也是其他相关专业的重要课程。为使学生掌握这门课程的基础知识、基本理论和方法,在总结多年材料力学课程教学实践的基础上,编写了本书。为便于学习,书末附有...
  • 1、我为什么要学习这门?AI时代来临,Python从众多编程语言中脱颖而出,各种人工智能算法大都基于Python编写,在人工智能领域内的机器学习、神经网络、深度学习等应用开发,Python都是主流的编程语言。Python简单...
  • 《程序员的思维修炼:开发认知潜能的九堂》 从程序员的角度去认清自己,思考问题,了解我们的大脑,进而发掘潜能。 作者是亨特(Andy Hunt),他曾经写过《程序员修炼之道——从小工到专家》,《高效程序员的45个习惯...
  • 大家好,欢迎和我们一起学习《SPSS软件应用与统计思维。统计对于你,是新朋友还是老朋友呢,或者根本算不上朋友?的确,有许多同学,尤其是我身边一些学医的小伙伴儿们,没有经过系统的数学训练,可能基本的微...
  • ----------------------------------------------------第一排--------------------------------------------------------------------------看了这本书,我决定细细研读,按照上面的九堂,慢慢提高自己...
  • 编程思维是什么编程是编定程序的简称。成年人的编程,就是让计算机代为解决某个问题。用编程语言写一套计算机能读懂的运算方式,然后计算机按照这个方式运行,得到相应的结果。而对于小学低年级的小朋友来说,让他们...
  • 昨天终于写完了,休息一下,今天又来更新~~ 中文系里的课程也有比较科学的,我觉得现代汉语是所有中文系必修课程中最科学的。上学期讲完语音后,这学期进入了语法部分。我一直想写一点与语言学相关的东西,骗些...
  • 首先,一定要纠正自己的惯性思维。 不要老是认为只有最后一行的m&lt;=20,,,最后一行不是100%,难道不是全部数据吗???黑人问号脸,所以我前一个小时各种字符串,各种字符数组到底在干嘛??? 行吧,...
  • ##本教程使用的课本是《Python编程:从入门到实践》,作者:[美] Eric Matthes学完前面十二节,已完成Python编程入门了,我们已经能编写组织有序而易于使用的Python程序了。接来下继续学习更多应用操作,比如文件...
  • 架构师训练营会讲啥? 第一还没开始之前,笔者猜会是从全局视角先整体概括。比如提供一个思维导图,涉及到的全部课程内容。类似演讲的总-- 分 – 总。 讲课老师 – 李智慧 1. 看书、上课等学习第一的门道 读书的...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 243
精华内容 97
关键字:

思维训练课