JavaWeb - 数据库设计 - 多表关系、三大范式、数据库的备份和还原、多表查询、事务、DCL用户、权限管理

1.多表之间的关系

　　1.分类

　　　　1.一对一：如人和身份证，一个人只能有一个身份证，一个身份证只能有一个人

　　　　2.一对多（多对一）：如部门和员工，一个部门有多个员工，一个员工只能对应一个部门

　　　　3.多对多：如学生和课程，一个学生能选择很多门课程，一个课程可以被很多个学生选择

　　2.实现关系

　　　　1.一对多（多对一）：

　　　　　　*如：部门和员工

　　　　　　*实现方式：在多的一方建立外键，指向一的一方的主键

　　　　2.多对多：

　　　　　　*如学生和课程

　　　　　　*实现方式：多对多的关系实现需要借助第三张中间表。中间表至少包含两个字段，这两个字段作为第三张表的外键，分别指向两张表的主键

　　　　3.一对一：

　　　　　　*如人和身份证

　　　　　　*实现方式：可以在任意一方添加唯一外键指向另一方的主键

案例：旅游路线

USE db3;
-- 创建旅游线路分类表
-- cid 添加旅游路线分类主键，自动增长
-- cname 旅游路线分类名称非空唯一，字符串 100
CREATE TABLE tab_category(
    cid INT PRIMARY KEY AUTO_INCREMENT,
    cname VARCHAR(100) NOT NULL UNIQUE
);

-- 创建线路表
/*
rid 旅游路线主键，自动增长
rname 旅游线路名称，非空唯一 字符串 100
price 价格
rdate 上架时间，日期类型
cid 外键 所属分类
*/
CREATE TABLE tab_road(
    rid INT PRIMARY KEY AUTO_INCREMENT,
    rname VARCHAR(100) NOT NULL UNIQUE,
    price DOUBLE,
    rdate DATE,
    cid INT,
    FOREIGN KEY (cid) REFERENCES tab_category(cid)
);

-- 创建用户表
/*
uid 用户主键，自增长
username 用户名长度 100 唯一 非空
password 密码 长度 30 非空
name 真实姓名 长度100
birthday 生日     
sex 性别 定长字符串 1
telephone 手机号，字符串 11
email 邮箱 字符串 100
*/
CREATE TABLE tab_user(
    uid INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(100) UNIQUE NOT NULL,
    PASSWORD VARCHAR(30) NOT NULL,
    NAME VARCHAR(100),
    birthday DATE,
    sex CHARACTER(1) DEFAULT '男',
    telephone VARCHAR(11),
    emaill VARCHAR(100)
);

-- 添加收藏表
/*
rid 旅游线路 id，外键
date 收藏时间
uid 用户id，外键
rid和uid不能重复，设置复合主键，同一个用户不能收藏一个线路两次
*/
CREATE TABLE tab_favorite(
    rid INT,  -- 线路id
    DATE DATETIME,
    uid INT,  -- 用户id
    -- 创建复合主键
    PRIMARY KEY(rid,uid),  -- 联合主键
    FOREIGN KEY(rid) REFERENCES tab_road(rid),
    FOREIGN KEY(uid) REFERENCES tab_user(uid)
);

2.三大范式

　　第一范式：数据库表的每一列都是不可分割的原子数据项

　　第二范式：在1NF的基础上，非码属性必须完全依赖于码（在1NF的基础上消除非主属性对主码的部分函数依赖）

　　　　*函数依赖：A-->B，如果通过A属性（属性组）的值能确定唯一B属性的值，则称B依赖于A

　　　　　　例如：学号被姓名所依赖（学号，课程名称） - - > 分数

　　　　*完全函数依赖：A-->B，如果A是一个属性组，则B属性值的确定需要依赖于A属性组中所有的属性值。

　　　　　　例如：（学号，课程名称） - - > 分数称该属性组被分数安全依赖

