[05-27] MySQL5.7.14下载安装及MySQL语句入门详解 
 [05-27] MySQL SQL语句对字段重命名的介绍 
 [05-26] mysql 半小时平均值计算的sql语句的心得体会 
 [05-25] MySQL 开启执行过的SQL语句的介绍 
 [05-25] MySQL常用SQL语句的介绍 
 [05-25] MySQL 存储过程执行动态SQL语句详解 
 [05-23] MySql 常用操作的SQL语句的介绍 
 [05-22] mysql语句插入多条数据的方法 
 [05-21] 远程用户访问mysql服务sql语句的心得体会 
 [05-21] MySQL 存储过程执行动态SQL语句的介绍 
 [05-20] MySQL复制表结构、内容到另一张表的SQL语句的介绍 
 [05-20] mysql 查询今天、昨天、近7天、近30天、本月、上一月的SQL语句的介绍 
 [05-20] mysql 获取一天、一周、一月时间的sql语句的方法 
 [05-19] mysql把一个表某字段复制到另一张表的某个字段的SQL语句的方法 
 [05-17] MySQL SQL语句优化的介绍 
 [05-10] mysql通过查看跟踪日志跟踪执行的sql语句的方法 
 [05-10] mysql语句运行时间的查看方法 
 [05-10] mysql建表常用sql语句的介绍 
 [05-10] MySQL字段自增自减的SQL语句的推荐 
 [05-04] SQL语句行列转换的两种方法 case...when与pivot函数的介绍 
 [05-04] SQL语句语法汇总的推荐 
 [05-04] sql语句like的用法的介绍 
 [05-04] MySQL查询数据库占用磁盘大小、单个库所有表的大小的sql语句 
 [05-02] sql语句left_join、inner_join中的on与where的区别介绍 
 [05-02] MySql 获取某字段存在哪个表的sql语句的介绍 
 [04-29] SQL语句Replace INTO与INSERT INTO不同的介绍 
 [04-29] 数据库字段分组显示数据的sql语句的介绍 
 [04-29] MySQL批量删除指定前缀表的sql语句的推荐 
 [04-29] MySQL优化sql语句查询常用30种方法的推荐 
 [04-25] MySQL 查询当前正在运行的SQL语句 
 [04-19] sql语句的常用语法 
 [04-19] PHP+Mysql常用SQL语句 
 [04-05] 将数字标识转为汉字展示的sql语句 
 [04-05] 数据表字段删除、添加的SQL语句 
 [04-05] sql批量修改字段值的方法_sql语句修改字段值 
 [03-03] mysql 实现查看表结构的SQL语句 
 [03-03] mysql 获取当前日期周一和周日的SQL语句 
 [03-03] mysql 实现按年度、季度、月度、周、日查询的SQL语句 
 [12-16] MySQL数据库操作实现的6条SQL语句 
 [12-16] 将blob的char取出来并转成数字保存在其它字段的sql语句 
 [12-16] mysql常用SQL语句小结 
 [10-24] mySQL使用Explain检查测Sql语句执行效率 
 [10-24] mysql查询当天,昨天,近7天,近30天,本月,上一月数据的SQL语句 
 [10-18] mysql使用SQL语句导入大数据文件 
 [10-08] 备份、还原数据库的SQL语句 
 [10-08] mysql实现存在记录则更新，不存在则插入sql语句 
 [10-08] mysql 实现获取当天发布信息的SQL语句 
 [10-08] SQL语句快速入门 
 [09-28] MySQL实现查询价格最高的几种SQL语句示例 
 [09-28] mysql数据库常用SQL语句 
 
 
 
 来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/29532788/viewspace-2140011/，如需转载，请注明出处，否则将追究法律责任。 
 
 
转载于:http://blog.itpub.net/29532788/viewspace-2140011/

 
 
目录
 
​
 
SQL基础知识整理:
 
常见的SQL面试题：经典50题
 
三、50道面试题
 
 
 
2.汇总统计分组分析
 
3.复杂查询
 
sql面试题：topN问题
 
4.多表查询
 
【面试题类型总结】这类题目属于行列如何互换，解题思路如下：
 
其他面试题:
 


 
SQL基础知识整理:
 
 
 
select 查询结果    如: [学号,平均成绩：组函数avg(成绩)]
from 从哪张表中查找数据   如:[涉及到成绩：成绩表score]
where 查询条件    如:[b.课程号='0003' and b.成绩>80]
group by 分组    如:[每个学生的平均：按学号分组](oracle,SQL server中出现在select 子句后的非分组函数，必须出现                                                                                        在group by子句后出现),MySQL中可以不用
having 对分组结果指定条件    如:[大于60分]
order by 对查询结果排序    如:[增序: 成绩  ASC / 降序: 成绩 DESC];
 
 
limit   使用limt子句返回topN（对应这个问题返回的成绩前两名）如:[ limit  2 ==>从0索引开始读取2个]
 limit==>从0索引开始 [0,N-1]
 
 
① select * from table limit 2,1;                

//含义是跳过2条取出1条数据，limit后面是从第2条开始读，读取1条信息，即读取第3条数据

② select * from table limit 2 offset 1;     

//含义是从第1条（不包括）数据开始取出2条数据，limit后面跟的是2条数据，offset后面是从第1条开始读取，即读取第2,3条
 
 
 
 
 
组函数: 去重 distinct()  统计总数sum()   计算个数count()  平均数avg()  最大值max() 最小数min()  
 
 
多表连接: 内连接(省略默认inner) join ...on..左连接left join tableName as b on a.key ==b.key右连接right join  连接union(无重复(过滤去重))和union all(有重复[不过滤去重])
 
 
 
 
--union 并集
 --union all(有重复)
 oracle(SQL server)数据库
 
 
--intersect 交集 
 --minus(except) 相减(差集)
 
 
 
 
 
oracle
 
 
一、数据库对象： 表(table)  视图(view)  序列(sequence)  索引(index)  同义词(synonym)
 
 
1. 视图: 存储起来的 select 语句
create view emp_vw
as
 select employee_id, last_name, salary
 from employees
 where department_id = 90;
 
 
select * from emp_vw;
 
 
--可以对简单视图进行 DML 操作
 update emp_vw
 set last_name = 'HelloKitty'
 where employee_id = 100;
 
 
select * from employees
 where employee_id = 100;
 
 
1). 复杂视图
 create view emp_vw2
 as
 select department_id, avg(salary) avg_sal
 from employees
 group by department_id;
 
 
select * from emp_vw2;
 
 
--复杂视图不能进行 DML 操作
 update emp_vw2
 set avg_sal = 10000
 where department_id = 100;
 
 
2. 序列：用于生成一组有规律的数值。（通常用于为主键设置值）
 create sequence emp_seq1
 start with 1
 increment by 1
 maxvalue 10000
 minvalue 1
 cycle
 nocache;
 
 
select emp_seq1.currval from dual;
 
 
select emp_seq1.nextval from dual;
 
 
--问题：裂缝 .  原因：①当多个表共用同一个序列时。  ②rollback  ③发生异常
 create table emp1(
        id number(10),
        name varchar2(30)
 );
 
 
