数据库系统概念|关系模型|SQL介绍|中级高级SQL|ER模型设计|函数依赖与关系型数据库|事务|并发控制|日志恢复系统|关键的英文单词目录

数据库系统概念学习笔记

Database System Concepts, 7E

第7版

---

前记：

• 整本书学习的是SQL标准，而不是某个具体的数据库。书上有句话这样说的：“尽管我们在这里介绍的部分语法在这些系统上并不支持，但是我们所阐述的概念在不同实现上都是适用的，虽然存在语法上的区别”，这就是学习SQL标准的意义。

---

一、引言

1. 数据库管理系统（DBMS）：由一个互相关联的数据的集合和一组用以访问这些数据的程序组成。

   即 DBMS = 数据 + 程序。

2. 原子性（atomicity）：要么全部发生，要么全部不发生。不可分割。

3. 一致性（consistency）：即某种正确性。

4. 数据模型：一个描述数据、数据联系、数据主义以及一致性约束的概念工具集合。

   • 关系模型：用表的集合来表示数据和数据间的关系。
   • 实体-联系模型
   • 半结构化数据模型。如JSON，XML
   • 对象数据模型。

5. 数据抽象：用来对用户屏蔽系统的复杂性

   • 物理层：描述数据具体是怎么存储的，包含大量复杂的数据结构
   • 逻辑层：描述数据库中存储什么数据以及这些数据间的关系
   • 视图层：描述整个数据库的某个部分。不同用户有不同的视图层

   

6. 数据库模式（这里指的是设计方面的）：数据库中总体的设计。

   根据数据抽象的层次，可分为物理模式（即物理上的设计，其他同理），逻辑模式，视图模式（子模式）。

7. DDL：Data-Definition Language：来说明数据库系统所采用的存储结构和访问方式（用逻辑的方式描述）。又称为数据存储和定义语言。（data storage and definition language)

8. DML：Data-Manipulation Language：访问或者操纵数据的语言

   • 过程化的DML（Procedural DML）：实现算法的，要具体描述如何获得数据的
   • 声明式的DML（declarative DML）：指定需要什么数据即可

9. 数据字典：可以看作某种表。数据库在读取和修改数据的时候都要参照这个表。

10. 完整性约束（integrity constraint)

    • 域约束：规定取值范围 (值)
    • 引用完整性：一个关系上的取值也在另一个关系上存在 （表）
    • 授权：不同用户有不同权限，如读，删除，更新等 （用户）

11. 数据库系统功能部件有三个部分：

    • 存储管理器
    • 查询处理器
    • 事务管理部件

12. 数据库体系图：

二、关系模型介绍

1基本概念

1. 关系数据库：由表的集合构成，用表的集合来表示数据和数据间的关系。
2. 关系数据模型名称的由来：表的一行代表了某种联系，而表是这种联系的一个集合，又刚好和数学上的关系概念有密切由来，所以就叫做关系型。即 ：关系（表），是数据联系（行）的集合。
3. 元组tuple：数学上是指n个值之间的联系。即对应数据库表中的一行。
4. 关系relation：指代表。但是，关系在数学上是指set（集合），元组是不能重复的。和表不同。可以说，表是关系的一种实现方式。
5. 元组tuple：指代行。
6. 属性attribute：指代列
7. 关系实例：一个关系的特定实例，即一组特定的行
8. 模式：即逻辑设计。
   • 数据库模式（database schema）对应着关系模式。是数据库的逻辑设计。
   • 数据库实例（database instance）对应着关系实例。是给定时刻数据库中数据的快照
9. 联系（行）的集合是关系（表），将关系抽象出来，就变成关系模式（所有列）

2码key

内码（自己乱编的名字）

1. 码的作用：用来区分一个给定关系中的不同元组

2. 超码（superkey）：能够唯一标识出一个元组

3. 候选码（candicate key）：对于一个特定的超码而言，最小的属性集合。

   请注意：这里的“最小”，是相对于一个特定超码的最小，而不是说在所有的候选码中最小。

4. 主码（primary key）：把候选码选出来，就称作主码

外码

1. 外码约束(foreing-key constraint) :引用关系（referencing relation）中的属性值是被引用关系(referenced relation)的主码
2. 引用完整性约束（referential integrity constraint）：引用关系中的出现的值必然出现在被引用关系的一个或多个元组上
3. 外码约束是引用完整性约束的一个特例。把桥梁变成了主码而已

3关系代数

定义

关系代数由一组运算组成，接受一个或两个关系作为输入，并生成一个新的关系。

即 输入 、 输出 都是关系。

实例

请注意：无论这些运算多么复杂，最后的结果都是一个关系。

1. 选择select运算（sql中的where）

2. 投影project运算（sql中的select）

3. 笛卡尔积Cartesian product

4. 连接join运算

5. 集合运算

   • 交intersection， 并Union， 差set-difference

   • 两个关系的元数要相同。元数（arity）指属性的数量

   • 每个关系对应属性要相同。即相容。

6. 赋值assignment运算

7. 更名rename运算

三、SQL介绍

1概览

SQL语言的组成部分：即SQL语言有哪方面的功能

1. DDL
2. DML
3. 完整性
4. 视图定义
5. 事务控制
6. 嵌入式sql
7. 授权

2数据定义

基本类型

基本的定义参照其他笔记。P46。

注意点：

1. char是固定长度的，如果存放的不够长，会追加空格
2. 比较char前，如果长度不一致，会先追加空格
3. 比较varchar和char如果长度不一致，不同数据库有不同处理结果。即不一定会用追加空格的形式比较。

基本模式定义

create table section(
`id` VARCHAR(8),
`NAME` VARCHAR(8),
`c_id` VARCHAR(8),
PRIMARY KEY(`id`，`name`),
FOREIGN KEY (`c_id`) REFERENCES course(`id`) --id 是course的主键
);


drop table <table_name>; --删除表
alter table <table_name> add <attribute> <domain>; -- 增加列
alter table <table_name> drop <attribute>; --去掉列
ALTER TABLE <table_name> MODIFY <attribute> <domain> -- 修改属性

3查询的基本结构

单关系查询

select <attributes...>
from <table>
where xxx


all : 显式指明不去除重复的，是缺省的
distinct : 去掉重复的

多关系查询

select A1,A2,……An
from r1,r2,……,rn   //这是一个笛卡尔积
where P;

上述sql的查询步骤如下：（实际上不会出现这个形式的查询，sql会尽可能地只产生满足于where子句的元组来进行优化执行）

1. 为from中子句产生笛卡尔积
2. 对步骤1 应用笛卡尔积
3. 对于步骤2产生的元组，通过select映射出去

4附加的基本运算

杂项

