《数据库系统概念（原书第 6 版）》读书笔记。

第一部分：2~6 章，详细讲解了关系型数据库。

第 6 章 形式化关系查询语言



- 形式语言 (Formal language)：用精确的数学或机器可处理的公式定义的语言。
- 本章讲解的是 sql 查询时所使用的三种形式语言，偏底层，稍晚些更新。

数据库系统概念 - 06

《数据库系统概念》书中示例所使用的数据。



```sql
-- 建表
-- 教室
CREATE TABLE classroom (
 building varchar(15),
 room_number varchar(7),
 capacity numeric(4, 0),
 PRIMARY KEY (building, room_number)
);
-- 部门
CREATE TABLE department (
 dept_name varchar(20),
 building varchar(15),
 budget numeric(12, 2) CHECK (budget > 0),
 PRIMARY KEY (dept_name)
);
-- 课程
CREATE TABLE course (
 course_id varchar(8),
 title varchar(50),
 dept_name varchar(20),
 credits numeric(2, 0) CHECK (credits > 0),
 PRIMARY KEY (course_id),
 FOREIGN KEY (dept_name) REFERENCES department(dept_name)
);
-- 讲师
CREATE TABLE instructor (
 ID varchar(5),
 name varchar(20) NOT NULL,
 dept_name varchar(20),
 salary numeric(8, 2) CHECK (salary > 29000),
 PRIMARY KEY (ID),
 FOREIGN KEY (dept_name) REFERENCES department(dept_name)
);
-- 部分
CREATE TABLE section (
 course_id varchar(8),
 sec_id varchar(8),
 semester varchar(6) CHECK (
 semester IN ('Fall', 'Winter', 'Spring', 'Summer')
 ),
 year numeric(4, 0) CHECK (
 year > 1701
 AND year < 2100
 ),
 building varchar(15),
 room_number varchar(7),
 time_slot_id varchar(4),
 PRIMARY KEY (course_id, sec_id, semester, year),
 FOREIGN KEY (course_id) REFERENCES course(course_id) ON DELETE CASCADE,
 FOREIGN KEY (building, room_number) REFERENCES classroom(building, room_number)
);
-- 
CREATE TABLE teaches (
 ID varchar(5),
 course_id varchar(8),
 sec_id varchar(8),
 semester varchar(6),
 year numeric(4, 0),
 PRIMARY KEY (ID, course_id, sec_id, semester, year),
 FOREIGN KEY (course_id, sec_id, semester, year) REFERENCES section(course_id, sec_id, semester, year) ON DELETE CASCADE,
 FOREIGN KEY (ID) REFERENCES instructor(ID) ON DELETE CASCADE
);
-- 学生
CREATE TABLE student (
 ID varchar(5),
 name varchar(20) NOT NULL,
 dept_name varchar(20),
 tot_cred numeric(3, 0) CHECK (tot_cred >= 0),
 PRIMARY KEY (ID),
 FOREIGN KEY (dept_name) REFERENCES department(dept_name)
);
-- 支出
CREATE TABLE takes (
 ID varchar(5),
 course_id varchar(8),
 sec_id varchar(8),
 semester varchar(6),
 year numeric(4, 0),
 grade varchar(2),
 PRIMARY KEY (ID, course_id, sec_id, semester, year),
 FOREIGN KEY (course_id, sec_id, semester, year) REFERENCES section(course_id, sec_id, semester, year) ON DELETE CASCADE,
 FOREIGN KEY (ID) REFERENCES student(ID) ON DELETE CASCADE
);
-- 顾问
CREATE TABLE advisor (
 s_ID varchar(5),
 i_ID varchar(5),
 PRIMARY KEY (s_ID),
 FOREIGN KEY (i_ID) REFERENCES instructor (ID),
 FOREIGN KEY (s_ID) REFERENCES student (ID) ON DELETE CASCADE
);
-- 时间段
CREATE TABLE time_slot (
 time_slot_id varchar(4),
 DAY varchar(1),
 start_hr numeric(2) CHECK (
 start_hr >= 0
 AND start_hr < 24
 ),
 start_min numeric(2) CHECK (
 start_min >= 0
 AND start_min < 60
 ),
 end_hr numeric(2) CHECK (
 end_hr >= 0
 AND end_hr < 24
 ),
 end_min numeric(2) CHECK (
 end_min >= 0
 AND end_min < 60
 ),
 PRIMARY KEY (time_slot_id, DAY, start_hr, start_min)
);
-- 
CREATE TABLE prereq (
 course_id varchar(8),
 prereq_id varchar(8),
 PRIMARY KEY (course_id, prereq_id),
 FOREIGN KEY (course_id) REFERENCES course(course_id) ON DELETE CASCADE,
 FOREIGN KEY (prereq_id) REFERENCES course(course_id)
);
```