insert into emp1
 values(emp_seq1.nextval, '张三');
 
 
select * from emp1;
 
 
3. 索引：提高查询效率
 --自动创建：Oracle 会为具有唯一约束(唯一约束，主键约束)的列，自动创建索引
 create table emp2(
        id number(10) primary key,
        name varchar2(30)
 )
 
 
--手动创建
 create index emp_idx
 on emp2(name);
 
 
create index emp_idx2
 on emp2(id, name);
 
 
4. 同义词
 create synonym d1 for departments;
 
 
select * from d1;
 
 
5. 表：
 DDL ：数据定义语言 create table .../ drop table ... / rename ... to..../ truncate table.../alter table ...
 DML : 数据操纵语言
insert into ... values ...
 update ... set ... where ...
 delete from ... where ...
 
 
【重要】
select ... 组函数(MIN()/MAX()/SUM()/AVG()/COUNT())
from ...join ... on ... 左外连接：left join ... on ... 右外连接: right join ... on ...
where ... 
 group by ... (oracle,SQL server中出现在select 子句后的非分组函数，必须出现在 group by子句后)
having ... 用于过滤 组函数
order by ... asc 升序， desc 降序
 
 
limit (0,4) 限制N条数据 如: topN数据
 
 
 
 
--union 并集
 --union all(有重复)
 --intersect 交集 
 --minus 相减
 
 
 
 
DCL : 数据控制语言  commit : 提交 / rollback : 回滚 / 授权grant...to...  /revoke 
 
 
 
 
 
 
 
 
 
 
 
索引
 
 
 
 
何时创建索引:
 
 
 
 
 
 
 
 
 
一、
 select employee_id, last_name, salary, department_id
 from employees
 where department_id in (70, 80) --> 70:1  80:34
--union 并集
 --union all(有重复部分)
 --intersect 交集 
 --minus 相减
 select employee_id, last_name, salary, department_id
 from employees
 where department_id in (80, 90)  --> 90:4  80:34
 
 

 --问题：查询工资大于149号员工工资的员工的信息
 select * 
 from employees
 where salary > (
       select salary
       from employees
       where employee_id = 149
 )
 
 
--问题：查询与141号或174号员工的manager_id和department_id相同的其他员工的
 --employee_id, manager_id, department_id  
 select employee_id, manager_id, department_id
 from employees
 where manager_id in (
       select manager_id
       from employees
       where employee_id in(141, 174)
 ) and department_id in (
       select department_id
       from employees
       where employee_id in(141, 174)
 ) and employee_id not in (141, 174);
 
 
select employee_id, manager_id, department_id
 from employees
 where (manager_id, department_id) in (
       select manager_id, department_id
       from employees
       where employee_id in (141, 174)
 ) and employee_id not in(141, 174);
 
 
--1. from 子句中使用子查询
 select max(avg(salary))
 from employees
 group by department_id;
 
 
select max(avg_sal)
 from (
       select avg(salary) avg_sal
       from employees
       group by department_id
 ) e
 
 
--问题：返回比本部门平均工资高的员工的last_name, department_id, salary及平均工资
 
 
select last_name, department_id, salary, (select avg(salary) from employees where department_id = e1.department_id)
 from employees e1
 where salary > (
       select avg(salary)
       from employees e2
       where e1.department_id = e2.department_id
 )
 
 
select last_name, e1.department_id, salary, avg_sal
 from employees e1, (
      select department_id, avg(salary) avg_sal
      from employees
      group by department_id
 ) e2
 where e1.department_id = e2.department_id
 and e1.salary > e2.avg_sal;
 
 

 --case...when ... then... when ... then ... else ... end 
 --查询：若部门为10 查看工资的 1.1 倍，部门号为 20 工资的1.2倍，其余 1.3 倍
 select employee_id, last_name, salary, case department_id when 10 then salary * 1.1
                                                           when 20 then salary * 1.2
                                                           else salary * 1.3
                                                           end "new_salary"
 from employees;
 
 
select employee_id, last_name, salary, decode(department_id, 10, salary * 1.1,
                                                              20, salary * 1.2,
                                                              salary * 1.3) "new_salary"
 from employees;
 
 

 --问题：显式员工的employee_id,last_name和location。其中，若员工
 --department_id与location_id为1800的department_id相同，则location为’Canada’,其余则为’USA’。
 select employee_id, last_name, case department_id when (
                     select department_id
                     from departments
                     where location_id = 1800
 ) then 'Canada' else 'USA' end "location"
 from employees;
 
 
--问题：查询员工的employee_id,last_name,要求按照员工的department_name排序
 select employee_id, last_name
 from employees e1
 order by (
       select department_name
       from departments d1
       where e1.department_id = d1.department_id
 )
 
 
-- SQL 优化：能使用 EXISTS 就不要使用 IN
 
 
--问题：查询公司管理者的employee_id,last_name,job_id,department_id信息
 select employee_id, last_name, job_id, department_id
 from employees
 where employee_id in (
       select manager_id
       from employees
 )
 
 

 select employee_id, last_name, job_id, department_id
 from employees e1
 where exists (
       select 'x'
       from employees e2
       where e1.employee_id = e2.manager_id
 ) 
 
 
-- 问题：查询departments表中，不存在于employees表中的部门的department_id和department_name
 select department_id, department_name
 from departments d1
 where not exists (
       select 'x'
       from employees e1
       where e1.department_id = d1.department_id
 )
 
 
--55. 更改 108 员工的信息: 使其工资变为所在部门中的最高工资, job 变为公司中平均工资最低的 job
     
 update employees e1
 set salary = (
     select max(salary)
     from employees e2
     where e1.department_id = e2.department_id
 ), job_id = (
    select job_id
    from employees
    group by job_id
    having avg(salary) = (
          select min(avg(salary))
          from employees
          group by job_id
    )
 )
 where employee_id = 108;
     
 --56. 删除 108 号员工所在部门中工资最低的那个员工.
 delete from employees e1
 where salary = (
       select min(salary)
       from employees
       where department_id = (
             select department_id
             from employees
             where employee_id = 108
       )
 )
 
 
select * from employees where employee_id = 108;
 select * from employees where department_id = 100
 order by salary;
 
 
rollback;
 
 
 
 
常见的SQL面试题：经典50题
 
========================================================
 
已知有如下4张表：
 
学生表：student(学号,学生姓名,出生年月,性别)
 
成绩表：score(学号,课程号,成绩)
 
课程表：course(课程号,课程名称,教师号)
 
教师表：teacher(教师号,教师姓名)
 
 
 
根据以上信息按照下面要求写出对应的SQL语句。
 
ps：这些题考察SQL的编写能力，对于这类型的题目，需要你先把4张表之间的关联关系搞清楚了，最好的办法是自己在草稿纸上画出关联图，然后再编写对应的SQL语句就比较容易了。下图是我画的这4张表的关系图，可以看出它们之间是通过哪些外键关联起来的：
 
 
 
 
一、创建数据库和表
 