　　　　*部分函数依赖：A-->B，如果A是一个属性组，则B属性值的确定只需要依赖于A属性组中某一些值即可。

　　　　　　例如：（学号，课程名称） - - >姓名学号即可确定姓名

　　　　*传递函数依赖：A-->B，B-->C，如果通过A属性（属性组）的值，可以确定唯一B属性的值，再通过B属性（属性组）的值可以确定唯一C属性的值，则称C传递函数依赖于A

　　　　　　例如：学号-->系名，系名-->系主任

　　　　*码：如果在一张表中，一个属性或属性组，被其他所有属性所完全依赖，则称这个属性（属性组）为该表的码

　　　　　　例如：该表中码为：（学号，课程名称）该属性组能确定其他所有数据

　　　　　　主属性：码属性组中的所有属性该表中为学号，课程名称

　　　　　　非主属性：除了码属性组的属性

　　第三范式：在2NF基础上，任何非主属性不依赖于其它非主属性（在2NF基础上消除传递依赖）

3.数据库的备份和还原

　　（1）命令行

　　　　*备份语法： mysqldump -u用户名 -p密码数据库名称 > 保存的路径

　　　　*还原：

　　　　　　1.登录数据库 mysql -u 用户名 -p 密码；

　　　　　　2.创建数据库 create database 数据库名称；

　　　　　　3.使用数据库 use 数据库名称；

　　　　　　4.执行文件 source 文件路径；

　　（2）图形化工具右键备份还原再导入脚本

4.多表查询

　　准备sql：

CREATE TABLE dept( id INT PRIMARY KEY AUTO_INCREMENT, NAME VARCHAR(20) ); 
INSERT INTO dept(NAME) VALUES('开发部'),('市场部'),('财务部'); 
CREATE TABLE emp(
    id INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(10),
    gender CHAR(1),
    salary DOUBLE,
    join_date DATE,
    dept_id INT,
    FOREIGN KEY (dept_id) REFERENCES dept(id)
);

INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('孙悟空','男',7200,'2013-02-24',1);
INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('猪八戒','男',3600,'2010-12-02',2);
INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('唐僧','男',9000,'2008-08-08',2);
INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('白骨精','女',5000,'2015-10-07',3);
INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('蜘蛛精','女',4500,'2011-03-14',1);

　　笛卡尔积：有两个集合A,B，取这两个集合的所有组成情况，要完成多表查询，需要消除无用的数据

　　多表查询的分类：

　　　　（1）内连接查询：

　　　　　　　　隐式内连接：使用where条件消除无用数据

　　　　　　　　　　例：查询所有员工信息和对应的部门信息： SELECT * FROM emp,dept WHERE dept.id = emp.`dept_id`;

　　　　　　　　　　例：查询员工表的名称，性别，部门表的名称： SELECT emp.`name`,emp.`gender`,dept.name FROM emp,dept WHERE dept.id = emp.`dept_id`;

　　　　　　　　　　一般取别名：

SELECT 
    t1.`name`,  -- 员工表姓名
    t1.`gender`, -- 员工表性别
    t2.name  -- 部门表姓名
FROM 
    emp t1, -- 员工表 别名t1,
    dept t2 -- 部门表 别名t2
WHERE 
    t1.`dept_id` = t2.id;

　　　　　　　　显式内连接：

　　　　　　　　　　　　语法：select 字段列表 from 表名1 [ inner] join 表名2 on 条件；

　　　　　　　　内连接查询的几项事项：

　　　　　　　　　　*从那些表中查询数据

　　　　　　　　　　*条件是什么

　　　　　　　　　　*查询那些字段

　　　　（2）外连接查询：

　　　　　　　　左外连接：　　

　　　　　　　　　　语法：select 查询字段列表 from 表1 left 【outer】 join 表2 on

　　　　　　　　　　*查询的是左表所有数据以及其交集（满足where条件的交集）部分

　　　　　　　　　　例子：查询所有员工信息，如果员工有部门，则查询部门名称，没有部门则不显示部门名称　　