1. 更名： as ; 更名。也称表别名，相关名称，相关变量，元组变量
2. “*” : 代表所有的属性
3. 排序：
   • 关键字 ： order by
   • 升序：是缺省的， asc
   • 降序：dec
   • 多次序排序 ： order by A1,A2,A3
4. (between and) = (<= and >=), 即闭区间
5. 行构造器 ： (v1,v2,……,vn)。 当 a1 <= b1 且 a2 <= b2 时，(a1, a2) <= (b1, b2)为真

模式匹配

1. % ： 匹配任意子串 （称为模式字符

2. _ : 匹配任意一个字符（称为模式字符

3. like 和 not like: 用来表达模式。MySql中是大小写不敏感的。

4. escape关键字：

   • 定义转义字符
   • like ‘ab%cd%’ escape '\ ’ 匹配以 " ab%cd"开头的字符串

5集合运算

1. 交、并、差： intersect , union, except
2. 会自动地去重。如果要不去重：则 union all, intersect all, except all

6空值

1. 对于运算：结果为空。如 1 + null = null 。
2. 对于比较：创造了除了true Or false 的第三种逻辑： unknown
3. is null 和 is not null 来测试空值
4. is unknown 来测试一个比较运算的结果是否为unknown : 如 ： where salary > 100 is unknown
5. where 对于逻辑结果是false和unknown的结果，不返回。即where 子句只返回true的结果
6. 在distinct 中， null = null 是被认为是true 的， 而不是unknown。所以只保留一个null。
7. 在集合运算中，空的运算规则与distinct一样，如果不用如union all, 则只保留一个null。
8. 聚合函数sum对null计算时，会自动忽略null值，所以结果不会是空
9. 聚合函数count对于null 是会计算的。但对空集计算，则为0。

7聚合函数

五个标准的聚合函数

1. avg
2. min
3. max
4. sum
5. count

分组聚合

1. group by ： 所有属性上取值相同的元组会被分在同一个组内。如 group by A1, A2, 则A1，A2属性相同的为一组。
2. Having 子句：
   • 对形成分组后应用having 。
   • 所以可以在having中使用聚合函数
   • 相当于对每个分组单独用where条件谓词限制
3. 聚合规则：
   • 任何没有出现在group by 子句的属性如果出现在select子句中，它只能作为聚合函数的参数，否则这样的查询就是错误的
   • 任何出现在having子句中，但没有被聚合的属性必须出现在group by子句中
   • 本质是：保证分组后聚合后的组内每一列结果是唯一的。

8嵌套子查询

子查询相关概念

1. 子查询是嵌套在另一个查询中的select-from-where表达式
2. 相关子查询：来自外层松紧度的相关名称可以用在where子句的子查询中，被称作相关子查询（correlated subquery）
3. 标量子查询P73：子查询只返回包含单个属性的元组。

where中的子查询

1. 测试存在性。
   • in 和 not in :
   • 如 where course_id in (select course_id xxxx)
   • 可以用行构造器的方法，如 where id in (‘23’, ‘34’, ‘33’)
2. 集合比较
   • some : 至少。如 where salary < some (select salary xxxx), 即salary 至少有小于子查询结果集中的一个
   • all ： 所有。如 where salary < all (select salary xxxx), 即salary 小于子查询结果集中的所有
   • 允许大于，小于或等于运算
3. 空关系测试 ：
   • exists 和 not exists 。
   • 看一个集合是否为空。
   • 如：where exists ( select …)
4. 重复元组存在性测试
   • unique

from中的子查询

1. 本质是from 表， 而子查询的结果就是一张表
2. mysql对于from中子查询结果集必须要求重命名
3. from子句嵌套的子查询不能使用来自同一个from子句的其他关系的相关变量
   • 如from r1, r2，则r1不能用r2的相关变量
   • 使用lateral可以打破这一限制

with子句（好用）

1. 可以临时定义一个关系表

2. 例子：

   with 
   dept_total(dept_name, value) as -- dept_total(dept_name, value)定义了一个临时schema
   (
       select dept_name,sum(salary) --得到所有系的工资和，以系为单位
       from instrutor
       group by dept_name
   ),
   dept_total_avg(value) as -- 得到系平均工资
   (
       select avg(value)
       from dept_total
   )
   ---- 上面和下面语句块之间是没有分号的，也就是说他们是一体的
   select dept_name
   from dept_total,dept_total_avg
   where dept_total.value > dept_total_avg.value
   

删除、插入、更新

执行逻辑

1. 先选所有，再进行相关更新

四、中级SQL

1连接表达式

连接框图（重要）

概念

1. 连接的结果是表，通常作为from子句的子查询

2. 内外连接定义：不保留未匹配元组的连接运算被作为内连接运算。相反，保留则为外连接

3. 每一种连接都可以从连接类型与连接条件来考虑

4. 自然连接：

   • 类型：内连接
   • 连接条件：把所以相同属性的列进行连接

5. using(a1,a2)和on的区别：

   • using指定连接的属性，结果中会合并相同的属性
   • on不会合并相同的属性

6. 全外连接：是左外连接和右外连接的并运算（mysql中没有，但是可以通过 左外连接 union 右外连接 来实现）

7. 关键词inner是可选的，当join子句没有出现inner前缀时，默认（缺省）为内连接

   所以：自然连接 等价于 自然内连接

2视图

基本概念

1. 视图的概念是数据抽象的一部分。可以针对不同的用户建立不同的视图，达到安全的目的。

2. 普通的视图中，不会进行预计算和存储。会实时进行查询

3. 视图和with子句的区别：视图是全局的，而with只在定义with的本子句中有效

4. 物化视图（materialized view）：把视图的结果存储下来。如果用于定义视图的实际关系发生改变，则视图也跟着变。

5. 视图维护：保持物化视图一直在最新状态的过程。

   更新时机有两个：一是当实际表发生更新时，视图立即更新；二是当视图被调用时才根据实际表的情况进行更新。

6. 视图和实际的表在查询表现上基本一样，但在对视图运行插入更新语句时，则会出现许多的连带问题P96。（完整性约束是最大的障碍）

语法

1. 定义：

 create view <view_name> as <查询表达式>
 
 create view my_view as
 	select ID,name
 	from instructor

2. 视图的使用：和正常的表一样的使用。

   select *
   from my_view
   where ...

3事务

1. 事务（transaction）：由查询或更新语句的序列组成。

2. commit work：提交事务；rollback work：回滚事务。work是可以缺省的。

3. 事务的重大意义：提供了一种具有原子性的抽象能力。

4. 事务有自动提交的功能，可以选择关闭和打开。

5. mysql中的语法：

   SET autocommit = 0;  ------设置事务自动提交关闭
   
   START TRANSACTION --事务开始
   
   UPDATE `student` SET `name`='黄' WHERE id='1' --一旦执行，数据库的数据会立即变，但没有持久化
   UPDATE `student` SET `age`='19' WHERE id='1'
   
   COMMIT   --提交事务
   ROLLBACK  --事务回滚
   
   SET autocommit = 1  --设置事务自动提交开启
   