为了演示题目的运行过程，我们先按下面语句在客户端navicat中创建数据库和表。
 
（如何你还不懂什么是数据库，什么是客户端navicat，可以先学习这个：
 
 
1.创建表
 
1）创建学生表（student）
 
按下图在客户端navicat里创建学生表
 
 
 
 
学生表的“学号”列设置为主键约束，下图是每一列设置的数据类型和约束
 
 
创建完表，点击“保存”
 
 
2）创建成绩表（score）
 
同样的步骤，创建"成绩表“。“课程表的“学号”和“课程号”一起设置为主键约束（联合主键），“成绩”这一列设置为数值类型（float，浮点数值）
 
 
3）创建课程表（course）
 
课程表的“课程号”设置为主键约束
 
 
4）教师表（teacher）
 
教师表的“教师号”列设置为主键约束，
 
教师姓名这一列设置约束为“null”（红框的地方不勾选），表示这一列允许包含空值（null）
 
 
 
 
2.向表中添加数据
 
 
1）向学生表里添加数据
 
添加数据的sql
 
insert into student(学号,姓名,出生日期,性别) 
values('0001' , '猴子' , '1989-01-01' , '男');

insert into student(学号,姓名,出生日期,性别) 
values('0002' , '猴子' , '1990-12-21' , '女');

insert into student(学号,姓名,出生日期,性别) 
values('0003' , '马云' , '1991-12-21' , '男');

insert into student(学号,姓名,出生日期,性别) 
values('0004' , '王思聪' , '1990-05-20' , '男');
 
在客户端navicat里的操作
 
 
 
 
2）成绩表（score）
 
添加数据的sql
 
insert into score(学号,课程号,成绩) 
values('0001' , '0001' , 80);

insert into score(学号,课程号,成绩) 
values('0001' , '0002' , 90);

insert into score(学号,课程号,成绩) 
values('0001' , '0003' , 99);

insert into score(学号,课程号,成绩) 
values('0002' , '0002' , 60);

insert into score(学号,课程号,成绩) 
values('0002' , '0003' , 80);

insert into score(学号,课程号,成绩) 
values('0003' , '0001' , 80);

insert into score(学号,课程号,成绩) 
values('0003' , '0002' , 80);

insert into score(学号,课程号,成绩) 
values('0003' , '0003' , 80);
 
客户端navicat里的操作
 
 
3）课程表
 
添加数据的sql
 
insert into course(课程号,课程名称,教师号)
values('0001' , '语文' , '0002');

insert into course(课程号,课程名称,教师号)
values('0002' , '数学' , '0001');

insert into course(课程号,课程名称,教师号)
values('0003' , '英语' , '0003');
 
客户端navicat里的操作
 
 
4）教师表里添加数据
 
添加数据的sql
 
-- 教师表：添加数据
insert into teacher(教师号,教师姓名) 
values('0001' , '孟扎扎');

insert into teacher(教师号,教师姓名) 
values('0002' , '马化腾');

-- 这里的教师姓名是空值（null）
insert into teacher(教师号,教师姓名) 
values('0003' , null);

-- 这里的教师姓名是空字符串（''）
insert into teacher(教师号,教师姓名) 
values('0004' , '');
 
客户端navicat里操作
 
 
添加结果
 
 
 
 
三、50道面试题
 
为了方便学习，我将50道面试题进行了分类
 
 
 
 
查询姓“猴”的学生名单
 
 
查询姓“孟”老师的个数
 
select count(教师号)
from teacher
where 教师姓名 like '孟%';
 
 
 
2.汇总统计分组分析
 
 
面试题：查询课程编号为“0002”的总成绩
 
*
分析思路
select 查询结果 [总成绩:汇总函数sum]
from 从哪张表中查找数据[成绩表score]
where 查询条件 [课程号是0002]
*/
select sum(成绩)
from score
where 课程号 = '0002';
 
查询选了课程的学生人数
 
/*
这个题目翻译成大白话就是：查询有多少人选了课程
select 学号，成绩表里学号有重复值需要去掉
from 从课程表查找score;
*/
select count(distinct 学号) as 学生人数 
from score;
 
 
查询各科成绩最高和最低的分， 以如下的形式显示：课程号，最高分，最低分
 
/*
分析思路
select 查询结果 [课程ID：是课程号的别名,最高分：max(成绩) ,最低分：min(成绩)]
from 从哪张表中查找数据 [成绩表score]
where 查询条件 [没有]
group by 分组 [各科成绩：也就是每门课程的成绩，需要按课程号分组];
*/
select 课程号,max(成绩) as 最高分,min(成绩) as 最低分
from score
group by 课程号;
 
查询每门课程被选修的学生数
 
/*
分析思路
select 查询结果 [课程号，选修该课程的学生数：汇总函数count]
from 从哪张表中查找数据 [成绩表score]
where 查询条件 [没有]
group by 分组 [每门课程：按课程号分组];
*/
select 课程号, count(学号)
from score
group by 课程号;
 
查询男生、女生人数
 
/*
分析思路
select 查询结果 [性别，对应性别的人数：汇总函数count]
from 从哪张表中查找数据 [性别在学生表中，所以查找的是学生表student]
where 查询条件 [没有]
group by 分组 [男生、女生人数：按性别分组]
having 对分组结果指定条件 [没有]
order by 对查询结果排序[没有];
*/
select 性别,count(*)
from student
group by 性别;
 
 
查询平均成绩大于60分学生的学号和平均成绩
 
/* 
题目翻译成大白话：
平均成绩：展开来说就是计算每个学生的平均成绩
这里涉及到“每个”就是要分组了
平均成绩大于60分，就是对分组结果指定条件

分析思路
select 查询结果 [学号，平均成绩：汇总函数avg(成绩)]
from 从哪张表中查找数据 [成绩在成绩表中，所以查找的是成绩表score]
where 查询条件 [没有]
group by 分组 [平均成绩：先按学号分组，再计算平均成绩]
having 对分组结果指定条件 [平均成绩大于60分]
*/
select 学号, avg(成绩)
from score
group by 学号
having avg(成绩)>60;
 
查询至少选修两门课程的学生学号
 
/* 
翻译成大白话：
第1步，需要先计算出每个学生选修的课程数据，需要按学号分组
第2步，至少选修两门课程：也就是每个学生选修课程数目>=2，对分组结果指定条件

分析思路
select 查询结果 [学号,每个学生选修课程数目：汇总函数count]
from 从哪张表中查找数据 [课程的学生学号：课程表score]
where 查询条件 [至少选修两门课程：需要先计算出每个学生选修了多少门课，需要用分组，所以这里没有where子句]
group by 分组 [每个学生选修课程数目：按课程号分组，然后用汇总函数count计算出选修了多少门课]
having 对分组结果指定条件 [至少选修两门课程：每个学生选修课程数目>=2]
*/
select 学号, count(课程号) as 选修课程数目
from score
group by 学号
having count(课程号)>=2;
 