SELECT 
    t1.*,t2.name 
FROM 
    emp t1 
LEFT JOIN     
    dept t2 
ON     
    t2.id = t1.`dept_id`;

　　　　　　　　右外连接：

　　　　　　　　　　语法：select 查询字段列表 from 表1 right 【outer】 join 表2 on

　　　　　　　　　　*查询的是右表所有数据以及其交集部分

　　　　（3）子查询：查询中嵌套查询，称嵌套查询为子查询

　　　　　　　　例如：查询最高工资的员工信息

　　　　　　　　　　SELECT * FROM emp WHERE salary = (SELECT MAX(salary) FROM emp);

　　　　　　子查询不同情况：

　　　　　　　　1.子查询的结果是单行单列的：

　　　　　　　　　　*子查询可以作为条件，使用运算符去判断

　　　　　　　　2.子查询的结果是多行单列的：

　　　　　　　　　　*子查询可以作为条件，使用运算符in来判断

-- 查询财务部和市场部的所有员工信息
SELECT id FROM dept WHERE NAME IN ('财务部','市场部');
SELECT * FROM emp WHERE dept_id IN (3,2);
SELECT * FROM emp WHERE dept_id IN (SELECT id FROM dept WHERE NAME IN ('财务部','市场部'));

　　　　　　　　3.子查询的结果是多行多列的：

　　　　　　　　　　*子查询可以作为一个虚拟表参与查询

-- 查询员工入职日期是2011-11-11日之后的员工信息和部门信息
SELECT * FROM emp WHERE join_date > '2011-11-11';

-- 将以上的表作为虚拟表 做内连接
SELECT * FROM dept t1, (SELECT * FROM emp WHERE join_date > '2011-11-11') t2 WHERE t1.`id` = t2.dept_id;

练习：

-- 部门表
CREATE TABLE dept (
  id INT PRIMARY KEY PRIMARY KEY, -- 部门id
  dname VARCHAR(50), -- 部门名称
  loc VARCHAR(50) -- 部门所在地
);

-- 添加4个部门
INSERT INTO dept(id,dname,loc) VALUES 
(10,'教研部','北京'),
(20,'学工部','上海'),
(30,'销售部','广州'),
(40,'财务部','深圳');



-- 职务表，职务名称，职务描述
CREATE TABLE job (
  id INT PRIMARY KEY,
  jname VARCHAR(20),
  description VARCHAR(50)
);

-- 添加4个职务
INSERT INTO job (id, jname, description) VALUES
(1, '董事长', '管理整个公司，接单'),
(2, '经理', '管理部门员工'),
(3, '销售员', '向客人推销产品'),
(4, '文员', '使用办公软件');



-- 员工表
CREATE TABLE emp (
  id INT PRIMARY KEY, -- 员工id
  ename VARCHAR(50), -- 员工姓名
  job_id INT, -- 职务id
  mgr INT , -- 上级领导
  joindate DATE, -- 入职日期
  salary DECIMAL(7,2), -- 工资
  bonus DECIMAL(7,2), -- 奖金
  dept_id INT, -- 所在部门编号
  CONSTRAINT emp_jobid_ref_job_id_fk FOREIGN KEY (job_id) REFERENCES job (id),
  CONSTRAINT emp_deptid_ref_dept_id_fk FOREIGN KEY (dept_id) REFERENCES dept (id)
);