4完整性约束

1. 完整性约束（integrity constraint）：保证授权用户对数据库的修改不会导致数据一致性的丢失

2. 安全性约束：防止未经授权的用户访问数据库

3. 约束：

   • not null

   • unique:unique(A1, A2,A3)声明指出A1,A2,A3是一个超码

   • check(谓词，里面是一个布尔而达式即可)

     create table `a` (
     `point` int not null check(`point` > 4),
     check (`point` in (5, 6, 7))
     )
     
     
     注意在mysql中：
     原因是因为，不同于SQL，在MYSQL中，CHECK只是一段可调用但无意义的子句。MySQL会直接忽略。
     
     CHECK子句会被分析，但是会被忽略。
     请参见“CREATE TABLE语法”：接受这些子句但又忽略子句的原因是为了提高兼容性，以便更容易地从其它SQL服务器中导入代码，并运行应用程序，创建带参考数据的表
     

   • 引用完整性：

     • 外码是引用完整性的一种形式

     • 级联删除，级联更新
       

4. 给约束增加名字和去掉名字：

   给约束增加名字的好处：在删除时可以准确找到某个约束

   create table `a` (
   `point` int not null,CONSTRAINT minsarrr check(`point` > 4)
   )
   
   --删除
   alter table `a` drop CONTAINS 'minsarrr' (mysql如外键约束，主键唯一约束都有特殊的语法)
   
   -----完成创建表后，用alter关键字和add关键字增加外键
   ALTER TABLE `teacher`
   ADD CONSTRAINT `FK_gradeID` FOREIGN KEY (`gradeID`) REFERENCES `grade` (`gradeID`)
   

5. 事务中完整性约束的违反：事务在执行的过程中，完整性约束可以会被破坏，导致事务停止。可以设置成约束在事务结束时候才检查

6. 添加删除索引：(和添加约束删除约束很像的)

   ALTER TABLE <tbl_name> ADD INDEX index_name (column_list)
   alter table <table_name> drop index index_name ;
   

6模式复制

模式的复制：

create table `b` as (select * from `a`)  带数据
create table `b` like `a`   不带数据

授权

1. 授权与收权：

   grant <权限列表>
   on <关系名>
   to <用户/角色>
   
   revoke <权限列表>  -- 与上面几乎是一样的
   on <关系名>
   from <用户/角色>
   
   show grants for root@localhost; -- 查看授权情况（mysql下）
   
   简单例子：
   grant select 
   on `instructor`
   to Tom
   
   grant update(name)
   on `instructor`
   to Tom
   

2. 数据库中可以建立角色集

3. 权限的转移：授权的用户可以把自己的权利传递给其他用户

4. 授权是是通过授权图来管理的：一个用户具有权限的充要条件是：当且仅当存在从授权图的根（即代表DBA的节点）到代表该用户的节点的路径

5. 授权图：

6. 为了防止级联收权，可以用角色的身份授权

五、高级SQL

1程序设计语言与SQL

1. 从通用程序设计语言中访问SQL有两种方式：
   • 动态SQL：允许程序在运行时构建和提交SQL查询
   • 嵌入式SQL：在编译时采用预处理器来进行识别，将式SQL表达的请求转换为函数调用（用宿主语言的表达的）。即调用宿主语言的函数，相当于调用SQL语句。
2. 嵌入式数据库：如果一个程序的编写专门用来操作数据库，而且不通过这个程序，任何方法都无法访问数据库。那么称这个数据库是这个程序的嵌入式数据库

2函数与过程

函数与过程的声明

以Mysql 5.7的官方手册为例：

CREATE
	[DEFINER = user]
	PROCEDURE sp_name ([proc_parameter[,...]])
	[characteristic ...] routine_body
    
CREATE
	[DEFINER = user]
	FUNCTION sp_name ([func_parameter[,...]])
	RETURNS type
	[characteristic ...]
    routine_body
    
proc_parameter:
	[ IN | OUT | INOUT ] param_name type
        
func_parameter:
	param_name type
        
type:
	Any valid MySQL data type
        