查询同名同性学生名单并统计同名人数
 
/* 
翻译成大白话，问题解析：
1）查找出姓名相同的学生有谁，每个姓名相同学生的人数
查询结果：姓名,人数
条件：怎么算姓名相同？按姓名分组后人数大于等于2，因为同名的人数大于等于2
分析思路
select 查询结果 [姓名,人数：汇总函数count(*)]
from 从哪张表中查找数据 [学生表student]
where 查询条件 [没有]
group by 分组 [姓名相同：按姓名分组]
having 对分组结果指定条件 [姓名相同：count(*)>=2]
order by 对查询结果排序[没有];
*/

select 姓名,count(*) as 人数
from student
group by 姓名
having count(*)>=2;
 
查询不及格的课程并按课程号从大到小排列
 
/* 
分析思路
select 查询结果 [课程号]
from 从哪张表中查找数据 [成绩表score]
where 查询条件 [不及格：成绩 <60]
group by 分组 [没有]
having 对分组结果指定条件 [没有]
order by 对查询结果排序[课程号从大到小排列：降序desc];
*/
select 课程号
from score 
where 成绩<60
order by 课程号 desc;
 
查询每门课程的平均成绩，结果按平均成绩升序排序，平均成绩相同时，按课程号降序排列
 
/* 
分析思路
select 查询结果 [课程号,平均成绩：汇总函数avg(成绩)]
from 从哪张表中查找数据 [成绩表score]
where 查询条件 [没有]
group by 分组 [每门课程：按课程号分组]
having 对分组结果指定条件 [没有]
order by 对查询结果排序[按平均成绩升序排序:asc，平均成绩相同时，按课程号降序排列:desc];
*/
select 课程号, avg(成绩) as 平均成绩
from score
group by 课程号
order by 平均成绩 asc,课程号 desc;
 
检索课程编号为“0004”且分数小于60的学生学号，结果按按分数降序排列
 
/* 
分析思路
select 查询结果 []
from 从哪张表中查找数据 [成绩表score]
where 查询条件 [课程编号为“04”且分数小于60]
group by 分组 [没有]
having 对分组结果指定条件 []
order by 对查询结果排序[查询结果按按分数降序排列];
*/
select 学号
from score
where 课程号='04' and 成绩 <60
order by 成绩 desc;
 
统计每门课程的学生选修人数(超过2人的课程才统计)
 
要求输出课程号和选修人数，查询结果按人数降序排序，若人数相同，按课程号升序排序
 
/* 
分析思路
select 查询结果 [要求输出课程号和选修人数]
from 从哪张表中查找数据 []
where 查询条件 []
group by 分组 [每门课程：按课程号分组]
having 对分组结果指定条件 [学生选修人数(超过2人的课程才统计)：每门课程学生人数>2]
order by 对查询结果排序[查询结果按人数降序排序，若人数相同，按课程号升序排序];
*/
select 课程号, count(学号) as '选修人数'
from score
group by 课程号
having count(学号)>2
order by count(学号) desc,课程号 asc;
 
查询两门以上不及格课程的同学的学号及其平均成绩
 
/*
分析思路
先分解题目：
1）[两门以上][不及格课程]限制条件
2）[同学的学号及其平均成绩]，也就是每个学生的平均成绩，显示学号，平均成绩
分析过程：
第1步：得到每个学生的平均成绩，显示学号，平均成绩
第2步：再加上限制条件：
1）不及格课程
2）两门以上[不及格课程]：课程数目>2


/* 
第1步：得到每个学生的平均成绩，显示学号，平均成绩
select 查询结果 [学号,平均成绩：汇总函数avg(成绩)]
from 从哪张表中查找数据 [涉及到成绩：成绩表score]
where 查询条件 [没有]
group by 分组 [每个学生的平均：按学号分组]
having 对分组结果指定条件 [没有]
order by 对查询结果排序[没有];
*/
select 学号, avg(成绩) as 平均成绩
from score
group by 学号;


/* 
第2步：再加上限制条件：
1）不及格课程
2）两门以上[不及格课程]
select 查询结果 [学号,平均成绩：汇总函数avg(成绩)]
from 从哪张表中查找数据 [涉及到成绩：成绩表score]
where 查询条件 [限制条件：不及格课程，平均成绩<60]
group by 分组 [每个学生的平均：按学号分组]
having 对分组结果指定条件 [限制条件：课程数目>2,汇总函数count(课程号)>2]
order by 对查询结果排序[没有];
*/
select 学号, avg(成绩) as 平均成绩
from score
where 成绩 <60
group by 学号
having count(课程号)>=2;
 
如果上面题目不会做，可以复习这部分涉及到的sql知识：
 
3.复杂查询
 
查询所有课程成绩小于60分学生的学号、姓名
 
【知识点】子查询

1.翻译成大白话
1）查询结果：学生学号，姓名
2）查询条件：所有课程成绩 < 60 的学生，需要从成绩表里查找，用到子查询

第1步，写子查询（所有课程成绩 < 60 的学生）
select 查询结果[学号]
from 从哪张表中查找数据[成绩表：score]
where 查询条件[成绩 < 60]
group by 分组[没有]
having 对分组结果指定条件[没有]
order by 对查询结果排序[没有]
limit 从查询结果中取出指定行[没有];

select 学号 
from score
where 成绩 < 60;

第2步，查询结果：学生学号，姓名，条件是前面1步查到的学号

select 查询结果[学号,姓名]
from 从哪张表中查找数据[学生表:student]
where 查询条件[用到运算符in]
group by 分组[没有]
having 对分组结果指定条件[没有]
order by 对查询结果排序[没有]
limit 从查询结果中取出指定行[没有];
*/
select 学号,姓名
from student
where  学号 in (
select 学号 
from score
where 成绩 < 60
);
 
查询没有学全所有课的学生的学号、姓名|
 
/*
查找出学号，条件：没有学全所有课，也就是该学生选修的课程数 < 总的课程数
【考察知识点】in，子查询
*/
select 学号,姓名
from student
where 学号 in(
select 学号 
from score
group by 学号
having count(课程号) < (select count(课程号) from course)
);
 
查询出只选修了两门课程的全部学生的学号和姓名|
 
select 学号,姓名
from student
where 学号 in(
select 学号
from score
group by 学号
having count(课程号)=2
);
 
1990年出生的学生名单
 
 
/*
查找1990年出生的学生名单
学生表中出生日期列的类型是datetime
*/
select 学号,姓名 
from student 
where year(出生日期)=1990; 
 
查询各科成绩前两名的记录
 
这类问题其实就是常见的：分组取每组最大值、最小值，每组最大的N条（top N）记录。
 
sql面试题：topN问题
 
工作中会经常遇到这样的业务问题：
 
如何找到每个类别下用户最喜欢的产品是哪个？
如果找到每个类别下用户点击最多的5个商品是什么？
 
 
这类问题其实就是常见的：分组取每组最大值、最小值，每组最大的N条（top N）记录。
 
 
 