-- 添加员工
INSERT INTO emp(id,ename,job_id,mgr,joindate,salary,bonus,dept_id) VALUES 
(1001,'孙悟空',4,1004,'2000-12-17','8000.00',NULL,20),
(1002,'卢俊义',3,1006,'2001-02-20','16000.00','3000.00',30),
(1003,'林冲',3,1006,'2001-02-22','12500.00','5000.00',30),
(1004,'唐僧',2,1009,'2001-04-02','29750.00',NULL,20),
(1005,'李逵',4,1006,'2001-09-28','12500.00','14000.00',30),
(1006,'宋江',2,1009,'2001-05-01','28500.00',NULL,30),
(1007,'刘备',2,1009,'2001-09-01','24500.00',NULL,10),
(1008,'猪八戒',4,1004,'2007-04-19','30000.00',NULL,20),
(1009,'罗贯中',1,NULL,'2001-11-17','50000.00',NULL,10),
(1010,'吴用',3,1006,'2001-09-08','15000.00','0.00',30),
(1011,'沙僧',4,1004,'2007-05-23','11000.00',NULL,20),
(1012,'李逵',4,1006,'2001-12-03','9500.00',NULL,30),
(1013,'小白龙',4,1004,'2001-12-03','30000.00',NULL,20),
(1014,'关羽',4,1007,'2002-01-23','13000.00',NULL,10);



-- 工资等级表
CREATE TABLE salarygrade (
  grade INT PRIMARY KEY,   -- 级别
  losalary INT,  -- 最低工资
  hisalary INT -- 最高工资
);

-- 添加5个工资等级
INSERT INTO salarygrade(grade,losalary,hisalary) VALUES 
(1,7000,12000),
(2,12010,14000),
(3,14010,20000),
(4,20010,30000),
(5,30010,99990);

-- 需求：

-- 1.查询所有员工信息。查询员工编号，员工姓名，工资，职务名称，职务描述
SELECT
    t1.id, -- 员工编号
    t1.`ename`, -- 员工姓名
    t1.`salary`, -- 员工工资
    t2.`jname`, -- 职务名称
    t2.`description` -- 职务描述
FROM
    emp t1,job t2
WHERE 
    t1.`job_id`=t2.`id`;
    
-- 2.查询员工编号，员工姓名，工资，职务名称，职务描述，部门名称，部门位置
SELECT
    t1.id, -- 员工编号
    t1.`ename`, -- 员工姓名
    t1.`salary`, -- 员工工资
    t2.`jname`, -- 职务名称
    t2.`description`, -- 职务描述
    t3.`dname`, -- 部门名称
    t3.`loc` -- 部门位置
FROM
    emp t1,job t2,dept t3
WHERE 
    t1.`job_id`=t2.`id` AND t1.`dept_id`=t3.`id`;   
-- 3.查询员工姓名，工资，工资等级
/*
    分析：
        条件：emp.salary between salarygrade.losalary and salarygrade.hisalary

*/
SELECT 
    t1.`ename`, -- 员工姓名
    t1.`salary`, -- 员工工资
    t2.`grade`  -- 工资等级
FROM 
    emp t1,salarygrade t2
WHERE 
    t1.`salary` BETWEEN t2.`losalary` AND t2.`hisalary`;
-- 4.查询员工姓名，工资，职务名称，职务描述，部门名称，部门位置，工资等级
/*
    分析条件：
        t1.`job_id`=t2.`id` AND t1.`dept_id`=t3.`id` and emp.salary between salarygrade.losalary and salarygrade.hisalary

*/
SELECT 
    t1.`ename`, -- 员工姓名
    t1.`salary`, -- 员工工资
    t2.`jname`, -- 职务名称
    t2.`description`, -- 职务描述
    t3.`dname`, -- 部门名称
    t3.`loc`, -- 部门位置
    t4.`grade` -- 工资等级
FROM 
    emp t1,job t2,dept t3,salarygrade t4
WHERE 
    t1.`job_id` = t2.`id` 
    AND t1.`dept_id` = t3.`id` 
    AND t1.`salary` BETWEEN t4.`losalary` AND t4.`hisalary`;
-- 5.查询出部门编号、部门名称、部门位置、部门人数
/*
    分析：
        1.部门编号、部门名称、部门位置 dept表，部门人数 emp表
        2.使用分组查询。按照emp.dept_id完成分组，查询count（id）
        3.使用子查询将第二步的查询结果作为虚拟表和dept表进行关联查询
*/
SELECT dept_id,COUNT(id) FROM emp GROUP BY  dept_id; -- 作为虚拟表
SELECT 
    t1.id, -- 部门编号
    t1.`dname`, -- 部门名称
    t1.`loc`, -- 部门位置
    t2.total -- 部门人数