```sql
-- 创建数据
INSERT INTO
 classroom
VALUES
 ('Packard', '101', '500');
INSERT INTO
 classroom
VALUES
 ('Painter', '514', '10');
INSERT INTO
 classroom
VALUES
 ('Taylor', '3128', '70');
INSERT INTO
 classroom
VALUES
 ('Watson', '100', '30');
INSERT INTO
 classroom
VALUES
 ('Watson', '120', '50');

INSERT INTO
 department
VALUES
 ('Biology', 'Watson', '90000');
INSERT INTO
 department
VALUES
 ('Comp. Sci.', 'Taylor', '100000');
INSERT INTO
 department
VALUES
 ('Elec. Eng.', 'Taylor', '85000');
INSERT INTO
 department
VALUES
 ('Finance', 'Painter', '120000');
INSERT INTO
 department
VALUES
 ('History', 'Painter', '50000');
INSERT INTO
 department
VALUES
 ('Music', 'Packard', '80000');
INSERT INTO
 department
VALUES
 ('Physics', 'Watson', '70000');

INSERT INTO
 course
VALUES
 ('BIO-101', 'Intro. to Biology', 'Biology', '4');
INSERT INTO
 course
VALUES
 ('BIO-301', 'Genetics', 'Biology', '4');
INSERT INTO
 course
VALUES
 (
 'BIO-399',
 'Computational Biology',
 'Biology',
 '3'
 );
INSERT INTO
 course
VALUES
 (
 'CS-101',
 'Intro. to Computer Science',
 'Comp. Sci.',
 '4'
 );
INSERT INTO
 course
VALUES
 ('CS-190', 'Game Design', 'Comp. Sci.', '4');
INSERT INTO
 course
VALUES
 ('CS-315', 'Robotics', 'Comp. Sci.', '3');
INSERT INTO
 course
VALUES
 ('CS-319', 'Image Processing', 'Comp. Sci.', '3');
INSERT INTO
 course
VALUES
 (
 'CS-347',
 'Database System Concepts',
 'Comp. Sci.',
 '3'
 );
INSERT INTO
 course
VALUES
 (
 'EE-181',
 'Intro. to Digital Systems',
 'Elec. Eng.',
 '3'
 );
INSERT INTO
 course
VALUES
 ('FIN-201', 'Investment Banking', 'Finance', '3');
INSERT INTO
 course
VALUES
 ('HIS-351', 'World History', 'History', '3');
INSERT INTO
 course
VALUES
 ('MU-199', 'Music Video Production', 'Music', '3');
INSERT INTO
 course
VALUES
 ('PHY-101', 'Physical Principles', 'Physics', '4');

INSERT INTO
 instructor
VALUES
 ('10101', 'Srinivasan', 'Comp. Sci.', '65000');
INSERT INTO
 instructor
VALUES
 ('12121', 'Wu', 'Finance', '90000');
INSERT INTO
 instructor
VALUES
 ('15151', 'Mozart', 'Music', '40000');
INSERT INTO
 instructor
VALUES
 ('22222', 'Einstein', 'Physics', '95000');
INSERT INTO
 instructor
VALUES
 ('32343', 'El Said', 'History', '60000');
INSERT INTO
 instructor
VALUES
 ('33456', 'Gold', 'Physics', '87000');
INSERT INTO
 instructor
VALUES
 ('45565', 'Katz', 'Comp. Sci.', '75000');
INSERT INTO
 instructor
VALUES
 ('58583', 'Califieri', 'History', '62000');
INSERT INTO
 instructor
VALUES
 ('76543', 'Singh', 'Finance', '80000');
INSERT INTO
 instructor
VALUES
 ('76766', 'Crick', 'Biology', '72000');
INSERT INTO
 instructor
VALUES
 ('83821', 'Brandt', 'Comp. Sci.', '92000');
INSERT INTO
 instructor
VALUES
 ('98345', 'Kim', 'Elec. Eng.', '80000');

INSERT INTO
 section
VALUES
 (
 'BIO-101',
 '1',
 'Summer',
 '2009',
 'Painter',
 '514',
 'B'
 );
INSERT INTO
 section
VALUES
 (
 'BIO-301',
 '1',
 'Summer',
 '2010',
 'Painter',
 '514',
 'A'
 );
INSERT INTO
 section
VALUES
 (
 'CS-101',
 '1',
 'Fall',
 '2009',
 'Packard',
 '101',
 'H'
 );
INSERT INTO
 section
VALUES
 (
 'CS-101',
 '1',
 'Spring',
 '2010',
 'Packard',
 '101',
 'F'
 );
INSERT INTO
 section
VALUES
 (
 'CS-190',
 '1',
 'Spring',
 '2009',
 'Taylor',
 '3128',
 'E'
 );
INSERT INTO
 section
VALUES
 (
 'CS-190',
 '2',
 'Spring',
 '2009',
 'Taylor',
 '3128',
 'A'
 );
INSERT INTO
 section
VALUES
 (
 'CS-315',
 '1',
 'Spring',
 '2010',
 'Watson',
 '120',
 'D'
 );
INSERT INTO
 section
VALUES
 (
 'CS-319',
 '1',
 'Spring',
 '2010',
 'Watson',
 '100',
 'B'
 );
INSERT INTO
 section
VALUES
 (
 'CS-319',
 '2',
 'Spring',
 '2010',
 'Taylor',
 '3128',
 'C'
 );
INSERT INTO
 section
VALUES
 (
 'CS-347',
 '1',
 'Fall',
 '2009',
 'Taylor',
 '3128',
 'A'
 );
INSERT INTO
 section
VALUES
 (
 'EE-181',
 '1',
 'Spring',
 '2009',
 'Taylor',
 '3128',
 'C'
 );
INSERT INTO
 section
VALUES
 (
 'FIN-201',
 '1',
 'Spring',
 '2010',
 'Packard',
 '101',
 'B'
 );
INSERT INTO
 section
VALUES
 (
 'HIS-351',
 '1',
 'Spring',
 '2010',
 'Painter',
 '514',
 'C'
 );
INSERT INTO
 section
VALUES
 (
 'MU-199',
 '1',
 'Spring',
 '2010',
 'Packard',
 '101',
 'D'
 );
INSERT INTO
 section
VALUES
 (
 'PHY-101',
 '1',
 'Fall',
 '2009',
 'Watson',
 '100',
 'A'
 );

INSERT INTO
 teaches
VALUES
 ('10101', 'CS-101', '1', 'Fall', '2009');
INSERT INTO
 teaches
VALUES
 ('10101', 'CS-315', '1', 'Spring', '2010');
INSERT INTO
 teaches
VALUES
 ('10101', 'CS-347', '1', 'Fall', '2009');
INSERT INTO
 teaches
VALUES
 ('12121', 'FIN-201', '1', 'Spring', '2010');
INSERT INTO
 teaches
VALUES
 ('15151', 'MU-199', '1', 'Spring', '2010');
INSERT INTO
 teaches
VALUES
 ('22222', 'PHY-101', '1', 'Fall', '2009');
INSERT INTO
 teaches
VALUES
 ('32343', 'HIS-351', '1', 'Spring', '2010');
INSERT INTO
 teaches
VALUES
 ('45565', 'CS-101', '1', 'Spring', '2010');
INSERT INTO
 teaches
VALUES
 ('45565', 'CS-319', '1', 'Spring', '2010');
INSERT INTO
 teaches
VALUES
 ('76766', 'BIO-101', '1', 'Summer', '2009');
INSERT INTO
 teaches
VALUES
 ('76766', 'BIO-301', '1', 'Summer', '2010');
INSERT INTO
 teaches
VALUES
 ('83821', 'CS-190', '1', 'Spring', '2009');
INSERT INTO
 teaches
VALUES
 ('83821', 'CS-190', '2', 'Spring', '2009');
INSERT INTO
 teaches
VALUES
 ('83821', 'CS-319', '2', 'Spring', '2010');
INSERT INTO
 teaches
VALUES
 ('98345', 'EE-181', '1', 'Spring', '2009');

INSERT INTO
 student
VALUES
 ('00128', 'Zhang', 'Comp. Sci.', '102');
INSERT INTO
 student
VALUES
 ('12345', 'Shankar', 'Comp. Sci.', '32');
INSERT INTO
 student
VALUES
 ('19991', 'Brandt', 'History', '80');
INSERT INTO
 student
VALUES
 ('23121', 'Chavez', 'Finance', '110');
INSERT INTO
 student
VALUES
 ('44553', 'Peltier', 'Physics', '56');
INSERT INTO
 student
VALUES
 ('45678', 'Levy', 'Physics', '46');
INSERT INTO
 student
VALUES
 ('54321', 'Williams', 'Comp. Sci.', '54');
INSERT INTO
 student
VALUES
 ('55739', 'Sanchez', 'Music', '38');
INSERT INTO
 student
VALUES
 ('70557', 'Snow', 'Physics', '0');
INSERT INTO
 student
VALUES
 ('76543', 'Brown', 'Comp. Sci.', '58');
INSERT INTO
 student
VALUES
 ('76653', 'Aoi', 'Elec. Eng.', '60');
INSERT INTO
 student
VALUES
 ('98765', 'Bourikas', 'Elec. Eng.', '98');
INSERT INTO
 student
VALUES
 ('98988', 'Tanaka', 'Biology', '120');

INSERT INTO
 takes
VALUES
 ('00128', 'CS-101', '1', 'Fall', '2009', 'A');
INSERT INTO
 takes
VALUES
 ('00128', 'CS-347', '1', 'Fall', '2009', 'A-');
INSERT INTO
 takes
VALUES
 ('12345', 'CS-101', '1', 'Fall', '2009', 'C');
INSERT INTO
 takes
VALUES
 ('12345', 'CS-190', '2', 'Spring', '2009', 'A');
INSERT INTO
 takes
VALUES
 ('12345', 'CS-315', '1', 'Spring', '2010', 'A');
INSERT INTO
 takes
VALUES
 ('12345', 'CS-347', '1', 'Fall', '2009', 'A');
INSERT INTO
 takes
VALUES
 ('19991', 'HIS-351', '1', 'Spring', '2010', 'B');
INSERT INTO
 takes
VALUES
 ('23121', 'FIN-201', '1', 'Spring', '2010', 'C+');
INSERT INTO
 takes
VALUES
 ('44553', 'PHY-101', '1', 'Fall', '2009', 'B-');
INSERT INTO
 takes
VALUES
 ('45678', 'CS-101', '1', 'Fall', '2009', 'F');
INSERT INTO
 takes
VALUES
 ('45678', 'CS-101', '1', 'Spring', '2010', 'B+');
INSERT INTO
 takes
VALUES
 ('45678', 'CS-319', '1', 'Spring', '2010', 'B');
INSERT INTO
 takes
VALUES
 ('54321', 'CS-101', '1', 'Fall', '2009', 'A-');
INSERT INTO
 takes
VALUES
 ('54321', 'CS-190', '2', 'Spring', '2009', 'B+');
INSERT INTO
 takes
VALUES
 ('55739', 'MU-199', '1', 'Spring', '2010', 'A-');
INSERT INTO
 takes
VALUES
 ('76543', 'CS-101', '1', 'Fall', '2009', 'A');
INSERT INTO
 takes
VALUES
 ('76543', 'CS-319', '2', 'Spring', '2010', 'A');
INSERT INTO
 takes
VALUES
 ('76653', 'EE-181', '1', 'Spring', '2009', 'C');
INSERT INTO
 takes
VALUES
 ('98765', 'CS-101', '1', 'Fall', '2009', 'C-');
INSERT INTO
 takes
VALUES
 ('98765', 'CS-315', '1', 'Spring', '2010', 'B');
INSERT INTO
 takes
VALUES
 ('98988', 'BIO-101', '1', 'Summer', '2009', 'A');
INSERT INTO
 takes
VALUES
 ('98988', 'BIO-301', '1', 'Summer', '2010', NULL);

INSERT INTO
 advisor
VALUES
 ('00128', '45565');
INSERT INTO
 advisor
VALUES
 ('12345', '10101');

INSERT INTO
 advisor
VALUES
 ('23121', '76543');

INSERT INTO
 advisor
VALUES
 ('44553', '22222');
INSERT INTO
 advisor
VALUES
 ('45678', '22222');
INSERT INTO
 advisor
VALUES
 ('76543', '45565');
INSERT INTO
 advisor
VALUES
 ('76653', '98345');
INSERT INTO
 advisor
VALUES
 ('98765', '98345');
INSERT INTO
 advisor
VALUES
 ('98988', '76766');

INSERT INTO
 time_slot
VALUES
 ('A', 'M', '8', '0', '8', '50');
INSERT INTO
 time_slot
VALUES
 ('A', 'W', '8', '0', '8', '50');
INSERT INTO
 time_slot
VALUES
 ('A', 'F', '8', '0', '8', '50');
INSERT INTO
 time_slot
VALUES
 ('B', 'M', '9', '0', '9', '50');
INSERT INTO
 time_slot
VALUES
 ('B', 'W', '9', '0', '9', '50');
INSERT INTO
 time_slot
VALUES
 ('B', 'F', '9', '0', '9', '50');
INSERT INTO
 time_slot
VALUES
 ('C', 'M', '11', '0', '11', '50');
INSERT INTO
 time_slot
VALUES
 ('C', 'W', '11', '0', '11', '50');
INSERT INTO
 time_slot
VALUES
 ('C', 'F', '11', '0', '11', '50');
INSERT INTO
 time_slot
VALUES
 ('D', 'M', '13', '0', '13', '50');
INSERT INTO
 time_slot
VALUES
 ('D', 'W', '13', '0', '13', '50');
INSERT INTO
 time_slot
VALUES
 ('D', 'F', '13', '0', '13', '50');
INSERT INTO
 time_slot
VALUES
 ('E', 'T', '10', '30', '11', '45 ');
INSERT INTO
 time_slot
VALUES
 ('E', 'R', '10', '30', '11', '45 ');
INSERT INTO
 time_slot
VALUES
 ('F', 'T', '14', '30', '15', '45 ');
INSERT INTO
 time_slot
VALUES
 ('F', 'R', '14', '30', '15', '45 ');
INSERT INTO
 time_slot
VALUES
 ('G', 'M', '16', '0', '16', '50');
INSERT INTO
 time_slot
VALUES
 ('G', 'W', '16', '0', '16', '50');
INSERT INTO
 time_slot
VALUES
 ('G', 'F', '16', '0', '16', '50');
INSERT INTO
 time_slot
VALUES
 ('H', 'W', '10', '0', '12', '30');

INSERT INTO
 prereq
VALUES
 ('BIO-301', 'BIO-101');
INSERT INTO
 prereq
VALUES
 ('BIO-399', 'BIO-101');
INSERT INTO
 prereq
VALUES
 ('CS-190', 'CS-101');
INSERT INTO
 prereq
VALUES
 ('CS-315', 'CS-101');
INSERT INTO
 prereq
VALUES
 ('CS-319', 'CS-101');
INSERT INTO
 prereq
VALUES
 ('CS-347', 'CS-101');
INSERT INTO
 prereq
VALUES
 ('EE-181', 'PHY-101');
```