面对该类问题，如何解决呢？
 
 
 
下面我们通过成绩表的例子来给出答案。
 
 
 
成绩表是学生的成绩，里面有学号（学生的学号），课程号（学生选修课程的课程号），成绩（学生选修该课程取得的成绩）
 
 
 
 
 
 
 
分组取每组最大值
 
 
 
案例：按课程号分组取成绩最大值所在行的数据
 
 
 
我们可以使用分组（group by）和汇总函数得到每个组里的一个值（最大值，最小值，平均值等）。但是无法得到成绩最大值所在行的数据。
 
 
 
select 课程号,max(成绩) as 最大成绩from score group by 课程号;
 
 
 
 
我们可以使用关联子查询来实现：
 
 
 
select * from score as a where 成绩 = (select max(成绩) from score as b where b.课程号 = a.课程号);
 
 
 
 
 
 
上面查询结果课程号“0001”有2行数据，是因为最大成绩80有2个
 
 
 
 
分组取每组最小值
 
 
 
案例：按课程号分组取成绩最小值所在行的数据
 
 
 
同样的使用关联子查询来实现
 
select * from score as a where 成绩 = (select min(成绩) from score as b where b.课程号 = a.课程号);
 
 
 
 
 
 
 
 
 
每组最大的N条记录
 
 
 
案例：查询各科成绩前两名的记录
 
 
 
第1步，查出有哪些组
 
我们可以按课程号分组，查询出有哪些组，对应这个问题里就是有哪些课程号
 
select 课程号,max(成绩) as 最大成绩from score group by 课程号;
 
 
 
 
 
 
第2步：先使用order by子句按成绩降序排序（desc），然后使用limt子句返回topN（对应这个问题返回的成绩前两名）
 
-- 课程号'0001' 这一组里成绩前2名select * from score where 课程号 = '0001' order by 成绩  desc limit 2;
 
同样的，可以写出其他组的（其他课程号）取出成绩前2名的sql
 
 
 
第3步，使用union all 将每组选出的数据合并到一起
 
-- 左右滑动可以可拿到全部sql(select * from score where 课程号 = '0001' order by 成绩  desc limit 2)union all(select * from score where 课程号 = '0002' order by 成绩  desc limit 2)union all(select * from score where 课程号 = '0003' order by 成绩  desc limit 2);
 
 
 
 
 
 
前面我们使用order by子句按某个列降序排序（desc）得到的是每组最大的N个记录。如果想要达到每组最小的N个记录，将order by子句按某个列升序排序（asc）即可。
 
 
 
求topN的问题还可以使用自定义变量来实现，这个在后续再介绍。
 
 
 
如果对多表合并还不了解的，可以看下我讲过的《从零学会SQL》的“多表查询”。
 
 
 
 
 
 
 
 
总结
 
常见面试题：分组取每组最大值、最小值，每组最大的N条（top N）记录。
 
4.多表查询
 
 
查询所有学生的学号、姓名、选课数、总成绩
 
selecta.学号,a.姓名,count(b.课程号) as 选课数,sum(b.成绩) as 总成绩
from student as a left join score as b
on a.学号 = b.学号
group by a.学号;
 
查询平均成绩大于85的所有学生的学号、姓名和平均成绩
 
select a.学号,a.姓名, avg(b.成绩) as 平均成绩
from student as a left join score as b
on a.学号 = b.学号
group by a.学号
having avg(b.成绩)>85;
 
查询学生的选课情况：学号，姓名，课程号，课程名称
 
select a.学号, a.姓名, c.课程号,c.课程名称
from student a inner join score b on a.学号=b.学号
inner join course c on b.课程号=c.课程号;
 
查询出每门课程的及格人数和不及格人数
 
-- 考察case表达式
select 课程号,
sum(case when 成绩>=60 then 1 
	 else 0 
    end) as 及格人数,
sum(case when 成绩 <  60 then 1 
	 else 0 
    end) as 不及格人数
from score
group by 课程号;
 
使用分段[100-85],[85-70],[70-60],[<60]来统计各科成绩，分别统计：各分数段人数，课程号和课程名称
 
-- 考察case表达式
select a.课程号,b.课程名称,
sum(case when 成绩 between 85 and 100 
	 then 1 else 0 end) as '[100-85]',
sum(case when 成绩 >=70 and 成绩<85 
	 then 1 else 0 end) as '[85-70]',
sum(case when 成绩>=60 and 成绩<70  
	 then 1 else 0 end) as '[70-60]',
sum(case when 成绩<60 then 1 else 0 end) as '[<60]'
from score as a right join course as b 
on a.课程号=b.课程号
group by a.课程号,b.课程名称;
 
查询课程编号为0003且课程成绩在80分以上的学生的学号和姓名|
 
select a.学号,a.姓名
from student  as a inner join score as b on a.学号=b.学号
where b.课程号='0003' and b.成绩>80;
 
下面是学生的成绩表（表名score，列名：学号、课程号、成绩）
 
 
使用sql实现将该表行转列为下面的表结构
 
 
【面试题类型总结】这类题目属于行列如何互换，解题思路如下：
 
【面试题】下面是学生的成绩表（表名score，列名：学号、课程号、成绩）
 
 
 
 
 
 
使用sql实现将该表行转列为下面的表结构
 
 
 
 
 
 
【解答】
 
 
 
第1步，使用常量列输出目标表的结构
 
可以看到查询结果已经和目标表非常接近了
 
 
 
select 学号,'课程号0001','课程号0002','课程号0003'from score;
 
 
 
 
 
 
第2步，使用case表达式，替换常量列为对应的成绩
 
select 学号,(case 课程号 when '0001' then 成绩 else 0 end) as '课程号0001',(case 课程号 when '0002' then 成绩 else 0 end) as  '课程号0002',(case 课程号 when '0003' then 成绩 else 0 end) as '课程号0003'from score;
 
 
 
 
 
 
在这个查询结果中，每一行表示了某个学生某一门课程的成绩。比如第一行是'学号0001'选修'课程号00001'的成绩，而其他两列的'课程号0002'和'课程号0003'成绩为0。
 
 
 
每个学生选修某门课程的成绩在下图的每个方块内。我们可以通过分组，取出每门课程的成绩。
 
 
 
 
 
 
第3关，分组
 
分组，并使用最大值函数max取出上图每个方块里的最大值
 
select 学号,max(case 课程号 when '0001' then 成绩 else 0 end) as '课程号0001',max(case 课程号 when '0002' then 成绩 else 0 end) as '课程号0002',max(case 课程号 when '0003' then 成绩 else 0 end) as '课程号0003'from scoregroup by 学号;
 
 
 
这样我们就得到了目标表（行列互换）
 
 
 
 
其他面试题:
 
https://blog.csdn.net/u010565545/article/details/100786293
 
 