FROM 
    dept t1,
    (SELECT dept_id,COUNT(id) total FROM emp GROUP BY  dept_id) t2 
WHERE
    t1.`id` = t2.dept_id
-- 6.查询所有员工的姓名及其直接上级的姓名,没有领导的员工也需要查询
/*
    分析：
        1.员工姓名 emp， 直接上级的姓名 emp
            emp表的id 和 mgr是自关联的
        2.条件：emp.id = emp.mgr
        3.查询左表的所有数据和交集数据
            *使用左外连接查询
*/
SELECT
    t1.ename, -- 员工姓名
    t1.mgr, -- 员工的领导编号
    t2.id, -- 领导的id
    t2.ename -- 领导的名字
FROM emp t1
LEFT JOIN emp t2
ON t1.mgr = t2.id;

View Code

5.事务基础

　　概念：如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败

　　操作：

　　　　（1）开启事务： start transaction;

　　　　（2）回滚：rollback；

　　　　（3）提交：commit；

　　修改事务的默认提交方式：

　　　　*查看事务的默认提交方式：SELECT @@autocommit; 1 代表自动提交 0代表手动提交 Oracle数据库默认手动提交！！！

　　　　*修改默认提交方式：set @@autocommit = 0；

**6.事务的四大特征

　　（1）原子性：是不可分割的最小操作单位，要么同时成功，要么同时失败

　　（2）持久性：当事务提交或回滚后，数据库会持久化的保存数据

　　（3）隔离性：多个事务之间相互独立　　

　　（4）一致性：事务操作前后数据总量不变

7.事务的隔离级别

　　概念：多个事务之间是隔离的，相互独立的。则会引发一下问题，设置不同的隔离级别就可以解决这些问题

　　*存在问题：

　　　　（1）脏读：一个事务，读取到另一个事务中没有提交的数据

　　　　（2）不可重复读（虚读）：在同一个事务中，两次读取到的数据不一样

　　　　（3）幻读：一个事务操作（DML）数据表中所有的记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改

　　*隔离级别：

　　　　（1）read uncommitted：读未提交

　　　　　　*产生的问题：脏读、不可重复读、幻读

　　　　（2）read committed：读已提交（Oracle默认）

　　　　　　*产生的问题：不可重复度、幻读

　　　　（3）repeatable read：可重复度（Mysql默认）

　　　　　　*产生的问题：幻读

　　　　（4）serializable：串行化相当于加锁一个事务在操作一个数据库表时，另一个事务不可操作

　　　　　　*可以解决所有的问题

　　　　*注意：隔离级别从小到大安全性越来越高，但是效率越来越低

　　　　*数据库查询隔离级别：select @@tx_isolation;

　　　　*数据库设置隔离级别：set global transaction isolation level 级别字符串；

8.DCL 管理用户授权

　　*DBA：数据库管理员

　　（1）管理用户：

　　　　*添加用户：

　　　　　　create user '用户名'@'主机名' identified by '密码'; 如果要任意用户都能登录则主机名写%

　　　　*删除用户：

　　　　　　drop user '用户名'@‘主机名’

　　　　*修改用户密码：

　　　　　　update user set password = password('新密码') where user = '用户名';

　　　　　　set password for '用户名'@'主机名' = password('新密码');

　　　　　　*mysql中忘记了root用户的密码？

　　　　　　　　1.cmd - - > net stop mysql 停止mysql服务要注意：需要管理员身份运行该cmd

　　　　　　　　2.使用无验证方式启动mysql服务：mysqld -- skip-grant-tables

　　　　　　　　3.打开新的cmd窗口直接输入 mysql 命令回车就可以登录成功