characteristic: {
	COMMENT 'string'
	| LANGUAGE SQL
	| [NOT] DETERMINISTIC  --表示函数不随着输入的改变而改变，是一个确定化的函数
	| { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
	| SQL SECURITY { DEFINER | INVOKER }
}

routine_body:
	Valid SQL routine statement

如果routin_body是多个语句，要用混合语法：
[begin_label:] BEGIN
[statement_list]
Statement Labels
END [end_label]

实例：

一函数定义与调用

create function my_function(aCount int)
	returns VARCHAR(5)
	DETERMINISTIC
BEGIN
DECLARE countnum INTEGER;  -- 可以声明变量
	select count(*) into countnum  -- 可以在查询结果列中使用into赋值
	from `company`;
return countnum;
END

select my_function(3);

二带有out的过程

create PROCEDURE count_avg(in a_name VARCHAR(30), out res INTEGER)
BEGIN
		select avg(salary) into res
		from works
		where company_name in (
		SELECT company_name
		from works
		where employee_name = a_name
		);
END

call count_avg('CbingQuan', @res);
SELECT @res;

结构化语法

循环：

[begin_label:] BEGIN
[statement_list]
END [end_label]

[begin_label:] LOOP
statement_list
END LOOP [end_label]

[begin_label:] REPEAT    //有点像，do while；会先执行一次。
statement_list
UNTIL search_condition
END REPEAT [end_label]

[begin_label:] WHILE search_condition DO
statement_list
END WHILE [end_label]

循环的例子：
create function my_function()
returns INTEGER
BEGIN
	declare n INTEGER default 0;
	repeat
		update `a` set `a`.point = 5;
		set n = n + 1;
	until n > -1
	end repeat;
	return n; -- 结果是 n = 1;
end

分支：

if boolean
    then xxx
  elseif boolean
    then xxx
 else xxx
 end if

跳出：

leave -- = break
iterate -- = continue

3触发器

	create TRIGGER `my_trigger`  -- 创建
	after insert  -- 什么时候。可以有before,after
	on `works`    -- 哪个表
	for each row  -- 对于每一行
	begin
		-- 首先插入一条记录
		-- new 可以直接引用新行
		insert into tax value(new.employee_name, new.salary, 0, 0);
		
		update tax
		set tax.tax = 
			case
				when new.salary < 3001 then new.salary * 0.03
				when new.salary < 12001 then new.salary * 0.1 - 210
				when new.salary < 25001 then new.salary * 0.2 - 1410
				when new.salary < 35001 then new.salary * 0.25 - 2660
				when new.salary < 55001 then new.salary * 0.3 - 4410
				when new.salary < 80001 then new.salary * 0.35 - 7160
				else new.salary * 0.45 - 15160
			end
		where tax.employee_name = new.employee_name;
		
		-- 更新扣除后的工资
		update tax
		set after_salary = before_salary - tax;
	end

六、ER模型的数据库设计

1设计过程概览

1. 设计阶段
   1. 描述用户需求
   2. 用数据模型（如ER），将需求转化为数据库的概念设计
   3. 书写功能需求规格说明：确保设计的模型满足需求
   4. 将抽象的数据模型转化为数据库实现，包括逻辑设计和物理设计
2. 实体：来指代任何可明确识别的个体
3. 冗余的危害：
   • 存储空间的浪费
   • 如果对信息进行更新，要对所有此信息的拷贝进行更新。如果逻辑有漏洞，容易更新漏掉

2实体-联系模型

• ER模型的三个基本概念：实体集，联系集，属性。

• 描述的是一种总体的逻辑结构。

• 在设计时，只考虑个体天然的属性。实体集设计与实际的表设计是有区别的。

实体集

1. Entity：是现实世界中可区别于所有其他对象的一个“事物”或“对象”
2. Entity Set：共享相同性质或属性的实体集合
3. 实体集的外延(extension)：指的是具体的实体集。类比数据库中关系和关系实例的关系
4. 实体通过一组属性来表示

联系集

1. 联系（relationship）：是多个实体间的相互关联
2. 联系集：是相同类型联系的集合。由动词变化而来。
3. 联系实例（relationship instance）：具体的实体间的联系
4. 在设计阶段，联系集是不是一张表是还不确定的。
5. 参与：实体集之间的关联称为参与：如实体集E，e参与联系集R
6. 角色：实体在联系中扮演的功能被称为实体的角色
7. 联系集的度：参与联系集的实体集的数目
8. 描述性属性：联系集的属性

3Complex Attributes

1. 实体集的属性应在第一次出现时显示，后续出现的不用写。避免重复信息带来的难以区分

2. 域：每个属性可取值的集合

3. simple arrtribute：不能再划分的；composite attribute (复合)：可以被划分为其他属性

4. single-valued ：一个特定的实体只有一个特定的值；multi-valued：一个特定的实体可以同时取多个值

5. derived attribute ：可以从其他属性推导出来。不存储，在要被使用时被计算出来。

6. 图例：

4Mapping cardinality

1. 映射基数：表示一个实体通过一个联系集关联的另一些实体的数量

2. 对于二元联系集：

   • one-to-one
   • one-to-many
   • many-to-one

   表示法：many用“——”表示；one用“→”单箭头表示。

3. 参与度：如果实体集的每个实体都必须参与，那么称为实体集E在联系R的参与是全部（all）的；否则称为部分的（partial）

4. 基数范围约束法：

   注意下面这个图容易判断为从instructor到student是many-to-one的关系。实际上是one-to-many的关系。

   和箭头表示法不一样：这种约束是限制了每个实体参与联系集中的联系产次数。

   映射基数概念法（乱叫的）：判断是时候一定要从基数映射的概念来判断，即一个特定实体通过联系集可联系的另一个实体数量（通过实体在联系集中所扮演的角色来辅助判断）。

5. 一对多和多对一：是现实中的模型，可以用于指定关于在现实世界中允许哪些联系的约束。是一种概念模型，不是指在联系中的数量。但是他可以推导出实体在联系集中参与的数量。

   而基数限制，是指这个实体可以在联系中出现多少次

5Primary key

用以区分实体集或联系集中的各个实例。

Entity Set

1. 关系模式中的超码、候选码、主码的概念可以适用于实体集
2. 在一个实体集中，不允许两个实体在所有属性上有完全相同的值。（注意和数据库的表不一样。在没有确定主键前，表中的数据是可以一样的）

Relationship Set

二元联系集的主码选择取决于联系集的映射基数。

1. one-to-one：选择任意一个参与实体的主码
2. one-to-many / many-to-one ：选择“many”的这一边。通过映射基数概念法来辅助判定
3. many-to-many：所有参与实体的主码的并集

Weak entity set

1. 弱实体集的存在依赖于另一个实体集，另外一个实体集称为标识性实体集。
2. 弱实体集本身的属性称为分辨符属性
3. 用双边框的矩形描述弱实体集
4. 弱实体集的主码的选择：标识性实体集的主码 + 弱实体集的分辨符属性

6Removing Redundant Attributes in Entity Sets

可以通过联系的方式去掉实体集中的一些冗余属性。

7Reducing E-R Diagrams to Relational Schemas

表示法

1. 强实体集的表示：
   • 实体集主码作为模式的主码即可
2. 复杂属性的表示：
   • 复合属性：全部拆开，用叶子结点来表示属性
   • 多值属性：另外新建一个表，新表的主码是原表的主码+值
3. 弱实体集的表示
   • 依赖的实体主码+分辨符
4. 联系集的表示：
   • 联系集的主码作为模式的主码即可

模式的冗余

一般而言，连接弱实体集与对应的强实体集的联系集的模式是冗余的，不用给出。（注意联系集中没有描述性属性）

如上图中的sec_course联系集如果转化出模式，由于是one-to-many, 那么sec_course的主键就是section的主键，即依赖的主码+分辨符=course_id + sec_id + semester + year, 所有是属性是冗余的。

模式的合并

1. many-to-one：可以将one的这一边的属性合并到many这一边
2. one-to-one：任意合并到一边
3. 如果是部分参与，合并时可以用空值来代替

8其他

1. 特化与概化：特殊与概括过程（衍生出子类与继承问题）。将一个实体集向下特殊化或向上归纳共同属性
2. 关于联系集是否要实体化的问题：
   • 转化为实体集：如果联系集中要保留额外的信息
   • 不用转化为实体集：仅仅表示一种动作
3. n元联系集可以转化为多数量的二元集
4. UML（unified modeling language）统一建模语言 与 ER图的关系：
   • ER图是对系统的数据表示部分进行建模
   • UML是对整个系统，包括系统交互、系统功能进行建模

9总结设计

1. 把所有实体，联系表示出来
2. 确定联系的主键（“选择many的一边”那些东西）
3. 转化：把强实体，弱实体，联系转化为表
4. 将一些联系进行合并，包括强实体的联系（合并到many的一边）和弱实体的联系
5. 多值，复合属性的处理

七、关系数据库的设计

1概述

1. 范式:normal form ,英文本意 “标准型”。
2. 有损分解：丢失信息的分解。（有多出信息的，也称为有损分解）
3. 无损分解：没有信息丢失的分解
4. 规范化的目的：生成一组模式，并避免不必要的冗余
5. 非规范化设计的问题：数据冗余，插入/删除/更新异常
6. 在判断一个模式是否符合范式的时候，通常用的是函数依赖

2使用函数依赖进行分解→

把“→”理解成“推导出”更好，表示一种从弱约束到强约束的一种严格数学推导。

理解成“决定"更有利于做题。

1. 函数依赖的定义：

   • 在一个关系实例中，任意元组t1和t2中，如果有t1[a] = t2[a], 则t1[b] = t2[b]也成立，那么称该关系实例满足函数依赖 。记为a→b（即一种单值映射，知道a，那么就知道b）
   • 如果关系r®上的每个合法实例都满足函数依赖a→b，则称该函数依赖在模式r®上成立(hold)

2. 平凡的函数依赖：a→a （准确地说，a（右边）属性集是a（左边）属性集的一个子集）。

   含义：被所有关系所满足

3. 注意：如果一个关系实例满足函数依赖a→b，并不代表其对应的模式也满足该函数依赖

4. 闭包：表示能从给定的集合F推导出所有的函数依赖的集合，记为F+。当然F+包含F中所有的函数依赖

5. 无损分解的基础规则：（重点理解）

   • 定义：设一个模式R分解成R1和R2。如果R1和R2相交的属性，是R1的超码或者是R2的超码，则该分解就是无损的。

   • 理解：假设R1和R2相交的属性（设为集合A）是R1的超码，说明从A可以推导出R1这个完整的关系。

     因为属性集合A也在R2中，说明从R2里面也可以推导出R1这个完整的关系。

     所以仅仅从R2，就可以复原出整个原始的关系R

   • 使用条件：约束仅仅只有函数依赖，且是二元分解。如果有外码等其它的约束，请看P212

3范式

Boyce-Codd范式

1. Boyce-Codd normal form , BCNF, 它消除了基于函数依赖能够发现的所有冗余

2. 定义：

   • 设关系模式R中的函数依赖集F，对于F+中的所有函数依赖a→b，至少满足以下条件
   • a→b是平凡的函数依赖
   • a是模式R的一个超码

3. 对BCNF范式的理解：即不存在一个属性集a，它是函数依赖的左部，且还不是一个超码。即如果一个属性集可以决定其它属性集，那么它一定是一个超码。（或者平凡的）

4. BCNF分解：是不保持函数依赖的分解，会使某些特定的函数依赖在不进行关系连接的情况下丢失。

   比如P214的例子，会导致第2个候选码函数依赖丢失。原因是第1个函数依赖的分解时，把候选码中的一些属性“带走”了。

第三范式

1. Third normal form, 3NF, 第三范式，允许存在左侧不是起码的特定的非平凡函数依赖
2. 定义：
   • 设关系模式R中的函数依赖集F，对于F+中的所有函数依赖a→b，至少满足以下条件
   • a→b是平凡的函数依赖
   • a是模式R的一个超码
   • b - a 的每个属性，都包含于R的一个候选码中（可以分别包含在不同的候选码中）。
3. 理解：如果一个函数依赖a→b中的a不是一个候选码，在BCNF范式中，(a, b)是要被分解到一个新的模式中去的。但是，如果b - a中有一些属性是属于候选码的，那么会将满足BCNF的 左部是候选码 的函数依赖会被破坏掉。3NF就是用于防止这种情况。

4函数依赖理论

基础理论

1. 逻辑蕴涵：F的闭包是被F所逻辑蕴涵的所有函数依赖的集合

2. 阿姆斯特朗公理（Armstrong’s axiom）：（下面的字母都为属性集）

   • 自反律（reflexivity rule）：b ⊆ a, 则 a→b （是大的决定小的，和
   • 增补律（augmentation rule）：a→b成立，则 ac→bc成立
   • 传递律（transitivity rule）：a→b， b→c成立，则a→c成立

3. 附加的规则：

   • 合并律（union rule）：a→b， b→c成立，则a→bc成立
   • 分解律（decomposition）：a→bc成立，则a→b， b→c成立
   • 伪传递律（pseudotransitivity rule）：如果a→b, cb→d成立，则 ca→d （弱约束能力更强）

4. 函数依赖的左部和右部都R的子集。子集的个数为2^n, 故可能的函数依赖总共有2^n * 2^n 个

5. 计算F+的算法：

   • 重复利用增补律和传递律进行计算，直到结果不发生改变

6. 计算F下属性集闭包的方法：重复考虑每一个函数依赖左部在结果集中的存在情况，存在，则把右部加入结果集。

7. 属性集a的闭包C的作用：

   • 测试a是否是R的一个超码

   • 如果一个属性集b ⊆ 闭包C， 那么a→b

   • 用于计算F+

正则覆盖

1. 定义：设F的正则覆盖为Fc

   • Fc逻辑蕴涵了F，F也逻辑蕴涵了Fc
   • Fc的每个函数依赖的左部都是唯一的

2. 是原函数依赖集的一个简化集，它没有无关属性，则逻辑蕴涵了原函数依赖集的所有函数依赖。

3. 作用：通过具有同样约束的简化集，来减小检测方面的开销

4. 无关属性：可以去除函数依赖中的一个属性，但不改变函数依赖集的闭包，则称该属性的无关的

5. 无关属性的形式化定义：（可以用来做验证）

   设原函数依赖集F删除后的函数依赖集为：Fa

   • 从左侧移除一个属性：如果 F（弱）→ Fa（强）， 则这个属性是无关的
   • 从右侧移除一个属性：如果 Fa（弱）→ F（强），则这个属性是无关的

6. 删除属性时，函数依赖约束强度的变化：

   • 从一个函数依赖的左部删除一个属性，可以使其变成一个更强的属性。
     更少的东西，可以做同样多的事情，约束就更强了

   • 从一个函数依赖的右部删除一个属性，可以使其成为一个更弱的约束
     同样多的东西，做的事情更少了，约束就更弱了

   • 逻辑上强约束与弱约束的关系：弱约束可以推导出强约束 （举例：满足BCNF范式的（强）也满足3NF范式（弱），好像这里有点不一样？？？？疑问。

     理解：

     • 如果是推导关系，确实是弱推导出强。它是数学上的严格定义，是一种约束。你不能说BCNF可以推导出3NF，但可以说从3NF推导出BCNF
     • 如果是满足关系，其实在数学上是一种属于关系（子集的概念），强满足弱，即强属于弱。BCNF（强）满足3NF（弱），即BCNF（强）属于3NF（弱）
     • 其实这里的强与弱是指约束关系！

     ）

7. 正则覆盖的计算方法：

5使用函数依赖的分解算法

去掉右边的属性：新的F要推出原来的F,
去掉左边的属性：原来的F要推出新的F

BCNF的分解

3NF的分解

6其它

1. 第一范式：如果一个域的元素被认为是不可再分的
2. 去规范化（denormalization）：把一个规范化的模式变成非规范化的过程。用来调整系统的性能等
3. 交叉表（crosstab）：一个属性的每一个值都作为一列

十七、事务

1基本概念

1. 构成单一逻辑的操作集合称作事务。从用户的角度看（这里的用户是包括程序员的！），事务被看成一个独立的单元。
2. 事务的ACID四个特性：
   • 原子性（Atomicity）：事务中的操作要么全部发生，要么全部不发生
   • 一致性（Consistency）：指的是一种逻辑上的正确性。
   • 隔离性（Isolation）：事务与事务之间感觉不到彼此
   • 持久性（Durability）：事务完成后，要把对数据库的改变持久化到物理存储中

2一个简单的事务模型

1. read（X）：把数据项X读入到事务的主存缓冲区中
2. write（X）：把事务缓冲区中X的值，写入到数据项。（注意，这里没有说写入到哪里，可以是共享缓冲区，也可以是磁盘存储）

3存储器结构

1. 易失存储器
2. 非易失存储器
3. 稳定存储器：理论上永远不会丢失

4原子性与持久性（事务的状态模型）

1. 中止：事务不能够完整地执行
2. 回滚：对数据库所做过的改变进行撤销
3. 已提交：成功完成事务
4. 补偿事务：撤销已提交事务所造成的影响的唯一方式
5. 事务的五个状态：
   • 活跃：正在执行
   • 部分提交状态：当最后一条语句被执行后
   • 失效：发现事务不能正常执行后
   • 中止：事务已经回滚，并恢复到事务开始前的状态
   • 提交：成功完成后

5隔离性（事务并发概述）

1. 问题来源：由并发问题引发而来的
2. 串行执行：一次执行一次事务
3. 数据库使用并发执行的动机本质上和操作系统中使用多道程序是一样的：提高吞吐量与利用率
4. 调度：事务指令在系统中的执行的时间顺序
5. 串行调度：属于一个单独事务的指令在调度中是一起出现的
6. 可串行化调度：在并发的情况下，调度的效果犹如串行一般。

6可串行化

1. 可串行化：在并发的情况下，调度的效果犹如串行一般。

2. （数据项操作）冲突：如果I和J是由不同事务上执行的操作，并且其中至少一条指令是write操作，那么说操作I和J是冲突的 （冲突操作指令的顺序是重要的）

3. 冲突等价：调度S可以经过一系列非冲突指令的交换而转换成调度S’（最终状态相同），则称S与S‘调度是冲突等价的

4. 冲突可串行化：如果一个调度S与一个串行调度是冲突等价的，则称S是冲突可串行化的。

   （即通过交换非冲突指令，使得最终效果和串行化一般）

5. 优先图：

   • 规则：

• 作用：如果有环则调度S是非可串行化的；如果无环，则是冲突可串行化的

• 对优先图进行拓扑排序，可得到一个线性次序，称为事务的可串行化次序 （重要）

7隔离性与原子性（调度恢复性）

1. 可恢复调度：对于每个事务Ti与Tj，如果Tj读取了Ti之前所写过的数据项，那么Ti的提交操作出现在Tj的提交操作之前
2. 不可恢复调度：抄了别人写的，还比别人交得早
3. 级联回滚：因单个事务失效而导致一系列事务回滚的现象
4. 无级联调度
   • 对于每个事务Ti与Tj，如果Tj要读取了Ti之前所写过的数据项，那么Ti的提交操作必须出现在Tj的读操作之前（已经提交再读，注意与可恢复调度的定义区别。无级联调度是一定不会和别的事务发生写耦合的，可恢复调度允许与别的事务发生写耦合，但是不能早提交就可以了。即无级联调度是更严格的）
   • 无级联调度都是可恢复的调度。数学关系如下：
     

8隔离级别

SQL标准定义的隔离级别（isolation level）有四个：

1. 可串行化（serializable）：通常保证可串行化的执行。
2. 可重复读（repeatable read）：只允许读取已经提交的数据，并且在一个事务两次读取一个数据项期间，其他事务不得更新该数据项。
3. 已提交读（read committed）：只允许读取已经提交的数据，但不要求可重复读。如一个事务两次读取一个数据项期间，另外的事务可以更新该数据项并提交
4. 未提交读（read uncommitted）：允许读取未提交的数据

说明：

• 所有的隔离级别都附带有不允许脏写(dirty write)：即如果一个数据项已经被另外一个尚未提交或中止的事务写过，则不允许对该数据项再执行写操作。
• 隔离级别由上到下是逐渐变弱的
• 可以为了提高系统性能而决定接受软弱的隔离级别

9隔离级别的实现

1. 锁
2. 时间戳
3. 多版本与快照隔离

10事务的SQL语句表示

与简单事务模型相比（即只能read和write操作），实际上的SQL会有删除与插入操作，事实上这也是一种write操作。简单事务无法处理幻象现象（即行数上的改变）。被引用的数据项是由谓词决定的，针对这个会有谓词锁的概念。在18.4.3节。

十八、并发控制

1基于锁的协议

重要： 每一对冲突事务之间在执行时的次序是由这个事务对中的每个成员都申请但涉及不相容模式的第一个锁来决定的。（有点不理解）

基本概念

1. 锁

   • 共享锁：获得锁之后可以读不能写，与其他事务的共享锁相容
   • 排他锁：获得锁之后中可以读写，与其他事务的共享、排他锁不相容

2. 锁相容：如果事务A已经在数据项x上获得了锁1，但B也可以立即获得锁2，那么锁1与锁2是相容的

3. 死锁发生时，最简单的处理方法是：回滚

4. 封锁协议：一组规则，规定事务何时可以对数据项进行加锁和解锁

5. 假设有一个事务持有x上的共享锁S，那么另外一个事务要获得排他锁时必须等待。如果还有其他的事务一直申请共享锁，那么数据项x会被持续被锁，导致那么要获得排他锁的事务饥饿。

   解决方法：当授予锁时，附加如下条件

   • 数据项中没有冲突的锁存在（这是基本要求）
   • 正在等待锁的事务的申请是不存在的

两阶段封锁协议

1. two-phase locking protocol：保证可串行化
2. 分为两个阶段：
   • 增长阶段：一个事务可以获得锁，但不能释放锁
   • 缩减阶段：一个事务可以释放锁，但不能获得新锁
3. 原理：
   • 封锁点：事务最后获得锁的位置（增长期的结束点）称为封锁点
   • 多个事务可以根据封锁点排序，这种次序就是对于这些事务一种可串行化次序
4. 两阶段的封锁协议不能保证不会发生死锁
5. 严格两阶段封锁协议
   • 定义：在基本的协议下，要求排他锁必须在事务提交后方可释放
   • 好处：保证了无级联回滚
   • 原理：保证其他事务在持久化后，本事务才能读
6. 强两阶段封锁协议：
   • 定义：事务在提交之前保留所有的锁
   • 好处：在强两阶段协议下，事务可以按其提交的次序串行化
7. 锁转换：（在基本的两阶段封锁协议下讨论）
   • 升级：共享升级成排他锁；降级：排他降级成共享锁
   • 时机：升级只能发生在增长阶段，降级只能发生在缩减阶段
   • 好处：可以获得更高的并发度。如当一个事务先对一个数据先读后写，那么可以先获得共享锁，其他事务这个时候也可以获得共享锁，然后再尝试升级成排他锁
   • 当事务尝试升级锁时，可能要等待

封锁的实现（数据结构）

关键点：

• 管理这个数据结构的东西叫做锁管理器
• 锁表是一个哈希表，键(表项）为数据项的名称，值为数据项链表（因为可能有哈希冲突）
• Java里面的实现就是这个的 new HashMap<String(name), LinkedList<数据项>>();，其中数据项这个数据结构也是一个链表： 数据项 = LinkedList<事务锁状态>();

3多粒度

概述

1. 出现的背景：在只有一个封锁粒度下：

   • 如果要封锁更大的粒度数据，必须逐个封锁小粒度数据直接把大粒度数据全部封锁完毕，浪费时间
   • 如果只想要封锁更小的粒度，但只能通过封锁更大的粒度来实现，减小了并发量

2. 多粒度机制：允许有各规模的数据项，并定义一种数据粒度的层次结构（小粒度嵌套在大粒度中）

3. 作用：提高效率

4. 模型：

多粒度下的封锁问题

1. 封锁：对一个锁进行显式封锁，意味着对它的后裔进行了隐式的封锁

2. 存在的问题：当一个事务K要给一个数据项加锁时，这个数据项没有被显式地加锁，但其祖先可能被其他事务T隐式加锁了。那么要判断K是否能持有当前数据项的锁，必须遍历整个树。非常地难受

3. 解决方案：加入意向锁模式（intention lock mode）

   • 规则：在一个节点被显示加锁前，必须遍历从当前节点到根的路径的祖先，对祖先全部加意向锁

4. 锁的类型：

   • 注意：SIX = S + IX， S是对整个当前结点和子树进行加S锁。

5. 锁的相容性矩阵：

   理解的方向：

   • 申请封锁时应该按自上而下的次序进行；释放封锁时则应该按自下而上的次序进行。
   • 树是有分支的。如表下面有记录分支

• 思考的方向：假设能加，看有没有冲突

5基于时间戳的协议

利用时间戳来决定事务之间的一种次序

1. 两种方法实现时间戳：系统时间和计数器

2. 表示法:

   • W-timestamp(Q)表示成功执行write(Q)的任意事务的最大时间戳
   • R-timestamp(Q)表示成功执行read(Q)的任意事务的最大时间戳
   • 注意：记录是的事务进入系统的时间戳，而不是读/写时的时间戳

3. 时间戳排序协议（TS表示事务进入系统时）

   如果事务T要读

   • 如果TS(T) < W-timestamp(Q) ：表示要读的数据已经被覆盖，拒绝并回滚
   • 如果TS(T) >= W-timestamp(Q) ：同意读取，并更新MAX（R-timestamp(Q)， TS-read(T)）,注意是更新成事务进入时的时间TS，而不是当前执行read操作的时间

   如果事务T要写

   • 如果TS(T) < R-timestamp(Q)：表示再写已经没有意义了，拒绝并回滚
   • 如果TS(T) < W-timestamp(Q) ：表示再写已经没有意义了，拒绝并回滚
   • 其他就执行write操作，更新W-timestamp(Q)

4. 当事务回滚时，系统会重新赋予一个时间戳，并重新启动它

5. Thomas写规则：对时间戳排序协议进行的修改称为Thomas写规则

   如果事务T要写

   • 如果TS(T) < R-timestamp(Q)：表示再写已经没有意义了，拒绝并回滚
   • 如果TS(T) < W-timestamp(Q) ：表示再写已经没有意义了，但因为事务T写的数据迟早会被覆盖，故不管（只有这里与标准的协议改变）
   • 其他就执行write操作，更新W-timestamp(Q)

十九、恢复系统

恢复机制：可以将数据库恢复到故障发生前一致性的状态

1故障分类

故障分类：

1. 事务故障：
   • 逻辑错误
   • 系统错误：死锁
2. 系统崩溃：硬件故障或系统漏洞
3. 磁盘故障

2存储器

参照上面那个。

内存模型

3恢复与原子性

立即更新：如果事务活跃时就发生了数据库的修改，就称。

1. 为了保持原子性的目标，在修改数据库之前，首先向稳定存储器输出信息，描述要做的修改

2. 日志记录的格式：

   <Ti, Xj, V1, V2>

   • Ti：事务的标识
   • Xj：数据项
   • V1：写之前，旧值
   • V2：写之后，新值

   其他：如<Ti start> <Ti commit> <Ti abort> 见文知意

3. 恢复过程的两个阶段：

   • redo : 将Ti更新过的所有数据项都更新成新值
   • undo：将Ti更新过的所有数据项都恢复成旧值（撤消完成后，写一条 记录

4. 在没有引入检查点时，系统是根据这样的规则来决定重做与否的：

   • 如果有 记录，但没有 记录，需要撤消

   • 如果有 记录，但有 或记录，需要重做。

     如果有 记录，那么日志中也会有撤销操作的redo-only记录，只有撤消时，才会产生redo-only记录这样的补偿记录

5. 检查点：保证在检查点之前的所有日志已经从主存写到了磁盘上了。

   • 好处：在恢复的时候，就不用考虑检查点之前提交过的事务了

4恢复算法

正常的事务回滚

1. 从后往前扫描日志，对于<Ti, Xj, V1, V2>记录
   • 写入旧值
   • 插入read-only <Ti, Xj, V1>记录，即补偿记录
2. 发现后，则写入一条 记录

恢复算法

1. 先重做：
   • 从检查点开始，全部重做一遍。并记录那些还没有提交或中止的事务列表L
2. 再撤消：
   • 从日志最后开始，用正常的事务回滚手段进行
   • 遇到 则从列表L中删除，并插入 记录
   • 直到列表L全部为空，即全部重做完成

附：关键英文单词

词语的具体含义，可以使用搜索功能，有些在上面的文章中可以搜索得到。

一、引言

英文名称	中文名称	备注
DataBase-Management System	数据库管理系统	DBMS
file-processing system	文件处理系统
data redundancy and inconsistency	数据冗余与不一致
access data	数据访问
data isolation	数据孤立
integrity	完整性
consistency constraint	一致性约束
atomicity problem	原子性问题
concurrent-access anomaly	并发访问异常
data model	数据模型
relational model	关系模型
entity-relationship model	实例-联系模型
semi-structured data model	半结构化数据模型
object-based data model	基于对象的数据模型
data abstraction	数据抽象
physical data independence	物理数据独立性
instance	实例
schema	模式
subschema	子模式
Data-Definition Language	数据定义语言	DDL
Data-Manipulation Language	数据操纵语言	DML
data storage and definition	数据存储与定义
domain constraint	域约束
referential integrity	引用完整性
authorization	授权
data dictionary	数据字典
metadata	元数据
procedural DML	过程化DML	实现算法的
declarative DML	声明式DML我们学习的是这个	屏蔽算法的。
conceptual-design	概念设计
normalization	规范化
query processor	查询处理器
query optimization	查询优化
transaction	事务
distributed database	分布式数据库	DBA
DataBase Administrator	数据库管理员
routine maintenance	日常维护

二、关系模型介绍

英文名称	中文名称	备注
relation	关系
tuple	元组
attribute	属性
relation instance	关系实例
domain	域
atomic	原子的
superkey	超码
candidate key	候选码
primary key	主码
foreign key	外码
referencing relation	引用关系
referedced relation	被引用关系
referential integrity constraint	引用完整性约束
schema diagram	模式图	P32
predicate	谓词	即一种限制
relational algebra	关系代数
arity	元数
unary	一元
binary	二元
ternary	三元
project	投影
Cartesian-product	笛卡尔积
union	并
intersection	交
set-difference	差
except	差集	**
compatible	相容的
assignment	赋值
equivalent	等价的

三、SQL介绍

英文名称	中文名称	备注
Structured Query Language	结构化查询语言	SQL
Data-Definition Language	数据定义语言	DDL
Data-Manipulation Language	数据操纵语言	DML
view definition	视图定义
embedded SQL	嵌入式SQL
dynamic SQL	动态SQL
correlation name	相关名称	和下面两个是一样的意思
correlation variable	相关变量
tuple variable	元组变量
row constructor	行构造器
aggregate function	聚集函数
Nested Subqueries	嵌套子查询
correlated subquery	相关子查询

四、中级SQL

英文名称	中文名称	备注
natural join	自然连接	等价于natural inner join
outer join	外连接
inner join	内连接
left outer join	左外连接
right outer join	右外连接
full outer join	全外连接
view	视图
materialized view	物化视图
rollback	回滚
functional dependency	函数依赖
cascade	级联
assertion	断言
timestamp	时间戳
interval	区间
clob	字符数据
blob	二进制数据
catalog	目录
index	索引
privilege	权限
grant	授权
revoke	收回

五、高级SQL

英文名称	中文名称	备注
dynamic SQL	动态SQL
embedded SQL	嵌入式SQL
function	函数
procedure	过程
trigger	触发器
on delete cascade	级联删除
transitive closure	传递闭包
recursion	递归
cross table	交叉表

六、ER模型的数据库设计

英文名称	中文名称	备注
conceptual-design	概念设计	前面还有需求分析
specification of functional requirement	功能需求规格说明
logical-design phase	逻辑设计阶段
physical-design phase	物理设计阶段
entity	实体
Entity-Relationship	实体-联系模型
relationship	联系
E-R diagram	ER图
entity set	实体集
extension	外延	即实体集的一个实例
relationship instance	联系实例
descriptive attribute	描述性属性	在联系集中用到
binary relationship set	二元联系集
degree	度	联系集的度表示参与的实体集的个数
composite	复合	相对于简单属性而言
single-valued value	单的
multivalued value	多值的
mapping cardinality	基数映射	也称基数比率
weak entity set	弱实体集
identifying entity set	标识性实体集
discriminator attribute	分辨符属性
strong entity set	强实体集
identifying relationship	标识性联系集
specialization	特化
generalization	概化
Unified Modeling Language	统一建模语言	UML

七、关系数据库的设计

英文名称	中文名称	备注
normal form	标准格式，即范式
lossy decomposition	有损分解
lossless decomposition	无损分解
normalization	规范化
functional dependency	函数依赖
hold	成立
trivial	平凡的	**
Boyce-Codd Normal Form	BCNF范式
dependency preserving	保留依赖
Third Normal Form	3NF范式
Armstrong’s axiom	阿姆斯特朗公理
reflexivity rule	自反律
augmentation rule	增补律
transitivity rule	传递律
union rule	合并律
decomposition rule	分解律
pseudotransitivity rule	伪传递律
canonical cover	正则覆盖，最小覆盖
dependency-preserving decomposition	保持函数依赖的分解
decomposition algorithm	分解算法
denormalization	去规范化

十七、事务

英文名称	中文名称	备注
Atomicity	原子性
Consistency	一致性
Isolation	隔离性
Durability	持久性
volatile storage	易失存储器
non-volatile storage	非存储器
stable storage	稳定存储器
compensating transaction	补偿事务
active	活跃的
partially committed	部分提交的
failed	失效的
aborted	中止的
committed	已提交的
terminated	终止的	注意与aborted的区别
serially	串行地
schedule	调度
serializable	可串行化的
conflict	冲突的
topological sorting	拓扑排序
precedence graph	优先图
conflict equivalent	冲突等价的
conflict serializable	冲突可串行化的
serializability order	可串行化次序
nonrecoverable	不可恢复的
cascading rollback	级联回滚
isolation level	隔离级别
serializable	可串行化的
repeatable read	可重复读
read committed	已提交读
read uncommitted	未提交读
dirty write	脏写

十八、并发控制

英文名称	中文名称	备注
two-phase locking	两阶段封锁
snapshot isolation	快照隔离
shared-mode rock	共享模式锁
exclusive-mode rock	排他模式锁
compatible	相容的
locking protocol	封锁协议
two-phase locking protocol	两阶段封锁协议
growing phase	增长阶段
shrinking phase	缩减阶段
lock point	封锁点
strict two-phase locking protocol	严格两阶段封锁协议
rigorous two-phase locking protocol	强两阶段封锁协议
lock conversion	锁转换
lock table	锁表
granularity	粒度	**
explicit lock	显示锁
implicit lock	隐式锁
intention lock mode	意向锁模式
phantom phenomenon	幻象现象
Thomas’ Write Rule	Thomas写规则

十九、恢复系统

英文名称	中文名称	备注
recovery scheme	恢复机制
high availability	高可用性
transaction failure	事务故障
system crash	系统崩溃
log-based recovery	基于日志的恢复
log record	日志记录
transaction identifier	事务标识
data-item identifier	数据项标识
deferred-modification	延迟修改
immediate-modification	立即修改
checkpoint	检查点
recovery algorithm	恢复算法
compensation log record	补偿日志记录
repeating history	重复历史