Sql常见面试题 受用了 
 
 
1.用一条SQL 语句 查询出每门课都大于80 分的学生姓名
 
 
name   kemu   fenshu
 张三    语文       81
 张三     数学       75
 李四     语文       76
 李四     数学       90
 王五     语文       81
 王五     数学       100
 王五     英语       90
 
 A: select distinct name from table where name not in (select distinct name from table where fenshu<=80)
 select name from table group by name having min(fenshu)>80
 
 

 2. 学生表 如下:
 自动编号   学号   姓名 课程编号 课程名称 分数
 1        2005001 张三 0001     数学    69
 2        2005002 李四 0001      数学    89
 3        2005001 张三 0001      数学    69
 删除除了自动编号不同, 其他都相同的学生冗余信息
 
 A: delete tablename where 自动编号 not in(select min( 自动编号) from tablename group by学号, 姓名, 课程编号, 课程名称, 分数)
 
 
3.一个叫 team 的表，里面只有一个字段name, 一共有4 条纪录，分别是a,b,c,d, 对应四个球对，现在四个球对进行比赛，用一条sql 语句显示所有可能的比赛组合.
 你先按你自己的想法做一下，看结果有我的这个简单吗？
 
 
答：select a.name, b.name
 from team a, team b 
 where a.name < b.name
 
 
4.请用SQL 语句实现：从TestDB 数据表中查询出所有月份的发生额都比101 科目相应月份的发生额高的科目。请注意：TestDB 中有很多科目，都有1 －12 月份的发生额。
 AccID ：科目代码，Occmonth ：发生额月份，DebitOccur ：发生额。
 数据库名：JcyAudit ，数据集：Select * from TestDB
 
 
答：select a.*
 from TestDB a 
 ,(select Occmonth,max(DebitOccur) Debit101ccur from TestDB where AccID='101' group by Occmonth) b
 where a.Occmonth=b.Occmonth and a.DebitOccur>b.Debit101ccur
 
 
************************************************************************************
 
 
5.面试题：怎么把这样一个表儿
 year   month amount
 1991   1     1.1
 1991   2     1.2
 1991   3     1.3
 1991   4     1.4
 1992   1     2.1
 1992   2     2.2
 1992   3     2.3
 1992   4     2.4
 查成这样一个结果
 year m1   m2   m3   m4
 1991 1.1 1.2 1.3 1.4
 1992 2.1 2.2 2.3 2.4 
 
 答案一、
 select year, 
 (select amount from   aaa m where month=1   and m.year=aaa.year) as m1,
 (select amount from   aaa m where month=2   and m.year=aaa.year) as m2,
 (select amount from   aaa m where month=3   and m.year=aaa.year) as m3,
 (select amount from   aaa m where month=4   and m.year=aaa.year) as m4
 from aaa   group by year
 
 
*******************************************************************************
 6. 说明：复制表( 只复制结构, 源表名：a新表名：b) 
 
 SQL: select * into b from a where 1<>1       (where1=1，拷贝表结构和数据内容)
 ORACLE:create table b
 
 
As
 
 
Select * from a where 1=2
 
 
 
 
 

  [<>（不等于）(SQL Server Compact)
 
 
 
 
 
 
 
比较两个表达式。 当使用此运算符比较非空表达式时，如果左操作数不等于右操作数，则结果为 TRUE。 否则，结果为 FALSE。]
 
 
 
 
 

 7. 说明：拷贝表( 拷贝数据, 源表名：a目标表名：b) 
 
 SQL: insert into b(a, b, c) select d,e,f from a; 
 
 8. 说明：显示文章、提交人和最后回复时间
 SQL: select a.title,a.username,b.adddate from table a,(select max(adddate) adddate from table where table.title=a.title) b
 
 9. 说明：外连接查询( 表名1 ：a表名2 ：b)
 
 SQL: select a.a, a.b, a.c, b.c, b.d, b.f from a LEFT OUTER JOIN b ON a.a = b.c
 
 
ORACLE：select a.a, a.b, a.c, b.c, b.d, b.f from a ,b
 
 
where a.a = b.c(+)
 
 10. 说明：日程安排提前五分钟提醒
 SQL: select * from 日程安排 where datediff('minute',f 开始时间,getdate())>5
 
 11. 说明：两张关联表，删除主表中已经在副表中没有的信息
 
 SQL: 
 Delete from info where not exists (select * from infobz where info.infid=infobz.infid )
 
 *******************************************************************************
 
 
12.有两个表A 和B ，均有key 和value 两个字段，如果B 的key 在A 中也有，就把B 的value 换为A 中对应的value
 这道题的SQL 语句怎么写？
 
 
update b set b.value=(select a.value from a where a.key=b.key) where b.id in(select b.id from b,a where b.key=a.key);
 
 
***************************************************************************
 
 

 
 
 
13.高级sql 面试题
 
 
原表:
 courseid coursename score
 -------------------------------------
 1 java 70
 2 oracle 90
 3 xml 40
 4 jsp 30
 5 servlet 80
 -------------------------------------
 为了便于阅读, 查询此表后的结果显式如下( 及格分数为60):
 courseid coursename score mark
 ---------------------------------------------------
 1 java 70 pass
 2 oracle 90 pass
 3 xml 40 fail
 4 jsp 30 fail
 5 servlet 80 pass
 ---------------------------------------------------
 写出此查询语句
 
 

 select courseid, coursename ,score ,decode（sign(score-60),-1,'fail','pass') as mark from course
 
 
完全正确
 
 SQL> desc course_v
 Name Null? Type
 ----------------------------------------- -------- ----------------------------
 COURSEID NUMBER
 COURSENAME VARCHAR2(10)
 SCORE NUMBER
 
 SQL> select * from course_v;
 
 COURSEID COURSENAME SCORE
 ---------- ---------- ----------
 1 java 70
 2 oracle 90
 3 xml 40
 4 jsp 30
 5 servlet 80
 
 SQL> select courseid, coursename ,score ,decode(sign(score-60),-1,'fail','pass') as mark from course_v;
 
 COURSEID COURSENAME SCORE MARK
 ---------- ---------- ---------- ----
 1 java 70 pass
 2 oracle 90 pass
 3 xml 40 fail
 4 jsp 30 fail
 5 servlet 80 pass
 
 
SQL面试题（1）
 
 
create table testtable1
 (
 id int IDENTITY,
 department varchar(12) 
 )
 
 
select * from testtable1
 insert into testtable1 values('设计')
 insert into testtable1 values('市场')
 insert into testtable1 values('售后')
 /*
 结果
 id department
 1   设计
 2   市场
 3   售后 
 */
 create table testtable2
 (
 id int IDENTITY,
 dptID int,
 name varchar(12)
 )
 insert into testtable2 values(1,'张三')
 insert into testtable2 values(1,'李四')
 insert into testtable2 values(2,'王五')
 insert into testtable2 values(3,'彭六')
 insert into testtable2 values(4,'陈七')
 /*
 用一条SQL语句，怎么显示如下结果
 id dptID department name
 1   1      设计        张三
 2   1      设计        李四
 3   2      市场        王五
 4   3      售后        彭六
 5   4      黑人        陈七
 */
 
 