　　　　　　　　4.use mysql；然后 update user set password = password（'新密码'） where user = 'root';

　　　　　　　　5.关闭两个窗口，打开任务管理器，手动结束mysqld.exe的进程

　　　　　　　　6.启动mysql的服务 net start mysql;

　　　　*查询用户：

　　　　　　切换到mysql数据库查询user表 use mysql； select * from user；

　　　　　　通配符：% 表示可以在任意主机使用用户登录数据库

　　（2）权限管理：

　　　　　1.查询权限：

　　　　　　　　show grants for '用户名'@'主机名';

　　　　　2.授予权限：

　　　　　　　　grant 权限列表 on 数据库.表名 to '用户名'@'主机名'；

　　　　　　　　授予张三所有权限：grant all on . to 'zhangsan'@'localhost';

　　　　　3.撤销权限：

　　　　　　　　revoke 权限列表 on 数据库名.表名 from '用户名'@'主机名';

posted @ 2020-06-03 15:22 五号世界阅读(484) 评论(0) 收藏举报

刷新页面返回顶部

五号世界

JavaWeb - 数据库设计 - 多表关系、三大范式、数据库的备份和还原、多表查询、事务、DCL用户、权限管理

1.多表之间的关系

1.分类

1.一对一：如人和身份证，一个人只能有一个身份证，一个身份证只能有一个人

2.一对多（多对一）：如部门和员工，一个部门有多个员工，一个员工只能对应一个部门

3.多对多：如学生和课程，一个学生能选择很多门课程，一个课程可以被很多个学生选择

2.实现关系

1.一对多（多对一）：

*如：部门和员工

*实现方式：在多的一方建立外键，指向一的一方的主键

2.多对多：

*如学生和课程

*实现方式：多对多的关系实现需要借助第三张中间表。中间表至少包含两个字段，这两个字段作为第三张表的外键，分别指向两张表的主键

3.一对一：

*如人和身份证

*实现方式：可以在任意一方添加唯一外键指向另一方的主键

案例：旅游路线

2.三大范式

第一范式：数据库表的每一列都是不可分割的原子数据项

第二范式：在1NF的基础上，非码属性必须完全依赖于码（在1NF的基础上消除非主属性对主码的部分函数依赖）

*函数依赖：A-->B， 如果通过A属性（属性组）的值能确定唯一B属性的值，则称B依赖于A

例如：学号被姓名所依赖 （学号，课程名称） - - > 分数

*完全函数依赖：A-->B，如果A是一个属性组，则B属性值的确定需要依赖于A属性组中所有的属性值。

例如：（学号，课程名称） - - > 分数 称该属性组被分数安全依赖

*部分函数依赖：A-->B，如果A是一个属性组，则B属性值的确定只需要依赖于A属性组中某一些值即可。

例如：（学号，课程名称） - - >姓名 学号即可确定姓名

*传递函数依赖：A-->B，B-->C，如果通过A属性（属性组）的值，可以确定唯一B属性的值，再通过B属性（属性组）的值可以确定唯一C属性的值，则称C传递函数依赖于A

例如：学号-->系名，系名-->系主任

*码：如果在一张表中，一个属性或属性组，被其他所有属性所完全依赖，则称这个属性（属性组）为该表的码

例如：该表中码为：（学号，课程名称） 该属性组能确定其他所有数据

主属性：码属性组中的所有属性 该表中为学号，课程名称

非主属性：除了码属性组的属性

第三范式：在2NF基础上，任何非主属性不依赖于其它非主属性（在2NF基础上消除传递依赖）

3.数据库的备份和还原

（1）命令行

*备份语法： mysqldump -u用户名 -p密码 数据库名称 > 保存的路径

*还原：

1.登录数据库 mysql -u 用户名 -p 密码；

2.创建数据库 create database 数据库名称；

3.使用数据库 use 数据库名称；

4.执行文件 source 文件路径；