数据库系统概念-示例代码

《数据库系统概念（原书第 6 版）》读书笔记。

第一部分：2~6 章，详细讲解了关系型数据库。

第三章 SQL



3、4、5 章将会讲解使用最为广泛的查询语言 SQL，讲解的目的并不是提供一个完整的 SQL 用户手册，而是介绍 SQL 的基本结构和概念。

- 第 3 章：对 SQL 的基本 DML 和 DDL 特征的概述；
- 第 4 章：对 SQL 更详细的介绍（各种链接的表达、视图、事务、完整性约束等等）；
- 第 5 章：SQL 高级特征：
 - 允许从编程语言中访问 SQL 的机制；
 - SQL 函数和过程
 - 触发器
 - 递归查询
 - 高级聚集特征

## 3.1 SQL 查询语言概览

SQL 最早叫 Squeal，由 IBM 开发，后来名称更改为 SQL(Structured Query Language)。

1986 年美国国家标准化组织（ANSI）和国际标准化组织（ISO）发布了 SQL 标准：SQL—86。现在 SQL 最新的版本是 SQL：2008。

> 截止到 2022 年 9 月 29 日，SQL 最新的版本为 SQL: 2016.

SQL 语言标准由以下几个部分组成：

- 数据定义语言（Data-Definition Language，DDL）：DDL 提供定义关系模式、删除关系以及修改关系模式的命令。
- 数据操纵语言（Data-Manipulation Language，DML）：DML 提供增删改查数据库的能力。
- 完整性（integrity）：保存在数据库中的数据必须满足所定义的完整性约束。破坏完整性约束的更新是不允许的。
- 视图定义（view definition）：定义视图的命令。
- 事务控制（transaction control）：定义事务的开始和结束的命令。
- 嵌入式 SQL 和动态 SQL（embedded SQL and dynamic SQL）：定义 SQL 语句如何嵌入到通用编程语言，如 C、C++和 Java 中。
- 授权（authorization）：SQL DDL 包括定义对关系和视图的访问权限的命令。