答案：
 
 
SELECT testtable2.* , ISNULL(department,'黑人')
 FROM testtable1 right join testtable2 on testtable2.dptID = testtable1.ID
 
 
也做出来了可比这方法稍复杂。
 
 
sql面试题（2）
 
 
有表A，结构如下： 
 A: p_ID p_Num s_id 
 1 10 01 
 1 12 02 
 2 8 01 
 3 11 01 
 3 8 03 
 其中：p_ID为产品ID，p_Num为产品库存量，s_id为仓库ID。请用SQL语句实现将上表中的数据合并，合并后的数据为： 
 p_ID s1_id s2_id s3_id 
 1 10 12 0 
 2 8 0 0 
 3 11 0 8 
 其中：s1_id为仓库1的库存量，s2_id为仓库2的库存量，s3_id为仓库3的库存量。如果该产品在某仓库中无库存量，那么就是0代替。
 
 
结果：
 
 
select p_id ,
 sum(case when s_id=1 then p_num else 0 end) as s1_id
 ,sum(case when s_id=2 then p_num else 0 end) as s2_id
 ,sum(case when s_id=3 then p_num else 0 end) as s3_id
 from myPro group by p_id
 
 
SQL面试题（3）
 
 
1．触发器的作用？
 
 
  答：触发器是一中特殊的存储过程，主要是通过事件来触发而被执行的。它可以强化约束，来维护数据的完整性和一致性，可以跟踪数据库内的操作从而不允许未经许可的更新和变化。可以联级运算。如，某表上的触发器上包含对另一个表的数据操作，而该操作又会导致该表触发器被触发。
 
 
2。什么是存储过程？用什么来调用？
 
 
答：存储过程是一个预编译的SQL 语句，优点是允许模块化的设计，就是说只需创建一次，以后在该程序中就可以调用多次。如果某次操作需要执行多次SQL ，使用存储过程比单纯SQL 语句执行要快。可以用一个命令对象来调用存储过程。
 
 
3。索引的作用？和它的优点缺点是什么？
 
 
答：索引就一种特殊的查询表，数据库的搜索引擎可以利用它加速对数据的检索。它很类似与现实生活中书的目录，不需要查询整本书内容就可以找到想要的数据。索引可以是唯一的，创建索引允许指定单个列或者是多个列。缺点是它减慢了数据录入的速度，同时也增加了数据库的尺寸大小。
 
 
3。什么是内存泄漏？
 
 
答：一般我们所说的内存泄漏指的是堆内存的泄漏。堆内存是程序从堆中为其分配的，大小任意的，使用完后要显示释放内存。当应用程序用关键字new 等创建对象时，就从堆中为它分配一块内存，使用完后程序调用free 或者delete 释放该内存，否则就说该内存就不能被使用，我们就说该内存被泄漏了。
 
 
4。维护数据库的完整性和一致性，你喜欢用触发器还是自写业务逻辑？为什么？
 
 
答：我是这样做的，尽可能使用约束，如check, 主键，外键，非空字段等来约束，这样做效率最高，也最方便。其次是使用触发器，这种方法可以保证，无论什么业务系统访问数据库都可以保证数据的完整新和一致性。最后考虑的是自写业务逻辑，但这样做麻烦，编程复杂，效率低下。
 
 
5。什么是事务？什么是锁？
 
 
答：事务就是被绑定在一起作为一个逻辑工作单元的SQL 语句分组，如果任何一个语句操作失败那么整个操作就被失败，以后操作就会回滚到操作前状态，或者是上有个节点。为了确保要么执行，要么不执行，就可以使用事务。要将有组语句作为事务考虑，就需要通过ACID 测试，即原子性，一致性，隔离性和持久性。
 
 
  锁：在所以的 DBMS中，锁是实现事务的关键，锁可以保证事务的完整性和并发性。与现实生活中锁一样，它可以使某些数据的拥有者，在某段时间内不能使用某些数据或数据结构。当然锁还分级别的。
 
 
6。什么叫视图？游标是什么？
 
 
答：视图是一种虚拟的表，具有和物理表相同的功能。可以对视图进行增，改，查，操作，试图通常是有一个表或者多个表的行或列的子集。对视图的修改不影响基本表。它使得我们获取数据更容易，相比多表查询。
 
 
  游标：是对查询出来的结果集作为一个单元来有效的处理。游标可以定在该单元中的特定行，从结果集的当前行检索一行或多行。可以对结果集当前行做修改。一般不使用游标，但是需要逐条处理数据的时候，游标显得十分重要。
 
 