（2）图形化工具 右键备份还原 再导入脚本

4.多表查询

准备sql：

笛卡尔积：有两个集合A,B，取这两个集合的所有组成情况，要完成多表查询，需要消除无用的数据

多表查询的分类：

（1）内连接查询：

隐式内连接：使用where条件消除无用数据

例：查询所有员工信息和对应的部门信息 ： SELECT * FROM emp,dept WHERE dept.id = emp.`dept_id`;

例：查询员工表的名称，性别，部门表的名称 ： SELECT emp.`name`,emp.`gender`,dept.name FROM emp,dept WHERE dept.id = emp.`dept_id`;

一般取别名：

显式内连接：

语法：select 字段列表 from 表名1 [ inner] join 表名2 on 条件；

内连接查询的几项事项：

*从那些表中查询数据

*条件是什么

*查询那些字段

（2）外连接查询：

左外连接：

语法：select 查询字段列表 from 表1 left 【outer】 join 表2 on

*查询的是左表所有数据以及其交集（满足where条件的交集）部分

例子： 查询所有员工信息，如果员工有部门，则查询部门名称，没有部门则不显示部门名称

右外连接：

语法：select 查询字段列表 from 表1 right 【outer】 join 表2 on

*查询的是右表所有数据以及其交集部分

（3）子查询：查询中嵌套查询，称嵌套查询为子查询

例如：查询最高工资的员工信息

SELECT * FROM emp WHERE salary = (SELECT MAX(salary) FROM emp);

子查询不同情况：

1.子查询的结果是单行单列的：

*子查询可以作为条件，使用运算符去判断

2.子查询的结果是多行单列的：

*子查询可以作为条件，使用运算符in来判断

3.子查询的结果是多行多列的：

*子查询可以作为一个虚拟表参与查询

练习：

5.事务基础

概念：如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败

操作：

　　1.分类

　　　　1.一对一：如人和身份证，一个人只能有一个身份证，一个身份证只能有一个人

　　　　2.一对多（多对一）：如部门和员工，一个部门有多个员工，一个员工只能对应一个部门

　　　　3.多对多：如学生和课程，一个学生能选择很多门课程，一个课程可以被很多个学生选择

　　2.实现关系

　　　　1.一对多（多对一）：

　　　　　　*如：部门和员工

　　　　　　*实现方式：在多的一方建立外键，指向一的一方的主键

　　　　2.多对多：

　　　　　　*如学生和课程

　　　　　　*实现方式：多对多的关系实现需要借助第三张中间表。中间表至少包含两个字段，这两个字段作为第三张表的外键，分别指向两张表的主键

　　　　3.一对一：

　　　　　　*如人和身份证

　　　　　　*实现方式：可以在任意一方添加唯一外键指向另一方的主键

　　第一范式：数据库表的每一列都是不可分割的原子数据项

　　第二范式：在1NF的基础上，非码属性必须完全依赖于码（在1NF的基础上消除非主属性对主码的部分函数依赖）

　　　　*函数依赖：A-->B，如果通过A属性（属性组）的值能确定唯一B属性的值，则称B依赖于A

　　　　　　例如：学号被姓名所依赖（学号，课程名称） - - > 分数

　　　　*完全函数依赖：A-->B，如果A是一个属性组，则B属性值的确定需要依赖于A属性组中所有的属性值。

　　　　　　例如：（学号，课程名称） - - > 分数称该属性组被分数安全依赖

　　　　*部分函数依赖：A-->B，如果A是一个属性组，则B属性值的确定只需要依赖于A属性组中某一些值即可。

　　　　　　例如：（学号，课程名称） - - >姓名学号即可确定姓名

　　　　*传递函数依赖：A-->B，B-->C，如果通过A属性（属性组）的值，可以确定唯一B属性的值，再通过B属性（属性组）的值可以确定唯一C属性的值，则称C传递函数依赖于A

　　　　　　例如：学号-->系名，系名-->系主任