> SQL 是一种标准，MySQL、ORACLE、PostgreSQL、SQLServer 等是对标准的实现，且在标准之上添加了一些自有的特征。SQL 和他们的关系类似于 ES 规范和各家浏览器对 ES 规范的实现。

## 3.2 SQL 数据定义

### 3.2.1 基本类型

SQL 标准支持多种固有类型，包括：

- **char(n)**/character(n)：固定长度的字符串，用户指定长度 n。
- **varchar(n)**/character varying(n)：可变长度的字符串，用户指定最大长度 n。
- **int**/integer：整数类型（和机器相关的整数的有限子集）。
- **smallint**：小整数类型（和机器相关的整数类型的子集）。
- numeric(p, d)：定点数，精度由用户指定。
 - 这个数有 p 位数字（加上一个符号位），其中 d 位数字在小数点右边。
 - 所以在一个这种类型的字段上，numeric(3，1) 可以精确储存 44.5，但不能精确存储 444.5 或 0.32 这样的数。
- real, double precision：浮点数与双精度浮点数，精度与机器相关。
- float(n)：精度至少为 n 位的浮点数。

注意：

- 每种类型都可能包含一个被称作空值的特殊值。空值表示一个缺失的值，该值可能存在但并不为人所知，或者可能根本不存在。在可能的情况下，我们希望禁止加入空值。
- char 数据类型存放固定长度。例如：属性 A 的类型是 char(10)，当我们传入`Avi`时，该字符串会追加 7 个空格来使其达到 10 个字符的长度。varchar 类型则不会这样做。
- 当 char 和 varchar 存入相同的字符`Avi`时，两者是否相等取决于数据库管理系统的实现，因此始终建议使用 varchar 类型。

### 3.2.2 基本模式定义

> 数据库模式：数据库的逻辑设计；
> 这里讲的是设计关系（表）时一些常用的命令。

使用 create table 定义 SQL 关系（表）。

```SQL
-- 通用形式
create table r (
 A1 D1,
 A2 D2,
 ...,
 An Dn,
 <完整性约束>,
 ...,
 <完整性约束>,
);

-- 示例
create table department (
 dept_name varchar(20),
 building varchar(15),
 budget numeric(12, 2),
 primary key (dept_name)
);
```

常见的完整性约束命令：

- primary key(Aj1, Aj2, ..., Ajm)：声明主键，主键属性必须**非空**且**唯一**。主键约束是可选的，但强烈建议声明主键。
- foreign key(Ak1, Ak2, ..., Akm) references s：外键声明，表示关系中任意数组在属性 (Ak1, Ak2, ..., Akm) 上的取值必须对应于关系 s 中某元组在主键属性上的取值。
- not null：该属性不允许空值。

insert 命令将数据加载到关系中：

```SQL
-- instructor 关系中插入一条数据
insert into instructor
 values (10211, 'Smith', 'Biology', 66000);
```

delete 命令用于从关系中删除元组：

```SQL
-- 从 student 关系中删除所有元组
delete from student;
```

drop table 用于从数据库中删除关系。该命令也会将关系中的所有元组删除。

```SQL
-- 删除表 r
drop table r;
```

## 3.3 SQL 查询的基本结构

- SQL 查询的基本结构由三个子句 (Clause) 组成：select、from、where；
- from 后放置关系的名称，select、where 后面放置进行运算的子句；
- 返回一个关系作为结果；

### 3.3.1 单关系查询

```SQL
-- 可以包括重复数据 
select A1, A2,.., An from R; 

-- 去除重复 
select distinct A1, A2,.., An from R; 

-- 显示的不去除重复 
select all A1, A2, ..., An from R; 

-- select 子句可以含有 + - * / 运算符的算术表达式；运算对象可以是常数或元组的属性。 
select A1, A2, ..., A3 * 1.1 from R; 

-- where 子句可以包括逻辑连词 and, or 和 not 
-- 逻辑连词的运算对象可以使包含比较运算符的 <, <=, >, >=, = 和 <> 的表达式 
select A1, A2, ... An from R where A1=V1 and A2=V2;
```