7。为管理业务培训信息，建立3个表：
 
 
     S(S#,SN,SD,SA)S#,SN,SD,SA分别代表学号，学员姓名，所属单位，学员年龄
 
 
     C(C#,CN)C#,CN分别代表课程编号，课程名称
 
 
      SC(S#,C#,G) S#,C#,G分别代表学号，所选的课程编号，学习成绩
 
 
    （1）使用标准SQL嵌套语句查询选修课程名称为’税收基础’的学员学号和姓名?
 
 
          答案：select s# ,sn from s where S# in(select S# from c,sc where c.c#=sc.c# and cn=’税收基础’)
 
 
      (2) 使用标准SQL嵌套语句查询选修课程编号为’C2’的学员姓名和所属单位?
 
 
答：select sn,sd from s,sc where s.s#=sc.s# and sc.c#=’c2’
 
 
      (3) 使用标准SQL嵌套语句查询不选修课程编号为’C5’的学员姓名和所属单位?
 
 
答：select sn,sd from s where s# not in(select s# from sc where c#=’c5’)
 
 
       (4)查询选修了课程的学员人数
 
 
答：select 学员人数=count(distinct s#) from sc
 
 
       (5) 查询选修课程超过5门的学员学号和所属单位?
 
 
答：select sn,sd from s where s# in(select s# from sc group by s# having count(distinct c#)>5)
 
 
SQL面试题（4）
 
 
1.查询A(ID,Name)表中第31至40条记录，ID作为主键可能是不是连续增长的列，完整的查询语句如下：
 
 select top 10 * from A where ID >(select max(ID) from (select top 30 ID from A order by A ) T) order by A
 
 2.查询表A中存在ID重复三次以上的记录,完整的查询语句如下：
 select * from(select count(ID) as count from table group by ID)T where T.count>3
 
 
SQL面试题（5）
 
 
在面试应聘的SQL Server数据库开发人员时，我运用了一套标准的基准技术问题。下面这些问题是我觉得能够真正有助于淘汰不合格应聘者的问题。它们按照从易到难的顺序排列。当你问到关于主键和外键的问题时，后面的问题都十分有难度，因为答案可能会更难解释和说明，尤其是在面试的情形下。
 
 
你能向我简要叙述一下SQL Server 2000中使用的一些数据库对象吗?
 
 
你希望听到的答案包括这样一些对象:表格、视图、用户定义的函数，以及存储过程;如果他们还能够提到像触发器这样的对象就更好了。如果应聘者不能回答这个基本的问题，那么这不是一个好兆头。
 
 
NULL是什么意思?
 
 
NULL(空)这个值是数据库世界里一个非常难缠的东西，所以有不少应聘者会在这个问题上跌跟头您也不要觉得意外。
 
 
NULL这个值表示UNKNOWN(未知):它不表示“”(空字符串)。假设您的SQL Server数据库里有ANSI_NULLS，当然在默认情况下会有，对NULL这个值的任何比较都会生产一个NULL值。您不能把任何值与一个 UNKNOWN值进行比较，并在逻辑上希望获得一个答案。您必须使用IS NULL操作符。
 
 
什么是索引?SQL Server 2000里有什么类型的索引?
 
 
任何有经验的数据库开发人员都应该能够很轻易地回答这个问题。一些经验不太多的开发人员能够回答这个问题，但是有些地方会说不清楚。
 
 
简单地说，索引是一个数据结构，用来快速访问数据库表格或者视图里的数据。在SQL Server里，它们有两种形式:聚集索引和非聚集索引。聚集索引在索引的叶级保存数据。这意味着不论聚集索引里有表格的哪个(或哪些)字段，这些字段都会按顺序被保存在表格。由于存在这种排序，所以每个表格只会有一个聚集索引。非聚集索引在索引的叶级有一个行标识符。这个行标识符是一个指向磁盘上数据的指针。它允许每个表格有多个非聚集索引。
 
 
什么是主键?什么是外键?
 
 
主键是表格里的(一个或多个)字段，只用来定义表格里的行;主键里的值总是唯一的。外键是一个用来建立两个表格之间关系的约束。这种关系一般都涉及一个表格里的主键字段与另外一个表格(尽管可能是同一个表格)里的一系列相连的字段。那么这些相连的字段就是外键。
 
 
什么是触发器?SQL Server 2000有什么不同类型的触发器?
 
 
让未来的数据库开发人员知道可用的触发器类型以及如何实现它们是非常有益的。
 
 
触发器是一种专用类型的存储过程，它被捆绑到SQL Server 2000的表格或者视图上。在SQL Server 2000里，有INSTEAD-OF和AFTER两种触发器。INSTEAD-OF触发器是替代数据操控语言(Data Manipulation Language，DML)语句对表格执行语句的存储过程。例如，如果我有一个用于TableA的INSTEAD-OF-UPDATE触发器，同时对这个表格执行一个更新语句，那么INSTEAD-OF-UPDATE触发器里的代码会执行，而不是我执行的更新语句则不会执行操作。
 
 
AFTER触发器要在DML语句在数据库里使用之后才执行。这些类型的触发器对于监视发生在数据库表格里的数据变化十分好用。
 
 
您如何确一个带有名为Fld1字段的TableB表格里只具有Fld1字段里的那些值，而这些值同时在名为TableA的表格的Fld1字段里?
 
 
这个与关系相关的问题有两个可能的答案。第一个答案(而且是您希望听到的答案)是使用外键限制。外键限制用来维护引用的完整性。它被用来确保表格里的字段只保存有已经在不同的(或者相同的)表格里的另一个字段里定义了的值。这个字段就是候选键(通常是另外一个表格的主键)。
 
 
另外一种答案是触发器。触发器可以被用来保证以另外一种方式实现与限制相同的作用，但是它非常难设置与维护，而且性能一般都很糟糕。由于这个原因，微软建议开发人员使用外键限制而不是触发器来维护引用的完整性。
 
 
对一个投入使用的在线事务处理表格有过多索引需要有什么样的性能考虑?
 
 
你正在寻找进行与数据操控有关的应聘人员。对一个表格的索引越多，数据库引擎用来更新、插入或者删除数据所需要的时间就越多，因为在数据操控发生的时候索引也必须要维护。
 
 
你可以用什么来确保表格里的字段只接受特定范围里的值?
 
 
这个问题可以用多种方式来回答，但是只有一个答案是“好”答案。您希望听到的回答是Check限制，它在数据库表格里被定义，用来限制输入该列的值。
 
 
触发器也可以被用来限制数据库表格里的字段能够接受的值，但是这种办法要求触发器在表格里被定义，这可能会在某些情况下影响到性能。因此，微软建议使用Check限制而不是其他的方式来限制域的完整性。
 
 
如果应聘者能够正确地回答这个问题，那么他的机会就非常大了，因为这表明他们具有使用存储过程的经验。
 
 
返回参数总是由存储过程返回，它用来表示存储过程是成功还是失败。返回参数总是INT数据类型。
 
 
OUTPUT参数明确要求由开发人员来指定，它可以返回其他类型的数据，例如字符型和数值型的值。(可以用作输出参数的数据类型是有一些限制的。)您可以在一个存储过程里使用多个OUTPUT参数，而您只能够使用一个返回参数。
 
 
什么是相关子查询?如何使用这些查询?
 
 
经验更加丰富的开发人员将能够准确地描述这种类型的查询。
 
 
相关子查询是一种包含子查询的特殊类型的查询。查询里包含的子查询会真正请求外部查询的值，从而形成一个类似于循环的状况。
 
 
SQL面试题（6）
 
 
原表: 
 courseid coursename score 
 ------------------------------------- 
 1 java 70 
 2 oracle 90 
 3 xml 40 
 4 jsp 30 
 5 servlet 80 
 ------------------------------------- 
 为了便于阅读,查询此表后的结果显式如下(及格分数为60): 
 courseid coursename score mark 
 --------------------------------------------------- 
 1 java 70 pass 
 2 oracle 90 pass 
 3 xml 40 fail 
 4 jsp 30 fail 
 5 servlet 80 pass 
 --------------------------------------------------- 
 写出此查询语句 
 
 ORACLE : select courseid, coursename ,score ,decode（sign(score-60),-1,'fail','pass') as mark from course
 
 
(DECODE函数是ORACLE PL/SQL是功能强大的函数之一，目前还只有ORACLE公司的SQL提供了此函数)
 
 
 
(SQL: select courseid, coursename ,score ,（case when score<60 then 'fail' else 'pass' end) as mark from course )
 

 
数据的竖向值转化为横向显示
 原数据表test
 
 想要的结果如下：
 
 sql如下：
 
select DISTINCT id,name,
(SELECT score FROM test t WHERE cour = '语文' and t.id=test.id) as '语文' ,
(SELECT score FROM test t WHERE cour = '数学' and t.id=test.id) as '数学' ,
(SELECT score FROM test t WHERE cour = '英语' and t.id=test.id) as '英语',
(SELECT score FROM test t WHERE cour = '历史' and t.id=test.id) as '历史',
 (SELECT score FROM test t WHERE cour = '化学' and t.id=test.id) as '化学'
from test GROUP BY FIELD(id,2,1,3)
 
参考链接: link.
 
 
查询数据大于80分的名称
 原数据：数据表s1
 
 结果：
 
 sql语句：
 
-- 方式1
SELECT DISTINCT name ,fenshu 
from s1
where name not in(select DISTINCT name from s1 where fenshu<=80) GROUP BY name
--方式2
SELECT name from s1 GROUP BY name having min(fenshu)>80