　　　　*码：如果在一张表中，一个属性或属性组，被其他所有属性所完全依赖，则称这个属性（属性组）为该表的码

　　　　　　例如：该表中码为：（学号，课程名称）该属性组能确定其他所有数据

　　　　　　主属性：码属性组中的所有属性该表中为学号，课程名称

　　　　　　非主属性：除了码属性组的属性

　　第三范式：在2NF基础上，任何非主属性不依赖于其它非主属性（在2NF基础上消除传递依赖）

　　（1）命令行

　　　　*备份语法： mysqldump -u用户名 -p密码数据库名称 > 保存的路径

　　　　*还原：

　　　　　　1.登录数据库 mysql -u 用户名 -p 密码；

　　　　　　2.创建数据库 create database 数据库名称；

　　　　　　3.使用数据库 use 数据库名称；

　　　　　　4.执行文件 source 文件路径；

　　（2）图形化工具右键备份还原再导入脚本

　　准备sql：

　　笛卡尔积：有两个集合A,B，取这两个集合的所有组成情况，要完成多表查询，需要消除无用的数据

　　多表查询的分类：

　　　　（1）内连接查询：

　　　　　　　　隐式内连接：使用where条件消除无用数据

　　　　　　　　　　例：查询所有员工信息和对应的部门信息： SELECT * FROM emp,dept WHERE dept.id = emp.`dept_id`;

　　　　　　　　　　例：查询员工表的名称，性别，部门表的名称： SELECT emp.`name`,emp.`gender`,dept.name FROM emp,dept WHERE dept.id = emp.`dept_id`;

　　　　　　　　　　一般取别名：

　　　　　　　　显式内连接：

　　　　　　　　　　　　语法：select 字段列表 from 表名1 [ inner] join 表名2 on 条件；

　　　　　　　　内连接查询的几项事项：

　　　　　　　　　　*从那些表中查询数据

　　　　　　　　　　*条件是什么

　　　　　　　　　　*查询那些字段

　　　　（2）外连接查询：

　　　　　　　　左外连接：　　

　　　　　　　　　　语法：select 查询字段列表 from 表1 left 【outer】 join 表2 on

　　　　　　　　　　*查询的是左表所有数据以及其交集（满足where条件的交集）部分

　　　　　　　　　　例子：查询所有员工信息，如果员工有部门，则查询部门名称，没有部门则不显示部门名称　　

　　　　　　　　右外连接：

　　　　　　　　　　语法：select 查询字段列表 from 表1 right 【outer】 join 表2 on

　　　　　　　　　　*查询的是右表所有数据以及其交集部分

　　　　（3）子查询：查询中嵌套查询，称嵌套查询为子查询

　　　　　　　　例如：查询最高工资的员工信息

　　　　　　　　　　SELECT * FROM emp WHERE salary = (SELECT MAX(salary) FROM emp);

　　　　　　子查询不同情况：

　　　　　　　　1.子查询的结果是单行单列的：

　　　　　　　　　　*子查询可以作为条件，使用运算符去判断

　　　　　　　　2.子查询的结果是多行单列的：

　　　　　　　　　　*子查询可以作为条件，使用运算符in来判断

　　　　　　　　3.子查询的结果是多行多列的：

　　　　　　　　　　*子查询可以作为一个虚拟表参与查询

　　概念：如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败

　　操作：

　　　　（1）开启事务： start transaction;

　　　　（2）回滚：rollback；

　　　　（3）提交：commit；

　　修改事务的默认提交方式：

　　　　*查看事务的默认提交方式：SELECT @@autocommit; 1 代表自动提交 0代表手动提交 Oracle数据库默认手动提交！！！

　　　　*修改默认提交方式：set @@autocommit = 0；

　　（1）原子性：是不可分割的最小操作单位，要么同时成功，要么同时失败

　　（2）持久性：当事务提交或回滚后，数据库会持久化的保存数据

　　（3）隔离性：多个事务之间相互独立　　