### 3.3.2 多关系查询

涉及多个关系的 SQL 查询中，各子句作用：

- select 子句：列出查询结果中所需要的属性
 - 若有多个属性名相同，需使用关系名作为前缀加以区分。
 - 星号`*`可表示“所有的属性”。
- from 子句：列出查询求值中需要访问的关系
- where 子句：列出作用在 from 子句中关系的属性上的谓词

理解查询所代表的的运算：

- 为 from 子句中列出的关系产生笛卡尔积
- 在步骤 1 的结果上应用 where 子句中指定的谓词
- 对步骤 2 结果中的每个元组，输出 select 子句中指定的属性（或表达式的结果）

上述步骤的顺序有助于理解 SQL 查询的结果应该是怎样的，而不是此结果怎样被执行的。

SQL 的实际实现中不会执行这种形式的查询，它尽可能只产生满足 where 子句谓词的笛卡尔积元素，以此优化执行。

> 笛卡尔积：
> ![cartesuan-product.png](resources/972c9341683d4c31bed826905829cd80.png)

### 3.3.3 自然连接

- 笛卡尔积：将第一个关系的每个元组与第二个关系的所有元组都进行连接。
- 自然连接：只考虑连接在两个关系模式中都出现的属性上取值相同的元组对。

例如：

```SQL
-- 笛卡尔积
select name, course_id
from instructor,teaches
where instructor. ID = teaches.ID;

-- 自然连接
select name, course_id
from instructor natural join teaches; 
```

## 3.4 附加的基本运算

**3.4.1 更名运算**

- old-name **as** new-name
- select、from 子句中均可出现；

```SQL
select T.name, S.course_id
from instructor as T, teaches as S
where T.ID = S.ID;
```

**3.4.2 字符串运算**

- 使用单引号标识字符串
- 字符串中的单引号使用双引号代替
- 有多种常用函数
 - upper(s)：将字符串 s 转为大写
 - lower(s)：将字符串 s 转为小写
 - trim(s): 去掉字符串后面的空格
- 可以使用 like 操作符实现模式匹配：
 - 百分号 (%) 匹配任意子串；
 - 下划线 (_) 匹配任意的单个子串；
 - 大小写敏感；

**3.4.3 select 子句中的属性说明**

`*`表示所有属性：

```sql
select instructor.*
from instructor,teaches
where instructor.ID = teaches.ID;
```

**3.4.4 排列元组的显示次序**

- 使用 order by 让查询结果中的元组按排列顺序显示
- 支持多列排序
- 默认升序，可以使用 asc/desc 表示升序/降序

```sql
select
from instructor
order by salary desc, name asc; 
```

**3.4.5 where 子句谓词**

使用比较运算符 between 可以简化 where 子句。

```sql
-- 使用前
select name
from instructor
where salary <=100000 and salary >=90000;

-- 使用后
select name
from instructor
where salary between 90000 and 100000; 
```

在元组上使用比较运算符，那么会按照字典顺序进行比较。

```sql
select name, course_id
from instructor, teaches
where instructor.ID= teaches.ID and dept_name = "Biology"; 

-- 可以重写为
select name, course_id
from instructor, teaches
where (instructor.ID, dept_name) = (teaches.ID, 'Biology');
```

## 3.5 集合运算

SQL 作用在关系上的 **union**、**intersect** 和 **except** 运算对应于数学集合论中的**并集** (∪)、**交集** (∩) 和**差集** (−) 运算。 

**3.5.1 并运算**

```sql
(select course_id
from section
where semester = 'Fall' and year = 2009)
union
(select course_id
from section
where semester = 'Spring' and year = 2010)
```

- 与 select 子句不同，union 会自动去除重复；
- 可以使用 union all 保留所有重复；

**3.5.2 交运算**

- 与 union 使用方式一致，会自动去除重复；
- 可以使用 intersect all 保留所有重复；

**3.5.3 差运算**

- 与 union 使用方式一致，会自动去除重复；
- 可以使用 except all 保留所有重复；

## 3.6 空值

空值运算规则：

如果算数表达式（+-*/）的任意输入为空，则该算数表达式结果为空
涉及空值的任何比较运算的结果视为 unknown（既不是谓词 is null, 也不是 is not null），是 true 和 false 之外的第三个逻辑值
扩展到 unknown 的布尔运算：

- and:
 - true and unknown ===> unknown
 - false and unknown ===> false
 - unknown and unknown ===> unknown
- or:
 - true or unknown ===> true
 - false or unknown ===> unknown
 - unknown or unknown ===> unknown
- not
 - not unknown ==> unknown

注意：

select distinct 会去除重复元组。在该过程中，需要比较两个元组的对应的属性值。如果两个值都是非空并且值相等，或者都为空，那么它们是相同的。

但是这与谓词对待空值的方式不同，谓词中 null = null 会返回 unknown，而不是 true。

## 3.7 聚集函数

以值的一个集合（集或多重集）为输入，返回单个值。

- 平均值：avg（必须数字集）
- 求和：sum（必须数字集）
- 计数：count
- 最大值：max
- 最小值：min

**3.7.1 基本聚集**

```sql
-- 找出 Comp. Sci. 系教师的平均工资
-- 计算平均值需要保留重复元祖
select avg(salary)
from instructor
where department = 'Comp. Sci.';

-- 找出在 2010 年春季学期讲授一门课程的教师总数
-- distinct 表示去掉重复元祖
select count(distinct ID)
from teaches
where semester = 'Spring' and year = 2010
```

**3.7.2 分组聚集**

目前为止的所有计算都是在表的所有数据或匹配特定的 WHERE 子句的数据上进行的。group by 子句可以将元祖进行分组。

```sql
select dept_name, avg(salary) as avg_salary
from instructor
group by dept_name;
```

需要注意的是：select 子句中没有使用聚集函数的属性，必须出现在 group by 子句中！

```sql
-- 错误示例！！！
select dept_name, ID, avg(salary)
from instructor
group by dept_name;
```

结果（错误的）：

| dept_name | ID | avg(salary) |
| ---------- | ----- | ------------ |
| Biology | 76766 | 72000.000000 |
| Comp. Sci. | 10101 | 77333.333333 |
| Elec. Eng. | 98345 | 80000.000000 |
| Finance | 12121 | 85000.000000 |
| History | 32343 | 61000.000000 |
| Music | 15151 | 40000.000000 |
| Physics | 22222 | 91000.000000 |

在一个特定分组中（dept_name）的每位老师都有一个 ID，因为每个分组只能输出一个元祖，所以无法确定选哪个 ID 作为输出结果。

```sql
-- 正确示例
select dept_name, ID, avg(salary)
from instructor
group by dept_name, ID;
```

结果（正确的）：

| dept_name | ID | avg(salary) |
| ---------- | ----- | ------------ |
| Biology | 76766 | 72000.000000 |
| Comp. Sci. | 10101 | 65000.000000 |
| Comp. Sci. | 45565 | 75000.000000 |
| Comp. Sci. | 83821 | 92000.000000 |
| Elec. Eng. | 98345 | 80000.000000 |
| Finance | 12121 | 90000.000000 |
| Finance | 76543 | 80000.000000 |
| History | 32343 | 60000.000000 |
| History | 58583 | 62000.000000 |
| Music | 15151 | 40000.000000 |
| Physics | 22222 | 95000.000000 |
| Physics | 33456 | 87000.000000 |

**3.7.3 having 子句**

- where 用来过滤 select 的筛选结果，having 子句用来过滤分组；
- having 支持所有 where 操作符；
- 与 select 类似，任何出现在 having 子句中且没有被聚集的属性，必须出现在 group by 子句中！

```sql
select dept_name, avg(salary) as avg_salary
from instructor
group by dept_name
having avg(salary) > 42000;
```

**3.7.4 对空值和布尔值的聚集**

聚集函数根据以下原则处理空值：除了 **count(*)** 外所有的聚集函数都忽略输入集合中的空值。
由于空值被忽略，有可能造成参加函数运算的输入值集合为空集。

## 3.8 嵌套子查询

3.8.1 集合成员资格
3.8.2 集合的比较
3.8.3 空关系测试
3.8.4 重复元组存在性测试
3.8.5 from 子句中的子查询
3.8.6 with 子句
3.8.7 标量子查询

## 3.9 数据库的修改

3.9.1 删除

```sql
delete from r where P;
```

3.9.2 插入

```sql
insert into r values (v1, v2, ..., vn); 
-- 先执行完 select 子句，然后执行 insert 子句
INSERT INTO
 r (
 SELECT
 (A1, A2,..., An)
 FROM
 r
 WHERE
 P
 );
```

3.9.3 更新

```sql
UPDATE
 r
SET
 A1 = v1
WHERE
 P;

-- case 结构 
CASE
 WHEN pred1 THEN res1
 WHEN pred2 THEN res2...
 WHEN predn THEN resn
 ELSE res0
END

-- 更新每个 student 的 tot_cred 属性值设为该生成功 学完的课程的总学分。
-- grade 既不是 F 也不是 null，则表明成功学完了该门课程
UPDATE
 student S
SET
 tot_cred = (
 SELECT
 sum(credits)
 FROM
 takes NATURAL
 JOIN course
 WHERE
 S.ID = takes.ID
 AND takes.grade <> 'F'
 AND takes.grode IS NOT NULL
 );

-- 如果学生没有成功完成任何一门课程，则 tot_cred 被设置为 null。 
-- 如果希望将这样的属性值设为 0，那么需要使用另一条 update

-- 上述 sql 可改写为 
UPDATE
 student S
SET
 tot_cred = (
 SELECT
 CASE
 WHEN sum(credits) IS NOT NULL THEN sum(credits)
 ELSE 0
 END
 FROM
 takes NATURAL
 JOIN course
 WHERE
 S.ID = takes.ID
 AND takes.grade <> 'F'
 AND takes.grode IS NOT NULL
 );
```

## 3.10 总结

略

数据库系统概念 - 03

《数据库系统概念（原书第 6 版）》读书笔记。

第一部分：2~6 章，详细讲解了关系型数据库。

第二章 关系模型



在商用模型应用中，关系模型已经占据了主要位置，原因是与早期的模型（网状模型/层次模型）相比，关系模型以其简易性简化了编程者的工作。

## 2.1 关系数据库的结构

- 关系数据库由**表** (table) 的集合构成，每个表有唯一的名称。
- 关系模型中的术语
 - **关系** (Relation) 用来指代**表** (Table)，
 - **元组** (Tuple) 用来指代**行** (Row)，
 - **属性** (Attribute) 用来指代**列** (Column)。
 - **关系实例** (relation instance)：表实例，就是一个有多行元组的表。
- 关系是元组的集合，元组出现的顺序无关紧要。
- 关系中的每个属性，都存在一个允许取值的集合（范围），称为该属性的**域** (domain)。
- 对所有关系 r 而言，r 的所有属性的域都是原子的。如果域中元素被看做是不可再分的单元，则域是**原子的** (atomic)。
- **空** (null) 是一个特殊的值，表示值未知或不存在。

> **表**这个概念和数学上的**关系**这个概念是密切相关的，这也正是关系数据模型名称的由来。在数学术语中，元组 (tuple) 只是一组值的序列（或列表）。在 n 个值之间的一种联系在数学上用关于这些值的一个 n 元组 (tuple) 来表示，n 元组就是一个有 n 个值的元组，它对应于表中的一行。[多元组 - wikipedia](https://zh.m.wikipedia.org/zh-cn/%E5%A4%9A%E5%85%83%E7%BB%84)

## 2.2 数据库模式

先做一个概念上的区分：

- 数据库模式：数据库的逻辑设计；
- 数据库实例：某一时刻数据库中数据的一个快照；

关系模式和关系实例：

- 关系的描述称为关系模式 (Relation Schema) ，对应于程序设计语言中**类型**的概念。
- 关系：对应于程序设计语言中**变量**的概念。
- 关系实例：对应于程序设计语言中**变量值**的概念。
- 关系模式可以形式化地表示为：
 - R(U，D，dom，F)
 - 其中 R 为关系名，U 为组成该关系的属性名集合，D 为属性组 U 中属性所来自的域，dom 为属性向域的映象集合，F 为属性间数据的依赖关系集合。
 - 通常简记为：R(U) 或 R(A1, A2, …, An)。其中 R 为关系名，U 为属性名集合，A1, A2, …, An 为各属性名。

## 2.3 键

一个问题，如何区分给定关系中的不同元组？

答案是使用 Superkey！Superkey 是一个或多个属性组合，它可以唯一的标识关系中的一个元组。如，在关系型数据库中我们常用 ID 来标识一个行记录。没有子集 Superkey 的 Superkey ，这种最小的 Superkey 称为**候选键** (Candidate Key)。

在数据库中我们使用术语**主键** (Primary Key) 来表示数据库设计人员选择的候选键。在一个关系中的任何两个元组不允许出现相同的 key 属性值。

> 当表中只有一个主键时，它是唯一的索引；
> 当表中有多个主键时，称为复合主键 (Superkey)，复合主键联合保证唯一索引；

一个关系 r1 的属性是另一个关系 r2 的主键，这个属性称为**外键** (Foreign Key)。

**参考完整性约束** (Referential Integrity Constraint) 表示一个外键属性值出现在参考关系中，它也必须出现在被参考的关系中。

## 2.4 模式图

一个含有主键和外键依赖的数据库模式可以通过模式图 (Schema Diagram) 来表示。每个关系用一个矩形表示，主键属性添加下划线表示，外键依赖表示为从外键属性出发的带箭头的线指向被参考的关系的主键属性。如图所示：

<img src="https://picgo-1254029119.cos.ap-beijing.myqcloud.com/blog/images/db-learn/2-8.png" style="max-height: 300px">

## 2.5 关系查询语言

数据库查询语言包括过程和非过程的。

- 非过程查询语言 (Nonprocedural Language) 是指用户描述希望得到的信息，但没有给出一个获得信息的具体的过程。常见的非过程查询语言，如 SQL(Structured Query Language)，关系演算 (relational calculus)。
- 过程查询语言 (Procedural Language) 是指用户指定了执行一系列的操作计算得到希望的结果。常见的过程查询语言，如关系代数 (relational algebra)。

## 2.6 关系运算

过程的关系型查询语言提供了一组运算，关系运算的结果总是单个的关系。

常见的关系运算有：

- 谓词运算：从单个关系（如 instructor）中选出满足一些特定为此（如 salary > 85000 美元）的特殊元组。
- 投影运算：从一个关系中选出特定的列。
- 连接运算：把分别来自两个关系的元组对合并成单个元组。
- 自然连接：两个关系的自然连接运算所匹配的元组在两个关系共有的所有属性上取值相同。
- 笛卡尔积：其结果包括来自两个关系元组的所有对，无论他们的属性值是否匹配。
- 集合运算：并集，交集，差集。

关系代数将在第 6 章详细讲解。

## 2.7 总结

略

数据库系统概念 - 02

《数据库系统概念（原书第 6 版）》读书笔记。

第一章 引言



## 1.1 数据库系统的应用

数据库系统很重要，很多地方都在用。用户界面隐藏了数据库的细节，但其实数据库系统已经成了人们生活中的组成部分，blabla~

## 1.2 数据库系统的目标

数据库系统 (DBMS) 出现之前，人们普遍采用**文件管理系统** (file-processing system) 来组织信息，但它有几个弊端。

以学生管理系统为例：

- **数据的冗余和不一致**
 - 例子：学生 A 读两个专业，音乐/数学
 - 冗余：学生 A 的地址可能出现在每个专业的记录中
 - 不一致：学生 A 的地址如果发生变更，可能只改了音乐系中的记录而没改数学系中的记录
- **数据访问困难**
 - 假如大学某个办事人员需要找出居住在某个特定地区的学生，只能手动筛选或找程序员重写一个程序
- **数据孤立**
 - 由于数据分散在不同的文件中，格式也可能不一致，因此编写程序来检索数据很困难
- **完整性问题**
 - 数据库中所存储的数据必须满足某些特定的一致性约束
 - 比方说大学每个系的账户余额不能低于零，由于数据分散在不同的文件中，当要添加新约束条件时很困难
- **原子性问题**
 - 多个操作相关联，要么全部发生，要么都不发生。([wikipedia](https://en.wikipedia.org/wiki/Atomicity_(database_systems)))
 - 例子：从银行账户 A 到账户 B 的货币转移。它由两个操作组成，从账户 A 中取出资金并保存到账户 B。在原子事务中执行这些操作可以确保数据库保持一致的状态，也就是说，如果这两个操作中的任何一个失败，资金都不会丢失或创建。
- **并发访问异常**
 - 多个用户同时更新数据的问题
 - 例子：A 账户有 1000 块钱，两个职员同时从 A 取钱，一个取 100，一个取 200. 取款操作的程序逻辑是读取余额，减去取钱额度。如果两个职员并发取钱，程序读到的的余额可能都是 1000，从而导致计算错误。
- **安全性问题**
 - 不同文件和数据访问权限的问题

## 1.3 数据视图

数据库系统是一些相关联的数据和一组程序（访问和修改数据）的集合。

数据库系统的一个主要目的是给用户提供**数据的抽象视图**，对数据的共性进行提取概括，隐藏掉关于数据存储和维护的某些细节。

### 1.3.1 数据抽象

数据库系统的一个要求是必须能高效的检索数据，这就需要结构化的去存储数据，这就涉及到许多数学和计算机方面的知识。由于许多用户并不是专业的计算机从业人员，对用户来说，了解数据库的设计和数据结构没有太大的必要，这是管理员需要关心的事情。数据库管理系统通过如下三个层次的抽象来向用户屏蔽复杂性，简化系统的用户界面。

- 物理层
 - 最低层次的抽象，描述数据实际上是如何存储的。
 - 这一层是开发 DBMS 的供应商应该研究的事情。
- 逻辑层
 - 比物理层稍高层次的抽象，描述数据库中存储什么数据以及这些数据间存在什么关系。
 - 虽然简单的逻辑层结构的实现涉及到复杂的物理层结构，但逻辑层的用户不必知道这种复杂性。这称作**物理数据独立性** (physical data independence)。
 - 这一层是由数据库管理员/数据库开发人员使用的，他们来确定数据库如何设计、应该保存哪些信息等等。
- 视图层
 - 最高层次的抽象，但只描述整个数据库的某个部分。
 - 数据库系统的多数用户并不需要关心所有的信息，而只需要访问数据库的一部分。比如老师要查询数据库中的某一部分学生的信息，老师不必知道数据库是如何设计的。
 - 视图抽象层的定义正是为了使用户与系统的交互更简单。系统可以为同一数据库提供多个视图，而视图又保证了数据的安全性。

<img src="https://picgo-1254029119.cos.ap-beijing.myqcloud.com/blog/images/db-learn/1-1.png" style="max-height: 300px">

### 1.3.2 实例和模式

- 数据库模式
 - 数据库的总体设计，不会经常变化。（比方说：变量声明）
 - 不同的抽象层次有不同的模式，从对应用程序的效果来看，逻辑层的数据库模式是最重要的。
- 实例：特定时刻存储在数据库中的信息的集合，会经常变化。（比方说：给变量赋值）

### 1.3.3 数据模型

数据库结构的基础就是数据模型。数据模型是描述数据（数据结构）、数据之间的联系、数据操作（语义），以及一致性（完整性）约束的概念工具的集合。

- 数据模型
 - 物理数据模型（物理层）
 - 逻辑数据模型（逻辑层、视图层）
 - 基于对象
 - 实体联系模型：第 7 章
 - 面向对象模型：第 22 章
 - 基于记录
 - 关系模型：常用，2~6 章详细讲解
 - 网状模型：数据联系紧密，很少用
 - 层次模型：数据联系紧密，很少用

## 1.4 数据库语言

数据库用户只能通过数据库语言来定义数据库的结构和访问数据库中的数据。数据库管理系统提供两种不同类型的语言：一种用于定义数据库模式，这就是数据定义语言 (DDL)；另一种用于表达数据库的查询和更新，这就是数据操纵语言 (DML)。

实际上我们使用时，DDL 和 DML 不是两种语言，而是一种语言（比如 SQL）的不同部分。

- 1.4.1 数据操纵语言
 - 过程式：需要用户指定获取什么数据以及如何获取；
 - 声明式：只需要用户指定获取什么数据，不关心获取方式；更加易学易用。
- 1.4.2 数据定义语言
 - 各行各业都有各自的"行话"，有时也称为"黑话"。数据定义语言就是数据库系统的"黑话"。
 - 例如这边一句"create table"语句，那边数据库管理系统就明白了要创建一张表。

## 1.5 关系数据库

2~6 章讲解。

## 1.6 数据库设计

7~9 章讲解，这里只是简要介绍。

## 1.7 数据存储和查询

10~13 章讲解。

## 1.8 事务管理

事务 (transaction) 是数据库应用中完成单一逻辑功能的操作集合，是一个既具原子性又具一致性的逻辑执行单元。

比如转账，转账操作要么完成要么不完成，这称作**原子性**；转帐之后钱的总数还应该保持不变，这种对数据库值的正确性要求称作**一致性**；当资金转帐成功结束后，不管发生什么事情，包括系统故障，帐户 A 和 B 的钱数也应该保持不变，这种对数据库的值保持不变的要求称作**持久性**。每个事务都不能违背这三个原则。

关于事务的更多概念将在 26 章讨论。

## 1.9 数据库体系结构

数据库系统由多个组件构成，它的系统结构如下图所示：

<img src="https://picgo-1254029119.cos.ap-beijing.myqcloud.com/blog/images/db-learn/1-5.png" style="max-height: 300px">

数据库应用程序通常划分为两层或者三层结构。如下图所示：

<img src="https://picgo-1254029119.cos.ap-beijing.myqcloud.com/blog/images/db-learn/1-6.png" style="max-height: 300px">

三层结构更适合大型的应用和互联网上的应用，更为常见。

## 1.10 数据挖掘与信息检索

- 数据挖掘（Data Mining）是指半自动分析大型数据库，从中找到有用的模式的过程。数据挖掘不同于机器学习，机器学习是处理大量的磁盘中的数据文件，而数据挖掘指的是处理数据库中的数据。由于很多查询是十分复杂的，很难使用 SQL 进行查询，所以需要使用数据挖掘技术。数据挖掘可以从数据中分析出有价值的规律，它可以帮助企业执行更好的决策。
- 数据仓库（Data Warehouse）可以在一个站点中一统一的模式收集不同来源的数据。提供为用户提供了一个统一的数据接口。
- 信息检索（Information Retrieval）是指查询无结构的文本数据。

## 1.11 特种数据库

在某些数据库系统的应用领域，关系型数据模型是受限制的。我们需要其它的数据模型来处理这些应用领域。常见的非关系型模型，如

- 对象基于的数据模型（Object-Based Data Model）。它可以便捷的实现面向对象编程的数据存储。
- 半结构化的数据模型（Semi-structured Data Model）。它的特点是相同类型的单个数据项可能具有不同的属性集。
- 键值数据模型（Key-value Data Model）。它是使用 map 或字典实现的。每一个 key 关联一个集合。键值数据模型没有查询语言，它使用简单的 get, put, 和 delete 命令去操作数据。它具有快速存取，可扩展性和可靠性等特点。

## 1.12 数据库用户和管理员

与数据库系统进行交互的人群可以以分为：数据库用户和数据库管理员。

不同类型的数据库用户的不同交互方式为：

- 普通的用户：通过应用程序与数据库系统进行功能。
- 应用开发人员：通过编程语言与数据库系统交互，开发应用程序，提供用户接口。
- 专业人员：直接使用数据库查询语言操作数据库系统。

数据库管理员的作用：

- 定义模式。通过执行 DDL 来创建数据库模式（Schema）。
- 定义存储结构和访问方式。
- 修改模式和物理组织。
- 授权数据的访问。
- 日常维护。周期性的备份数据库。确保有充足的磁盘空间。监控数据库系统的运行状态等等。

## 1.13 数据库系统的历史

- 20 世纪 50 年代~20 世纪 60 年代：使用磁带进行数据存储，只能顺序读取；
- 20 世纪 60 年代末~20 世纪 70 年代：硬盘广泛使用，数据在磁盘上的位置无关紧要；
- 20 世纪 80 年代：IBM 研究院在关系型数据库上取得突破性进展，此后关系模型在数据模型中一直独占鳌头。
- 20 世纪 90 年代初：决策支持和查询再度成为数据库的一个重要领域，分析大量数据的工具取得进展；
- 20 世纪 90 年代：互联网爆炸式发展，数据库必须支持更高的事务处理速度和更高的可靠性。
- 21 世纪第一个十年：
 - XML、XQuery 的兴起；
 - 开源数据库应用的显著增长，特别是 PostgreSQL 和 MySQL；
 - 专门用于数据分析的数据库有了很大增长；
 - 数据挖掘技术被广泛部署应用；

## 1.14 总结

- 首先认识了数据库系统，知道了它是什么和为什么，以及了解数据的表现形式、数据库语言等基本的数据库系统相关的概念。
- 然后介绍了具体类型的数据库，了解了关系型数据库。以及如何设计数据库。
- 接着介绍了数据库系统的内部结构，了解了存储，查询和事务等核心的数据库系统的组件。
- 最后讲了一些和数据库系统相关的其它概念。