Stari's Blog

26summer

Tue, 07 Jul 2026 00:00:00 GMT

数据库复习

Sat, 27 Jun 2026 00:00:00 GMT

C1 绪论

数据库的基本概念

⭐数据库、DBMS、数据库系统

概念	含义
数据库 DB	长期存储、有组织、可共享的大量数据的集合
数据库管理系统 DBMS	管理数据库的软件，位于应用程序和数据库之间（如 MySQL、Oracle、SQLSever）
数据库系统 DBS	数据库、DBMS、应用程序、数据库管理员、硬件等构成的整体
数据库应用系统	面向具体业务开发的应用程序及其数据库环境 = 数据库 + DBMS + 应用程序 + 数据库管理员 +硬件环境

⭐文件系统 vs 数据库

对比角度	文件方式	数据库方式
分散/统一	数据分散在不同文件	数据统一组织和管理
共享	共享困难	支持多用户共享
冗余	冗余较多	可以控制冗余
耦合/独立	程序与数据耦合较强	具有数据独立性
性质	一致性、安全性难保证	DBMS 统一保证完整性、安全和并发
适用场景	适合简单、独立的小规模数据	适合长期、共享、结构化业务数据

数据模型的组成要素 & 常用数据模型

⭐数据模型
- 两大类、共三种数据模型：概念数据模型、逻辑数据模型、物理数据模型
- 数据模型的组成要素：<u>数据结构、数据操作、数据约束</u> （二维关系表、原则/插入等、实体完整性）
- ⭐关系模型基本概念
  <div style="display: flex; width: 100%; gap: 0px;"> <div style="flex: 1; text-align: center;"> <img src="/images/relationModel1.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/relationModel2.png" alt="象集2" style="width: 100%;"> </div> </div>

数据库的三级模式

从数据库应用开发人员角度看，数据库通常采用 <u>三级模式结构</u>

层次	描述内容
外模式	某一类用户看到的局部数据，也叫用户视图
模式/概念模式	整个数据库的全局逻辑结构
内模式	数据的物理存储结构、文件组织和存取路径

两种数据独立性

逻辑数据独立性：<u>概念模式</u>改变时，外模式和应用程序尽量不用改变。 <br>例如增加一个属性，只需调整外模式与概念模式之间的映像，原有应用仍可使用原来的视图。
物理数据独立性：<u>内模式</u>改变时，概念模式和应用程序不用改变。 <br>例如把顺序文件改成 B+ 树索引，应用程序仍然执行相同的 SQL。

⭐关系的完整性约束

实体完整性 <br><u>主码属性不能为空 NULL</u>
参照完整性
1. <u>外码值要么为空，要么等于被参照关系的主码值</u>
2. 外码： <br>参照关系：R（拿着外码的表，比如学生表） <br>被参照关系：S（被引用主键的表，比如专业表） <div style="display: flex; width: 100%; gap: 10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/outerMa1.png" alt="外码1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/outerMa2.png" alt="外码2" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/outerMa3.png" alt="外码2" style="width: 100%;"> </div> </div>
用户定义的完整性

⭐码与相关概念

超码

能 <u>唯一标识</u> 元组的任意属性集。
- 关系：候选码是最小超码，候选码的任意超集都是超码。
- 例如：S(Sno, Sdept, Sage)，若：Sno → Sno, Sdept, Sage， <br>{Sno}是<u>候选码</u> 也是<u>超码</u>，(Sno, Sdept)也是<u>超码</u>。
候选码（码）

能够唯一标识元组的 <u>最小</u> 超码 <br>{Sno}是候选码
全码

如果关系的所有属性U才是R的码，称为全码 <br>例：$R(P,W,A)$（演奏者、作品、听众），全码为 $(P,W,A)$。P, W, A 都是关系R的主属性，在关系R中没有非主属性
主码

如果一个关系模式有多个候选码，则从中选一个作为主码。
- 例如：Student(Sno, Sname, Ssex, Sage, Sdept)：Sno 是候选码，Sname 也是候选码。 <br> → 可以选 Sno 作为主码。
外码

R中 $X$ 不是当前关系R的码，是另一关系的码，则 $X$ 为 $R$ 的外码。 <br>例：$SC(<u>Sno,Cno</u>,Grade)$ 中 Sno不是码，Sno是 S(<u>Sno</u>,Sdept,Sage)的码， <br> 则 $Sno$ 是 $SC$ 的外码 <br> FOREIGN KEY (deptno) REFERENCES Department(deptno) <br> 外码的作用是：建立表之间的引用联系，并保证参照完整性。

主属性与非主属性
- 主属性：包含在任意候选码中的属性。
- 非主属性：不包含在任何候选码中的属性。

例

S(<u>Sno</u>, Sdept, Sage)中，只有一个候选码Sno，所以：Sno是关系S的主属性，Sdept和Sage是关系S的2个非主属性；
SC(<u>Sno, Cno</u>, Grade)中，只有一个候选码(Sno, Cno)，所以：Sno和Cno是关系SC的2个主属性，Grade是关系SC的非主属性。
Student(Sno, Sname, Ssex, Sage, Sdept)中。有两个候选码：Sno 和 Sname（不允许学生同名），所以：Sno 和 Sname是关系Student的2个主属性，Ssex, Sage, Sdept是关系Student的3个非主属性。

⭐C2 关系代数

关系运算 选择：$\sigma_{Sdept='IS'}(Student)$、投影：$\pi_{Sdept}(Student)$
例
- 所有：除运算÷；只：
最大/最高 在当前的所有顾客中, 查询折扣(discnt)最高的顾客的编号？ <br>令 $S := C$, “折扣不是最高的顾客的id”
$R_2 := \pi_{C.cid}(\sigma_{C.discnt < S.discnt}(C \times S))$ <br>答案是 $\pi_{cid}(C) - \pi_{C.cid}(\sigma_{C.discnt < S.discnt}(C \times S))$ <div style="display: flex; width:100%; gap: 10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/tj.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/max1.png" alt="象集1" style="width: 100%;"> </div> </div>

<div style="display: flex; width:100%; gap: 10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/max2.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/max3.png" alt="象集1" style="width: 100%;"> </div> </div>
象集 <br>该属性值对应的其他属性值集合，相当于除法 <div style="display: flex; width: 100%; gap: 10px; margin: 5px 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/xj1.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/xj2.png" alt="象集2" style="width: 100%;"> </div> </div>

除运算 R ÷ S <span id="除运算"></span> <br>找出R、S中相同的属性列(B、C)，R 剩下的属性列(A) 作为结果。 <br>$a_i$的所有($b_j$,$c_j$)，$a_i$包含S中的全部b、c。
<div style="display: flex; width:100%; margin: 2px;"> <div style="flex: 1; text-align: center;"> <img src="/images/div1.png" alt="外连接" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/div2.png" alt="左右外连接" style="width: 100%;"> </div> </div>
- 例 <div style="display: flex; width:100%; margin: 2px;"> <div style="flex: 1; text-align: center;"> <img src="/images/divExample.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/divExample2.png" alt="象集1" style="width: 100%;"> </div> </div>

⭐C3 SQL

SQL基本执行结构
```
SELECT ...
 FROM ...
 WHERE ...
 GROUP BY ...
 HAVING ...
 ORDER BY ...;
```
逻辑顺序：FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY

对查询结果的处理

对查询结果排序 ORDER BY 属性名 ASC升序/DESC降序 查询选修了3号课程的学生的学号及其成绩，查询结果按分数降序排列。
```
SELECT Sno, Grade
FROM SC
WHERE Cno= '3'
ORDER BY Grade DESC;
```
对查询结果分组 GROUP BY/HAVING 求各个课程号及相应的选课人数。
```
SELECT Cno，COUNT(Sno)
FROM SC
GROUP BY Cno; // 按照Cno为一行,相同Cno为一行
```
查询选修了3门以上课程的学生学号。
```
SELECT Sno
FROM SC
GROUP BY Sno
HAVING COUNT(*) >3;
```
- 辨析 HAVING 与 WHERE：只有HAVING可以用AVG()等

基本表 TABLE

定义基本表 <br>PRIMARY KEY 主键，唯一标识一行数据，不能重复、不能为空 <br>UNIQUE 唯一，不能重复，但能为空 <br>外键 FOREIGN KEY (cno) PREFERENCE course(cno) ON UPDATE/DELETE 规约条件

CREATE TABLE Student
    (Sno CHAR(9) PRIMARY KEY,  /* 列级完整性约束条件, Sno是**主码**/
    Sname CHAR(20) UNIQUE,  /* **约束**，Sname的取值具有唯一性*/
    Ssex CHAR(2) NOT NULL CHECK (Ssex IN ('男', '女')),/*  非空且只能是男/女 */
    Sage SMALLINT,
    Sdept CHAR(20)
    );

CREATE TABLE enrollment(
    sno char(9) NOT NULL,
    clsno char(8) NOT NULL,
    grade INT CHECK (grade BETWEEN 0 AND 100),
    PRIMARY KEY(sno,clsno), -- 课程班代码和学号联合构成PRIMARY KEY
    );

CREATE TABLE courseclass(
clsno char(8) PRIMARY KEY,
cno char(8) NOT NULL,
tno char(9) ,
-- 先定义再外键 + 违约规则
FOREIGN KEY (cno) REFERENCES coures(cno) ON UPDATE CASCADE ON DELETE RESTRICT,
FOREIGN KEY (tno) REFERENCES teachers(tno) ON UPDATE CASCADE ON DELETE SET NULL
-- 父表更新cno，子表cno自动同步更新；父表删除cno，子表还有该课程就禁止删除
-- 父表更新tno，子表tno自动同步更新；父表删除tno，子表对应的tno自动设为NULL
);

违约规则 <br>什么是违约？父表更新主键/删除父表记录会破坏参照关系，触发违约

关键字	中文	含义
CASCADE	级联	父表改 / 删 → 子表自动跟着改 / 删
SET NULL	置空	父表删 → 子表外键自动设为 NULL
RESTRICT	限制 / 拒绝	数据库直接禁止父表的改/删操作

修改基本表（ALTER TABLE）

ADD新增列/完整性约束

ALTER TABLE Student 
ADD COLUMN S_email VARCHAR(50) NOT NULL UNIQUE;  -- 增加邮箱列，要求非空且唯一
ADD CONSTRAINT chk_sex CHECK (Ssex IN ('男', '女'));  -- 为 Ssex 增加 CHECK 约束（性别只能是男 / 女）

DROP 删除列

ALTER TABLE Student 
DROP COLUMN S_email CASCADE; --删除“邮箱”列，默认RESTRICT
DROP CONSTRAINT chk_sex; -- 删除性别CHECK约束

修改列的定义

ALTER TABLE Student 
ALTER COLUMN Sage INT;  -- 修改数据类型：年龄从SMALLINT改为INT
ALTER COLUMN Sname CHAR(30); -- 修改列长度（姓名从 CHAR (20) 改为 CHAR (30)）
ALTER TABLE Course ADD UNIQUE(Cname); -- 增加课程名称必须取唯一值的约束条件

删除基本表
```
DROP TABLE <表名>［RESTRICT| CASCADE］;
```
- RESTRICT：只有在该表没有被其他数据库对象依赖时，才能删除。
- CASCADE：删除该表的同时，还会删除依赖于该表的相关对象或依赖关系

视图 VIEW

视图的作用？ <br>简化复杂查询； <br>为不同用户提供不同数据视图； <br>隐藏敏感属性，提高安全性； <br>阻止不符合条件的数据加入/修改成不符合条件的数据。

定义视图 AS

CREATE VIEW S_G(Sno,Gavg) -- 可选：列名
AS
 SELECT Sno,AVG(Grade)
 FROM SC
 GROUP BY Sno;

查询视图
更新视图
删除视图 DROP VIEW S_G [RESTRICT | CASCADE]

字符串匹配

⭐字符匹配 LIKE/=

SELECT* FROM Student WHERE Sno LIKE '24%'  -- 通配符，查询学号以24开头的学生的详细信息
SELECT* FROM Student WHERE Sno = '24%' -- 查询学号就是'24%'学生的详细信息

⭐字符串中的通配符

SELECT Sname, Sno, Ssex
FROM Student
WHERE Sname LIKE '刘%';  -- 查询所有姓刘学生的姓名、学号和性别

SELECT Sname
FROM Student
WHERE Sname LIKE '欧阳_'; -- 查询姓"欧阳"且全名为三个汉字的学生的姓名

SELECT Sname, Sno
FROM Student
WHERE Sname LIKE '_阳%'; -- 查询名字中第2个字为"阳"字的学生的姓名和学号

SELECT Sname, Sno, Ssex
FROM Student
WHERE Sname NOT LIKE '刘%'; -- 查询所有不姓刘的学生姓名、学号和性别

多表连接 JOIN

SELECT DISTINCT s.sid, s.sname
FROM Student s
JOIN Enroll e ON s.sid = e.sid
JOIN Course c ON e.cid = c.cid
WHERE c.cname = '数据管理基础'
AND c.dept = '智软学院';

使用 DISTINCT 是为了消除同一学生由于多条匹配记录产生的重复

DISTINCT 的位置：SELECT 子句；聚集函数内部。

SELECT DISTINCT dept
FROM Student;

COUNT(DISTINCT sid)
AVG(DISTINCT score)
SUM(DISTINCT amount)

分组与 HAVING先Group 分组后 HAVING <div style="display: flex; width:50%; margin: -2px;"> <div style="flex: 1; text-align: center;"> <img src="/images/GroupHaving.png" alt="分组" style="width: 100%;"> </div> </div>

EXISTS 子查询有结果，返回TRUE；子查询无结果，返回FALSE

SELECT Sname
FROM Student S
WHERE EXISTS (
    SELECT *
    FROM SC
    WHERE SC.Sno = S.Sno
    AND Cno = '1' -- 从 Student 表里，找出那些‘存在’选修 1 号课程记录的学生
); -- 查询选修了 1 号课程的学生

SELECT Sname
FROM Student S
WHERE NOT EXISTS (
    SELECT *
    FROM SC
    WHERE SC.Sno = S.Sno
    AND Cno = '1'
); -- 查询没选1号课程的学生

查询选修全部课程的学生

SELECT Sname
FROM Student
WHERE NOT EXISTS ( -- ③ 除去没有选择课程的学生
    SELECT *
    FROM Course -- ② 有NOT EXISTS学生选择的课程中的：学生没有选择的课程
    WHERE NOT EXISTS (
        SELECT *
        FROM SC
        WHERE SC.Sno = Student.Sno  
        AND SC.Cno = Course.Cno -- ① 对SC中的每门课程，去Student、Course中寻找有无记录
    ) -- 学生选择的课程
);
✅ 理解：不存在一门课是这个学生没选的

例 <div style="display: flex; width: 100%; margin-left: 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/exists1.png" alt="exists" style="width: 80%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/exists2.png" alt="exists" style="width: 80%; max-width: 600px; height: auto;"> </div> </div> <div style="display: flex; width: 100%; margin-left: 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/exists3.png" alt="exists" style="width: 80%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/exists4.png" alt="exists" style="width: 80%; max-width: 600px; height: auto;"> </div> </div>

⭐例题

所有课程都及格：HAVING MIN(grade)>=60 <div style="display: flex; width:50%; gap: 1px;margin-top: -2px;margin-bottom: 20px"> <div style="flex: 1; text-align: center;"> <img src="/images/qq2.png" alt="分组" style="width: 100%;"> </div> </div>
修完本院所有必修课 <div style="display: flex; width:50%; gap: 1px;margin-top: -2px;margin-bottom: 20px"> <div style="flex: 1; text-align: center;"> <img src="/images/qq3.png" alt="分组" style="width: 100%;"> </div> </div>
每组最大值 <div style="display: flex; width:50%; gap: 1px;margin-top: -2px;margin-bottom: 20px"> <div style="flex: 1; text-align: center;"> <img src="/images/qq1.png" alt="分组" style="width: 100%;"> </div> </div>
只讲授本院课程

⭐C4 数据库编程

方式	怎么使用	主要场景
交互式 SQL	用户直接输入 SQL	临时查询、数据库管理
嵌入式 SQL	主语言＋SQL	SQL与C、C++结合
过程化 SQL	SQL＋变量、判断、循环	存储过程、函数、触发器

嵌入式SQL

主变量：能在SQL中使用的主语言变量

必须在声明区声明

-- 声明区
EXEC SQL BEGIN DECLARE SECTION;
char givensno[10];
char hsname[21];
int hsage;
EXEC SQL END DECLARE SECTION;
-- 声明区
EXEC SQL select Sno, Cno, Grade 
    into :hsno, :hcno, :hgrade, :gradeid -- 指示变量
    from Student
    where Sno = :givensno ; -- 查找给定学号的学生的信息

指示变量 gradeid：说明成绩是否为空

取值含义

0 返回的是正常非空值

大于 0 字符串被截断

-1 数据库值为 NULL
- 用指示变量写入NULL：把成绩置为空
```
gradeIndicator = -1;

EXEC SQL UPDATE SC
SET Grade = :hgrade :gradeIndicator -- 实际写入的是 grade = NULL
WHERE Sno = :hsno
AND Cno = :hcno;
```
通信区 SQLCA：记录每条SQL执行后的状态信息 <br>SQLCODE = 0：执行成功； <br>非0：没有找到数据、警告或者错误。
```
if (SQLCA.SQLCODE != 0) {
    break;
} -- 前一条执行SQL语句，然后检查：若不为0 → 退出
```
⭐游标 Cursor
游标是系统为查询结果建立的 数据缓冲区 和 当前位置指针，用于存放SQL查询的执行结果。解决SQL批量返回数据、主语言单条处理之间的矛盾
- 声明游标 EXEC SQL DECLARE 游标名 CURSOR FOR 查询语句;
- 打开游标 EXEC SQL OPEN 游标名;
- 提取数据 EXEC SQL FETCH 游标名 INTO 主变量;
- 关闭游标 EXEC SQL CLOSE 游标名;

取值	含义
0	返回的是正常非空值
大于 0	字符串被截断
-1	数据库值为 NULL

例依次检查某个系的学生记录，交互式更新某些学生年龄。

EXEC SQL BEGIN DECLARE SECTION; /*主变量声明开始*/
    char Deptname[21];
    char Hsno[10];
    char Hsname[21];
    char Hssex[3];
    int HSage;
    int NEWAGE;
EXEC SQL END DECLARE SECTION; /*主变量声明结束*/

long SQLCODE;
EXEC SQL INCLUDE SQLCA; /*定义SQL通信区*/

#include <sqlca.h>

int main(void) /*C语言主程序开始*/
{
    int count = 0;
    char yn; /*变量yn代表yes或no*/
    printf("Please choose the department name(CS/MA/IS): ");
    scanf("%s",deptname); /*为主变量deptname赋值*/
    EXEC SQL CONNECT TO TEST@localhost:54321 USER "SYSTEM"/"MANAGER"; /*连接数据库TEST*/
    -- 我现在要登录连接到数据库，数据库地址是本机，端口是 54321，数据库名字叫 TEST，登录账号是 SYSTEM，密码是 MANAGER
    EXEC SQL DECLARE SX CURSOR FOR /*定义游标SX*/
        SELECT Sno,Sname,Ssex,Sage /*游标SX对应的查询语句*/
        FROM Student
        WHERE SDept = :deptname;
    EXEC SQL OPEN SX;
/*打开游标SX，执行游标对应的查询，并指向查询结果的第一行*/

    for (;;) -- 循环读取游标里的每一条数据，直到游标读完 / 出错时退出
    {
        /* 推进游标，将当前数据放入主变量 */
        EXEC SQL FETCH SX INTO :Hsno, :Hsname, :Hssex, :HSage;
        if (sqlca.sqlcode != 0) { -- 操作不成功时退出
            break;
        }

        /* 是第一行的话，打印表头和学生信息 */
        if (count++ == 0) {
            printf("\n%-10s %-20s %-10s %-10s\n", "Sno", "Sname", "Ssex", "Sage");
        }

        /* 打印当前学生信息 */
        printf("%-10s %-20s %-10s %-10d\n", Hsno, Hsname, Hssex, HSage);

        /* 询问用户是否要更新该学生的年龄 */
        printf("UPDATE AGE(y/n)? ");
        do {
            scanf("%c", &yn);
            -- getchar();  --吃掉多余的换行符
        } while (yn != 'N' && yn != 'n' && yn != 'Y' && yn != 'y');
        -- 强制让用户必须输入 Y/y/ N/n 才往下走，输错就一直重新输

        /* 如果选择更新操作 */
        if (yn == 'y' || yn == 'Y') {
            printf("INPUT NEW AGE: ");
            scanf("%d", &NEWAGE);
            getchar();

            /* 嵌入式SQL更新语句*/
            EXEC SQL UPDATE Student
                SET Sage = :NEWAGE  -- Sage更新为读入的NWEAGE
                WHERE CURRENT OF SX;
        } /* 对当前游标指向的学生年龄进行更新 */
    }

    /* 收尾 */
    EXEC SQL CLOSE SX; -- 关闭游标SX，不再和查询结果对应
    EXEC SQL COMMIT WORK; -- 提交更新
    EXEC SQL DISCONNECT TEST; -- 断开数据库连接
} -- 只在 EXEC SQL FETCH SX INTO 语句之后检查了状态码 SQLCA.SQLCODE
-- 在其他嵌入式SQL语句之后，都没有检查SQL语句的执行状态码！
-- Solution：添加异常处理👇

异常处理

whenever是嵌入式SQL的全局异常捕获机制
```
EXEC SQL WHENEVER 条件 动作;
```
预编译器在处理过程中，会根据WHENEVER语句的定义，在每一条嵌入式SQL语句之后添加下面的异常状态检查命令： if ( condition ) { action }
常见执行异常 <br>SQLERROR、NOT FOUND、SQLWARNING
处理方法 CONTINUE、GOTO label、STOP、DO function | BREAK | CONTINUE

例

exec sql whenever sqlerror goto report_error ; -- SQL执行错误
exec sql whenever not found goto notfound ; -- 查询/FETCH没有得到记录，用于结束游标循环

<!-- - 全局变量 & 局部变量

VARIABLE fac NUMBER;

DECLARE
    NUM NUMBER(3) := 5;
BEGIN
    :fac := 1;

    IF NUM > 0 THEN
        FOR i IN 1..NUM LOOP
            :fac := :fac * i;
        END LOOP;
    END IF;
END;
``` -->
---
## 动态SQL
<!-- ```sql
-- 例1
EXEC SQL BEGIN DECLARE SECTION;
const char *stmt = "CREATE TABLE test(a int);";
EXEC SQL END DECLARE SECTION;

EXEC SQL EXECUTE IMMEDIATE :stmt;
-- 例2
const char *stmt = "INSERT INTO test VALUES(?);";

EXEC SQL PREPARE mystmt FROM :stmt;

EXEC SQL EXECUTE mystmt USING 100;
EXEC SQL EXECUTE mystmt USING 200;

这里 stmt 保存的不是普通数据，而是一整条 SQL 语句。 -->

过程化SQL

<!-- 1. 基本结构 sql DECLARE -- 变量、常量、游标、异常等定义 BEGIN -- SQL语句/流程控制语句 EXCEPTION -- 异常处理语句 END; 2. 变量 sql sex BOOLEAN := TRUE; --Boolean类型的变量sex，赋值为true today DATE NOT NULL := SYSDATE; -- Date类型的非空变量，赋值为系统Date age NUMBER(3) NOT NULL := 25; -- 最多3位数字，不允许为空，赋值为25

常量常量一旦赋值，就不允许修改
```
pi CONSTANT NUMBER := 3.14
```

数据类型

%TYPE 复制数据类型：方式修改数据类型之后需要手动更改；降低类型不匹配的风险

DECLARE
    teacher_name CHAR(5);
    student_name teacher_name%TYPE; -- 自动采用 teacher_name 的类型
BEGIN
    ...
END;

%ROWTYPE 变量结构与一整行相同

v_student Student%ROWTYPE; -- v_student中有student类型的id、name等

自定义记录类型 RECORD

DECLARE
    TYPE student IS RECORD (
        id        NUMBER(4) NOT NULL DEFAULT 0,
        name      CHAR(10),
        sex       BOOLEAN NOT NULL DEFAULT TRUE,
        birthdate DATE,
        physics   NUMBER(3),
        chemistry NUMBER(3)
    );

    student1 student; -- 使用自定义数据类型
BEGIN
    student.id := 1001; -- 访问赋值
END;

流程控制

if/else

IF 条件 THEN
    语句1;
ELSE
    语句2;
END IF;

循环

LOOP
    循环体;
    EXIT WHEN 退出条件;
END LOOP;

i := 1;
WHILE i <= 5 LOOP
    DBMS_OUTPUT.PUT_LINE(i);
    i := i + 1;
END LOOP;

FOR循环

FOR i IN 1..NUM LOOP -- for(i = 1; i <= NUM; i++)
    :fac := :fac * i;
END LOOP;
``` -->

⭐触发器

**什么是触发器？**当某张表发生插入、删除或修改时，数据库自动执行一段事先写好的程序。 <br>学生成绩提高超过10%时，自动记录日志； <br>插入教师信息时，如果教授工资低于4000，自动改成4000； <br>删除数据时，自动备份被删除的数据。

格式只要修改就会触发，满足条件才执行后续操作

CREATE TRIGGER 触发器名
BEFORE | AFTER
INSERT | UPDATE | DELETE(OR 其他操作)
ON 表名
FOR EACH ROW
BEGIN
    -- 触发后自动执行的语句
END;
……

例1：成绩提高10%时记录日志

CREATE TRIGGER SC_T -- 创建名为 SC_T 的触发器
AFTER UPDATE OF Grade ON SC -- SC 中的 Grade 修改完成后，触发该触发器
REFERENCING
    OLD ROW AS OldTuple,  -- 代表修改前的旧记录
    NEW ROW AS NewTuple   -- 代表修改后的新记录
FOR EACH ROW              -- 每修改一行执行一次
WHEN (NewTuple.Grade >= 1.1 * OldTuple.Grade) -- 新成绩比旧成绩至少提高10%，触发器才会执行下面的操作
INSERT INTO SC_U(Sno, Cno, OldGrade, NewGrade) 
VALUES(         -- 把下面信息插入日志表 SC_U
    OldTuple.Sno,
    OldTuple.Cno,
    OldTuple.Grade,
    NewTuple.Grade
);

例2：教授工资不能低于4000 <br>插入/修改教师信息时，如果该教师是教授，并且工资低于4000，就自动把工资改成4000。

CREATE TRIGGER Insert_Or_Update_Sal
BEFORE INSERT OR UPDATE ON Teacher
REFERENCING NEW ROW AS newTuple
FOR EACH ROW
BEGIN
    IF newTuple.Job = '教授'
    AND newTuple.Sal < 4000 THEN
        newTuple.Sal := 4000;
    END IF;
END;

函数

IS：声明部分：接下来存放查询结果的 局部变量、常量、游标等

例：计算总输入

CREATE OR REPLACE FUNCTION totalsal -- 创建/替换一个名为totalsal的函数
(
    v_empno IN emp.empno%TYPE  -- 调用者输入
)
RETURN NUMBER  -- 函数最终返回一个 NUMBER 类型的数值
IS
    totalsal1 NUMBER;
BEGIN
    SELECT sal + comm
    INTO totalsal1    
    FROM emp
    WHERE empno = v_empno;
-- 把v_empno编号的员工的 sal工资+comm奖金，结果存入totalsal1
    RETURN totalsal1;
END;

存储过程

AS 声明部分：接下来存放查询结果的 局部变量、常量、游标等

CREATE OR REPLACE PROCEDURE TRANSFER (
    inAccount  IN Account.AccountNum%TYPE, -- 转入账户：IN调用者传入
    outAccount IN Account.AccountNum%TYPE, -- 转出账户
    amount     IN NUMBER                   -- 转账金额
)
AS -- 内部局部变量
    /* 保存转出账户的余额 */
    totalDepositOut Account.Total%TYPE;

    /* 保存查询到的转入账户号 */
    inAccountNum Account.AccountNum%TYPE;

IN 调用者传入

CREATE OR REPLACE PROCEDURE TRANSFER (
    inAccount  IN Account.AccountNum%TYPE, -- 转入账户：IN调用者传入
    outAccount IN Account.AccountNum%TYPE, -- 转出账户
    amount     IN NUMBER                   -- 转账金额
)

INTO 查询并保存到局部变 → 异常处理

SELECT AccountNum
INTO inAccountNum
FROM Account
WHERE AccountNum = inAccount
FOR UPDATE;

EXCEPTION
        /* SELECT INTO没有查询到账户 */
        WHEN NO_DATA_FOUND THEN
            ROLLBACK;

            RAISE_APPLICATION_ERROR(
                -20004,
                '转入账户或转出账户不存在'
            );

        /* 处理其他异常 */
        WHEN OTHERS THEN
            ROLLBACK;
            RAISE;

例：转账存储过程

/*====================================================
1. 创建账户基本表
====================================================*/
CREATE TABLE Account (
    AccountNum VARCHAR2(11) PRIMARY KEY,  -- 账户号
    Total      NUMBER(15, 2) DEFAULT 0 NOT NULL, -- 账户余额

    CONSTRAINT CK_Account_Total
        CHECK (Total >= 0)
-- 创建名为 CK_Account_Total 的检查约束，要求：账户余额必须大于或等于0
);


/*====================================================
2. 插入测试数据
====================================================*/

/* 转入账户：初始余额20000元 */
INSERT INTO Account(AccountNum, Total)
VALUES ('01003813828', 20000);

/* 转出账户：初始余额50000元 */
INSERT INTO Account(AccountNum, Total)
VALUES ('01003815868', 50000);

COMMIT; -- 提交插入操作


/*====================================================
3. 查看转账前的账户余额
====================================================*/
SELECT AccountNum, Total
FROM Account
ORDER BY AccountNum;


/*====================================================
4. 创建转账存储过程
====================================================*/
CREATE OR REPLACE PROCEDURE TRANSFER (
    inAccount  IN Account.AccountNum%TYPE, -- 转入账户：IN调用者传入
    outAccount IN Account.AccountNum%TYPE, -- 转出账户
    amount     IN NUMBER                   -- 转账金额
)
AS -- 内部局部变量
    /* 保存转出账户的余额 */
    totalDepositOut Account.Total%TYPE;

    /* 保存查询到的转入账户号 */
    inAccountNum Account.AccountNum%TYPE;

BEGIN
    /*------------------------------------------
    1. 检查转账金额：小于0 不合法
    ------------------------------------------*/
    IF amount <= 0 THEN
        RAISE_APPLICATION_ERROR(
            -20001,
            '转账金额必须大于0'
        );
    END IF;

    /* 转入账户和转出账户不能相同 */
    IF inAccount = outAccount THEN
        RAISE_APPLICATION_ERROR(
            -20002,
            '转入账户和转出账户不能相同'
        );
    END IF;


    /*------------------------------------------
    2. 查询并锁定转出账户
    ------------------------------------------*/
    SELECT Total
    INTO totalDepositOut -- 查询并保存到局部变量totalDepositOut
    FROM Account
    WHERE AccountNum = outAccount
    FOR UPDATE; -- 加行级锁。防止转账过程中，其他事务同时修改该账户余额。
    -- 一直到COMMIT/ROLLBACK

    /*------------------------------------------
    3. 检查转出账户余额：小于转账金额 抛出ERROR
    ------------------------------------------*/
    IF totalDepositOut < amount THEN
        RAISE_APPLICATION_ERROR(
            -20003,
            '转出账户余额不足'
        );
    END IF;


    /*------------------------------------------
    4. 检查并锁定转入账户
    ------------------------------------------*/
    SELECT AccountNum
    INTO inAccountNum
    FROM Account
    WHERE AccountNum = inAccount
    FOR UPDATE;


    /*------------------------------------------
    5. 转出账户扣款
    ------------------------------------------*/
    UPDATE Account
    SET Total = Total - amount
    WHERE AccountNum = outAccount;


    /*------------------------------------------
    6. 转入账户加款
    ------------------------------------------*/
    UPDATE Account
    SET Total = Total + amount
    WHERE AccountNum = inAccount;


    /*------------------------------------------
    7. 提交转账事务
    ------------------------------------------*/
    COMMIT;


EXCEPTION
    /* SELECT INTO没有查询到账户 */
    WHEN NO_DATA_FOUND THEN
        ROLLBACK;

        RAISE_APPLICATION_ERROR(
            -20004,
            '转入账户或转出账户不存在'
        );

    /* 处理其他异常 */
    WHEN OTHERS THEN
        ROLLBACK;
        RAISE;

END TRANSFER;

静态SQL vs 动态SQL

C5 关系数据规范化理论

⭐数据依赖：函数依赖

定义 <br>X确定唯一Y，则称“X函数确定Y”或“Y函数依赖于X”，记作 $X \to Y$。
- $X$：决定因素
- $Y$：依赖因素 <div style="display: flex; width: 100%; margin-left: 0; margin-top: -40px; margin-bottom: -10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/FDli1.png" alt="函数依赖例1" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

1. 平凡/非平凡函数依赖

平凡函数依赖：$X \to Y$ 且 $Y \subseteq X$（Sno本来就在左边）例：$(Sno,Cno) \to Sno$，$(Sno, Cno) → Cno$
非平凡函数依赖：$X \to Y$ 且 $Y \nsubseteq X$ 例：$(Sno,Cno) \to Grade$

2. 完全/部分函数依赖

完全函数依赖：要决定Y，X的所有部分都要用上，如要确定一门课的成绩，需要同时知道学号+课程名 <br>例：$(Sno,Cno) \stackrel{F}{\to} Grade$
部分函数依赖：要决定Y，只需要X中的一部分属性就可以，如确定专业，只需知道Sno就行，Cno是不必要的 <br>例：$(Sno,Cno) \stackrel{P}{\to} Sdept$

3. 传递函数依赖

定义：若 $X \to Y$，$Y \nrightarrow X$，$Y \to Z$（$Y \nsubseteq X$ $Z \nsubseteq Y$），则 $X \stackrel{\text{传递}}{\to} Z$
例：$Sno \to Sdept$，$Sdept \to Mname$ $\Rightarrow$ $Sno \stackrel{\text{传递}}{\to} Mname$

数据依赖：多值依赖

范式 & 规范化

范式（NF）：是对一个关系中允许存在的数据依赖的要求 <br>规范化：通过投影分解将低范式转换为高范式。
范式等级（从低到高包含关系）： $$1NF \supset 2NF \supset 3NF \supset BCNF \supset 4NF \supset 5NF$$
规范化：将低范式通过模式分解转为高范式，消除不良数据依赖 <br>范式越高，对表中数据依赖的要求越严格。

范式	主要解决的问题	一句话理解
1NF	属性不可再分	每个格子只能放一个值
2NF	部分函数依赖	非主属性不能由主属性部分函数依赖推出，必须完全依赖
3NF	传递函数依赖	不存在非主属性对候选码的传递函数依赖
BCNF	决定因素不是码	所有非平凡函数依赖中的决定因素（左边），都必须是包含候选码（是超码）
4NF	-	每个非平凡多值依赖 X →→ Y 都满足 X含有码

1NF：属性原子性；2NF：不存在主属性部分函数依赖非主属性； <br>3NF：不存在 非主属性 对 候选码的传递依赖；BCNF：左边都是超码 <br>部分主 → 非主；非主 $\xRightarrow{传递}$ 候选码；超码 →

二、1NF（第一范式）

定义
关系模式的所有属性均为 不可再分的原子数据项，是关系数据库的最低要求。
实例
关系模式 SLC(Sno, Sdept, Sloc, Cno, Grade) 中，所有属性均为原子属性，满足 1NF。

三、2NF（第二范式）

定义 <br>非主属性不能由候选码部分函数依赖推出，必须完全依赖。
- 如：AF 是候选码，D 是非主属性。 <br>若A → D，说明非主属性 D对候选码部份依赖 $\Rightarrow$ 不满足2NF
实例：SLC 关系 <div style="display: flex; width: 100%; margin-left: 0; margin: -20px; top"> <div style="flex: 1; text-align: center;"> <img src="/images/2NF1.png" alt="函数依赖集1" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>
Solution <br>分解成2个关系模式（但插入异常、删除异常任然存在） <div style="display: flex; width: 100%; margin-left: 0; margin-top: -20px; top"> <div style="flex: 1; text-align: center;"> <img src="/images/2NF2.png" alt="函数依赖集1" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

四、3NF（第三范式）

定义 <br>不存在非主属性对候选码的传递函数依赖 <br>码 ~不能~和 非主属性 有传递依赖关系 <br>不存在码X、属性Y、非主属性Z使得 $X→Y，Y→Z$ 成立 $\Rightarrow Y \nrightarrow X$
实例：SL 关系（Sno是码）

五、BCNF（巴斯范式）

定义 <br>所有非平凡函数依赖中的决定因素（左边），都必须是包含候选码（都必须是超码）
实例 1：仓库管理关系：把违反的（管理员，仓库名）单独成表 <div style="display: flex; width: 100%; margin-left: 0; margin-top: -20px;"> <div style="flex: 6; text-align: center;"> <img src="/images/BCNF.png" alt="BCNF1" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 4; text-align: center;"> <img src="/images/BCNF2.png" alt="BCNF1" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

4NF（第四范式）

定义 <br>每个非平凡多值依赖 X →→ Y 都满足 X含有码
分解 <br>把独立的多值事实拆开

⭐Armstrong公理系统

Armstrong公理系统 - 基本规则
1. <u>A1 自反律</u>：知道一组属性，一定知道部分 <br> {Cno, Sname} → Cno
2. <u>A2 增广律</u>：若 $X \rightarrow Y$，则 $XZ \rightarrow YZ$ <br> Cno → Sname $\Rightarrow$ {Cno, clsno} → {Sname, clsno}
3. <u>A3 传递律</u>：若 $X\rightarrow Y$ 且 $Y\rightarrow Z$，则 $X\rightarrow Z$ <br> Cno → Class、Class → Teacher $\Rightarrow$ Cno → Teacher
Armstrong公理系统 -扩充规则
1. <u>合并规则</u>：若 X $\to$ Y 且 X $\to$ Z，则 X → YZ
2. <u>分解规则</u>：若：X → YZ，则：X → Y，X → Z
3. <u>伪传递规则</u>：若 X $\to $Y 且 WY $\to$ Z，则 XW $\to$ Z
- 引理：$X \to A_1A_2\cdots A_k \Rightarrow X \to A_i( i=1,2,\dots,k)$ 成立 <br>学号 → (姓名, 班级, 专业) $\Rightarrow$ 学号 → 姓名，学号 → 班级，学号 → 专业
函数依赖的逻辑蕴涵
- F 的所有规则，必然导致 X→Y 成立（X Y是属性/属性集）。是由F带来的，没有写出但必然成立的规则。 <br>则称：F 逻辑蕴涵 X → Y，记作 F ⊨ X → Y
- 例：F = {学号 → 系名, 系名 → 系主任 }，则：F ⊨ 学号 → 系主任
函数依赖集的覆盖 & 等价
- 核心概念
  - 覆盖：若 F 能推出 G 里的所有依赖 ($G\subseteq F^+$) ，就说 F覆盖G
  - 等价：若 F覆盖G 且 G覆盖F（$F^+ = G^+$），就说 F和G等价（充要关系）
- 例 <br>设：F = { A → B, A → C }，设：G = { A → BC } <br>$\Rightarrow$ F 和 G 等价。 <br>因为：由 F 可用合并规则推出 A → BC；由 G 可用分解规则推出 A → B 和 A → C <br>所以：F⁺ = G⁺（“分开写”和“合起来写”本质上表达的是同一件事）
函数依赖集

函数依赖：A→B 从A出发能确定唯一B。即一对一/多对一（不能出现多对一/多对多） <br> A→B 多对一/AC→D 一对一；但是A→B 多对一/A→C 多对多 <div style="display: flex; width: 100%; margin-left: 0; margin-top: -40px; top"> <div style="flex: 1; text-align: center;"> <img src="/images/hanshuylj1.png" alt="函数依赖集1" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/hanshuylj2.png" alt="函数依赖集2" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>
3.1 函数依赖集的闭包 F^+
- 定义：$F^+ = { X \to Y \mid F \vDash X \to Y }$，即：所有被 F 逻辑蕴涵的函数依赖的集合。
- 属性集 U={A,B,C}，函数依赖集 F={A→B, B→C} → $F^+$ ={ A→A, A→B, A→C, A→BC, A→AB, A→AC, A→ABC, B→B, B→C, B→BC, C→C, AB→A, AB→B, AB→C, AB→AB, AB→AC, AB→BC, AB→ABC, AC→A, AC→B, AC→C, AC→AB, AC→AC, AC→BC, AC→ABC, BC→B, BC→C, BC→BC, ABC→A, ABC→B, ABC→C, ABC→AB, ABC→AC, ABC→BC, ABC→ABC }
- 直接计算 F⁺ 很麻烦。因为可能推出非常多的函数依赖。所以实际做题时， <br>一般不直接求 F⁺，而是用 属性集闭包 X⁺ 👇来判断某个依赖是否成立。
3.2 属性集的闭包 $A_F^+$
- 根据 F，属性集 A 最终能够确定哪些属性，$A_F^+$称为属性A关于函数依赖集F的闭包。
- ⭐例：计算A关于F的闭包 $A_F^+$（迭代算法） <br>初始：$A_F^+ = {A}$ 用 A→B：$A_F^+ = {A,B}$ 用 B→C：$A_F^+ = {A,B,C}$ <div style="display: flex; width: 100%; margin-left: 0; margin-top: -40px;margin-bottom: -20px"> <div style="flex: 6; text-align: center;"> <img src="/images/image-62.png" alt="属性集的闭包" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>
- ⭐例：求候选码若A能推导出所有属性 → A是候选码
3.3 极小函数依赖集 / 最小依赖集 / 最小覆盖：F的最简形式
- 需满足 3 个条件：
  设 F 为函数依赖集，$F_m$ 是其极小依赖集，需满足：
  1. 右边只有一个属性
  2. 左边没有多余属性 <br>AB → C，如果：A⁺ 中已经包含 C说明只用 A 就能推出 C，B 是多余的。 <br>于是：AB → C可以简化为：A → C
  3. 没有冗余函数依赖
- 计算算法
  1. 右部拆分：AD → EF 拆成：AD → E，AD → F；
  2. 删左边多余属性：对于 ADF→ C：∵AD → F ，故可简化为 AD → C； <br>对于 ADF → D：∵D已经包含在左边 $\rightarrow$ 可以删除该平凡函数依赖；
  3. 删冗余依赖：对于C → B，可以由C → F，F → B推出。删除 C → B；
  - 特性：每个函数依赖集都等价于一个极小依赖集，且不唯一。

🌟例题

⭐例1：属性集闭包算法 -计算A关于F的闭包 $A_F^+$
<br>初始：$A_F^+ = {A}$ 用 A→B：$A_F^+ = {A,B}$ 用 B→C：$A_F^+ = {A,B,C}$
- 计算方法：迭代算法 <div style="display: flex; width: 100%; margin-left: 0; margin-top: -30px;margin-bottom: -20px"> <div style="flex: 6; text-align: center;"> <img src="/images/image-62.png" alt="属性集的闭包" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>
⭐例：等价/最小函数依赖集 -属性集闭包算法
<div style="display: flex; width: 100%; margin-left: 0; margin-top: -40px;margin-bottom: -20px"> <div style="flex: 6; text-align: center;"> <img src="/images/image44.png" alt="属性集的闭包" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>
⭐例2：极小函数依赖集算法
1. 右部拆分：AD → EF 拆成：AD → E，AD → F；
2. 删左边多余属性：对于 ADF→ C：∵AD → F ，故可简化为 AD → C； <br>对于 ADF → D：∵D已经包含在左边 $\rightarrow$ 可以删除该平凡函数依赖；
3. 删冗余依赖：对于C → B，可以由C → F，F → B推出。删除 C → B；
⭐（补充3）例：判断冗余依赖
1. 函数依赖集 M = {C → E，E → B，BCD → A}，断言：BCD → A 可以简化成 CD → A，它是一个冗余函数依赖 <br>构造 N = {C → E，E → B，CD → A}，只需证明：$M^+ = N^+$（M能推出的=N能推出的） <br>✅只需证明：M ⊨ CD → A？ N ⊨ BCD → A？
  
  ① 证明：M ⊨ CD → A <br>只需证明 ${C，D}_M^+$ 中包含 A，就能证明 CD → A <br>初始值：{CD}_M^+ = {C，D} <br>第一遍：{CD}_M^+ = {C，D，E}（C → E） <br>第二遍：{CD}_M^+ = {B，C，D，E}（E → B） <br>第三遍：{CD}_M^+ = {A，B，C，D，E}（BCD → A）
  
  ② 同理得证：N ⊨ BCD → A
2. 函数依赖集 M = {B → D，D → E，C → F，BC → A，EF → A}，断言：BC→ A 是一个冗余的函数依赖 <br>构造 N = {B → D，D → E，C → F，EF → A}，要证明 $M^+ = N^+$，<br>只需证明：N ⊨ BC → A，即：${BC}_N^+$ 包含A
3. 函数依赖集 F = {A → B，B → A，AB → C}，判断 AB → C 是否为部分函数依赖？ <br>只需假设把AB → C 换成 A → C/B → C是否依然成立。同上。
⭐例3：计算候选码
要求候选码K，只需找到能推出全部属性U的 $K_R^+=U$ 即可。
1. 没有出现在右边的属性 → 一定在候选码内（因为没有属性能推出它）
2. 只出现在右边的属性 → 一般不放在候选码（因为可以由其他属性推出）
3. 其他属性待选跟1结合
- 先算1必须出现在候选码中的属性K，是否有 $K_R^+ = U$
- 再依次跟3中属性结合。候选码可能不止1个。

⭐模式分解

模式分解的三个理解
1. 无损连接：自然连接后完全等于原表
2. 保持函数依赖：分解后所有依赖规则都能找到
3. 既 无损连接 又 保持函数依赖

⭐无损连接

有损连接：会产生多余元组。
定义：R = R1 ⋈ R2 ⋈ ... ⋈ Rn，能 自然连接$\bowtie$ 回来，完全等于原表。

💫判定：两张表的<u>公共属性</u>，如果能推出某一张表的<u>非公共属性</u>，就是无损连接。 <br>例如1：设有一个关系模式T(A,B,C)，函数依赖集F，请判断下述的分解$ρ={T_1,T_2}$是否具有无损连接性？A是公共属性，能推出T1的非公共属性B。故满足无损连接性

函数依赖集	分解ρ	是否满足无损连接性？	解释
{A→B}	$T_1(A,B) T_2(A,C)$	✅	A是公共属性，能推出B
{A→C，B→C}	$T_1(A,B) T_2(A,C)$	✅	A是公共属性，能推出C
{A→B}	$T_1(A,B) T_2(B,C)$	❌	B是公共属性，不能推出非公共属性
{A→B，B→C}	$T_1(A,C) T_2(B,C)$}	❌	C是公共属性，不能推出非公共属性

⭐保持函数依赖

分解后，原来的函数依赖能在子关系中直接检查。

🌟3NF模式分解

目标：得到满足3NF 且既有无损连接性又保持函数依赖的分解
步骤：<u>每条依赖建一张表，最后检查有没有候选码，没有就补上</u>
1. 求 F 的极小函数依赖集 Fmin
2. 求候选码
3. 谁决定谁，就把它们放在一张表里。 <br>例如：Sno → Sdept就建：SD(Sno, Sdept)
4. 合并左边相同的
5. 💫检查是否需要补候选码表：如果没有任何子关系包含原关系的候选码 K，则补一个关系 R(K)

💫例：到3NF的模式分解示例

🌟BCNF 模式分解

目标：分解到 BCNF，并且保证无损连接。
步骤：
1. 初始 ρ = {R}
2. 检查每个关系是否满足 BCNF
3. 如果某个关系不满足 BCNF，则存在：X → Y，且 X 不是超码
4. 分解为：R₁ = (X,Y)，R₂ = (U - (Y-X)) <br>例：U={A,B,C,D,E},X={A,B} Y={B,C} <br> → Y-X={B,C}-{A,B}={C}减去公共属性 <br> → $R_2$ = U-(Y-X) = {A,B,D,E},$R1$={A,B,C}
5. 继续检查，直到全部满足 BCNF

💫例：转换为BCNF的无损连接分解 <br>STJ(S学生,T老师,J课程)，依赖包括：T → J，(S,J) → T，(S,T) → J，候选码为ST、SJ <br>STJ 满足 3NF，但不满足 BCNF。

原因：T → J 中，T 不是超码。

所以分解为：TJ(T,J) ST(S,T)

多值依赖

定义：一个属性决定的不是一个值，而是一组值。记作 X →→ Y，读作Y多值依赖于X（有其他属性Z，Y、Z都多值依赖于X的充要条件是 X、Y可以自由组合）
多值依赖 vs 函数依赖
1. 跟Z的关系 <br>函数依赖：只问“X 能不能唯一确定 Y”。 <br>多值依赖：还要问“Y 和剩下的属性是不是独立”。
2. 跟子集的关系 <br>A → BC，则：A → B A → C <br>多值依赖不一定成立

⭐C6 数据库的安全性

授权：授予GRANT 与回收REVOKE

授予 GRANT

GRANT SELECT,INSERT
ON Student
TO U1 -- 把对Student的查询、插入权限授予用户U1

GRANT ALL PRIVILIGES
ON TABLE Student,Course
TO U2,U3 -- 把对Student表和Course表的全部权限授予用户U2和U3

转授 WITH GRANT OPTION

GRANT SELECT
ON Student
TO user2
WITH GRANT OPTION;

回收 REVOKE

REVOKE UPDATE(Sno) ON STUDENT FROM U4 -- 把用户U4修改学生学号的权限收回
REVOKE SELECT ON SC FROM PUBLIC -- 收回所有用户对表SC的查询权限

⭐C7 数据库设计

数据库设计基本步骤 <div style="display: flex; width: 70%; margin-left: 0; margin-top: -40px;margin-bottom: -20px"> <div style="flex: 6; text-align: center;"> <img src="/images/DBDP.png" alt="数据库的设计" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

工作	所属阶段
收集业务需求、数据流	需求分析
画 ER/EER 图	概念结构设计
ER 转关系模式、规范化	逻辑结构设计
设计索引、文件组织、聚簇	物理结构设计
建表、装载数据、编程	数据库实施

⭐C8 ER/EER模型

父子关系-ISA联系：不相交 & 完全特化（超类&子类） <br>不相交约束 x：不能是多个 <br>完全特化 ||：必须是一个
Part-of联系 双菱形
弱实体：双矩形。自己的属性不一定能独立区分自己（有不同贷款但可能在同一天还款、金额也可能一样）（不同职工可能都有叫“张伟”的家属；因此仅用“家属姓名”不能唯一确定家属）
基数约束表示：min（强制参与/非强制参与）..max（单值参与/多值参与） <br>左边基数：一个左边，对应多少个右边
- 为什么引入：消除歧义
组合属性 / 多值属性 <div style="display: flex; width: 120%; margin-left: 0; margin-top: -20px;margin-bottom: -10px"> <div style="flex: 6; text-align: center;"> <img src="/images/zuheshux.png" alt="组合属性的子属性表示" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 6; text-align: center;"> <img src="/images/duozhishux1.png" alt="多值属性的双线桥表示" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 6; text-align: center;"> <img src="/images/duozhishux2.png" alt="多值属性的基数约束表示" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

C9 数据库恢复技术

事务 & ACID特性

什么是事务？：原子操作，事务是一个不可分割的数据库操作序列：

ACID四个特性

特性	含义	例子	主要由什么保证
Atomicity 原子性	要么全做，要么全不做	扣款和加款必须一起完成	UNDO、ROLLBACK、日志
Consistency 一致性	从一个一致状态变为另一个一致状态	转账前后总金额不变	正确事务程序、完整性约束、并发与恢复机制
Isolation 隔离性	并发事务之间互不干扰	别人不能看到只扣款、未加款的中间状态	第11章并发控制、封锁
Durability 持久性	提交后的结果不会因故障丢失	转账提交后，断电也不能丢失	REDO、日志、转储

COMMIT、ROLLBACK & 保存点 SAVEPOINT

3. SQVEPOINT sql 操作1 操作2 SAVEPOINT sp1 -- 定义操作3 操作4 ROLLBACK TO sp1 -- 操作3、操作4撤销；

三类故障及恢复方法

这是判断UNDO、REDO的基础。

故障类型	是否破坏磁盘数据库	典型原因	恢复方法
事务故障：程序错误	通常不破坏数据库文件	溢出、死锁、违反完整性约束	UNDO该事务
系统故障：外界错误CPU/OS/DBMS/停电	不破坏磁盘文件，但内存丢失	断电、操作系统崩溃、DBMS崩溃	UNDO未提交，REDO已提交
介质故障：磁盘损坏/强磁场造成外存数据丢失	破坏数据库文件	磁盘损坏、磁头碰撞	重装副本，再REDO
病毒等人为故障	可能破坏数据或文件	恶意修改、删除	管理员：后备副本＋日志REDO

数据转储

静态转储 & 动态转储
海量存储 & 增量存储

⭐日志文件

**什么是日志文件？**日志文件记录事务对数据库的更新操作。

UNDO前像 & REDO后像

 <START T1>
 <T1, A, 100, 80>-- 账户 A 原来余额为100元，事务T1要扣除20元→修改为80元
 <COMMIT T1>     -- 事务T1已经成功完成，修改结果应当永久保存

 <START T2>
 <T2, B, 50, 70>
 <ROLLBACK T2>   -- T2放弃事务，撤销自己的全部修改。回滚回前像B=50
 <CHECKPOINT ...>

T1没有提交，系统故障 <br>没有COMMIT，T1尚未完成 → UNDO T1使用前像，把A恢复成100
T1已经提交，系统故障 <br>CONNIT已经提交，但80还没写入磁盘 → REDO T1使用后像，A写入80

tmp

Sun, 24 May 2026 00:00:00 GMT

一些临时记录

计算机网络

Thu, 05 Mar 2026 00:00:00 GMT

U4 数据链路层
U5 网络层
U6 传输层
- 概述
- UDP vs TCP
- UDP
- TCP
U7 应用层

<!-- # U1 计算机网络体系结构

基本概念

<u>计算机网络</u>：由若干结点(node)和连接这些结点的链路(link)组成 <br>通过集线器、交换机构建计算机网络，通过路由器连接不同计算机网络
<u>互联网（因特网）</u>：各大ISP(Internet Service Provider)和国际机构组建成的、覆盖全球的互连网， <br>必须使用 TCP/IP协议通信；
<u>互连网</u>：路由器连接的大规模计算机网络，可以使用任意协议通信。
<u>交换机</u>：把多个节点链接起来，组成一个计算机网络 <br><u>路由器</u>：把两个或多个计算机网络连接起来，形成规模更大的计算机网络。也称为“互连网”
总结 <div style="display: flex; width: 100%; margin-left: 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/img_24.png" alt="计算机网络基本概念总结" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

计算机网络的组成

从组成部分看

从工作方式看

从逻辑功能看

资源子网:主要由连接到互连网上的**主机**组成
通信子网：负责计算机间信息传输的部分，即所有通信设备和通信介质 <br><u>网络适配器</u>、<u>底层协议</u> 属于通信子网 -->

计算机网络的功能

三种交换技术

<u>电路交换</u> Circuit switching
1. 定义：通信前从主叫端到被叫端建立一条专用的 物理通路，在通信的全部时间内，两个用户始终占用端到端的线路资源。
2. 优缺点：
  - 优点：数据直送，传输速率高；
  - 缺点：建立/释放连接，需要额外的时间开销； <br> 线路被通信双方独占，利用率低；线路分配的灵活性差； <br> 交换节点不支持“差错控制”(无法发现传输过程中的发生的数据错误)
3. 更适用于：低频次、大量传输数据（电话网） <span id="报文交换"></span>
<u>报文交换</u>
1. 定义：把传送的数据单元先存储在中间节点，再转发给下一地址 <br> massage报文包括：控制信息 + 用户数据（发送方/接收方 + 传送的数据内容）
2. 优缺点
  - 优点：通信前无需建立连接 <br> 数据以“报文”为单位被交换节点间“存储转发”，通信线路可以灵活分配 <br> 在通信时间内，两个用户无需独占一整条物理线路。相比于电路交换，线路利用率高 <br> 交换节点支持“差错控制”(通过校验技术)
  - 缺点：报文不定长，不方便存储转发管理 <br> 长报文的存储转发时间开销大、缓存开销大 <br> 长报文容易出错，重传代价高 <span id="分组交换"></span>
<u>分组交换</u> Packet switching
1. 基本概念：长报文的数据分为若干个小的定长数据，<br>每部分的定长数据增加 控制信息(首部 Header) （包含：源地址、目的地址、分组号）；<br>定长数据+控制信息 = 分组（packet） <br>路由器是一种典型的分组交换机
2. 过程：数据被分成定长小数据，可以通过不同路径传输，最后在终端按照分组号进行排列
3. 优缺点
  - 优点：相比于报文交换 <br> 分组定长，方便存储转发管理 <br> 分组的存储转发时间开销小、缓存开销小 <br> 分组不易出错，重传代价低
  - 缺点: <br> 相比于报文交换，控制信息占比增加 <br> 相比于电路交换，需要在中间存储，依然存在存储转发时延 <br> 报文被拆分为多个分组，传输过程中可能出现失序、丢失等问题，增加处理的复杂度
<u>虚电路交换</u> Virtual Circuit
1. 过程：将源地址、目的地址建立联系(虚拟电路)，交换机处理，在传输过程中一直按序传输，最后释放连接
2. 现代计算机采用 分组交换，用网络边缘终端强大的算力进行排序，而非用网络的核心部分
性能分析
1. <a href="https://www.bilibili.com/video/BV19E411D78Q?t=65.1&p=5" target ="_blank">电路交换</a> <a href="https://www.bilibili.com/video/BV19E411D78Q?t=597.0&p=5" target="_blank">报文交换</a> <a href="https://www.bilibili.com/video/BV19E411D78Q?t=780.5&p=5" target="_blank">分组交换</a>

<!-- ---

计算机网络的分类

计算机网络的性能指标

<u>速率</u> ：连接到网络上的节点在信道上传输数据的速率。也称为数据率/比特率/数据传输速率
1. 信道：向某一方向传送信息的通道（一条通信线路逻辑上对应 <u>发送信道</u>、<u>接收信道</u>）
2. 速率单位：bit/s（b/s、bps）
3. 数量前缀：k → M → G → T（$10^3$） <span id="带宽"></span>
<u>带宽</u>：信道能传送的<u>最高数据率</u>
1. 信道语序通过的信号频率范围（Hz）
2. 通信线路通过的信号最高数据传输速率 <br>香农定理、奈氏准则
吞吐量：单位时间内通过某个网络/信道/接口的<u>数据传输总量</u>
- 学以致用：结点间实际能达到的最高速率，由带宽、节点性能共同限制（<u>短板效应</u>） <br>家用为例：光纤 → 光猫(调制解调器) → 网线 → 家用路由器WAN → 设备
时延：从网络/链路的一端传送到另一端所需要的时间
- 总时延 = 发送时延 + 传播时延（+ 处理时延 + 排队时延） <br> = 将数据推向信道所花的时间 + 在信道传播所花的时间 = $\frac{数据长度}{发送速率/链路带宽}+\frac{信道长度}{传播速率}$
- <div style="display: flex; align-items: center; gap: 12px;"> <span>例：</span> <img src="/images/transtimeposphone.png" alt="例题" style="height: 180px;"> </div>
时延带宽积 = 传播时延s × 带宽bit/s = bit
- 已发送但未被接收的最大比特数 <div style="display: flex; align-items: center; gap: 12px;"> <span>例：</span> <img src="/images/202333.png" alt="例题" style="height: 180px;"> </div>
往返时延 RTT（Round-Trip Time）
- 从发送方<u>发送完数据</u>，到发送方收到来自接收方的<u>确认</u>总共经历的时间
信道利用率 = $\frac{信道中有数据的时间}{总时间}$

U2 计算机网络分层结构

计算机网络的3种分层/体系结构 <br>网络体系结构：计算机网络的各层及其协议的集合 <span id="两个角度"></span>
水平方向的传输过程
垂直方向的传输过程 <br>对于相邻两层实体，上一层请求下一层的服务，需要访问下一层提供的接口（服务访问点Service Access Point，SAP）
每层的数据：协议数据单元（PDU）：对等层次之间传送的包含首部/尾部的数据单元。第n层的记作 n-PDU
- 协议控制信息（PCI）：控制协议操作的信息，即首部+尾部。第n层记作 n-PCI
- 服务数据单元（SDU）：除去本层协议控制信息的数据。 <span id="协议"></span>
协议 Protocol
- 协议三要素：语法（数据/控制信息的格式）、语义（需要完成什么动作/做出什么应答）、同步/时序（动作发生的顺序） <span id="TCP/IP模型"></span>

OSI参考模型

<br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=326.8&p=11" target ="_blank">各层</a>名称：（物联网叔会使用）

应用层：实现特定网络应用（eg：两个应用传一个文件，文件就是一个<u>报文</u>Message）
表示层：数据格式转化
会话层：会话管理（检查点机制，通信失效时从检查点恢复通信）
传输层：以 <u>报文段</u>Segment为单位，实现进程(端口)到进程(端口)的通信。 <br>差错控制、流量控制、连接管理、可靠传输管理
网络层：向上层提供虚电路服务，转成 <u>分组/数据报</u>Packet。实现主机到主机的通信。 <br> 路由选择(选择传输路径)、分组转发、拥塞控制、(异构网络)网际互联、差错控制、流量控制、连接管理、可靠传输管理
数据链路层：(用校验编码技术检查每 <u>帧</u>frame的信息)差错控制、流量控制(协调结点间的速率)
物理层：定义电路接口参数、传输信号的含义等

TCP/IP模型

各层名称：（接网叔用）

应用层：包括之前的应用层+表示层+会话层。如果有些应用需要相应功能，用特定协议实现
传输层：报文 → 报文段。复用/分用、差错控制、流量控制、连接管理、可靠传输管理 <br> 向上层提供有连接可靠的服务TCP服务；提供无连接不可靠的服务UDP服务
网络层：路由选择、分组转发、拥塞控制、网际互连、~~差错控制、流量控制、连接管理、可靠传输管理~~（会传输可能出错的分组，只在传输层进行处理）
网络接口层：实现相邻节点间的数据传输，未规定死接口层（交给网络设备商发挥）。具有更强的灵活性、创造性

对比

TCP/IP模型简化网络层功能，降低网络核心部分-路由器的负载。（网络核心部分只包含到网络层） <br>

U3 物理层

基础概念

信源(数据发送方) → 信宿(数据接收方) ，通过信道进行传输（一条物理线路通常包括 <u>发送信道、接收信道</u>） <br>信号(数据的载体)：数字信号(离散)、模拟信号(连续)
码元：每一个信号就是一个码元；码元宽度：几bit代表一个信号（8进制码元携带3bit数据） <br> eg:一个信号周期最多可以表示4种信号，0V→00/1V→01/3V→11是一个四进制码元，码元宽度是2
波特率：每秒传输几个码元（信号）。码元/秒，波特 Baud <br>比特率：每秒传输几个比特。bit/s，b/s，bps

信道的极限容量

内奎斯特定理(奈氏准则)
对于一个理想低通信道（没有噪声、带宽有限） <br><u>极限波特率</u> $= 2W波特(W是信道的频率带宽Hz) =$ <u>比特率</u> $ 2Wlog_2K$（一个信号周期出现K种信号）
香农定理
对于一个有噪声、带宽有限的信道 <br><u>极限比特率</u> $= Wlog_2(1+\frac{S}{N})）= 频率带宽log_2(1+信噪比)$（要使用无单位的信噪比） <br>信噪比会很大，无单位的换成 分贝dB 表示法：$信噪比 = 10log_{10}\frac{S}{N}dB$

编码和调制

编码：二进制数据 → 数字信号；解码：二进制数据 ← 数字信号（有线网络适配器：编码-解码器） <br>调制：二进制数据 → 模拟信号；解调：二进制数据 ← 模拟信号（光猫：调制-解调器）
编码方式 <div style="display: flex; width: 100%; align-items: center;"> <div style="width: 70%; text-align: center;"> <img src="/images/bianm1.png" alt="图1" style="width: 100%;"> </div> <div style="width: 30%; text-align: center;"> <img src="/images/bianma2.png" alt="图2" style="width: 100%;"> </div> </div>

以太网默认用曼彻斯特编码
自同步能力：连续传输相同的0/1信号，能够区分比特边界/信源和信宿可以根据信号完成节奏同步，无需时钟信号。只有非归零编码无，NRZI可以增加冗余位(8+1bit)支持自同步。 <br>浪费带宽：信号是否全都用来传输数据。NRZI有1bit冗余位，会浪费一点

调制 <div style="display: flex; width: 100%; gap: 10px; align-items: center;"> <div style="flex: 3; text-align: center;"> <img src="/images/tiaoz1.png" alt="拓扑结构1" style="width: 100%; max-height: 400px;"> </div> </div>

正交幅度调制 QAM：AM/QM的结合.若有m种幅值+n种相位,可调制出mn种信号,1码元$=log_2mn bit$数据 <br>QAM-16，调制1种信号，1码元携带$log_216 = 4bit$数据

例
- 1. 某无噪声理想信道带宽为 4MHz，采用 QAM 调制，若该信道的最大数据传输速率是 48Mbps，则该信道采用的 QAM 调制方案是（）。 <br>A. QAM-16 B. QAM-32 C. QAM-64 D. QAM-128
- 1. 在一条带宽为 200 kHz 的无噪声信道上，若采用 4 个幅值的 ASK 调制，则该信道的最大数据传输速率是（）。 <br>A. 200 kbps B. 400 kbps C. 800 kbps D. 1600 kbps
- C\C

传输介质

常见的传输介质
- 导向型（有线）
  1. <u>双绞线</u> Twisted Pair：由两根导线绞合而成。有屏蔽层(STP)；无屏蔽层(UTP) <br>提升速率&抗电磁干扰能力：提升绞合度+增加屏蔽层。 <br>早期局域网、早期有线电话
  2. <u>同轴电缆</u>:内导体（传输信号）+绝缘层+外导体屏蔽层（抗电磁干扰）+绝缘保护层 <br>信号传输损耗小，长距离传输中继器少，很细很省布线空间。
  3. <u>光纤</u>:纤芯(高折射率)+包层(低折射率) 全反射 <br>多模光纤：纤芯更粗，可传输多条光线，信号传输损耗更高，适合近距离传输 <br>单模光纤：纤芯更细，只能传输一条光线，信号传输损耗更低，适合远距离传输
- 非导向型（无线）
  1. <u>无线电波</u>：穿透能力强，传输距离强，信号指向性弱 <br>如：手机信号、WIFI
  2. <u>微波通信</u>：频率带宽高，信号指向性强 <br>如：卫星通信
- 以太网对有线传输介质的命名规则：速度+Base+介质信息 <br>数字：同轴电缆的最远传输举例，F 光纤optical Fiber，T 双绞线Twisted pair

物理层设备

中继器 Pepeater <br>一个端口接收信号，将失真信号整形再生，并转发到另一端口。两个端口对应两个 <u>网段</u> <br>支持<u>半双工通信</u>：支持双向传播，但不同方向不能同时进行
集线器 Hub <br>本质上是多端口中继器。 <br>将一个端口收到的信号整形再生后，转发到所有其他端口。 <br>N个端口对应N个网段，所有网段属于同一个 <u>冲突域</u> <br>各端口不能同时发送数据，会导致冲突。两台主机同时发送数据会导致冲突，则两台主机处于同一个冲突域。
特征
- 集线器、中继器不能无限串联（5-4-3原则）
- 集线器连接的网络物理上是星形拓扑，逻辑上是总线型拓扑。各网段共享带宽 <div style="display: flex; width:100%; gap: 1px;"> <div style="flex: 1; text-align: center;"> <img src="/images/Hub1.png" alt="数据模型" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/Hub2.png" alt="数据模型" style="width: 100%;"> </div> </div> --- -->

U4 数据链路层

所处地位 <!-- - 功能

⭐组帧

定义 <br>数据链路层把网络层的数据打包成帧的过程叫做组帧
四种组帧方法

<div style="display: flex; gap: 20px;"> <div style="flex: 1;">
1. 字符计数法 <br>缺点：任何一个计数字段出错，都会导致后续所有帧无法定界
</div> <div style="flex: 1;">
1. 字节填充法 <br>在帧的起始/结束位置加上控制字符SOH/EOT(Start Of Header/Ending Of Transmission) <br>在数据部分防止歧义，SOH、EOT、ESC前加上ESC(Escape Character)
</div> </div>

<div style="display: flex; gap: 20px; margin-top: 20px;"> <div style="flex: 1;">
1. 零比特传输法 <br>特殊比特串设为 0111 1110。对于连续5个1的数据部分进行“填充0”处理
</div> <div style="flex: 1;">
1. 违规编码法 <br>曼彻斯特编码中时钟周期必跳变，加入“不变”的违规编码作为帧的分界
</div> </div> -->

<!-- ## ⭐差错控制

定义 <br>发现并解决一个帧内部的“错位”
奇/偶校验码
- 整个校验码中 1的个数 是奇/偶数个，接收方的数据链路层检查1的个数是否还是奇/偶数 → 只能检测奇数位错误。
- 求偶校验位：异或运算$\oplus$信息位 <br>进行偶校验：所有位$\oplus$ ，结果应为0
循环冗余校验码（CRC码）
- K位信息位+R个校验位作为被除数，保证除法的余数为0
<div style="display: flex; width:100%; gap: 1px; margin-top: 4px; margin-bottom: 4px;"> <div style="flex: 1; text-align: center;"> <img src="/images/CRC1.png" alt="数据模型" style="width: 100%; margin: 0; padding: 0;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/CRC2.png" alt="数据模型" style="width: 100%; margin: 0; padding: 0;"> </div> </div>
- 能够纠错的长度 <br>K个信息位，R个校验位，若 $2^R \ge K + R + 1$ CRC校验位能表示的个数 $\ge$ 信息位的位数 <div style="display: flex; width:100%; gap: 1px;margin-top: 4px;"> <div style="flex: 1; text-align: center;"> <img src="/images/CRC.png" alt="数据模型" style="width: 100%;margin: 0; padding: 0;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/CRClen1.png" alt="数据模型" style="width: 100%;margin: 0; padding: 0;"> </div> </div>
海明校验码
- 总体思路 <br>K位检验码能纠错$2^k$位，要 $\ge$ R+K 中任何一位可能出现错误 + 1种正确状态
  <div style="display: flex; width: 100%; gap: 10px; align-items: flex-start;"> <div style="width: 60%; display: flex; flex-direction: column; line-height: 0; font-size: 0;"> <img src="/images/himing1.png" alt="海明校验码1" style="width: 100%; display: block; margin: 0; padding: 0;"> <img src="/images/himing3.png" alt="海明校验码3" style="width: 100%; display: block; margin: 0; padding: 0;"> </div> <div style="width: 40%; line-height: 0; font-size: 0;"> <img src="/images/himing2.png" alt="海明校验码2" style="width: 100%; display: block; margin: 0; padding: 0;"> </div> </div>
- <a href="https://www.bilibili.com/video/BV19E411D78Q?t=97.8&p=23" target="_blank" rel="noopener noreferrer">具体</a> -->

⭐1. 可靠传输/流量控制与滑动窗口

可靠传输：解决帧之间的“帧错”：帧丢失、帧重复、帧失序 <br>流量控制：控制发送方发送帧的速率别太快，要让接收方来得及接收
3种机制
实现这两个功能需要多种机制配合：
本质是滑动窗口的3种协议
1. 停止-等待协议 S-W：发送窗口 = 1，接收窗口 = 1
2. 后退N帧协议 GBN：发送窗口＞ 1，接收窗口 = 1
3. 选择重传协议SR：发送窗口＞ 1，接收窗口＞ 1

⭐1.1停止等待协议 S-W

stop-wait

滑动窗口机制
发送窗口 = 1，接收窗口 = 1
帧编号
仅需 1 bit 给帧编号
- 数据帧的组成：首数据部分(可长可短) 尾 <br>确认帧的数据部分很短/为空 <br>首尾主要是：帧定界信息，校验码、<u>帧类型</u>(确认帧/反向传输的数据)、<u>帧序号</u>(0/1)

正常情况
发送方发送给接收方；接收方对数据进行“差错控制” 没有问题发送ACK给发送方，同时接收窗口右移；发送方接收到ACK也右移继续发送数据。
异常情况
数据帧丢失：超时重传机制； <br>确认帧丢失：超时重传，接收方收到重复帧→丢弃重复帧，并重新返回ACK； <br>重复数据帧：接收方通过帧序号判断收到重复数据帧→丢弃重复帧、返回重复帧的ACK <br>数据帧有差错：接收方检测到差错→接收方将此帧“丢弃”，且不会返回ACK。导致超时重传

⭐1.2 后退N帧协议 GBN -累积确认

go back N

滑动窗口机制
发送窗口＞ 1，接收窗口 = 1
确认机制
确认帧：“<u>累积确认</u>”，连续收到多个数据帧返回<u>最后一个帧</u>的ACK，表示收到i号帧及之前的所有帧
重传机制
超时重传：若发送方超时未收到$ACK_i$，则重传i号帧及其之后的所有帧
帧编号
$W_T + W_R \leq n$

正常情况

发送窗口连续传输数据，接收到最后一个数据 → 返回“累积确认”ACK2 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=26&t=153.4&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>
异常情况

数据帧丢失：发送最后收到的ACK，发送窗口移动<iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=26&t=289.0&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe> <br>确认帧丢失：发送方全部超时重传 → 但是接收方全都已经收到过了 → 丢弃重复帧，重传ACK<iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=26&t=580.3&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>

⭐1.3 选择重传协议 SR -差错帧返回“NCK”

Selective Repeat

滑动窗口机制
发送窗口＞ 1，接收窗口＞ 1。$W_R \leq W_T$
确认机制
确认帧：每一帧返回$ACK_i$
重传机制：<u>超时重传 + 请求重传</u> <br>超时重传：超过时间，发送方重新传Data <br>请求重传：NAK 否认帧：若接收方检测到$Data_i$有“差错” → 则丢弃该帧，返回发送方$NAK_i$，请求重传 <br>不必等到计时器超时再重传，而是收到NCK就立即重传 → 提升效率
帧编号
$W_T + W_R \leq n,W_R \leq W_T$（接收窗口小于发送窗口）

正常情况

<iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=27&t=414.6&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>
异常情况

数据帧丢失：超时重传<iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=27&t=501.1&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>

<br>数据帧检测出差错而被丢弃：返回给发送方 NAK → 发送方重传帧、重置计时器<iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=27&t=615.5&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>

<br>确认帧丢失 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=27&t=822.6&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>

1.4 对于可靠传输/流量控制机制的信道利用率分析

发送信道的信道利用率：发送完当前数据到发送下一次数据（发送数据的占比） <br>ARQ 自动重传请求协议：包括这3个协议

S-W协议
GBN协议、SR协议
分母：第一次发送 ~ 可以发送下一组（分母中数据传输时间只取1个） <br>利用率不会大于1。若N=5，信道一直有发送的数据填充，$\alpha=1$

例1<iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=28&t=1002.2&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>
例2

⭐2.介质/多路访问控制

广播通信时，多个节点争抢物理传输介质。怎么解决争抢问题，实现有序传输

2.1 信道划分

时分复用 TDM
频分复用 FDM
码分复用 CDM <!--

码分复用 <br>码片序列包含m个码片，看作m维向量、各节点的m维向量必须相互正交、<br>信号值与码片序列相同为1 相反为0、“规格化内积”叠加信号×码片序列=±1（1/0） -->

随机访问

ALOHA协议
- 纯ALOHA：准备好数据帧，就立即发送；
- 时隙ALOHA协议：准备好的数据要等到一个时隙的开始才发送；若发生冲突，分别随机等一段时间后发送 <div style="display: flex; width:100%; gap: 1px;margin-top: 4px;"> <div style="flex: 1; text-align: center;"> <img src="/images/sxaloha1.png" alt="数据模型" style="width: 100%;margin: 0; padding: 0;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/sxaloha2.png" alt="数据模型" style="width: 100%;margin: 0; padding: 0;"> </div> </div>
CSMA协议：发送数据之前，先监听信道是否空闲，只有空闲时才发送数据（网络适配器要安装“载波监听装置”）
- 1-坚持CSMA协议
- 非坚持CSMA协议 <br>优点：使各节点错开发送数据，降低冲突概率； <br>缺点：信道空闲时，可能不会被立即里哟个，导致信道利用率降低
- p-坚持CSMA协议 <br>折中方法，降低冲突概率、提高信道利用率
CSMA/CD协议：用于早期有线以太网（总线型）Collusion Detection <div style="display: flex; width:100%; gap: 1px;margin-top: 4px;"> <div style="flex: 1; text-align: center;"> <img src="/images/csmacd1.png" alt="数据模型" style="width: 100%;margin: 0; padding: 0;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/csam2.png" alt="数据模型" style="width: 100%;margin: 0; padding: 0;"> </div> </div>
- 接收方：依次检查检查若帧小于最短帧长、不是发给自己的、CRC检错帧有差错 → 丢弃帧
CSMA/CA协议：用于IEEE 802.11 无线局域网（WIFI）

轮询访问

令牌传递协议

获得令牌的节点会持有令牌帧，想要发送数据时，把令牌帧转换为数据帧 <br> 数据帧 = 令牌号 + 源地址&目的地址 + 数据部分 + 是否已接收(false/true)
按固定方向遍历每个节点 <br> 是目的地址：复制数据部分，已接收=true <br> 回到源地址：检查已接受。true：发送成功；false：发送失败，尝试重传
<div style="display: flex; width:100%; gap: 1px;margin-top: 4px;"> <div style="flex: 1; text-align: center;"> <img src="/images/76.png" alt="数据模型" style="width: 75%;margin: 0; padding: 0;"> </div> </div>

<!-- # U4 局域网

局域网基础

IEEE 802 委员会

现存技术 <br>802.3工作组：以太网技术 <br>802.11工作组：Wi-Fi技术
802委员会的层次划分现在所学的所有功能与MAC子层有关 <br>[名存实亡]为兼容各种局域网技术 → 逻辑链路控制子层（LLC层）
- 有线局域网已被 802.3垄断
- 无线局域网已被 802.11垄断

局域网的特点

覆盖较小的地理范围
较低的时延和误码率
局域网内的各节点之间以“帧”为单位进行传输
支持单播、广播、多播 <br>（一对一、一堆全部、一对多发送帧） <br>会拥有唯一的 MAC地址（48bit 物理地址）

局域网的分类

LAN
1. Ethernet（同轴电缆 → 双绞线/光纤）
2. 令牌环网技术
WLAN

硬件架构

网络适配器（网卡）：

把帧发送到局域网。将帧数据报封装成帧，由主机/网络适配器实现
从局域网接收帧
实现数据链路层+物理层功能
完成数据的串/并行转换
支持帧缓冲

单播帧/广播帧的传播

VLAN

VLAN的划分方式

基于接口 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=39&t=495.8&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>
基于MAC地址 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=39&t=681.6&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe> --- -->

以太网交换机

自学习功能：最开始交换表为空[MAC帧:端口号]
- 记录发送方的端口号
- 不知道接收方地址 → 广播/直到接收方地址 → 精准发送 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=44&t=447.7&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>

U5 网络层

IP数据报（分组） <br>首部（包括源IP地址、目的IP地址） + 报文段
网络层 实现主机间的传输（∵首部规定源地址、目的地址） <br>数据链路层 实现节点间的传输

网络层功能

异构网络互联

异构？每个网络的拓扑结构不同、物理层&数据链路层的实现不同、连接的主机不同
重要设备：路由器 Router/网关

路由 & 转发
- 路由： <br>各个路由器通过“路由协议”实现相互配合，最终生成各自的“路由表”。规划分组的“最佳转发路径”
- 转发 <br>一台路由器有自己的“转发表”（精简的路由表），将收到的IP数据报选择合适的接口转发出去
拥塞控制
- 原因：网络上出现过量分组，超负荷，引起网络性能下降
- 拥塞控制方法：
  - 开环控制（静态） ：部署网络时，提前设计好的防止拥塞控制的方法
  - 闭环控制（动态）：将拥塞信息转发给相关路由器（ICMP协议），路由器动态调整“路由表”

IPv4

IP数据报/分组的构成

首部（20B 固定部分+0~40B 可变部分） + 数据部分 <br>以下是首部固定部分的组成

第一行 <div style="display: flex; width:100%; gap: 1px;margin-top: -2px;margin-bottom: 20px"> <div style="flex: 1; text-align: center;"> <img src="/images/IPv41.png" alt="分组" style="width: 100%;margin: 0; padding: 0;">

</div>

分片组装问题

标识	标志	片偏移
16bit	3bit	13bit
检查是否来自同一个IP数据报	最低位MF=1（是否还有更多分片More Fragment）次低位DF=1（不允许被分片Don't Fragment）	被分片前的位置，×8B为单位

标识相同、源地址相同 → 分片原同属于一个IP数据报
<div style="display: flex; width:100%; gap: 1px;margin-top: -5px;"> <div style="flex: 1; text-align: center;"> <img src="/images/image-46.png" alt="分组" style="width: 100%;margin: 0; padding: 0;"> </div> </div>
生存时间TTL、协议、首部校验
32 bit的源地址、32 bit的目的地址

分片问题

IP地址的分类

最初的分类（A/B/C/D/E） <br>判断目的IP类别 → 是否跟当前源IP地址的网络号相同 → 看前面的网络号 → 加上MAC地址封装成帧 <a href="https://www.bilibili.com/video/BV19E411D78Q?t=1114.1&p=47" target="_blank">不同网络的转发过程</a>、 <a href="https://www.bilibili.com/video/BV19E411D78Q?t=1470.7&p=47" target="_blank">同一个网络的转发过程</a>
子网划分 & 子网掩码 <br>源地址、目的地址 & 源IP、目的IP → 是否属于同一个子网 → 跟子网掩码相与后是否等于目的网络号 → MAC帧转发给目的主机 <a href="https://www.bilibili.com/video/BV19E411D78Q?t=961.6&p=48" target="_blank">子网内</a>、 <a href="https://www.bilibili.com/video/BV19E411D78Q?t=1058.1& p=48" target="_blank">不同子网</a> <a href="https://www.bilibili.com/video/BV19E411D78Q?t=1248.5&p=48">有子网划分&无子网划分的网络之间</a> <div style="display: flex; width:100%; gap: 1px;margin-top: -5px;"> <div style="flex: 1; text-align: center;"> <img src="/images/image-100.png" alt="最初分类" style="width: 100%;margin: 0; padding: 0;"> </div> <img src="/images/image-101.png" alt="子网划分" style="width: 100%;margin: 0; padding: 0;"> </div> </div>

分类	选择接口	匹配后处理
最初ABCDE	通过最先几位判断分类 → 保留多少位	MAC帧直接定位目的主机
子网划分	直接和子网掩码相与，判断属于哪个子网	MAC帧直接定位目的主机

无分类编制 CIDR 网络前缀 + 主机号
- 子网划分：定长子网划分、变长子网划分 <a href="https://www.bilibili.com/video/BV19E411D78Q?t=668.2&p=49" target="_blank">解答</a>
路由聚合
- 会减小路由表的大小，但会引入无效地址
- 最长前缀匹配原则 <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=732.2&p=50" target="blank">例</a>
- <a href="https://www.bilibili.com/video/BV19E411D78Q?t=1248.0&p=50" target="_blank">⭐综合过程</a>
网络地址转换 NAT <br>NAT路由器包含传输层，普通路由器只包含网络层及以下。
- <a href="https://www.bilibili.com/video/BV19E411D78Q?t=1199.1&p=51">过程</a>

协议

ARP协议

<a href="https://www.bilibili.com/video/BV19E411D78Q?t=393.2&p=52" target="_blank">过程</a>
<a href="https://www.bilibili.com/video/BV19E411D78Q?t=950.9&p=52" target="_blank">集线器广播/交换机通过MAC表转发</a>

DHCP协议

<a href="https://www.bilibili.com/video/BV19E411D78Q?t=588.4&p=53" target="_blank">发现报文 Discover的组成</a>、<a href="https://www.bilibili.com/video/BV19E411D78Q?t=857.2&p=53" target="_blank">非DHCP服务器过程（端口号才发现错误/丢弃）</a>
<a href="https://www.bilibili.com/video/BV19E411D78Q?t=1034.4&p=53" target="_blank">提供报文 Offer</a>
<a href="https://www.bilibili.com/video/BV19E411D78Q?t=1318.6&p=53" target="_blank">请求报文 Request</a>
<a href="https://www.bilibili.com/video/BV19E411D78Q?t=1598.1&p=53" target="_blank">确认报文 ACK</a>

ICMP协议（网际控制报文协议）

ICMP报文的常见分类
1. 差错控制报告：直接传输数据报，有问题就反馈给发送方
2. 询问报文：传送之前，先询问接收方，确保网络通畅
怎么区分分类？ ICMP最先1B
1. 差错控制报告
  1. 终点不可达 <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=509.2&p=54" target="_blank">路由器返回</a>：目的IP地址不可到达，路由器返回ICMP报文告诉发送方终点不可达；<a href="https://www.bilibili.com/video/BV19E411D78Q?t=676.7&p=54" target="_blank">目的主机的端口不存在</a>：目的主机告诉发送方进程不存在
  2. 时间超过 <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=749.7&p=54" target="_blank">路由器返回</a>：IP数据报的TTL=0，被丢掉；<a href="https://www.bilibili.com/video/BV19E411D78Q?t=857.7&p=54" target="_blank">目的主机返回</a>：IP数据报被分片，但是规定时间内分片没有到齐 → 全部丢弃
  3. 参数问题 <br>检测出IP首部错误/参数不合法，路由器把IP数据报丢弃
  4. 改变路由（重定向） <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=1044.8&p=54" target="_blank">路由器告诉发送方</a>：对于某目的网络，发送到另一个路由器更近，下一次发送到该目的网络时改变路由
2. 询问报文
  1. Echo Request、Echo Reply（回送请求/回送回答ping） <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=1322.0&p=54" target="_blank">过程</a>：源地址发送ICMP请求，目的地址返回ICMP回答告诉当前道路是否通畅
  2. 时间戳请求、时间戳回答 <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=1615.8&p=54" target="_blank">过程</a>：源地址的时间xx，目的地址收到时间戳的时间yy，发送ICMP报文的时间是zz
不必反馈ICMP差错报告报文的<a href="https://www.bilibili.com/video/BV19E411D78Q?t=1704.7&p=54" target="_blank">情况</a>

IPv6

对比

选项	IPv4	IPv6
位数	32bit	128bit
转换	8位，二进制 → 十进制	4×4位，十六进制
分片	源主机/路由器	只有源主机
地址组成（same）	网络号+主机号	前缀+接口标识符
数据报结构	略	略

IPv6下的数据报结构
IPv4到IPv6的迁移
- 双栈协议：设备同时支持IPv4、IPv6
- 隧道技术：IPv6封装进IPv4的数据部分。IPv4的数据报 = 首部 + 数据（IPv6数据报）

路由协议

路由算法
分层次的路由协议

RIP

<a href="https://www.bilibili.com/video/BV19E411D78Q?t=649.0&p=59" target="_blank">定时更新过程/触发响应</a>
路由表 = 目的网络 + 距离 + 下一跳路由器
路由表更新过程
1. <a href="https://www.bilibili.com/video/BV19E411D78Q?t=188.0&p=60" target="_blank">初始路由表</a>
2. <a href="https://www.bilibili.com/video/BV19E411D78Q?t=416.6&p=60" target="_blank">每次给邻居发送RIP Response报文</a>：目的网络号不变，距离+1，下一路由器 → 转发来的路由器
3. <a href="https://www.bilibili.com/video/BV19E411D78Q?t=978.6&p=60" target="_blank">每隔30s，更新</a> <div style="flex: 1; text-align: center;margin-top:0px"> <img src="/images/image-104.png" alt="最初分类" style="width: 100%;margin: 0; padding: 0;"> </div> </div>
4. 慢收敛现象 <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=183.0&p=62" target="_blank">超过180s</a>没收到邻居路由器 → 设为16，认为不可达 <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=293.0&p=62" target="_blank">更新</a>：但还会通过其他Router路由表形成<a href="https://www.bilibili.com/video/BV19E411D78Q?t=399.6&p=62" target="_blank">环路</a>，直到 TTL=0 才丢弃
  <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=537.0&p=62" target="_blank">更新</a> → 左脚踩右脚（R3通过R4可以到Net2，R4通过R3可以到Net2） <div style="flex: 1; text-align: center;margin-top:0px"> <img src="/images/image-105.png" alt="最初分类" style="width: 100%;margin: 0; padding: 0;"> </div> </div> <a href="https://www.bilibili.com/video/BV19E411D78Q?t=756.3&p=62" target="_blank">发现错误</a>：每次迭代距离+1，直到加到16才知道不可达
  - <a href="https://www.bilibili.com/video/BV19E411D78Q?t=71.3&p=63" target="_blank">重新接入路由器</a> <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=244.0&p=63" target="_blank">下一个30s，更新</a> ：每一对Router的周期可以不同
RIP的优缺点

OSPF

<u>网络层</u>，边带权

建立单链表 <div style="flex: 1; text-align: center;margin-top:0px"> <img src="/images/image-1051.png" alt="最初分类" style="width: 100%;margin: 0; padding: 0;"> </div> </div>
基础
- 洪泛法：转发到除了入口之外的出口（不回流） <br>检测到邻居的变化 → 洪泛最新的链表信息
- <a href="https://www.bilibili.com/video/BV1uT4y1p7Jy?t=58.5" target="_blank">Dijstra算法</a>：每次看总共的最短路径
怎么生成路由表？ <br>构造本地链路状态数据库 LSDB（临界表） → Dijkstra算法计算最短路径 → 根据结果，构造路由表 <br>若网络拓扑变化 → 引起洪泛 → 基于新的网络重新计算路由表 <div style="flex: 1; text-align: center;margin-top:0px"> <img src="/images/image-1052.png" alt="区域划分" style="width: 100%;margin: 0; padding: 0;"> </div> </div>
<a href="https://www.bilibili.com/video/BV19E411D78Q?t=681.2&p=65" target="_blank">“区域”划分</a>：系统过大，洪泛压力过大，Dijsktra运算开销也过大 <div style="flex: 1; text-align: center;margin-top:0px"> <img src="/images/image-106.png" alt="区域划分" style="width: 100%;margin: 0; padding: 0;"> </div> </div>
（选学）具体过程 <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=401.9&p=66" target="_blank">HELLO 问候分组<a>：每10s发送，超过40s说明另据不存在 <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=726.8&p=66" target="_blank">DD 数据库描述分组</a>：告诉对方自己有的信息 <br>LSR 链路状态请求分组：想要对方的哪些信息 <br>LSU ；链路状态更新分组：响应请求，给对方发送需要的信息 <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=1012.7&p=66" target="_blank">LSAck 链路状态确认分组</a>：告诉对方已经收到需要的数据
- <a href="https://www.bilibili.com/video/BV19E411D78Q?t=1133.0&p=66" target="_blank">LSU分组可能引发的洪泛</a>

BGP协议

<u>应用层</u>，基于<u>TCP协议</u>

<a href="https://www.bilibili.com/video/BV19E411D78Q?t=114.1&p=68" target="_blank">eBGP</a>：发送BGP报文[目的网络，所属AS，下一跳路由器] <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=346.1&p=68" target="_blank">iBGP</a>：BGP报文不修改 → 根据内部网关协议IGP，找到到达下一跳Router最短路径的路由器。
BGP路由选择
1. 本地偏好值最高（优先级）
2. AS跳数最少
3. 热土豆路由
- 网络内部协议不同的处理： <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=461.6&p=69" target="_blank">RIP协议</a> <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=544.6&p=69" target="_blank">OSPF协议</a>
BGP的4种报文
- <a href="https://www.bilibili.com/video/BV19E411D78Q?t=39.1&p=70" target="_blank">OPEN报文</a>

移动IP

<a href="https://www.bilibili.com/video/BV19E411D78Q?t=502.0&p=72" target="_blank">A在归属网络</a>：和前面一样，直接传数据报
A不在归属网络

接收IP数据报 <br><a href="https://www.bilibili.com/video/BV19E411D78Q?t=813.1&p=72" target="_blank">两次登记</a>、<a href="https://www.bilibili.com/video/BV19E411D78Q?t=689.5&p=72" target="_blank">隧道</a>、<a href="https://www.bilibili.com/video/BV19E411D78Q?t=812.9&p=72" target="_blank">全过程</a>
<a href="https://www.bilibili.com/video/BV19E411D78Q?t=936.5&p=72" target="_blank">发送IP数据报</a>

U6 传输层

概述

UDP vs TCP

对比	UDP	TCP
首部	很小，8B	更大，20~60B
报文传输	传输完整报文，不支持报文拆分/重装	支持报文自动拆分/重装
连接性 & 可靠性	无连接、不可靠（交给应用层处理）	有连接、可靠
拥塞控制	不支持拥塞控制	支持拥塞控制
传输方式	一对一/一对多	只支持一对一传输

UDP一对多：封装成IP数据报时，IP首部为广播首部 → 会转发给不同网络中相同端口号的进程

UDP

数据报格式

TCP

<a href="https://www.bilibili.com/video/BV19E411D78Q?t=664.6&p=77" target="_blank">面向字节流</a>：UDP协议时面向报文的（把完整应用层报文 → 封装到UDP数据报→ 封装到IP数据报）
TCP报文段格式
<a href="https://www.bilibili.com/video/BV19E411D78Q?t=622.1&p=79" target="_blank">建立连接（三次握手）</a>
释放连接（四次挥手） <div style="flex: 1; text-align: center;margin-top:0px"> <img src="/images/image-107.png" alt="区域划分" style="width: 100%;margin: 0; padding: 0;"> </div> </div>
- 从客户发出挥手1，到客户进程进入CLOSE状态，至少需要多久?一-1RTT+2MSL
- 从客户发出握手1，到服务器进程进程进入CLOSE状态，至少需要多久?一-1.5RTT
TCP传输的过程

三次握手 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=81&t=795.1&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen> </iframe>
TCP传输的过程
1. 发送3bit → Server检查有无比特错误 → 没有就接收 → 发送TCP报文：ack=603（接下来期待收到的序号），rcvwnd=5 <br>Client 就把发送成功的3bit移出buffer缓冲区 → 读入后面的数据 → 根据发来的rcvwnd动态调整发送buffer为5 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=82&t=8.9&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>
2. 累积确认：连续收到多个报文段，只返回1个ACK <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=82&t=320.0&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>
3. 接收缓冲区满了 → 清空接收缓冲区 → 发送TCP数据报：ACK=609，rwnd=8 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=82&t=530.8&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>
4. 捎带确认：确认+数据 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=82&t=695.3&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>
5. 超时重传 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=82&t=1518.7&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>

TCP拥塞控制
- 例 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=85&t=2173.6&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>

U7 应用层

网络应用模型：C/S模型、P2P模型

DNS域名系统

基础
- 协议工作原理
- 域名划分 -顶级域名
DNS四类域名服务器
DNS查询方式
1. <a href="https://www.bilibili.com/video/BV19E411D78Q?t=1376.8&p=90" target="_balnk">递归查询</a>：你问我问题，我想方设法帮你找到最终答案。
2. <a href="https://www.bilibili.com/video/BV19E411D78Q?t=1628.8&p=90 target="_balnk">递归查询</a>：你问我问题，我如果不知道最终答案，就告诉你你“下一个该问谁”（踢皮球）

FTP

登录 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=91&t=647.3&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>
数据传输
- 主动模式：客户端告诉Server，想要Server主动传输数据 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=91&t=947.6&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>
- 被动模式：Client传给Server <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=91&t=1298.8&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>
总结 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=91&t=2088.3&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>

电子邮件

过程 <iframe width="100%" height="468" src="https://player.bilibili.com/player.html?bvid=BV19E411D78Q&p=92&t=1469.4&danmaku=0&autoplay=0" title="Bilibili video player" frameborder="0" allowfullscreen></iframe>

万维网 www

访问网络的背后
响应报文的分类
- 非连续连接：可以连续建立3个/图片.png的TCP连接 <div style="flex: 1; text-align: center;margin-top:0px"> <img src="/images/image-112.png" alt="区域划分" style="width: 100%;margin: 0; padding: 0;"> </div> </div>
- 连续连接：流水线方式/非流水线方式 <div style="flex: 1; text-align: center;margin-top:0px"> <img src="/images/http1.png" alt="区域划分" style="width: 100%;margin: 0; padding: 0;"> </div> <img src="/images/http2.png" alt="区域划分" style="width: 100%;margin: 0; padding: 0;"> </div> </div>

数据管理基础

Wed, 04 Mar 2026 00:00:00 GMT

成绩组成 4:6

C1 绪论
C2 关系数据库
C3 SQL
⭐数据库安全性
C4 数据库的安全性
- 数据安全性概述
- 数据库安全性控制
C6 关系数据理论
🌟C6例题
C7 数据库设计
⭐C8 数据库编程

C1 绪论

数据库的基本概念

⭐数据库、DBMS、数据库系统

概念	含义
数据库 DB	长期存储、有组织、可共享的大量数据的集合
数据库管理系统 DBMS	管理数据库的软件，位于应用程序和数据库之间（如 MySQL、Oracle、SQLSever）
数据库系统 DBS	数据库、DBMS、应用程序、数据库管理员、硬件等构成的整体
数据库应用系统	面向具体业务开发的应用程序及其数据库环境 = 数据库 + DBMS + 应用程序 + 数据库管理员 +硬件环境

⭐文件系统 vs 数据库

对比角度	文件方式	数据库方式
分散/统一	数据分散在不同文件	数据统一组织和管理
共享	共享困难	支持多用户共享
冗余	冗余较多	可以控制冗余
耦合/独立	程序与数据耦合较强	具有数据独立性
性质	一致性、安全性难保证	DBMS 统一保证完整性、安全和并发
适用场景	适合简单、独立的小规模数据	适合长期、共享、结构化业务数据

数据管理技术的**产生和发展**：人工管理阶段 → 文件系统阶段 → 数据库系统阶段
数据库系统的<u>特点</u>
1. 数据结构化
2. 数据共享性高，冗余度低、易扩充
3. 数据独立性高
4. 数据由数据库管理系统统一管理和控制

数据模型的组成要素 & 常用数据模型

⭐数据模型
- 两大类、共三种数据模型：概念数据模型、逻辑数据模型、物理数据模型
- 数据模型的组成要素：<u>数据结构、数据操作、数据约束</u> （二维关系表、原则/插入等、实体完整性）
- ⭐关系模型基本概念
  
  <div style="display: flex; width: 100%; gap: 0px;"> <div style="flex: 1; text-align: center;"> <img src="/images/relationModel1.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/relationModel2.png" alt="象集2" style="width: 100%;"> </div> </div>

数据库的三级模式

从数据库应用开发人员角度看，数据库通常采用 <u>三级模式结构</u>

层次	描述内容
外模式	某一类用户看到的局部数据，也叫用户视图
模式/概念模式	整个数据库的全局逻辑结构
内模式	数据的物理存储结构、文件组织和存取路径

两种数据独立性

逻辑数据独立性：<u>概念模式</u>改变时，外模式和应用程序尽量不用改变。 <br>例如增加一个属性，只需调整外模式与概念模式之间的映像，原有应用仍可使用原来的视图。
物理数据独立性：<u>内模式</u>改变时，概念模式和应用程序不用改变。 <br>例如把顺序文件改成 B+ 树索引，应用程序仍然执行相同的 SQL。

C2 关系数据库

关系数据结构

关系
1. 关系模型只有单一的数据结构：关系；<br>关系模型的逻辑结构：二维表
2. 关系：在域 $D_1, D_2, \dots, D_n$ 上的关系 $R$ 也是一个 $n$ 元有序组的集合，并且是其笛卡尔积的一个子集：$R \subseteq D_1 \times D_2 \times \dots \times D_n$
  - 属性：二维表中的 每一列，被称为是该关系中的一个‘属性’
  - 元组 tuple：二维表中的 每一行，$(d_1,d_2,…,d_n)$，$t[A_i]$表示元组t在属性 $A_i$上的取值；$t[i]$ 表示元组t在第i列上的取值。如：(李敏君，软件工程专业，19)
  - 分量：元组中的每一个值$d_i$叫做一个分量.如：李敏君、软件工程专业、19 <br>元组连接：$t_r t_s$上弧线，表示把两个表连接起来。
  - 基数：一个域允许的不同取值个数
  - 关系的表示：在域 $D_1,D_2,…,D_n$ 上的关系R可以被表示为 $R(A_1,A_2,…,A_n)$ <br>其中 $A_i$ 是属性名 eg:“专业”
3. 域 <br>相同数据类型的值的集合，域内元素互不相同。如：整数集合、{男，女}、char (25) 字符串集合
4. （候选）码 Key <br>若关系中的某一 属性组 的值能唯一地标识一个元组，而其所有的真子集都不能，则称该 属性组 为关系的 ‘候选码’ ，简称 ‘码’
5. 主码：
6. 全码 All-key：关系中的所有属性构成的属性组是这个关系的候选码，称为 ‘全码’（All-key）
7. 主属性 与 非主属性/非码属性
  - <u>候选码</u>中的诸属性称为该关系的 ‘主属性’（Prime attribute）
  - 不包含在任何侯选码中的属性称为该关系的 ‘非主属性’/‘非码属性’

⭐关系的完整性约束

实体完整性 <br><u>主码属性不能为空 NULL</u>
参照完整性
1. <u>外码值要么为空，要么等于被参照关系的主码值</u>
2. 外码： <br>参照关系：R（拿着外码的表，比如学生表） <br>被参照关系：S（被引用主键的表，比如专业表） <div style="display: flex; width: 100%; gap: 10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/outerMa1.png" alt="外码1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/outerMa2.png" alt="外码2" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/outerMa3.png" alt="外码2" style="width: 100%;"> </div> </div>
用户定义的完整性

⭐关系代数

关系运算 选择：$\sigma_{Sdept='IS'}(Student)$、投影：$\pi_{Sdept}(Student)$
例
- 所有：除运算÷；只：
最大/最高 在当前的所有顾客中, 查询折扣(discnt)最高的顾客的编号？ <br>令 $S := C$, “折扣不是最高的顾客的id”
$R_2 := \pi_{C.cid}(\sigma_{C.discnt < S.discnt}(C \times S))$ <br>答案是 $\pi_{cid}(C) - \pi_{C.cid}(\sigma_{C.discnt < S.discnt}(C \times S))$ <div style="display: flex; width:100%; gap: 10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/tj.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/max1.png" alt="象集1" style="width: 100%;"> </div> </div>

<div style="display: flex; width:100%; gap: 10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/max2.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/max3.png" alt="象集1" style="width: 100%;"> </div> </div>
象集 <br>该属性值对应的其他属性值集合，相当于除法 <div style="display: flex; width: 100%; gap: 10px; margin: 5px 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/xj1.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/xj2.png" alt="象集2" style="width: 100%;"> </div> </div>

<!-- ### 关系代数的基本运算

并$\cup$、差-、笛卡尔积$\times$ <div style="display: flex; width: 100%; margin: -20px;"> <div style="flex: 1; text-align: center;"> <img src="/images/exam1.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/exam2.png" alt="象集1" style="width: 100%;"> </div> </div>
选择 $\sigma_{Sub}=_{限定条件}(Obj)$ / Student where SC = 'ISE' <br>题干： <div style="display: flex; width: 100%; margin: -10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/course.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/student.png" alt="象集1" style="width: 100%;"> </div>
<div style="flex: 1; text-align: center;"> <img src="/images/sc.png" alt="象集1" style="width: 100%;"> </div> </div> <div style="display: flex; width: 100%; gap: 10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/select1.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/select2.png" alt="象集1" style="width: 100%;"> </div> </div>
投影 $\pi_{property1,property2}(Domain)$ / $Domain[property]$ <div style="display: flex; width: 100%; gap: 10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/ty1.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/ty2.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/xt.png" alt="象集1" style="width: 100%;"> </div> </div> -->

<!-- ---

关系代数的补充运算

例 --> <!--

$\theta-$连接 $R \underset{C < E}{\bowtie} S$ <br>等值连接 $R \underset{C.B = E.B}{\bowtie} S$ <br>自然连接 $R \bowtie S$：把相同属性全都尽可能拼接到一起 <br>(左/右)外连接：加上悬浮元组 <div style="display: flex; width:100%; gap: 10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/connect1.png" alt="θ连接" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/connect2.png" alt="等值连接" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/connect3.png" alt="自然连接" style="width: 100%;"> </div> </div> <div style="display: flex; width:100%; gap: 10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/connect4.png" alt="外连接" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/connect4.png" alt="左右外连接" style="width: 100%;"> </div> </div>
- 例 <div style="display: flex; width:100%; gap: 10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/example1.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/example2.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/example3.png" alt="象集1" style="width: 100%;"> </div> </div> -->
除运算 R ÷ S <span id="除运算"></span> <br>找出R、S中相同的属性列(B、C)，R 剩下的属性列(A) 作为结果。 <br>$a_i$的所有($b_j$,$c_j$)，$a_i$包含S中的全部b、c。
<div style="display: flex; width:100%; margin: 2px;"> <div style="flex: 1; text-align: center;"> <img src="/images/div1.png" alt="外连接" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/div2.png" alt="左右外连接" style="width: 100%;"> </div> </div>
- 例 <div style="display: flex; width:100%; margin: 2px;"> <div style="flex: 1; text-align: center;"> <img src="/images/divExample.png" alt="象集1" style="width: 100%;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/divExample2.png" alt="象集1" style="width: 100%;"> </div> </div>

C3 SQL

SQL基本执行结构
```
SELECT ...
 FROM ...
 WHERE ...
 GROUP BY ...
 HAVING ...
 ORDER BY ...;
```
逻辑顺序：FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY

基本表 TABLE

CREATE TABLE Student
    (Sno CHAR(9) PRIMARY KEY,  /* 列级完整性约束条件, Sno是**主码**/
    Sname CHAR(20) UNIQUE,  /* **约束**，Sname的取值具有唯一性*/
    Ssex CHAR(2) NOT NULL CHECK (Ssex IN ('男', '女')),/*  非空且只能是男/女 */
    Sage SMALLINT,
    Sdept CHAR(20)
    );

CREATE TABLE enrollment(
    sno char(9) NOT NULL,
    clsno char(8) NOT NULL,
    grade INT CHECK (grade BETWEEN 0 AND 100),
    PRIMARY KEY(sno,clsno), -- 课程班代码和学号联合构成PRIMARY KEY
    );

CREATE TABLE courseclass(
clsno char(8) PRIMARY KEY,
cno char(8) NOT NULL,
tno char(9) ,
-- 先定义再外键 + 违约规则
FOREIGN KEY (cno) REFERENCES coures(cno) ON UPDATE CASCADE ON DELETE RESTRICT,
FOREIGN KEY (tno) REFERENCES teachers(tno) ON UPDATE CASCADE ON DELETE SET NULL
-- 父表更新cno，子表cno自动同步更新；父表删除cno，子表还有该课程就禁止删除
-- 父表更新tno，子表tno自动同步更新；父表删除tno，子表对应的tno自动设为NULL
);

违约规则 <br>什么是违约？父表更新主键/删除父表记录会破坏参照关系，触发违约

关键字	中文	含义
CASCADE	级联	父表改 / 删 → 子表自动跟着改 / 删
SET NULL	置空	父表删 → 子表外键自动设为 NULL
RESTRICT	限制 / 拒绝	数据库直接禁止父表的改/删操作

修改基本表（ALTER TABLE）

ADD新增列/完整性约束

ALTER TABLE Student 
ADD COLUMN S_email VARCHAR(50) NOT NULL UNIQUE;  -- 增加邮箱列，要求非空且唯一
ADD CONSTRAINT chk_sex CHECK (Ssex IN ('男', '女'));  -- 为 Ssex 增加 CHECK 约束（性别只能是男 / 女）

DROP 删除列

ALTER TABLE Student 
DROP COLUMN S_email CASCADE; --删除“邮箱”列，默认RESTRICT
DROP CONSTRAINT chk_sex; -- 删除性别CHECK约束

修改列的定义

ALTER TABLE Student 
ALTER COLUMN Sage INT;  -- 修改数据类型：年龄从SMALLINT改为INT
ALTER COLUMN Sname CHAR(30); -- 修改列长度（姓名从 CHAR (20) 改为 CHAR (30)）
ALTER TABLE Course ADD UNIQUE(Cname); -- 增加课程名称必须取唯一值的约束条件

删除基本表
```
DROP TABLE <表名>［RESTRICT| CASCADE］;
```
- RESTRICT：只有在该表没有被其他数据库对象依赖时，才能删除。
- CASCADE：删除该表的同时，还会删除依赖于该表的相关对象或依赖关系

视图 VIEW

视图的作用？ <br>简化复杂查询； <br>为不同用户提供不同数据视图； <br>隐藏敏感属性，提高安全性； <br>阻止不符合条件的数据加入/修改成不符合条件的数据。

定义视图 AS

CREATE VIEW S_G(Sno,Gavg) -- 可选：列名
AS
 SELECT Sno,AVG(Grade)
 FROM SC
 GROUP BY Sno;

查询视图
更新视图
删除视图
```
DROP VIEW S_G [RESTRICT | CASCADE]
```

字符串匹配

⭐字符匹配 LIKE/=

SELECT* FROM Student WHERE Sno LIKE '24%'  -- 通配符，查询学号以24开头的学生的详细信息
SELECT* FROM Student WHERE Sno = '24%' -- 查询学号就是'24%'学生的详细信息

⭐字符串中的通配符

SELECT Sname, Sno, Ssex
FROM Student
WHERE Sname LIKE '刘%';  -- 查询所有姓刘学生的姓名、学号和性别

SELECT Sname
FROM Student
WHERE Sname LIKE '欧阳_'; -- 查询姓"欧阳"且全名为三个汉字的学生的姓名

SELECT Sname, Sno
FROM Student
WHERE Sname LIKE '_阳%'; -- 查询名字中第2个字为"阳"字的学生的姓名和学号

SELECT Sname, Sno, Ssex
FROM Student
WHERE Sname NOT LIKE '刘%'; -- 查询所有不姓刘的学生姓名、学号和性别

多表连接 JOIN

SELECT DISTINCT s.sid, s.sname
FROM Student s
JOIN Enroll e ON s.sid = e.sid
JOIN Course c ON e.cid = c.cid
WHERE c.cname = '数据管理基础'
AND c.dept = '智软学院';

使用 DISTINCT 是为了消除同一学生由于多条匹配记录产生的重复

DISTINCT 的位置：SELECT 子句；聚集函数内部。

SELECT DISTINCT dept
FROM Student;

COUNT(DISTINCT sid)
AVG(DISTINCT score)
SUM(DISTINCT amount)

分组与 HAVING先Group 分组后 HAVING <div style="display: flex; width:50%; margin: -2px;"> <div style="flex: 1; text-align: center;"> <img src="/images/GroupHaving.png" alt="分组" style="width: 100%;"> </div> </div>

EXISTS 子查询有结果，返回TRUE；子查询无结果，返回FALSE

SELECT Sname
FROM Student S
WHERE EXISTS (
    SELECT *
    FROM SC
    WHERE SC.Sno = S.Sno
    AND Cno = '1' -- 从 Student 表里，找出那些‘存在’选修 1 号课程记录的学生
); -- 查询选修了 1 号课程的学生

SELECT Sname
FROM Student S
WHERE NOT EXISTS (
    SELECT *
    FROM SC
    WHERE SC.Sno = S.Sno
    AND Cno = '1'
); -- 查询没选1号课程的学生

查询选修全部课程的学生

SELECT Sname
FROM Student
WHERE NOT EXISTS ( -- ③ 除去没有选择课程的学生
    SELECT *
    FROM Course -- ② 有NOT EXISTS学生选择的课程中的：学生没有选择的课程
    WHERE NOT EXISTS (
        SELECT *
        FROM SC
        WHERE SC.Sno = Student.Sno  
        AND SC.Cno = Course.Cno -- ① 对SC中的每门课程，去Student、Course中寻找有无记录
    ) -- 学生选择的课程
);
✅ 理解：不存在一门课是这个学生没选的

例 <div style="display: flex; width: 100%; margin-left: 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/exists1.png" alt="exists" style="width: 80%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/exists2.png" alt="exists" style="width: 80%; max-width: 600px; height: auto;"> </div> </div> <div style="display: flex; width: 100%; margin-left: 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/exists3.png" alt="exists" style="width: 80%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/exists4.png" alt="exists" style="width: 80%; max-width: 600px; height: auto;"> </div> </div>

⭐例题

所有课程都及格：HAVING MIN(grade)>=60 <div style="display: flex; width:50%; gap: 1px;margin-top: -2px;margin-bottom: 20px"> <div style="flex: 1; text-align: center;"> <img src="/images/qq2.png" alt="分组" style="width: 100%;"> </div> </div>
修完本院所有必修课 <div style="display: flex; width:50%; gap: 1px;margin-top: -2px;margin-bottom: 20px"> <div style="flex: 1; text-align: center;"> <img src="/images/qq3.png" alt="分组" style="width: 100%;"> </div> </div>
每组最大值 <div style="display: flex; width:50%; gap: 1px;margin-top: -2px;margin-bottom: 20px"> <div style="flex: 1; text-align: center;"> <img src="/images/qq1.png" alt="分组" style="width: 100%;"> </div> </div>
只讲授本院课程
SQL（Structured Query Language）结构化查询语言，是关系数据库的标准语言
SQL与关系数据库的三级模式
核心功能：

数据定义：CREATE，DROP，ALTER - 数据查询：SELECT - 数据操作：INSERT，UPDATE，DELETE - 数据控制：GRANT，REVOKE

⭐数据库安全性

授权：授予GRANT 与回收REVOKE

授予 GRANT

GRANT SELECT,INSERT
ON Student
TO U1 -- 把对Student的查询、插入权限授予用户U1

GRANT ALL PRIVILIGES
ON TABLE Student,Course
TO U2,U3 -- 把对Student表和Course表的全部权限授予用户U2和U3

转授 WITH GRANT OPTION

GRANT SELECT
ON Student
TO user2
WITH GRANT OPTION;

回收 REVOKE

REVOKE UPDATE(Sno) ON STUDENT FROM U4 -- 把用户U4修改学生学号的权限收回
REVOKE SELECT ON SC FROM PUBLIC -- 收回所有用户对表SC的查询权限

SQL数据定义

操作对象	创建	删除	修改
模式 SCHEMA	CREATE SCHEMA	DROP SCHEMA	-
表 TABLE	CREATE TABLE	DROP TABLE	ALTER TABLE
视图 VIEW	CREATE VIEW	DROP VIEW	-
索引 INDEX	CREATE INDEX	DROP INDEX	ALTER INDEX

定义/删除模式（CREATE/DROP SCHEMA）

例：为用户WANG 定义一个学生-课程模式S-T

CREATE SCHEMA “S_T” AUTHORIZATION WANG;
CREATE SCHEMA AUTHORIZATION WANG;  -- 该语句没有指定<模式名>，<模式名>隐含为<用户名> WANG

模式中定义其他 <br>为用户ZHANG创建了一个模式TEST，并且在其中定义一个表TAB1

CREATE SCHEMA TEST AUTHORIZATION ZHANG
    CREATE TABLE TAB1 ( 
        COL1 SMALLINT,
        COL2 INT,
        COL3 CHAR(20),
        COL4 NUMERIC(10,3),
        COL5 DECIMAL(5,2) );

删除模式
```
DROP SCHEMA <模式名> <CASCADE|RESTRICT> 
```
- CASCADE（级联）：删除模式的同时，把里面所有表/数据/对象全部删除；
- RESTRICT（限制）：模式里有任何东西(表/视图/数据)，就禁止删除 <br>eg:DROP SCHEMA ZHANG CASCADE; 删除模式ZHANG，同时该模式中定义的表TAB1也被删除

<!-- ### 基本表 TABELE

定义基本表 -三大核心完整性约束：

PRIMARY KEY 主键，唯一标识一行数据，不能重复、不能为空
UNIQUE 唯一，不能重复，但能为空

CREATE TABLE Student
    (Sno CHAR(9) PRIMARY KEY,  /* 列级完整性约束条件, Sno是**主码**/
    Sname CHAR(20) UNIQUE,  /* **约束**，Sname的取值具有唯一性*/
    Ssex CHAR(2) NOT NULL CHECK (Ssex IN ('男', '女')),/*  非空且只能是男/女 */
    Sage SMALLINT,
    Sdept CHAR(20)
    );

CREATE TABLE enrollment(
    sno char(9) NOT NULL,
    clsno char(8) NOT NULL,
    grade INT CHECK (grade BETWEEN 0 AND 100),
    PRIMARY KEY(sno,clsno), -- 课程班代码和学号联合构成PRIMARY KEY
    );

外键

两张表关联起来，SC表里的Cno必须来自Student里的Cno

CREATE TABLE courseclass(
clsno char(8) PRIMARY KEY,
cno char(8) NOT NULL,
tno char(9) ,
-- 先定义再外键 + 违约规则
FOREIGN KEY (cno) REFERENCES coures(cno) ON UPDATE CASCADE ON DELETE RESTRICT,
FOREIGN KEY (tno) REFERENCES teachers(tno) ON UPDATE CASCADE ON DELETE SET NULL
-- 父表更新cno，子表cno自动同步更新；父表删除cno，子表还有该课程就禁止删除
-- 父表更新tno，子表tno自动同步更新；父表删除tno，子表对应的tno自动设为NULL
);

违约规则 <br>什么是违约？父表更新主键/删除父表记录会破坏参照关系，触发违约

关键字	中文	含义
CASCADE	级联	父表改 / 删 → 子表自动跟着改 / 删
SET NULL	置空	父表删 → 子表外键自动设为 NULL
RESTRICT	限制 / 拒绝	数据库直接禁止父表的改/删操作

修改基本表（ALTER TABLE）

ADD新增列/完整性约束

ALTER TABLE Student 
ADD COLUMN S_email VARCHAR(50) NOT NULL UNIQUE;  -- 增加邮箱列，要求非空且唯一
ADD CONSTRAINT chk_sex CHECK (Ssex IN ('男', '女'));  -- 为 Ssex 增加 CHECK 约束（性别只能是男 / 女）

DROP 删除列

ALTER TABLE Student 
DROP COLUMN S_email CASCADE; --删除“邮箱”列，默认RESTRICT
DROP CONSTRAINT chk_sex; -- 删除性别CHECK约束

修改列的定义

ALTER TABLE Student 
ALTER COLUMN Sage INT;  -- 修改数据类型：年龄从SMALLINT改为INT
ALTER COLUMN Sname CHAR(30); -- 修改列长度（姓名从 CHAR (20) 改为 CHAR (30)）
ALTER TABLE Course ADD UNIQUE(Cname); -- 增加课程名称必须取唯一值的约束条件

删除基本表

DROP TABLE <表名>［RESTRICT| CASCADE］;
``` -->

索引 INDEX

建立索引 CREATE INDEX

CREATE UNIQUE INDEX Coucno ON Course(Cno); -- Course表按课程号
CREATE UNIQUE INDEX SCno ON SC(Sno ASC,Cno DESC); -- 升序建唯一索引，SC表按学号升序和课程号降序建唯一索引

修改索引 ALTER INDEX

ALTER INDEX SCno RENAME TO SCSno; -- 将SC表的SCno索引名改为SCSno

删除索引 DROP INDEX

 DROP INDEX Stusname; -- 删除Student表的Stusname索引

关系代数 vs SQL语言

$$ \pi_{A_1, A_2, ..., A_m} \left( \sigma_F ( R ) \right) $$其中 $A_i \in head(R)$ for $i = 1, 2, \dots, m$ <br>SQL表示
```
SELECT A_1, A_2, ..., A_m
FROM   R
WHERE  F
```

笛卡尔积 $R\times S$ <br>SQL表示

SELECT R.A_1,...,R.A_n,s.b_1,...,s.b_m
FROM   R,S

$\theta-$连接 $R\underset{F}\bowtie S$ <br>SQL表示

    SELECT R.A_1,...,R.A_n,s.b_1,...,s.b_m
    FROM R,S
    WHERE F

自然连接 $R\bowtie S$ <br>SQL表示

    SELECT R.A_1,...,R.A_n,s.b_1,...,s.b_m
    FROM R,S
    WHERE R.B_1 = S.B_1 and R.B_2 = S.B_2 and ... and R.B_k = S.B_k

$\pi_{attr_1, attr_2, ..., attr_x} (\sigma_F (R \times S))$ <br>SQL表示
```
SELECT attr_1, attr_2, ..., attr_x
FROM   R,S
WHERE  F
```

SQL数据查询

单表查询

基本格式：SELECT SNO FROM Student WHERE Sage<18
SELECT 目标子句
- 查所有列：SELECT * FROM Student
- 查指定列：SELECT Sno, Sname FROM Student; 查询全体学生的学号与姓名
- 起别名：SELECT Sname,2026-Sage AS 计算(2026-Sage)结果出生年份起名为AS
- 列去重：SELECT DISTINCT Sno FROM SC; 查询学号
- 计算
```
SELECT ordno, year(orddate), month(orddate), day(orddate)
FROM orders;  -- 查询每一份订单的编号、订购的年、月、日；

SELECT ordno, orddate, datediff(curdate(), orddate)
FROM orders ;  -- 查询每一份订单的编号、订购日期、距离至今相隔的天数；
```
- 例：查询全体学生的姓名、出生年份和所在的院系，要求用小写字母表示系名。
```
SELECT Sname,'Year of Birth: ', 2014 - Sage, LOWER(Sdept)
FROM Student;
```

FROM 范围子句

SELECT S.Sno, S.Sname 
FROM Student S;  //S是Student的别名

WHERE 条件子句

比较

SELECT Sname
FROM Student
WHERE Sdept = ‘CS’ ;
WHERE Sdept <> ‘CS’;//过滤条件，相当于!=不等于

确定范围

SELECT Sname, Sdept, Sage
FROM Student
WHERE Sage (NOT) BETWEEN 20 AND 23; -- 查询年龄(不)在[20,23]的学生的姓名、系别和年龄

确定集合

SELECT Sname, Ssex
FROM Student
WHERE Sdept (NOT) IN ( 'CS','MA','IS' );-- 查询(不是)计算机科学系（CS）、数学系（MA）和信息系（IS）学生的姓名和性别。

'字符串常量'加单引号

SELECT Sname,'Year of Birth: ', 2014 - Sage, LOWER(Sdept)  FROM Student;//系名小写

字符匹配 LIKE/=

SELECT* FROM Student WHERE Sno LIKE '24%'  -- 通配符，查询学号以24开头的学生的详细信息
SELECT* FROM Student WHERE Sno = '24%' -- 查询学号就是'24%'学生的详细信息

字符串中的通配符

SELECT Sname, Sno, Ssex
FROM Student
WHERE Sname LIKE '刘%';  -- 查询所有姓刘学生的姓名、学号和性别

SELECT Sname
FROM Student
WHERE Sname LIKE '欧阳_'; -- 查询姓"欧阳"且全名为三个汉字的学生的姓名

SELECT Sname, Sno
FROM Student
WHERE Sname LIKE '_阳%'; -- 查询名字中第2个字为"阳"字的学生的姓名和学号

SELECT Sname, Sno, Ssex
FROM Student
WHERE Sname NOT LIKE '刘%'; -- 查询所有不姓刘的学生姓名、学号和性别

转义字符用 ESCAPE '' 表示字符\为换码字符（转义指示符）

查询DB_Design课程的课程号和学分。
SELECT Cno，Ccredit
FROM Course
WHERE Cname LIKE 'DB\_Design' ESCAPE '\' ;
WHERE Cname = 'DB_Design';  -- 等效

涉及空值的查询

SELECT Sno，Cno
FROM SC
WHERE Grade IS NOT NULL; -- 查所有有成绩的学生学号和课程号

多重条件查询（AND/OR）

连接查询（多表）

等值连接/自然连接查询= <div style="display: flex; gap: 8px; align-items: center; margin: 4px 0;"> <img src="/images/image-14.png" alt="等值连接" style="width: 60%; height: auto;"> </div>
自身连接 起别名 = <br>查询每一门课的间接先修课（即先修课的先修课）
```
SELECT FIRST.Cno, SECOND.Cpno
FROM Course FIRST, Course SECOND -- 需要给表起别名
WHERE FIRST.Cpno = SECOND.Cno;
```
<div style="display: flex; width: 100%; margin-left: 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/image-15.png" alt="计算机网络基本概念总结" style="width: 80%; max-width: 600px; height: auto;"> </div> </div>

外连接

SELECT Student.Sno,Sname,Ssex,Sage,Sdept,Cno,Grade
FROM Student LEFT OUTER JOIN SC ON (Student.Sno=SC.Sno); -- 左外连接：左边为标准，右边不存在的填NULL
FROM Student RIGHT OUTER JOIN SC ON (Student.Sno=SC.Sno); -- 右外连接：右边为标准，右边不存在的填NULL
FROM Student FULL OUTER JOIN SC ON S.Sno = SC.Sno; -- 全外连接，全部补NULL

嵌套查询（子查询）

IN <div style="display: flex; width: 100%; margin-left: 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/qt1.png" alt="计算机网络基本概念总结" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/qt2.png" alt="计算机网络基本概念总结" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/qt3.png" alt="计算机网络基本概念总结" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

带有比较运算符的子查询

SELECT Sno,Sname,Sdept
FROM Student
WHERE Sdept = (SELECT Sdept FROM Student WHERE Sname = '刘晨');
-- 在[例3.55]中，由于一个学生只可能在一个系学习，则可以用 = 代替IN 
SELECT Sno, Cno
FROM SC x
WHERE Grade >= ( SELECT AVG(Grade)
FROM SC y
WHERE y.Sno = x.Sno ); -- 找出每个学生超过他选修课程平均成绩的课程号。

限定比较谓词(SOME/ANY/ALL)

-- 查询非计算机科学系中比计算机科学系任意一个学生年龄小的学生姓名和年龄
SELECT Sname,Sage
FROM Student
WHERE Sage < ANY (
        SELECT Sage
        FROM Student
        WHERE Sdept = 'CS')
    AND Sdept <> 'CS' ;
-- 聚集函数
SELECT Sname,Sage
FROM Student
WHERE Sage < (
        SELECT MAX（Sage）
        FROM Student
        WHERE Sdept= 'CS ' )
    AND Sdept <> 'CS';

< ANY → 小于最大值；

SELECT * FROM SC
WHERE Grade < ANY (80,90,70); -- 任意一个，小于最大值。成绩 < 90

SELECT * FROM SC
WHERE Grade < ALL (80,90,70); -- 所有，小于最小值。成绩 ＜ 70

EXISTS谓词子查询有结果，返回TRUE；子查询无结果，返回FALSE

SELECT Sname
FROM Student S
WHERE EXISTS (
    SELECT *
    FROM SC
    WHERE SC.Sno = S.Sno
    AND Cno = '1' -- 从 Student 表里，找出那些‘存在’选修 1 号课程记录的学生
); -- 查询选修了 1 号课程的学生

SELECT Sname
FROM Student S
WHERE NOT EXISTS (
    SELECT *
    FROM SC
    WHERE SC.Sno = S.Sno
    AND Cno = '1'
); -- 查询没选1号课程的学生

查询选修全部课程的学生

SELECT Sname
FROM Student
WHERE NOT EXISTS ( -- ③ 除去没有选择课程的学生
    SELECT *
    FROM Course -- ② 有NOT EXISTS学生选择的课程中的：学生没有选择的课程
    WHERE NOT EXISTS (
        SELECT *
        FROM SC
        WHERE SC.Sno = Student.Sno  
        AND SC.Cno = Course.Cno -- ① 对SC中的每门课程，去Student、Course中寻找有无记录
    ) -- 学生选择的课程
);
✅ 理解：不存在一门课是这个学生没选的

例 <div style="display: flex; width: 100%; margin-left: 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/exists1.png" alt="exists" style="width: 80%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/exists2.png" alt="exists" style="width: 80%; max-width: 600px; height: auto;"> </div> </div> <div style="display: flex; width: 100%; margin-left: 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/exists3.png" alt="exists" style="width: 80%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/exists4.png" alt="exists" style="width: 80%; max-width: 600px; height: auto;"> </div> </div>

聚集函数/统计函数

COUNT 统计元组个数
SUM 计算一列的总和/AVG 计算一列的平均值
MIN 一列值中的最大值/MIN 一列值中的最小值 <div style="display: flex; gap: 8px; align-items: center; margin: 4px 0;"> <img src="/images/jjhs1.png" alt="聚集函数1" style="width: 60%; height: auto;"> <img src="/images/jjhs2.png" alt="聚集函数2" style="width: 40%; height: auto;"> </div>

对查询结果的处理

对查询结果排序 ORDER BY 属性名 ASC升序/DESC降序 查询选修了3号课程的学生的学号及其成绩，查询结果按分数降序排列。
```
SELECT Sno, Grade
FROM SC
WHERE Cno= '3'
ORDER BY Grade DESC;
```
对查询结果分组 GROUP BY/HAVING 求各个课程号及相应的选课人数。
```
SELECT Cno，COUNT(Sno)
FROM SC
GROUP BY Cno; // 按照Cno为一行,相同Cno为一行
```
查询选修了3门以上课程的学生学号。
```
SELECT Sno
FROM SC
GROUP BY Sno
HAVING COUNT(*) >3;
```
- 辨析 HAVING 与 WHERE

指定结果列的列标题

SELECT Sname NAME,'Year of Birth:' BIRTH,2014-Sage BIRTHDAY,
-- Sname一列的结果列标题为NAME，'Year of Birth:'常量列的列标题为BIRTH…
FROM Student;

查询结果 <br>WHERE → GROUP → SELECT → ORDER WHERE → GROUP → HAVING → SELECT → ORDER <div style="display: flex; width: 100%; margin-left: 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/checking2.png" alt="计算机网络基本概念总结" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/checking1.png" alt="计算机网络基本概念总结" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

集合操作

并操作 UNION [ALL]
交操作 INTERSECT [ALL]
差操作 EXCEPT [ALL] <div style="display: flex; width: 100%; margin-left: 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/intersect1.png" alt="计算机网络基本概念总结" style="width: 80%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/intersect2.png" alt="计算机网络基本概念总结" style="width: 80%; max-width: 600px; height: auto;"> </div> </div>

基于派生表的查询

数据更新

插入

格式

INSERT
INTO <表名> (属性名1，属性名2,…)
VALUES (expr1|NULL , expr2|NULL ,…)

插入子查询结果

INSERT
INTO <表名>(属性1，属性2，…)
子查询

修改

格式

UPDATE <表名>
SET <属性1>=<expr1>，<属性2>=<expr2>
WHERE <条件>

删除
1. 格式
```
DELETE
FROM <表名>
[WHERE <条件>]
```

事务

定义是用户定义的一个数据库操作序列，这些操作要么全做，要么全不做
例
事务的特性（ACID）原子性(Atomicity)、一致性(Consistency)、隔离性(Isolation)、持久性(Durability)
定义事务
- 事物的启动：隐式方式（由数据库管理系统来决定，何时为何用户启动一个新的事务）
- 事物的结束：用户调用commit或rollback命令，显式地结束当前事务；由数据库管理系统强行结束一个用户的当前正在运行中的事务
1. 事务启动方式
  - 数据定义命令 DDL <br>只要你执行 CREATE、ALTER 等定义语句，系统自动把这一条语句当成一个独立事务。 <br>执行前，如果你正在做其他操作，系统会自动先提交之前的事务。
  - 将系统设为自动提交方式（打开自动提交标志） <br>这是最常见的默认状态。每一条 SELECT、UPDATE 等操作，做完后系统自动帮你 COMMIT，立即生效。
  - 数据操纵命令(DML) <br>如果你没有开启自动提交，当你执行 INSERT/UPDATE/DELETE 时，系统检测到你没有事务，就自动帮你开启一个新事务，等着你手动提交或回滚。
2. 事务结束方式
  - 事务提交：COMMIT <br>事务正常结束，确认所有操作生效
  - 事务回滚：ROLLBACK <br>事务异常终止，撤销所有操作。保存点 savepoint，支持部分回滚。只撤销保存点后的操作
相关的SQL语句
- 事务结束命令事务提交命令：COMMIT/事务放弃命令：ROLLBACK
- 事务设置命令
  - 设置事务的自动提交命令：SET AUTOCOMMIT ON | OFF
  - 设置事务的类型：SET TRANSACTION READONLY | READWRITE
- 在MySQL数据库中，设置事务自动提交功能的SQL命令格式是
  - SET AUTOCOMMIT = 0; /* 关闭事务自动提交功能 */
  - SET AUTOCOMMIT = 1; /* 打开事务自动提交功能 */
- 只读/读写型事务 SET TRANSACTION READONLY | READWRITE ;
- 事隔离级别——解决相互干扰
  1. READ UNCOMMITTED 读未提交
  2. READ COMMITTED 读已提交
  3. REPEATABLE READ 可重复读
  4. SERIALIZABLE 串行化
- 基于封锁的并发控制（Locking）——具体执行策略
  1. 读锁（共享锁/S锁）事务 T 持有读锁时，只允许别人读，不允许写。作用：保证大家看到的是同一时刻的数据。
  2. 写锁（排他锁/X锁）事务 T 持有写锁时，别人既不能读，也不能写。作用：保证修改操作不被打断，原子性执行。
  3. 互斥原则一个数据对象上，同一时刻只能有一种锁（要么一堆读锁，要么一个写锁），不能混着来。

SQL中的空值

注意取值

视图

格式

CREATE VIEW <视图名> [(<列名> [,<列名>]…)]
AS <子查询>
[WITH CHECK OPTION];

例-行列子集视图 若一个视图是从单个基本表导出的，并且只是去掉了基本表的某些行和某些列，但保留了主码，我们称这类视图为行列子集视图。
WITH CHECK OPTION 阻止不符合条件的数据加入/修改成不符合条件的数据…/而基本表没有限制
建立视图
删除视图 DROP VIEW <视图名> [CASCADE]
查询视图
更新视图

C4 数据库的安全性

数据安全性概述

数据库安全性：保护数据库防止非法使用造成的数据泄露、更改或破坏，是数据库系统核心性能指标之一
数据库不安全因素 & 安全措施
- 非授权用户对数据库的恶意存取和破坏：用户身份鉴别、存取控制、视图
- 数据库中重要或敏感的数据被泄露：强制存取控制、数据加密存储、加密传输
- 安全环境的脆弱性：建立可信计算机系统
- 故障/误操作/并发访问
安全标准
- 美国国防部颁布TCSEC(DoD85) → 不同国家在其基础上建立的评估准则ITSEC/CTCPEC/FC → CC (国际通用标准)
- TCSEC/TDI安全级别划分（从低到高）/ CC评估保证级(EAL)划分 <div style="display: flex; width: 100%; margin-left: 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/TCSEC.png" alt="TCSEC划分" style="width: 80%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/CC.png" alt="CC评估保证级划分" style="width: 80%; max-width: 600px; height: auto;"> </div> </div>
- 中国标准：GB 17859-1999
计算机系统的安全模型 <div style="display: flex; width: 100%; margin-left: 0;"> <div style="flex: 1; text-align: center;"> <img src="/images/computersyssafemodel.png" alt="计算机系统的安全模型" style="width: 80%; max-width: 600px; height: auto;"> </div> </div>
数据库管理系统安全性控制模型数据库安全性控制的常用方法:用户标识和鉴定、存取控制、视图、审计、数据加密

数据库安全性控制

数据库安全性控制的常用方法：用户标识和鉴定、存取控制、视图、审计、数据加密

用户身份鉴别

系统提供的最外层安全保护措施 <br>用户标识 = 用户名 + 用户标识号（用户标识号在系统整个生命周期内唯一） <br>用户身份鉴别的方法：静态口令鉴别、动态口令鉴别、生物特征鉴别(掌纹/虹膜)、智能卡鉴别

存取控制

组成：定义用户权限，并将用户权限登记到数据字典中 + 合法权限检查(用户发出存取数据库的操作请求后,DBMS根据字典检查权限)
存取控制方法:自主存取控制、强制存取控制

自主存取控制 DAC

SQL支持：通过 GRANT语句、REVOKE语句 提供支持
核心目标：
用户权限的组成要素：数据库对象 + 操作类型
用户存取权限的方式 <br>(i) 客体的属主(客体的创建者)自动拥有客体上的所有存取权限 <br>(ii) 拥有权限的用户可以自主地将他拥有的权限传授给在数据库系统中注册的其他用户 5. 访问控制检查流程第一步：是不是管理员？第二步：是不是客体的属主？第三步：有没有被授予对应的权限？(检查用户 S 是否被授予了“以方式A 访问客体O”的权限) <!-- ### 授权：授予GRANT 与收回REVOKE <span id="GRANT"></span>

基础GRANT

GRANT SELECT
ON TABLE Student
TO U1 -- 把查询Student表权限授给用户U1

GRANT ALL PRIVILIGES
ON TABLE Student,Course
TO U2,U3 -- 把对Student表和Course表的全部权限授予用户U2和U3

GRANT SELECT
ON TABLE SC
TO PUBLIC; -- 把对表SC的查询权限授予所有用户

GRANT SELECT,UPDATE(Sno)
ON TABLE Student
TO U4-- 把查询Student表和修改学生学号的权限授给用户U4

再授权

GRANT INSERT ON TABLE SC TO U5 WITH GRANT OPTION -- 把对表SC的INSERT权限授予U5用户，并允许他再将此权限授予其他用户
-- 用户U5可以执行下述命令，将之前获得的表SC的INSERT权限及传播权限 授予用户U6。
GRANT INSERT ON TABLE SC TO U6 WITH GRANT OPTION;
-- 同样，U6还可以将此权限授予U7，但U7不能再传播此权限。
GRANT INSERT ON TABLE SC TO U7;

REVOKE

REVOKE UPDATE(Sno) ON STUDENT FROM U4 -- 把用户U4修改学生学号的权限收回
REVOKE SELECT ON SC FROM PUBLIC -- 收回所有用户对表SC的查询权限

创建数据库模式的权限

拥有的权限	CREATE USER	CREATE SCHEMA	CREATE TABLE	登录数据库，执行数据查询和操纵
DBA	可以	可以	可以	可以
RESOURCE	不可以	不可以	可以	可以
CONNECT	不可以	不可以	不可以	可以，但必须拥有相应权限

数据库角色 ROLE

强制存取控制 MAC

其他安全技术

视图机制、审计（Audit）、数据加密、其他安全性保护

<!-- ### GRANT语句

一般格式

GRANT <权限> [ , <权限> ] ... 
ON <对象类型> <对象名> [ , <对象类型> <对象名> ]…
TO <用户> [ , <用户> ] ... 
[ WITH GRANT OPTION ];

C6 关系数据理论

如何评价关系模式设计的好坏？
如何设计性能良好的关系模式？ <br>关系数据库的规范化理论，就是为了解决上述两个问题而提出的关系数据库设计理论

问题的提出

为什么数据库表不能随便设计？为什么需要“规范化理论”？

关系模式 & 第一范式(1NF)

关系模式结构
完整五元组：R(U,D,DOM,F) 简化三元组：R<U,F> 关系名(属性名集合，属性取值域，属性到域的映射，属性间数据依赖)
第一范式(1NF)的 6 条核心性质
- 列同质：每列数据来自同一域（同类型或范围）
- 不同列可同域（“学生姓名”和“教师姓名”都可以是字符串）
- 列无序（属性顺序不影响语义）
- 行唯一（无重复元组/行）
- 行无序（元组顺序不影响语义）
- ⭐分量必须取原子值：数据项不可再分 <br>第一范式（1NF）地位：关系数据库最基础范式，是所有高级范式的前提

不良关系模式的问题

单一的关系模式/三个关系模式 <div style="display: flex; width: 100%; margin-left: 0; margin-top: -40px; margin-bottom: -30px;"> <div style="flex: 1; text-align: center;"> <img src="/images/Rmodel1.png" alt="计算机网络基本概念总结" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/Rmodel2.png" alt="计算机网络基本概念总结" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>
带来的问题：数据冗余、更新异常、插入异常、删除异常 <div style="display: flex; width: 100%; margin-left: 0; margin-top: -40px; margin-bottom: -10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/image-41.png" alt="计算机网络基本概念总结" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/yic2.png" alt="计算机网络基本概念总结" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/image-43.png" alt="计算机网络基本概念总结" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/image-44.png" alt="计算机网络基本概念总结" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

数据依赖基础

定义：关系内部属性与属性间的语义约束
核心类型
- 函数依赖（FD）：一个属性值确定，另一属性值唯一确定（如Sno→Sdept）
- 多值依赖（MVD）：高级数据依赖，后续章节讲解

范式与规范化

范式（NF）：是对一个关系中允许存在的数据依赖的要求
范式等级（从低到高包含关系）： $$1NF \supset 2NF \supset 3NF \supset BCNF \supset 4NF \supset 5NF$$
规范化：将低范式通过模式分解转为高范式，消除不良数据依赖 <br>范式越高，对表中数据依赖的要求越严格。

函数依赖 & 码

函数依赖的定义 Ø 非平凡函数依赖，平凡函数依赖 q 定义6.2 完全函数依赖，部分函数依赖 q 定义6.3 传递函数依赖（直接函数依赖）

一、常用符号表示

符号表示	含义说明
$A, B, C$	属性名
$ABC$	代表由 $A$、$B$、$C$ 三个属性组成的属性集合，即：$ABC = {A, B, C}$<br>有时候也用 $(\dots)$ 代替其中的 ${\dots}$，即表示为：$ABC = (A, B, C)$
$X, Y, Z$	关系的属性子集(subset)
$XY$	表示 $X$ 和 $Y$ 的并集，即：$XY = X \cup Y$
$R, S, T$	关系名（关系模式）
$R(U)$	关系模式：关系名 $R$，关系中的属性集合 $U$
$R(U, F)$	关系模式：关系名 $R$，属性集合 $U$，函数依赖集 $F$
$r, s, t$	关系实例（一个关系中的元组集合）
$r_1, r_2, r_3$	关系中的元组
$r_1[A]$	元组 $r_1$ 在属性（集）$A$ 上的取值

二、函数依赖 FD

定义 <br>X确定唯一Y，则称“X函数确定Y”或“Y函数依赖于X”，记作 $X \to Y$。
- $X$：决定因素
- $Y$：依赖因素 <div style="display: flex; width: 100%; margin-left: 0; margin-top: -40px; margin-bottom: -10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/FDli1.png" alt="函数依赖例1" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

1. 平凡/非平凡函数依赖

平凡函数依赖：$X \to Y$ 且 $Y \subseteq X$（Sno本来就在左边）例：$(Sno,Cno) \to Sno$ $(Sno, Cno) → Cno$
非平凡函数依赖：$X \to Y$ 且 $Y \nsubseteq X$ 例：$(Sno,Cno) \to Grade$

2. 完全/部分函数依赖

完全函数依赖：要决定Y，X的所有部分都要用上，如要确定一门课的成绩，需要同时知道学号+课程名 <br>例：$(Sno,Cno) \stackrel{F}{\to} Grade$
部分函数依赖：要决定Y，只需要X中的一部分属性就可以，如确定专业，只需知道Sno就行，Cno是不必要的 <br>例：$(Sno,Cno) \stackrel{P}{\to} Sdept$

3. 传递函数依赖

定义：若 $X \to Y$，$Y \nrightarrow X$，$Y \to Z$（$Y \nsubseteq X$ $Z \nsubseteq Y$），则 $X \stackrel{\text{传递}}{\to} Z$
例：$Sno \to Sdept$，$Sdept \to Mname$ $\Rightarrow$ $Sno \stackrel{\text{传递}}{\to} Mname$ -->

<!-----

三、函数依赖的判定规则

实例判定逻辑

对任意元组 $r_1,r_2$：若 $r_1[X] = r_2[X]$，则必有 $r_1[Y] = r_2[Y]$ $\Rightarrow$ $X \to Y$。

数量对应关系判断
- 一对一(1:1)：$X \to Y$ 且 $Y \to X$（如身份证号 ↔ 学号）
- 多对一(n:1)：多端属性 $\to$ 一端属性（如 $Sno \to Sdept$）
- 多对多(m:n)：不存在函数依赖（如：Sno $$\nrightarrow$$ Cno）
关键结论 & ⭐函数依赖集
- $B \nrightarrow 所有$ $D \rightarrow 所有$（同一个值是否只能最初一个值）
- $所有 \rightarrow B$（一定不会对应两个）
<div style="display: flex; width: 100%; margin-left: 0; margin-top: -40px; top"> <div style="flex: 1; text-align: center;"> <img src="/images/hanshuylj1.png" alt="函数依赖集1" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 1; text-align: center;"> <img src="/images/hanshuylj2.png" alt="函数依赖集2" style="width: 100%; max-width: 600px; height: auto;"> </div> </div> -->

<!-- ### 四、⭐码与相关概念

超码

能 <u>唯一标识</u> 元组的任意属性集。
- 关系：候选码是最小超码，候选码的任意超集都是超码。
- 例如：S(Sno, Sdept, Sage)，若：Sno → Sno, Sdept, Sage， <br>{Sno}是<u>候选码</u> 也是<u>超码</u>，(Sno, Sdept)也是<u>超码</u>。
候选码（码）

能够唯一标识元组的 <u>最小</u> 超码 <br>{Sno}是候选码
全码

如果关系的所有属性U才是R的码，称为全码 <br>例：$R(P,W,A)$（演奏者、作品、听众），全码为 $(P,W,A)$。P, W, A 都是关系R的主属性，在关系R中没有非主属性
主码

如果一个关系模式有多个候选码，则从中选一个作为主码。
- 例如：Student(Sno, Sname, Ssex, Sage, Sdept)：Sno 是候选码，Sname 也是候选码。 <br> → 可以选 Sno 作为主码。
外码

R中 $X$ 不是当前关系R的码，是另一关系的码，则 $X$ 为 $R$ 的外码。 <br>例：$SC(<u>Sno,Cno</u>,Grade)$ 中 Sno不是码，Sno是 S(<u>Sno</u>,Sdept,Sage)的码， <br> 则 $Sno$ 是 $SC$ 的外码 <br> FOREIGN KEY (deptno) REFERENCES Department(deptno) <br> 外码的作用是：建立表之间的引用联系，并保证参照完整性。

主属性与非主属性
- 主属性：包含在任意候选码中的属性。
- 非主属性：不包含在任何候选码中的属性。

例

S(<u>Sno</u>, Sdept, Sage)中，只有一个候选码Sno，所以：Sno是关系S的主属性，Sdept和Sage是关系S的2个非主属性；
SC(<u>Sno, Cno</u>, Grade)中，只有一个候选码(Sno, Cno)，所以：Sno和Cno是关系SC的2个主属性，Grade是关系SC的非主属性。
Student(Sno, Sname, Ssex, Sage, Sdept)中。有两个候选码：Sno 和 Sname（不允许学生同名），所以：Sno 和 Sname是关系Student的2个主属性，Ssex, Sage, Sdept是关系Student的3个非主属性。 -->

<!-- ---

范式 & 规范化

一、核心概述

范式是关系模式的规范化标准，用于消除数据冗余与插入、更新、删除异常； <br>规范化通过投影分解将低范式转换为高范式。 <br>层级关系(从低到高)：1NF ⊃ 2NF ⊃ 3NF ⊃ BCNF ⊃ 4NF ⊃ 5NF，高

范式	主要解决的问题	一句话理解
1NF	属性不可再分	每个格子只能放一个值
2NF	部分函数依赖	非主属性不能由主属性部分函数依赖推出，必须完全依赖
3NF	传递函数依赖	不存在非主属性对候选码的传递函数依赖
BCNF	决定因素不是码	所有非平凡函数依赖中的决定因素（左边），都必须是包含候选码
4NF	-	每个非平凡多值依赖 X →→ Y 都满足 X含有码

二、1NF（第一范式）

定义
关系模式的所有属性均为 不可再分的原子数据项，是关系数据库的最低要求。
实例
关系模式 SLC(Sno, Sdept, Sloc, Cno, Grade) 中，所有属性均为原子属性，满足 1NF。

三、2NF（第二范式）

定义 <br>非主属性不能由候选码部分函数依赖推出，必须完全依赖。
- 如：AF 是候选码，D 是非主属性。 <br>若A → D，说明非主属性 D对候选码部份依赖 $\Rightarrow$ 不满足2NF
实例：SLC 关系 <div style="display: flex; width: 100%; margin-left: 0; margin: -20px; top"> <div style="flex: 1; text-align: center;"> <img src="/images/2NF1.png" alt="函数依赖集1" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>
Solution <br>分解成2个关系模式（但插入异常、删除异常任然存在） <div style="display: flex; width: 100%; margin-left: 0; margin-top: -20px; top"> <div style="flex: 1; text-align: center;"> <img src="/images/2NF1.png" alt="函数依赖集1" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

四、3NF（第三范式）

定义 <br>不存在非主属性对候选码的传递函数依赖，没有非主属性 → 3NF <br>不存在码X、属性Y、非主属性Z使得 $X→Y，Y→Z$ 成立 $\Rightarrow Y \nrightarrow X$ <br>码 ~不能~和 非主属性 有传递依赖关系
实例：SL 关系

五、BCNF（巴斯范式）

定义 <br>所有非平凡函数依赖中的决定因素（左边），都必须是包含候选码（都必须是超码）
实例 1：仓库管理关系 <div style="display: flex; width: 100%; margin-left: 0; margin-top: -20px;"> <div style="flex: 6; text-align: center;"> <img src="/images/BCNF.png" alt="BCNF1" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 4; text-align: center;"> <img src="/images/BCNF2.png" alt="BCNF1" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

4NF（第四范式）

定义 <br>每个非平凡多值依赖 X →→ Y 都满足 X含有码
分解 <br>把独立的多值事实拆开 -->

<!-----

Armstrong公理系统

用于：

从已有函数依赖推出新的函数依赖
计算属性集闭包
计算候选码
支持模式分解算法

Armstrong公理系统 - 基本规则
<u>A1 自反律</u>：知道一组属性，一定知道部分 <br> {Cno, Sname} → Cno
<u>A2 增广律</u>：若 $X \rightarrow Y$，则 $XZ \rightarrow YZ$ <br> Cno → Sname $\Rightarrow$ {Cno, clsno} → {Sname, clsno}
<u>A3 传递律</u>：若 $X\rightarrow Y$ 且 $Y\rightarrow Z$，则 $X\rightarrow Z$ <br> Cno → Class、Class → Teacher $\Rightarrow$ Cno → Teacher
Armstrong公理系统 -扩充规则
1. <u>合并规则</u>：若 X $\to$ Y 且 X $\to$ Z，则 X → YZ
2. <u>分解规则</u>：若：X → YZ，则：X → Y，X → Z
3. <u>伪传递规则</u>：若 X $\to $Y 且 WY $\to$ Z，则 XW $\to$ Z
- 引理：$X \to A_1A_2\cdots A_k \Rightarrow X \to A_i( i=1,2,\dots,k)$ 成立 <br>学号 → (姓名, 班级, 专业) $\Rightarrow$ 学号 → 姓名，学号 → 班级，学号 → 专业
3.1 函数依赖的逻辑蕴涵
- F 的所有规则，必然导致 X→Y 成立（X Y是属性/属性集）。是由F带来的，没有写出但必然成立的规则。 <br>则称：F 逻辑蕴涵 X → Y，记作 F ⊨ X → Y
- 例：F = {学号 → 系名, 系名 → 系主任 }，则：F ⊨ 学号 → 系主任
3.2 函数依赖集的闭包 F^+
- 定义：$F^+ = { X \to Y \mid F \vDash X \to Y }$，即：所有被 F 逻辑蕴涵的函数依赖的集合。
- 属性集 U={A,B,C}，函数依赖集 F={A→B, B→C} → $F^+$ ={ A→A, A→B, A→C, A→BC, A→AB, A→AC, A→ABC, B→B, B→C, B→BC, C→C, AB→A, AB→B, AB→C, AB→AB, AB→AC, AB→BC, AB→ABC, AC→A, AC→B, AC→C, AC→AB, AC→AC, AC→BC, AC→ABC, BC→B, BC→C, BC→BC, ABC→A, ABC→B, ABC→C, ABC→AB, ABC→AC, ABC→BC, ABC→ABC }
- 直接计算 F⁺ 很麻烦。因为可能推出非常多的函数依赖。所以实际做题时，一般不直接求 F⁺，而是用 属性集闭包 X⁺ 👇来判断某个依赖是否成立。
3.3 属性集的闭包 $X_F^+$
- 从属性A 出发，用 F 中的依赖能推导出的所有属性的集合，$A_F^+$称为属性A关于函数依赖集F的闭包。
- ⭐例：计算A关于F的闭包 $A_F^+$ <br>初始：$A_F^+ = {A}$ 用 A→B：$A_F^+ = {A,B}$ 用 B→C：$A_F^+ = {A,B,C}$
- 计算方法：迭代算法 <div style="display: flex; width: 100%; margin-left: 0; margin-top: -40px;margin-bottom: -20px"> <div style="flex: 6; text-align: center;"> <img src="/images/image-62.png" alt="属性集的闭包" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>
函数依赖集的覆盖与等价
- 核心概念
  - 覆盖：若 F 能推出 G 里的所有依赖 ($G\subseteq F^+$) ，就说 F覆盖G
  - 等价：若 F覆盖G 且 G覆盖F（$F^+ = G^+$），就说 F和G等价（充要关系）
- 例 <br>设：F = { A → B, A → C }，设：G = { A → BC } <br>$\Rightarrow$ F 和 G 等价。 <br>因为：由 F 可用合并规则推出 A → BC；由 G 可用分解规则推出 A → B 和 A → C <br>所以：F⁺ = G⁺（“分开写”和“合起来写”本质上表达的是同一件事）
极小函数依赖集 / 最小依赖集 / 最小覆盖
- 需满足 3 个条件：
  
  设 F 为函数依赖集，F_m 是其极小依赖集，需满足：
  1. 右边只有一个属性
  2. 左边没有多余属性 <br>AB → C，如果：A⁺ 中已经包含 C说明只用 A 就能推出 C，B 是多余的。 <br>于是：AB → C可以简化为：A → C
  3. 没有冗余函数依赖 <br>F={A → B，B → C，A → C}，其中A → C 可由前两个推出来，所以A → C是冗余依赖，可删除
    - 例：$F' = { Sno \rightarrow Sdept, Sno \rightarrow Mname, Sdept \rightarrow Mname, $ <br> $(Sno, Cno) \rightarrow Grade, (Sno, Sdept) \rightarrow Sdept } $ <br>不是最小覆盖，上是冗余依赖，下是左边多于属性
- 计算算法
  1. 右部拆分：AD → EF 拆成：AD → E，AD → F；
  2. 删左边多余属性：对于 ADF→ C：∵AD → F ，故可简化为 AD → C； <br>对于 ADF → D：∵D已经包含在左边 $\rightarrow$ 可以删除该平凡函数依赖；
  3. 删冗余依赖：对于C → B，可以由C → F，F → B推出。删除 C → B；
  - 特性：每个函数依赖集都等价于一个极小依赖集，且不唯一。 -->

<!-- ---

模式分解

模式分解的三个理解
1. 无损连接：自然连接后完全等于原表
2. 保持函数依赖：分解后所有依赖规则都能找到
3. 既 无损连接 又 保持函数依赖

⭐无损连接

有损连接：会产生多余元组。
定义：R = R1 ⋈ R2 ⋈ ... ⋈ Rn，能 自然连接$\bowtie$ 回来，完全等于原表。

💫判定：两张表的<u>公共属性</u>，如果能推出某一张表的<u>非公共属性</u>，就是无损连接。 <br>例如1：A是公共属性，能推出T1的非公共属性B。故满足无损连接性

函数依赖集	分解ρ	是否满足无损连接性？
{A→B}	$T_1(A,B) T_2(A,C)$	✅
{A→C，B→C}	$T_1(A,B) T_2(A,C)$	✅
{A→B}	$T_1(A,B) T_2(B,C)$	❌
{A→B，B→C	$T_1(A,B) T_2(B,C)$}	❌

⭐保持函数依赖

分解后，原来的函数依赖能在子关系中直接检查。

🌟3NF模式分解

目标：得到满足3NF 且既有无损连接性又保持函数依赖的分解
步骤：<u>每条依赖建一张表，最后检查有没有候选码，没有就补上</u>
1. 求 F 的极小函数依赖集 Fmin
2. 求候选码
3. 谁决定谁，就把它们放在一张表里。 <br>例如：Sno → Sdept就建：SD(Sno, Sdept)
4. 检查是否需要补候选码表：如果没有任何子关系包含原关系的候选码 K，则补一个关系 R(K)

💫例：到3NF的模式分解示例

🌟BCNF 模式分解

目标：分解到 BCNF，并且保证无损连接。
步骤：
1. 初始 ρ = {R}
2. 检查每个关系是否满足 BCNF
3. 如果某个关系不满足 BCNF，则存在：X → Y，且 X 不是候选码
4. 分解为：R₁ = XY，R₂ = U - Y
5. 继续检查，直到全部满足 BCNF

💫例：转换为BCNF的无损连接分解 <br>STJ(S学生,T老师,J课程)，依赖包括：T → J，(S,J) → T，(S,T) → J <br>STJ 满足 3NF，但不满足 BCNF。

原因：T → J 中，T 不是超码。

所以分解为：TJ(T,J) ST(S,T)

多值依赖

定义：一个属性决定的不是一个值，而是一组值。记作 X →→ Y，读作Y多值依赖于X（有其他属性Z，Y、Z都多值依赖于X的充要条件是 X、Y可以自由组合）
多值依赖 vs 函数依赖
1. 跟Z的关系 <br>函数依赖：只问“X 能不能唯一确定 Y”。 <br>多值依赖：还要问“Y 和剩下的属性是不是独立”。
2. 跟子集的关系 <br>A → BC，则：A → B A → C <br>多值依赖不一定成立 --- --> <!-- # 🌟C6例题

⭐例1：属性集闭包算法 -计算A关于F的闭包 $A_F^+$
<br>初始：$A_F^+ = {A}$ 用 A→B：$A_F^+ = {A,B}$ 用 B→C：$A_F^+ = {A,B,C}$
- 计算方法：迭代算法 <div style="display: flex; width: 100%; margin-left: 0; margin-top: -30px;margin-bottom: -20px"> <div style="flex: 6; text-align: center;"> <img src="/images/image-62.png" alt="属性集的闭包" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>
⭐例：等价/最小函数依赖集 -属性集闭包算法
<div style="display: flex; width: 100%; margin-left: 0; margin-top: -40px;margin-bottom: -20px"> <div style="flex: 6; text-align: center;"> <img src="/images/image44.png" alt="属性集的闭包" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>
⭐例2：极小函数依赖集算法
1. 右部拆分：AD → EF 拆成：AD → E，AD → F；
2. 删左边多余属性：对于 ADF→ C：∵AD → F ，故可简化为 AD → C； <br>对于 ADF → D：∵D已经包含在左边 $\rightarrow$ 可以删除该平凡函数依赖；
3. 删冗余依赖：对于C → B，可以由C → F，F → B推出。删除 C → B；
⭐（补充3）例：判断冗余依赖
1. 函数依赖集 M = {C → E，E → B，BCD → A}，断言：BCD → A 可以简化成 CD → A（C可以推出B），它是一个冗余函数依赖 <br>构造 N = {C → E，E → B，CD → A}，只需证明：$M^+ = N^+$（M能推出的=N能推出的） <br>✅只需证明：M ⊨ CD → A？ N ⊨ BCD → A？
  
  ① 证明：M ⊨ CD → A <br>只需证明 ${C，D}_M^+$ 中包含 A，就能证明 CD → A <br>初始值：{CD}_M^+ = {C，D} <br>第一遍：{CD}_M^+ = {C，D，E}（C → E） <br>第二遍：{CD}_M^+ = {B，C，D，E}（E → B） <br>第三遍：{CD}_M^+ = {A，B，C，D，E}（BCD → A）
  
  ② 同理得证：N ⊨ BCD → A
2. 函数依赖集 M = {B → D，D → E，C → F，BC → A，EF → A}，断言：B→ A 是一个冗余的函数依赖 <br>构造 N = {B → D，D → E，C → F，EF → A}，要证明 $M^+ = N^+$，<br>只需证明：N ⊨ BC → A，即：${BC}_N^+$ 包含A
3. 函数依赖集 F = {A → B，B → A，AB → C}，判断 AB → C 是否为部分函数依赖？ <br>只需假设把AB → C 换成 A → C/B → C是否依然成立。同上。
⭐例3：计算候选码
要求候选码K，只需找到能推出全部属性U的 $K_R^+=U$ 即可。
1. 没有出现在右边的属性 → 一定在候选码内（因为没有属性能推出它）
2. 只出现在右边的属性 → 一般不放在候选码（因为可以由其他属性推出）
3. 其他属性待选跟1结合
- 先算1必须出现在候选码中的属性K，是否有 $K_R^+ = U$
- 再依次跟3中属性结合。候选码可能不止1个。 -->

C7 数据库设计

数据库设计的基本方法

设计方法	对象	目的
新奥尔良法	整体的数据库设计流程方式	覆盖各阶段
基于E-R模型设计	概念结构设计	用 E-R / EER 图把用户需求抽象成实体、属性、联系
3NF设计方法	逻辑结构设计	将概念模型转为关系表，并保证满足3NF
面向对象的数据库设计方法	面向对象数据库	把实体看作对象，属性/方法封装在对象中
统一建模语言（UML）方法	概念建模/逻辑设计	用类图、对象图、时序图等 UML 工具表示

数据库设计基本步骤（新奥尔良法）

工作	所属阶段
收集业务需求、数据流	需求分析
画 ER/EER 图	概念结构设计
ER 转关系模式、规范化	逻辑结构设计
设计索引、文件组织、聚簇	物理结构设计
建表、装载数据、编程	数据库实施

1. 需求分析

目标：明确用户信息需求（What）与处理需求（How），为概念设计提供基础
需求分析产出结果
- <u>数据字典</u>（学号：字符型，10位，唯一标识学生）
- <u>用户需求规格说明书</u>（学生可以选课、退课、查成绩；教师可以录入成绩）
- 这两个结果是概念结构设计的基础输入（为下一步画 E-R 图提供依据）

数据字典 DD
1. 定义：数据字典是对数据库中数据的<u>描述</u>，也叫元数据/基础数据
  - 例：具体数据：张三，20240001，数据库原理，88 <br>元数据：学号是 CHAR(10)，姓名是 VARCHAR(20)，成绩是 0~100 的整数
2. 数据字典的内容
  - 数据项
    
    数据项是不可再分的数据单位，是数据的最小组成单位
  - 数据结构
    
    数据结构：由若干数据项/数据结构组成，反映数据之间的组合关系
  - 数据流
    
    数据流：数据结构在系统内部传输的路径(数据从哪里来，到哪里去)
  - 数据存储
    
    数据存储：数据结构停留或保存的地方，也是数据流来源和去向之一（数据存在哪里）
  - 处理过程
    - 处理过程：系统对数据进行加工处理的过程。处理过程的具体处理逻辑一般用判定表或判定树来描述。
    - 判定表 & 判定树

2. 概念结构设计

概念结构设计：把需求抽象成概念模型
描述概念模型的工具：E-R 模型 / EER 模型
概念结构设计方法

自顶向下、自下向上、二者混合策略、逐步扩张（学生的核心需求和概念结构 → 再扩展教师等其他需求和概念结构）

<!-- ### E-R模型

E-R 模型三要素：实体（学生，学生实体集 = 所有学生）、属性（姓名、年龄）、联系（学生“选修”课程）

联系

联系的相关概念 学生 —— 选修 —— 课程 <br>联系名：选修；联系属性：成绩； <br>联系的度：2（因为参与的是学生、课程两个实体）；函数关系：m:n，因为一个学生选多门课，一门课被多个学生选

联系的分类

类型	含义	例子
二元联系	两个实体型之间	学生-课程
多元联系	三个或更多实体型之间	供应商-项目-零件
一元联系	一个实体型内部	职工领导职工（联系的度是2）

⭐怎么画E-R图？

三要素的表示
联系的三种分类的表示 <div style="display: flex; width: 100%; margin-left: 0; margin-top: -20px;margin-bottom: -10px"> <div style="flex: 6; text-align: center;"> <img src="/images/relationship1.png" alt="联系1" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 6; text-align: center;"> <img src="/images/relationship2.png" alt="联系2" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 6; text-align: center;"> <img src="/images/relationship3.png" alt="联系3" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>
例 <div style="display: flex; width: 100%; margin-left: 0; margin-top: -20px;margin-bottom: -10px"> <div style="flex: 6; text-align: center;"> <img src="/images/er1.png" alt="er图1" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 6; text-align: center;"> <img src="/images/er2.png" alt="er图2" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 6; text-align: center;"> <img src="/images/er3.png" alt="er图3" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

EE-R模型

扩展(Extended)E-R模型

ISA联系：不相交 & 完全特化
Part-of联系 双菱形

弱实体：双矩形。自己的属性不一定能独立区分自己（有不同贷款但可能在同一天还款、金额也可能一样）

基数约束表示：min（强制参与/非强制参与）..max（单值参与/多值参与） <br>对联系R来说，当前实体可以对应多少个另一个实体

标法	含义
`0..1`	可以不参与；如果参与，最多一次
`1..1`	必须参与；且只能一次
`0..*`	可以不参与；也可以参与很多次
`1..*`	必须至少参与一次；可以参与很多次

为什么引入：消除歧义

属性的划分

类型	含义	实例
标识符	唯一标识一个实体的属性	学生的学号、职工的工号
描述符	普通描述属性，不能唯一识别实体	姓名、性别、年龄
单值属性	一个实体在这个属性上只有一个值	学生的学号、学生的姓名
组合属性	本身是一个属性，但内部由多个简单属性组成	地址 = 省 + 市 + 区 + 街道
多值属性	一个实体在这个属性上可以有多个值	一个学生可以有多个兴趣爱好

组合属性 / 多值属性 <div style="display: flex; width: 120%; margin-left: 0; margin-top: -20px;margin-bottom: -10px"> <div style="flex: 6; text-align: center;"> <img src="/images/zuheshux.png" alt="组合属性的子属性表示" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 6; text-align: center;"> <img src="/images/duozhishux1.png" alt="多值属性的双线桥表示" style="width: 100%; max-width: 600px; height: auto;"> </div> <div style="flex: 6; text-align: center;"> <img src="/images/duozhishux2.png" alt="多值属性的基数约束表示" style="width: 100%; max-width: 600px; height: auto;"> </div> </div> -->

E-R模型设计原则

i、实体 or 属性

原则：能作为属性处理的，尽量作为属性处理，以简化 E-R 图
两条判断准则：
- 如果某个对象本身还需要描述其他性质，应作为实体
- 如果某个对象还要和其他实体发生联系，应作为实体
例 <div style="display: flex; width: 80%; margin-left: 0; margin-top: -40px;margin-bottom: -20px"> <div style="flex: 6; text-align: center;"> <img src="/images/image-76.png" alt="数据库的设计" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

ii、实体 or 联系

实体：可以独立存在的持久对象
- 例：学生、课程、商品、顾客、订单
联系：因为某种事情发生而产生的信息，通常依赖多个实体
- 例：学生选课、顾客购买商品、教师讲授课程
有些事件也可以被设计成实体
- 例：订单
  - 如果只是简单零售购买行为。
    若购买动作有属性（购买时间、购买数量等），这些信息<u>只在购买发生时才存在</u>，不能直接放在顾客/商品上 → 属于联系属性购买[时间、数量] 顾客 —— 购买（时间，数量） —— 商品
  - 如果大量购买，订单有订单号、时间、金额、状态等属性，应把订单作为实体 顾客 —— 下达 —— 订单；订单 —— 包含 —— 订单明细

iii、二元联系 or 多元联系

二元联系：两个实体之间的联系
- 例： 学生 —— 选修 —— 课程
多元联系：三个或更多实体之间的联系
- 例：供应商给某项目供应某零件 <br>联系上可以有属性：供应量、供应日期、价格 供应商 —— 供应 —— 项目 —— 零件

iv、属性依附于实体 or 联系

实体属性：实体本身具有的属性
- 例： 学生姓名属于学生；课程学分属于课程
联系属性：跟随联系存在而存在，消亡而消亡的属性
- 例： 学生 —— 选修(成绩, 选课时间) —— 课程

E-R图集成

处理冲突：命名冲突、属性冲突、结构冲突
消除冗余：冗余数据可由基本数据推出，冗余联系可由其他联系推出（适当保留提高效率）

3. 逻辑结构设计

逻辑结构设计：把 E-R 图翻译成关系表
实体集 & 属性 → 表
1. 规则1：实体集转换为关系模式
  - E-R图中有实体：科室、医生、病人、病例 <br>→ 科室表、医生表、病人表、病例表
  - E-R图中有实体：医生，有属性：医生号，姓名，职称 <br>→ 医生（<u>医生号</u>，姓名，职称）
2. 规则2：组合属性拆成子属性
  - 不写emp_address，而是子属性（staddress、city、state、zipcode 要么全为空，要么全不为空）
3. 规则3：多值属性拆成新表
  - 对于学号S1307，姓名王承志，选修课程（Database, Operating System, Computer Network）
  - 方法一：纵向展开；方法二：分解出去，单独成表

联系转换 & 全参与/非全参与

补充：实体集与联系的全参与/非全参与

1:1联系转换

1:1 联系可以单独建表，也可以合并到任意一端（要考虑是否全参与）

规则

参与情况	建表方式	例子
两边非全参与（0..1/0..1）	联系单独建表	电单车—电池
一边全参与(1..1)，一边非全参与(0..1)	依赖存在方+依赖的主码	人—驾驶证
两边全参与(1..1/1..1)	联系和实体合并成一个表	学生—校园卡

例：非全参与、非全参与（分开单独建表） <div style="display: flex; width: 100%; margin-left: 0; margin-top: -40px;margin-bottom: -20px"> <div style="flex: 6; text-align: center;"> <img src="/images/image-94.png" alt="数据库的设计" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>
例：全参与、非全参与（依赖存在的全参与端驾驶证要加上依赖存在的人的主码） <div style="display: flex; width: 100%; margin-left: 0; margin-top: -40px;margin-bottom: -20px"> <div style="flex: 6; text-align: center;"> <img src="/images/image-95.png" alt="数据库的设计" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>
例：全参与、全参与（合并） <div style="display: flex; width: 100%; margin-left: 0; margin-top: -40px;margin-bottom: -10px"> <div style="flex: 6; text-align: center;"> <img src="/images/image-96.png" alt="数据库的设计" style="width: 100%; max-width: 600px; height: auto;"> </div> </div>

1:n联系转换
- 1:n 联系通常把 1 端的主码加入到 n 端作为外码
- 多端全参与：多方加上外码
- 多端非全参与：3张表
m:n联系转换

建3张表
例：病人去医生那就诊（一个医生有多个病人，一个病人也有多个医生）

病人（病人号，姓名）
医生（医生号，姓名）
就诊（病人号，医生号，就诊时间，就诊记录）

多元联系转换
- 实体建表之外，多元联系也建一个表
- 例：供应商向项目供应零件（E-R图中E-R 图：供应商 —— 供应 —— 项目 —— 零件） <br>某供应商给某项目供应某零件，供应量是多少。
```
供应商(供应商号, 供应商名)
项目(项目号, 项目名)
零件(零件号, 零件名)

供应(供应商号, 项目号, 零件号, 供应量)
```
单个实体集内部的联系转换
- 例：职工之间存在领导关系 <br>这里“领导职工号”也是职工号，表示该职工的上级（1：1）
```
职工(职工号, 姓名, 领导职工号)
```
- 如果是 m:n 的内部关系，需要新建关系
```
 职工(职工号, 姓名)
 合作(职工号1, 职工号2, 项目名)
```
- 例：一个职工可以管理多个下级职工、一个职工只能有一个上级职工
ISA联系转换（父子类）
- 方法一：建3个表（不相交 + 部分特化） <br>建学生（），教师（），职工（），硕导（），博导（）
- 方法二：只建2个子表（不相交 + 完全特化II）
- 方法三：建1个表

具有相同码的关系模式合并
1. 如果两个关系模式具有相同主码，且语义上属于同一对象，可以考虑合并
2. 例：
```
学生基本信息(学号, 姓名, 性别)
学生学籍信息(学号, 专业, 入学年份)
```
可以合并为：学生(学号, 姓名, 性别, 专业, 入学年份)

数据模型优化

数据模型优化通常用规范化理论作指导
目标：
- 减少数据冗余（拆成多个表）
- 避免更新异常
- 避免插入异常
- 避免删除异常
- 提高数据一致性
分解方法：水平分解（分行：分成23级学生、24级学生）、垂直分解（分列：分成学生基本信息+联系方式）
设计用户子模式（视图）
- 视图作用： <br>简化用户操作； <br>满足不同用户需求； <br>隐藏敏感数据，保证安全性； <br>封装复杂查询。

物理结构设计

物理结构设计：为逻辑数据结构选择最适合应用环境的物理结构
常见的存取方法

方法适合场景

B+ 树索引 范围查询/连接/排序/最值

Hash 索引 等值查询/连接

聚簇存取 经常按某属性集中访问的数据

方法	适合场景
B+ 树索引	范围查询/连接/排序/最值
Hash 索引	等值查询/连接
聚簇存取	经常按某属性集中访问的数据

数据库实施

⭐C8 数据库编程

SQL语言的三种使用方式：交互式SQL(可独立运行)、嵌入式SQL(主语言+ESQL)、过程化SQL

嵌入式SQL

嵌入式SQL是将SQL语句嵌入程序设计语言中，被嵌入的程序设计语言称为 (宿)主语言。如Java、C++

格式

前缀 EXEC SQL 后缀 ; into获取结果元组值前缀 : 来区分主变量

EXEC SQL select Sno, Sname, Sage
    into :hsno, :hsname, :hsage -- 输出主变量（由SQL语句对其赋值/设置状态信息，返回给应用程序）
    from Student
    where Sno = :givensno ; -- 输入主变量（由应用程序对其赋值，在SQL语句引用）
    -- 根据程序传入的学号，从 Student 表查询单个学生的学号、姓名、年龄，并把结果存入主变量

SQL通信区（SQLCA）
SQL语句执行后，数据库系统需要反馈给应用程序的信息：<u>描述系统当前工作状态</u>、<u>描述运行环境</u> <br>这些信息将送到并保存在SQL通信区中、应用程序从SQL通信区中获取这些状态信息。
- 定义SQLCA <br>用 EXEC SQL INCLUDE SQLCA 定义
- 使用SQLCA <br>SQLCA中有一个用于存放每次执行SQL语句后返回当前SQL语句执行状态的代码变量SQLCODE； <br>每执行完一条SQL语句之后都测试：执行成功返回SUCCESS（0），否则表示出错或异常。 SQLCODE的值，以了解该SQL语句执行情况并做相应处理。

主变量

嵌入式SQL语句中可以使用的主语言程序变量

指示变量 <br>是一个整型变量，是一种特殊的主变量，用来“指示”相关主变量的值是否为空值 <br>指示变量的用途：指示输入主变量是否为空值；检测输出变量是否为空值，值是否被截断

指示变量取值	含义
0	主变量正常接收到了非空的数据库值
> 0	数据库字符串被截断，只存了部分到主变量
-1	数据库值是NULL，主变量里的值无意义

例：查询返回的Grade属性值是否为NULL/根据课程号把该课程的成绩都置为空。

EXEC SQL SELECT Sno, Cno, Grade
    INTO :Hsno, :Hcno, :Hgrade :Gradeid 
    -- 多一个:Gradeid。:Hgrade 是接收成绩的主变量，:Gradeid 就是它的指示变量
    FROM SC
    WHERE Sno = :givensno AND Cno = :givencno;
-- 如果数据库里 Grade 不是空值 → Gradeid = 0，可以直接用 Hgrade 的值
-- 如果数据库里 Grade 是 NULL → Gradeid = -1，说明 Hgrade 里的值是无效的，不能直接用

gra_ind = -1 ;  -- 要把数据库里的值改成 NULL
EXEC SQL UPDATE SC
    SET Grade = :Hgrade INDICATOR :gra_ind 
    -- 把 Grade 字段的值设置成 :Hgrade，但要首先参考指示变量 gra_ind
    -- 数据库会忽略 :Hgrade 里的数字，直接把 Grade 设为 NULL
    WHERE cno = :givencno; -- 根据学号查找

为了使用主语言变量，必须首先在DECLARE SECTION部分声明这些变量 <br>Why? 编译时类型检查、预先申请内存空间。只有在declare section中定义的主语言变量才能被用在ESQL中

exec sql begin declare section; -- 主变量声明开始
char hsno[10]，givensno[10], hsname[21];
int hsage;
exec sql end declare section; -- 主变量生声明结束

EXEC SQL select Sno, Sname, Sage
into :hsno, :hsname, :hsage
from Student
where Sno = :givensno ; --根据学号查询学号、姓名、年龄

⭐游标 Cursor
游标是系统为用户开设的一个数据缓冲区，用于存放SQL查询的执行结果。解决SQL批量返回数据、主语言单条处理之间的矛盾
- 声明游标 EXEC SQL DECLARE 游标名 CURSOR FOR 查询语句;
- 打开游标 EXEC SQL OPEN 游标名;
- 提取数据 EXEC SQL FETCH 游标名 INTO 主变量;
- 关闭游标 EXEC SQL CLOSE 游标名;
过程

建立/关闭数据库连接

EXEC SQL CONNECT TO target [AS 连接名] [USER 用户名]; -- 建立连接
EXEC SQL SET CONNECTION 连接名 | DEFAULT; -- 切换连接
EXEC SQL DISCONNECT 连接名 | DEFAULT; -- 关闭连接

例依次检查某个系的学生记录，交互式更新某些学生年龄。

EXEC SQL BEGIN DECLARE SECTION; /*主变量声明开始*/
    char Deptname[21];
    char Hsno[10];
    char Hsname[21];
    char Hssex[3];
    int HSage;
    int NEWAGE;
EXEC SQL END DECLARE SECTION; /*主变量声明结束*/

long SQLCODE;
EXEC SQL INCLUDE SQLCA; /*定义SQL通信区*/

#include <sqlca.h>

int main(void) /*C语言主程序开始*/
{
    int count = 0;
    char yn; /*变量yn代表yes或no*/
    printf("Please choose the department name(CS/MA/IS): ");
    scanf("%s",deptname); /*为主变量deptname赋值*/
    EXEC SQL CONNECT TO TEST@localhost:54321 USER "SYSTEM"/"MANAGER"; /*连接数据库TEST*/
    -- 我现在要登录连接到数据库，数据库地址是本机，端口是 54321，数据库名字叫 TEST，登录账号是 SYSTEM，密码是 MANAGER
    EXEC SQL DECLARE SX CURSOR FOR /*定义游标SX*/
        SELECT Sno,Sname,Ssex,Sage /*游标SX对应的查询语句*/
        FROM Student
        WHERE SDept = :deptname;
    EXEC SQL OPEN SX;
/*打开游标SX，执行游标对应的查询，并指向查询结果的第一行*/

    for (;;) -- 循环读取游标里的每一条数据，直到游标读完 / 出错时退出
    {
        /* 推进游标，将当前数据放入主变量 */
        EXEC SQL FETCH SX INTO :Hsno, :Hsname, :Hssex, :HSage;
        if (sqlca.sqlcode != 0) { -- 操作不成功时退出
            break;
        }

        /* 是第一行的话，打印表头和学生信息 */
        if (count++ == 0) {
            printf("\n%-10s %-20s %-10s %-10s\n", "Sno", "Sname", "Ssex", "Sage");
        }

        /* 打印当前学生信息 */
        printf("%-10s %-20s %-10s %-10d\n", Hsno, Hsname, Hssex, HSage);

        /* 询问用户是否要更新该学生的年龄 */
        printf("UPDATE AGE(y/n)? ");
        do {
            scanf("%c", &yn);
            -- getchar();  --吃掉多余的换行符
        } while (yn != 'N' && yn != 'n' && yn != 'Y' && yn != 'y');
        -- 强制让用户必须输入 Y/y/ N/n 才往下走，输错就一直重新输

        /* 如果选择更新操作 */
        if (yn == 'y' || yn == 'Y') {
            printf("INPUT NEW AGE: ");
            scanf("%d", &NEWAGE);
            getchar();

            /* 嵌入式SQL更新语句*/
            EXEC SQL UPDATE Student
                SET Sage = :NEWAGE  -- Sage更新为读入的NWEAGE
                WHERE CURRENT OF SX;
        } /* 对当前游标指向的学生年龄进行更新 */
    }

    /* 收尾 */
    EXEC SQL CLOSE SX; -- 关闭游标SX，不再和查询结果对应
    EXEC SQL COMMIT WORK; -- 提交更新
    EXEC SQL DISCONNECT TEST; -- 断开数据库连接
} -- 只在 EXEC SQL FETCH SX INTO 语句之后检查了状态码 SQLCA.SQLCODE
-- 在其他嵌入式SQL语句之后，都没有检查SQL语句的执行状态码！
-- Solution：添加异常处理👇

异常处理

whenever是嵌入式SQL的全局异常捕获机制
```
EXEC SQL WHENEVER 条件 动作;
```
预编译器在处理过程中，会根据WHENEVER语句的定义，在每一条嵌入式SQL语句之后添加下面的异常状态检查命令： if ( condition ) { action }
常见执行异常 <br>SQLERROR、NOT FOUND、SQLWARNING
处理方法 CONTINUE、GOTO、STOP、DO function | BREAK | CONTINUE

例

exec sql whenever sqlerror goto report_error ;
exec sql whenever not found goto notfound ;

不用游标的SQL语句

说明性语句、数据定义 / 控制语句

-- 1. 主变量声明（必须用固定段包裹）
EXEC SQL BEGIN DECLARE SECTION;
    char givensno[10];  
    char hsno[10], hsname[21];  
EXEC SQL END DECLARE SECTION;

-- 2. 定义SQL通信区（获取SQL执行状态）
EXEC SQL INCLUDE SQLCA;

-- 3. 异常处理声明（出错跳转、无数据跳转）
EXEC SQL WHENEVER SQLERROR GOTO error_handle;  
EXEC SQL WHENEVER NOT FOUND GOTO no_    data;  

-- 创建学生表 CREATE
EXEC SQL CREATE TABLE Student (
    Sno CHAR(9) PRIMARY KEY,   
    Sname CHAR(20) NOT NULL,    
    Sage SMALLINT,              
    Sdept CHAR(20)             
);   
--删除表DROP
EXEC SQL DROP TABLE TEST;
-- 修改ALTER:为Student表添加手机号字段
EXEC SQL ALTER TABLE Student ADD Sphone CHAR(11); 

-- 授权：给用户user1授予Student表的查询、修改权限
EXEC SQL GRANT SELECT, UPDATE ON Student TO user1;
-- 回收user1对Student表的修改权限
EXEC SQL REVOKE UPDATE ON Student FROM user1;
-- 事务控制：提交数据库更新（如增删改）
EXEC SQL COMMIT WORK;

单条结果查询：SELECT ... INTO ...

EXEC SQL SELECT Sno,Cno,Grade
    INTO :Hsno, :Hname, :Hcno, :Hgrade, :Gradeid /* 指示变量Gradeid */
    FROM SC
    WHERE Sno = :givensno AND Cno = :givencno;
if(Gradeid < 0){ 
  ……    -- 学生givensno在课程givencno上的成绩为空值
}else{ 
  …… 
}

普通增删改（非 CURRENT 形式的 INSERT、DELETE、UPDATE） <br>增：某个学生新选修了某门课程，将有关记录插入SC表中。假设插入的学号已赋给主变量stdno，课程号已赋给主变量couno。
```
gradeid = −1； /* gradeid为指示变量 */
EXEC SQL INSERT
INTO SC(Sno, Cno, Grade)
VALUES(:stdno, :couno, :gr :gradeid);
```

使用游标的SQL语句

使用语句多条结果的 SELECT 查询、CURRENT 形式的 UPDATE/DELETE 语句
游标(Cursor)的使用操作
1. 声明游标 EXEC SQL DECLARE 游标名 CURSOR FOR 查询语句;
2. 打开游标 EXEC SQL OPEN 游标名;
3. 提取数据 EXEC SQL FETCH 游标名 INTO 主变量;
4. 关闭游标 EXEC SQL CLOSE 游标名;

可滚动游标 SCROLL

-- 加SCROLL
EXEC SQL DECLARE agent_dollars SCROLL CURSOR FOR
SELECT aid, sum(dollars)
FROM orders
WHERE cid = :cust_id
GROUP BY aid;

EXEC SQL OPEN agent_dollars;

EXEC SQL FETCH FIRST agent_dollars INTO :agent_id,:dollar_sum;
EXEC SQL FETCH LAST agent_dollars INTO :agent_id,:dollar_sum;
EXEC SQL FETCH PRIOR agent_dollars INTO :agent_id,:dollar_sum; -- 上一个
EXEC SQL FETCH NEXT agent_dollars INTO :agent_id,:dollar_sum; -- 下一个

例

EXEC SQL INCLUDE SQLCA; --定义SQL状态区
-- 声明主变量
EXEC SQL BEGIN DECLARE SECTION;
    char cust_id[10];   
    char agent_id[10];  
    float dollar_sum; 
EXEC SQL END DECLARE SECTION;

-- 声明异常处理（必须写在最前面！）
EXEC SQL WHENEVER NOT FOUND GOTO finish;  

/* 声明游标 agent_dollars */
EXEC SQL DECLARE agent_dollars CURSOR FOR
    SELECT aid,sum(dollars)
    FROM orders
    WHERE cid=:cust_id
    GROUP BY aid;
/* 打开游标 */
EXEC SQL OPEN agent_dollars;
/* 提取数据 */
while (TRUE) { 
    EXEC SQL FETCH agent_dollars INTO :agent_id, :dollar_sum;
    -- 推动游标指针至下一条记录，同时将当前记录取出来送至主变量
    printf("%s %11.2f\n", agent_id, dollar_sum);
}
/* 关闭游标 */
finish: EXEC SQL CLOSE agent_dollars;

CURRENT 形式的 UPDATE/DELETE 语句

需要对查询结果集做差异化修改（如有的行改、有的不改、有的改的数值不同），而不是批量UPDATE/DELETE WHERE CURRENT OF 游标名

EXEC SQL DECLARE SX CURSOR FOR
    SELECT Sno,Sname,Ssex,Sage
    FROM Student
    WHERE Sdept=:deptname;
EXEC SQL OPEN SX;
for(;;){
    EXEC SQL FETCH SX INTO :HSno,:Hname,:HSsex,:HSage;
    if (SQLCA.SQLCODE != 0) break; -- 操作不成功，则退出循环
    ……
    EXEC SQL UPDATE Student
        SET Sage=:NEWAGE
        WHERE CURRENT OF SX;  -- 只对当前游标指向的一行记录
    ……
}
EXEC SQL CLOSE SX;

动态SQL

使用SQL语句主变量 <br>程序主变量包含的内容是SQL语句的内容**

EXEC SQL BEGIN DECLARE SECTION;
    const char *stmt = "CREATE TABLE test(a int);";
    -- 定义了一个字符串指针变量stmt，内容是一条完整的 SQL 语句文本
    -- CREATE TABLE test(a int);（功能是创建一张名为test的表，包含一个int类型的列a）
    const char *stmt = "CREATE TABLE student(sno char(9), sname char(20));";
    -- 或者这么写
EXEC SQL END DECLARE SECTION;
/* 执行动态SQL语句,可以动态创建TABLE   */
EXEC SQL EXECUTE IMMEDIATE :stmt;

动态参数 <br>用？当占位符

执行准备好的语句（EXECUTE）

EXEC SQL BEGIN DECLARE SECTION;
    const char *stmt="INSERT INTO test VALUES(?);";-- 动态参数
EXEC SQL END DECLARE SECTION;
/* 准备语句 */
EXEC SQL PREPARE mystmt FROM :stmt;
/*执行INSERT语句，设定参数为100*/
EXEC SQL EXECUTE mystmt USING 100;

过程化SQL

what？写在数据库中的带编程逻辑的SQL语言，可用于定义触发器、存储过程、存储函数对应的SQL程序块。
过程化SQL vs 嵌入式SQL <br>可独立编程，不再需要区分主变量与 SQL变量 <br>不需要经历从预编译到编译的处理 <br>在数据库服务器内部实现数据交换与处理
常用的两种过程化SQL：Oracle：PL/SQL；SQL Server：T-SQL

过程化SQL的块结构

过程化SQL的基本单位是块 Block

块结构拆解

<u>定义部分(DECLARE)</u> <br>声明局部变量、常量、游标、自定义异常

DECLARE
    v_sname CHAR(20); -- 变量
    v_age CONSTANT INT := 18; -- 常量
    CURSOR c_stu IS SELECT Sname FROM Student; -- 游标
    e_age_too_old EXCEPTION; -- 自定义异常

<u>执行部分(BEGIN…END)</u>

BEGIN
    -- 正常执行的逻辑
    SELECT Sname INTO v_sname FROM Student WHERE Sno = '241880543';
    
    IF v_age > 30 THEN
        RAISE e_age_too_old; -- 抛出自定义异常
    END IF;

EXCEPTION
    WHEN NO_DATA_FOUND THEN
        DBMS_OUTPUT.PUT_LINE('未找到该学生！');
    WHEN e_age_too_old THEN
        DBMS_OUTPUT.PUT_LINE('年龄超过限制！');
    WHEN OTHERS THEN
        DBMS_OUTPUT.PUT_LINE('发生未知错误：' || SQLERRM);
END;

PL/SQL变量和常量的定义

变量定义

基本数据结构 Number、Char、Date、Long、Boolean、Varchar2

注意：

char h_sno[10] = "211210166"; // 对应 char(9)，需 n+1 长度

DECLARE
-- ① 无初值、允许为NULL（PPT里的基础形式）
    v_name VARCHAR2(20); -- 变长字符型，最大为4000个字符/Char 字符型，最大2000个字符

    -- ② 带NOT NULL + 用:=赋值（语法1，严格按PPT）
    v_age NUMBER(3) NOT NULL := 18; 

    -- ③ 带NOT NULL + 用DEFAULT赋值（等价于PPT的语法2，效果和:=完全一致）
    v_score NUMBER NOT NULL DEFAULT 60; 
BEGIN
-- 赋值语句
    v_name := '张三';
END;

常量定义

流程控制

存储过程和函数

前端三件套

Mon, 02 Mar 2026 00:00:00 GMT

HTML
letter-spacing: 2px;
- 样式表
JavaScript

HTML

HTML简介

全称：Hyper Text Markup Language（超文本标记语言）
作用：专门用来搭建网页的结构（骨架），比如文字、图片、按钮、表单、布局等。

了解基本骨架

<!-- 文档声明：告诉浏览器这是HTML5文档 -->
<!DOCTYPE html>
<!-- 网页语言是中文（简体） -->
<html lang="zh-CN">
  <!-- 头部：给浏览器看的配置，不显示在页面上 -->
  <head>
    <meta charset="UTF-8">
    <!-- 设置网页字符编码为 UTF-8，保证中文不乱码 -->
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <!-- 网页适配手机，宽度跟随设备宽度，初始缩放比例 1:1 -->
    <title>我的第一个网页</title>
    <!-- 显示在浏览器标签栏上-->
  </head>

  <!-- 身体：页面所有可见内容都写在这里 -->
  <body>
    网页的文字、图片、按钮都在这里！
  </body>
</html>

<table border="1" width="400"> <!-- border=1 加边框，宽度width -->
  <tr>    <!-- 第一行：表头 -->
    <th>姓名</th>
    <th>年龄</th>
    <th>城市</th>
  </tr>

  <tr>     <!-- 第二行 -->
    <td>张三</td>
    <td>20</td>
    <td>北京</td>
  </tr>

  <tr>    <!-- 第三行 -->
    <td>李四</td>
    <td>22</td>
    <td>上海</td>
  </tr>
</table>

合并单元格 rowspan/colspan="x"

 <table border="1">
   <tr>
     <th colspan="2">学生信息</th> <!-- 合并2列 -->
   </tr>
   <tr>
     <td rowspan="2">张三</td> <!-- 合并2行 -->
     <td>20岁</td>
   </tr>
   <tr>
     <!-- 这里原本应该有<td>，但被合并了，所以删掉！ -->
     <td>男</td>
   </tr>
 </table>

表单标签

<!-- 文本框 -->
<input type="text" placeholder="请输入用户名">
<!-- 密码框 -->
<input type="password" placeholder="请输入密码">
<!-- 单选框 -->
<input type="radio" name="gender"> 男
<input type="radio" name="gender"> 女
<!-- 复选框 -->
<input type="checkbox"> 看书
<!-- 提交按钮 -->
<input type="submit" value="登录">
<!-- 普通按钮 -->
<input type="button" value="点击">

下拉菜单 <select> + <option>

<select>
  <option>北京</option>
  <option selected>上海</option>     <!-- 默认选中 -->
  <option>广州</option>
  <option>深圳</option>
</select>

转义字符

空格	&nbsp;
<	&lt;
>	&gt;
&	&amp;
人民币	&yen;
版权	&copy;

CSS

css 简介

CSS 是层叠样式表(Cascading Style Sheets)的简称。 <br>CSS 主要用于设置HTML页面中的文本内容、图片外形以及版面的布局和外观显示样式。

选择器

标签选择器

h3 {
    color: pink;
    font-size: 20px;
}

id选择器
```
#d {
   color: darkblue;   
}
```

类选择器

基本写法

.c {
   color: pink;
}

<div class="c"> 粉色 </div>

多类名选择器 <br>无空格：同时选中 <u>c1、c2</u>，优先级更高，会覆盖单个类名选择器
```
<div class="c1 c2"> 多类名选择器 </div>  /* 有空格 */
```
```
.c1.c2{   /* 无空格 */
  color: blue;
}
```
后代选择器 <br>选中 c1 里的子元素 <u>c2</u>
```
.c1 .c2{
  color: yellow;
}
```

通配符选择器 <br>给所有的元素使用样式
```
* {
  margin: 0;
  padding: 0;
}
```

字体属性

body{font: italic bold 20px/1.5 "Microsoft YaHei";} 
/* 字体格式 字体粗细 字体大小/一行文字高度 “字体” */

font-style	font-weight	font-size	line-height	font-family
italic 斜体/normal	字体粗细 normal(400)/bold(700)	字体大小 20px	一行文字所占的高度	字体

文本属性

文字颜色

预定义的颜色值十六进制 RGB代码

blue/red… #ff0000 rgb{255,0,0}/rgb{100%,0%,0%}

预定义的颜色值	十六进制	RGB代码
blue/red…	#ff0000	rgb{255,0,0}/rgb{100%,0%,0%}

水平对齐

p{
   text-align: left;
   text-align: center;
   text-align: right;
}

文本装饰 text-decoration

默认下划线上划线删除线

none underline overline line-through
文本缩进 <br>text-indent： 2em; <br>em 是一个相对单位，就是当前元素（font-size) 1 个文字的大小, 如果当前元素没有设置大小，则会按照父元素的 1 个文字大小。
行间距 line-height line-height: 1.5; line-height: 30px;
字间距 letter-spacing letter-spacing: 2px;

默认	下划线	上划线	删除线
none	underline	overline	line-through

样式表

行内样式表 <br>写在标签里

<div style="color:red; font-size:20px;">我是红色文字</div>

内部样式表 <br>写在 head 里

<head>
  <style>
    div {
      color: blue;
      font-size: 20px;
    }
  </style>
</head>

外部样式表新建 style.css，在HTML中引入，放在head

<link rel="stylesheet" href="style.css">
/* rell=引入的是stylesheet样式表;href=引入的css文件路径*/

JavaScript

移动网络新技术

Sun, 01 Mar 2026 00:00:00 GMT

点对点通信Point to Point comm
协议 Protocol
1. Protocols in ISO
  1. 第四层（TCP、UDP）
    1. TCP（Transmission Control Protocol）先在源地址-目的地址之间建立联系；丢包则重传。流量控制；拥堵时放慢速度。（准确性）
    2. UDP（User Datagram Protocol）没有上述功能，eg：语音/视频。（时效性）
2. 地址 address
  1. IP查找硬件设备（用以太网的服务，给上层的 TCP 提供服务）
  2. 端口号查找软件
复用技术
1. 四维复用技术:时间、空间、频率、码字
2. 信道共享方法
  - 频分复用
  - 时分复用
  - 时频空复用
  - 码分复用
蜂窝网络
- fluster & 频率复用距离

VOIP

Jitter抖动的影响：buffer 大，会带来大的时延，但是能承受大的抖动，需要买昂贵的网络资源。端系统-网络共同占有
Loss丢包的影响：人耳20ms内反应不过来，若丢包过大，不能用replay解决。
- 单包丢失时：PLC 可以通过插值 / 重放前一帧音频来掩盖，人耳几乎听不出损伤。
- 连续 2 包及以上丢失时：PLC 无法有效掩盖，才会产生可感知的 “可听失真（audible impairment）”。
BER（bit error rate） / PER\PLR（Packet error rate）
视频/音频编码/流媒体传输领域的核心标准化组织：MPEG/ITU-T

MPEG 视频编码与帧类型

MPEG 编码器的核心思想是利用视频帧间的时间冗余进行高效压缩

三种 MPEG 帧类型

帧类型	参考依赖	压缩率	数据量占比（相对 I-Frame）	核心作用
I-Frame	无（独立）	最低	100%	解码基准、随机访问、错误恢复
P-Frame	前向（I/P）	中等	10%~30%	时间冗余压缩
B-Frame	双向（I/P/B）	最高	5%~15%	极致时间冗余压缩

1. I-Frame（Intra Frame，帧内编码帧）定义：包含完整的视频帧数据，编码时不依赖任何其他帧，完全独立编码。作用：作为解码的基准参考点，是流中随机访问（跳播）和错误恢复的关键。新接入的解码器必须从 I-Frame 开始才能正确解码后续内容。特点：数据量最大，压缩率最低。
2. P-Frame（Predictive Frame，预测编码帧）定义：基于之前的 I-Frame 或 P-Frame，通过运动补偿预测当前帧内容，仅传输预测误差和运动向量。作用：相比 I-Frame 实现更高压缩率，通常仅为对应 I-Frame 大小的 10%~30%。依赖关系：必须依赖前面的参考帧，无法独立解码。
3. B-Frame（Bidirectional Frame，双向预测编码帧）定义：同时参考前后的 I-Frame 或 P-Frame，通过双向运动补偿进行预测，仅传输差异数据。作用：压缩率最高，通常仅为对应 I-Frame 大小的 5%~15%。依赖关系：依赖前后帧，解码顺序与播放顺序不一致，需要更多缓存。
压缩本质：MPEG 压缩的核心是消除帧间时间冗余，通过预测编码只传输变化部分。 I-Frame 是基础：没有 I-Frame 就无法解码后续的 P/B 帧，同时 I-Frame 保证了视频流的可跳转性和抗误码能力。 P/B 帧提升效率：P/B 帧通过运动补偿大幅降低数据量，是实现高压缩比的关键，但也带来了帧间依赖和解码复杂度。典型应用：在流媒体场景中，I-Frame 间隔通常为几秒（如 2~10 秒），中间插入大量 P/B 帧，平衡压缩效率和播放体验。

GOP（Group of Pictures）视频帧会被组织成GOP（图像组），是一个以 I-Frame 开头、包含若干 P/B 帧的连续序列。例：示例：15 帧、P 间隔为 3 的 15/3 GOP 结构： B₁ B₂ I₃ B₄ B₅ P₆ B₇ B₈ P₉ B₁₀ B₁₁ P₁₂ B₁₃ B₁₄ P₁₅ <br>与 VoIP 的关键差异 VoIP：编解码器实现定义非常严格，格式固定。流媒体视频：即使是同一种 MPEG 编码，也存在大量编码方式与 GOP 结构变体。 GOP 结构的重要性：具体的 GOP 结构会显著影响网络丢包、延迟、吞吐量对接收端视频播放效果的冲击，是流媒体 QoS 优化的关键变量。
TCP 表格对比维度 TCP (Transmission Control Protocol) UDP (User Datagram Protocol) 连接特性面向连接，通信前需通过三次握手建立连接，结束后通过四次挥手释放连接无连接，发送前无需建立连接，直接封装数据报发送可靠性可靠传输：保证数据不丢失、不重复、按序到达，丢包会自动重传不可靠传输：不保证数据到达，不处理丢包、乱序或重复头部开销头部最小 20 字节，最多 60 字节（含选项字段）头部固定 8 字节，开销极小流量 / 拥塞控制内置流量控制（滑动窗口）和拥塞控制算法，避免网络过载无任何流量 / 拥塞控制，发送速率由应用层决定延迟表现延迟较高（连接建立、重传、排序等机制带来额外开销）延迟极低，无连接和重传机制，适合实时场景数据单位数据单位为段（Segment），受 MSS 限制数据单位为数据报（Datagram），受 MTU 限制典型应用场景文件传输、网页浏览（HTTP/HTTPS）、电子邮件、远程登录实时音视频通话、直播、在线游戏、DNS 查询、流媒体

QoS机制

buffer 缓冲区

缓冲大小
1. RFC 2429：C = 10 Gbps link: 2.5 Gbit buffer
2. N条流时。$buffer = RTT\times \frac{C}{}$

笔者的读书笔记

Sun, 01 Mar 2026 00:00:00 GMT

2025年

July ~ August 《窄门》
September 《月亮与六便士》

2026年

Jan. ~ March 《呼兰河传》
March ~ April 《人鼠之间》
《霍乱时期的爱情》

python

Sat, 28 Feb 2026 00:00:00 GMT

python基础
模块
类 & 方法
- 继承
- 属性封装&property

python基础

注释

#/三引号"""……""" 多行注释

字符串与字符串连接

字符串连接 +
```
print("Hello"+"World"+"!")
```

双单引号转义

 print('He said "good!"') # 单引号包裹 He said "good"
 print("He said 'good!'") # 双引号包裹 He said 'good'
 print("He said \"Let's go!\"") # 转义符 He said "Let's go!"

三引号跨行字符串自换行
```
print("""Hello
World""")
```

常用方法

 s = "hello"
 s.upper()    # 转大写 HELLO
 s.lower()    # 转小写
 s.strip()    # 去掉首尾空格
 s.replace("h", "H")  # 替换
 s.split(",") # 按符号分割成列表

格式化字符串

format()

print("My name is {0},I'm {1} years old".format("Liz", 19))
 print("My name is {name},I'm {age} years old".format(name="Liz", age=19))
 name = "Yuzy"
 age = 20
 print(f"My name is {name},I'm {age} years old")

f-字符串

数据类型

字符串 str

len("Hello") # 5
len("哟! ") # 2
len("\n") # 1

整型 int、浮点数 float

grade =93.546
 print("Your grade is: " + f"{grade:.2f}") # Your grade is: 93.55

布尔类型
type 输出数据类型

输入 input

user_name = str(input("请输入用户名："))

条件判断语句

grade = int(input("please input your grade: "))
if grade >= 90:
    print("A")
elif grade >= 80:
    print("B")
elif grade >= 65:
    print("C")
else:
    print("D")

循环语句

constants = ("Alice", "Bob", "Charlie", "David", "Eve")
for contant in constants:
    print(contant)

for i in range(5,10):  # [5,10)
    print(i)
for i in range(5,10,2):  # 5 7 9 步长为2
    print(i)
    
i = 0
while i <len(constants):
    print(constants[i])
    i += 1

逻辑运算

x = int(input("Enter a number: "))
print(not(x>5 and x<10)) # 6 -False;2 - True

列表 List

有序、可重复、可扩展

shopping_list = ["milk", "eggs", "bread"]
shopping_list.append("bread") # ['milk', 'eggs', 'bread', 'bread']
shopping_list.remove("eggs") # ['milk', 'bread', 'bread']
len(shopping_list) # 3
print(shopping_list[1]) # eggs
print(shopping_list[0:2]) # ['milk', 'eggs']
print(shopping_list[0:2]) # ['milk', 'eggs']
shopping_list.insert(1, 15)  # 指定位置插入
shopping_list.pop()          # 删除最后一个
shopping_list.pop(0)         # 删除指定索引
shopping_list.clear()        # 清空
shopping_list.sort()         # 对于int排序
shopping_list.reverse()      # 反转
print(shopping_list)         # []

元组 Tuple

有序、可重复、不可扩展，当作键使用

example_tuple = ("keyboard", "mouse", "monitor")
example_tuple.append("printer")  # ❌
example_tuple.remove("mouse")  # ❌
# 作为键
contacts = {
    ("Lily",19):"421880110",
    ("Bob",25):"421880111",
    ("Tom",30):"421880112"
}
print(contacts[("Lily",19)])  # 输出：421880110

集合 Set

无序、不可重复、可扩展

names = {"Lily","Rose","Daisy","Iris"}
print("Lily" in names) # True
print(type(names)) # <class 'set'>

字典 {}

键 : 值

contacts ={
    "Alice": "152-555-1234",
    "Bob": "152-555-5678",
}
print(contacts.get("Alice")) # 152-555-1234
print(contacts.get("Charlie")) # None
print(contacts["Alice"]) # Output: 152-555-1234
print("Bob" in contacts) # Output: True
# 删除键值对 del 字典名[键]
del contacts["Alice"]
print(len(contacts)) # Output: 1
# 遍历字典
for name in contacts:
    print(name, contacts[name])
# 所有键
print(contacts.keys()) # Output: dict_keys(['Bob'])
# 所有值    
print(contacts.values()) # Output: dict_values(['152-555-5678'])
# 所有键值对
print(contacts.items()) # Output: dict_items([('Bob', '152-555-5678')])

模块

继承很多功能的函数集合称作模块

# 自定义模块，导入module.py中的函数
import math
print(math.sqrt(16))
# 直接调用，不加模块名
from math import *
print(sqrt(16))
print(math.sqrt(16)) # math 本身没有被导入！NameError: name 'math' is not defined

# 导入内置模块
import random
num = random.randint(1, 100)
print(num)
random_list = [11,22,33,44]
data = random.choice(random_list)
print(data)

# from 模块名 import sqrt
from math import sqrt
print(sqrt(16))

# import 模块名 as 别名
import math as m
print(m.sqrt(16))

类 & 方法

基本语法

class Dog:
 pass

 my_dog = Dog()          # 创建实例（对象）
 print(type(my_dog))     # <class '__main__.Dog'>

初始化方法__init__和实例属性 <br>双下划线：私有属性

class Dog:
    def __init__(self, name, age):
        self.name = name   # 实例属性
        self.age = age

my_dog = Dog("旺财", 3)

魔术方法

class Cat:
    def __init__(self, name):
        self.name = name

    # 魔术方法：控制对象打印结果
    def __str__(self):
        return f"猫咪：{self.name}"

tom = Cat("汤姆")
print(tom)  # 自动执行 __str__，输出：猫咪：汤姆

class Book:
    def __len__(self):
        return 200  # 自定义页数

b = Book()
print(len(b))  # 自动调用 __len__，输出 200

实例方法

 class Dog:
     def __init__(self, name, age):
         self.name = name
         self.age = age

     def get_human_age(self):
         return self.age * 7

 my_dog = Dog("旺财", 3)
 human_age = my_dog.get_human_age()  # 21

类属性 vs 实例属性

class Dog:
    species = "Canis familiaris"   # 类属性

    def __init__(self, name):
        self.name = name            # 实例属性

dog1 = Dog("旺财")
dog2 = Dog("来福")
print(dog1.species)  # Canis familiaris
print(dog2.species)  # Canis familiaris
print(Dog.species)  # 直接通过类名查询：Canis familiaris
Dog.species = "狗"    # 修改类属性会影响所有实例
print(dog1.species)  # 狗

类方法 <br>第一个参数是cls（类本身）

class Dog:
    total_dogs = 0

    def __init__(self, name):
        self.name = name
        Dog.total_dogs += 1

    @classmethod
    def get_total(cls):
        return cls.total_dogs

print(Dog.get_total())  # 0
d1 = Dog("旺财")
d2 = Dog("来福")
print(Dog.get_total())  # 2

静态方法和普通函数的区别是：不能访问实例属性或类属性

class MathUtils:
    @staticmethod
    def add(x, y):
        return x + y

print(MathUtils.add(3, 5))  # 8

继承

基础格式

class Animal:
    ……
class Dog(Animal):
    ……

super()调用父类方法

class Cat(Animal):
 def speak(self):
     super().speak()      # 先调用父类方法
     print("喵喵喵")      # 再添加子类行为

属性封装&property

Python 没有严格的私有属性，但约定以 _ 开头的属性为“保护”的，不应当直接访问。可以使用@property提供 getter/setter。

class Person:
    def __init__(self, name):
        # 私有属性，外部不直接访问
        self._name = name

    # 取值方法：对象.name 自动调用
    @property
    def name(self):
        return self._name

    # 赋值方法：对象.name = 值 自动调用
    @name.setter
    def name(self, val):
        # 简单校验
        if len(val) < 2:
            raise ValueError("名字太短")
        self._name = val

# 使用
p = Person("小明")
print(p.name)     # 调用@property，取值

p.name = "小红"    # 调用setter，赋值
print(p.name)

杂记

Mon, 23 Feb 2026 00:00:00 GMT

Node.js

是什么？ <br>是一个能让JavaScript跑在电脑本地（服务器/Windows电脑上）的运行环境。 <br>浏览器里的JS只能在网页运行，Node.js 让 JS 变成了能直接操作电脑文件、装软件、跑脚本的 后台程序 <br>npm 是 Node.js 自带的软件商店/包管理器，要装的 claude-code 就是发布在 npm 上的一个命令行工具，必须靠 Node.js + npm 来安装。
安装路径的影响为什么这么大？

关于prompt

Java

Wed, 28 Jan 2026 00:00:00 GMT

⭐<a href="https://docs.oracle.com/javase/8/docs/api/" target="_blank">Oracle推出的Java SE文档-核心API</a><br> 重写快捷键：按下 Fn+Alt+Insert / 右键 -> generate -> toString -> OK<br> 看方法的源码：选中方法，按 Ctrl+B

Java语言的特点
数据类型
泛型
关键字
- static
- super
- final
常用类
集合结构体系
- 集合基础
- Collections 工具类
- Collection 接口迭代器
  - List 子接口
    - ArrayList
    - Vector
    - LinkList
  - Set 子接口
    - HashSet
    - TreeSet Comparator接口
- Map集合
  - HashMap
其他类
内部类
JVM

Java语言的特点

面向对象OOP，省略 C中一些难点(eg: 指针)
平台无关性：Java虚拟机 实现，Java软件不受计算机硬件和操作系统的约束
健壮性：Java的 安全检查机制，将许多程序中的错误扼杀在摇篮之中

具备许多保证程序稳定、健壮的特性（强类型机制、异常处理、垃圾的自动收集等），有效地减少了错误
安全性：Java通常被用在网络环境中，为此，Java提供了一个 安全机制 以防恶意代码的攻击
支持多线程：多线程机制使应用程序在同一时间并行执行多项任务，该机制使得程序能够具有更好的交互性、实时性。
编译与解释共存

数据类型

基本数据类型：数值直接存储在栈空间；引用数据类型：引用类型在栈里，对象在堆里(堆中创建对象，存储属性，栈中存储对象的相应地址)

泛型

泛型类

public static class MyGeneric<T> {
    T t;

    public MyGeneric(T t) {
        this.t = t;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

public static void main(String[] args) {
    // 使用String类型的泛型对象
    MyGeneric<String> stringBox = new MyGeneric<>("Hello 泛型");
    String str = stringBox.getT();
    System.out.println(str); // 输出：Hello 泛型

    // 使用Integer类型的泛型对象
    MyGeneric<Integer> intBox = new MyGeneric<>(100);
    Integer num = intBox.getT();
    System.out.println(num); // 输出：100

    // intBox.setT("错误类型"); // 编译失败：不兼容的类型
}

泛型接口

public class code1 {
    public interface MyInterface<T> {
        String name = "ZhangSan";

        T server(T t); //自定义抽象方法
    }

    /* 创建类的时候直接确定类型T */
    public static class MyInterfaceImpl1 implements MyInterface<String> {
        @Override
        public String server(String s) {
            return s;
        }
    }

    /* 之后确定 */
    public static class MyInterfaceIml2<T> implements MyInterface<T> {

        @Override
        public T server(T t) {
            return t;
        }
    }

    public static void main(String[] args) {
        MyInterfaceImpl1 impl = new MyInterfaceImpl1();
        System.out.println(impl.server("Hello"));

        MyInterfaceIml2<Integer> impl2 = new MyInterfaceIml2<>();
        System.out.println(impl2.server(1000));
    }
}

泛型方法

public class MyGenericMethod {
    public <T> T show(T t){
        System.out.println(t);
        return t;
    }//整个方法中可以使用泛型T，作为返回值/参数类型

    public static void main(String[] args) {
        MyGenericMethod myGenericMethod = new MyGenericMethod();
        myGenericMethod.show("String");
        myGenericMethod.show(100);
        //相当于自动重载方法
    }
}

关键字

static

静态变量：<u>静态变量</u> 在内存中只有一个副本，当且仅当在类初次加载时会被初始化；而 <u>非静态变量</u> 是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
静态方法：静态方法可以不依赖于任何对象进行访问（对于静态方法来说，是没有this的），在静态方法中 <u>不能访问类的非静态成员变量/非静态成员方法</u>(因为非静态成员方法变量都是必须依赖具体的对象才能够被调用)；只能调用<u> 静态对象/静态方法</u>

super

<span id="super"></span> super 代表的是 父类对象。<br> 每一个子类的构造方法在没有显示调用 super() <u>系统</u> 都会 <u>提供默认的 super()</u>，super() 必须是构造器的 <u> 第一条语句</u>

final

包装类

<span id="包装类"></span> 基本数据类型所对应的引用类型,在java.lang包中

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

类型转换与装箱/拆箱

int num1 = 19;
// 装箱：基本数据类型/String → 引用数据类型
Integer integer1 = new Integer(num1);//每次调用都创建一个对象
Integer integer2 = Integer.valueOf(num1); //推荐使用，复用[-128~127]常量池对象
// 拆箱：引用数据类型 → 基本数据类型
Integer integer3 = new Integer(100);
int num2 = integer3.intValue();
/*-------------JDK1.5之后，提供自动装箱/拆箱-------------*/
int age = 30;
Integer integer4 = age;// 自动装箱
int age2 = integer4;// 自动拆箱

基本类型 ↔ 字符串

都是 包装类 内的方法，目标类 内的方法<br> int → string String s = String.valueOf(number);<br> string → int int i = Integer.parseInt(s);

/*基本类型转换成字符串*/
int n1 = 100;
String s1 = n1+"";
String s2 = Integer.toString(n1);//toString(n1,16)按照16进制转换/toOctalString(n1)
/*字符串转换成基本类型*/
String str = "150";
int n2 = Integer.parseInt(str);
/*boolean类型 只有"true"才转化成true，其余都是false*/
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);// true
boolean b1 = Boolean.parseBoolean("treu");// false

整数缓冲区

Integer int1 = new Integer(100);
Integer int2 = new Integer(100);
sout(int1 == int2);// false
/*------自动装箱------*/
Integer integer1 = 100;
Integer integer2 = 100;
sout(integer1 == integer2);// true

Integer integer3 = 200;
Integer integer4 = 200;
sout(integer3 == integer4);// false

堆中有-128 ~ 127 之间的对象，在此范围内的数据把地址赋值给栈中，<br> 不在这个范围内的 new Integer(num);创建新对象

Object类

<span id="Object"></span> 基类/超类，是所有类的父类。

getClass() 返回对象类型
hashCode() 返回对象的哈希码
toString() 返回该对象的字符串表示，常在类内重写该方法
obj1.equals(obj2) 比较两个对象的地址是否相等,直接比较两个对象的地址是否完全相同，可以用"=="替代equals;常在类中重写

Objects类

Objects.equals(s1,s2);
Objects.isNull(s1);

Math类

<span id="Math类"></span> 所有方法都是静态的（static修饰），通过类名直接调用

public class MathDemo {
    public static void main(String[] args) {
        //1、public static int abs(int a)	a的绝对值
        System.out.println(Math.abs(88)); //88
        System.out.println(Math.abs(-88)); //88

        //2、public static double ceil(double a)	向上取整
        System.out.println(Math.ceil(12.34)); //13.0
        System.out.println(Math.ceil(12.56)); //13.0

        //3、public static double floor(double a)	向下取整
        System.out.println(Math.floor(12.34)); //12.0
        System.out.println(Math.floor(12.56)); //12.0

        //4、public static long round(double a)	四舍五入取整
        System.out.println(Math.round(12.34)); //12
        System.out.println(Math.round(12.56)); //13

        //5、public static int max(int a,int b)	返回两个数中较大值
        System.out.println(Math.max(66,88)); //88

        //6、public static int min(int a,int b)	返回两个数中较小值
        System.out.println(Math.min(66,88)); //66

        //7、public static double pow(double a,double b)	获取a的b次幂
        System.out.println(Math.pow(2.0,3.0)); //8.0

        //8、public static double random()	返回值为double类型随机数 [0.0~1.0）
        System.out.println(Math.random()); //0.36896250602163483
        System.out.println(Math.random()); //0.3507783145075083
    }
}

Arrays类

    int[] arr = {21,56,15,89,62};
//toString 数组转化为字符串
    System.out.println("排序前："+ Arrays.toString(arr)); //排序前：[21, 56, 15, 89, 62]
//按照指定顺序排序
    Arrays.sort(arr);
    System.out.println("排序后："+Arrays.toString(arr)); //排序后：[15, 21, 56, 62, 89]

String类

字符串是常量，创建之后不可改变；
字符串字面量存储在字符串池中，可以共享。

创建：

String s = "Hello" 产生一个对象，字符串池中存储
String s = new String("Hello") 产生两个对象，~~堆/池中各存储一个~~（实际上是堆中对象指向常量池）

String s1 = new String();
System.out.println("s1:"+s1); //s1:（无内容）

char[] chs = {'a','b','c'};
String s2 = new String(chs);
System.out.println("s2:"+s2); //s2:abc

byte[] bys = {97,98,99}; //对应计算机底层字符
String s3 = new String(bys);
System.out.println("s3:"+s3); //s3:abc

String s4 = "abc";
System.out.println("s4:"+s4); //s4:abc

存储

String name1 = "Hello";
name1 = "zhangsan";//Hello 还存储在常量池中，只是name指向"zhangsan"
String name2 = "zhangsan";
System.out.println(name1 == name2);//true，地址都是"zhangsan"所在的地址

String str1 = new String("Java");
String str2 = new String("Java");
System.out.println(str1 == str2);//false,创建的两个对象都指向池中的"Java"，但是两个对象在堆中的地址不同
System.out.println(str1.equals(str2));//true,比较的是值，而非地址

常用方法

str.length();//字符串长度
str.charAt(0);//第i位字符
str.contains("apple");//是否包含字符串

str.toCharArray();//转化成字符数组
str.indexOf("app");//第一个app的开始下标
str.lastIndexOf("app");//最后一个app的开始下标

str1="  hello world  ";
sout(str1.trim());//去掉前后空格
str1.toUpperCase();//全部转换成大写字母
str1.toLowerCase();//全部转换成小写字母

str.replace('a','c');//把a替换成c
str.replace("Java","php");//替换字符/字符串

String s ="java is the best programing language.";
String[] arr = s.split(" ");//以" "为分割，得到字符串数组

/*正则表达式
s.split("[ ,]");//以空格/,进行分割
s.split("[ ,]+");//空格/,可以出现多个*/

String s1 = "hello";
String s2 = "HELLO";
s1.equals(s2);
s1.equalsIgnoreCase(s2);//忽略大小写 比较大小

String s3 ="abc";
String s4 ="xyz";
String s5 = "abcdef";
sout(s3.compareTo(s4));//第一个不同的字符相差数值（'a'-'x' = -23）
sout(s3.compareTo(s5));//和一个String相同，返回长度差(3-6 = -3)

//substring子字符串
str.substring(1);//第1号位置开始的子字符串

StringBuffer/StringBuilder

<span id="stringbuffer"></span> 一般用 StringBuilder

为什么需要StringBuffer？

String 是不可变的。若执行 str = str + "a", JVM 会 创建新的字符串对象，频繁拼接会产生大量临时对象，效率极低。 <span id="str"></span>

2.StringBuffer 特性：

线程安全：所有方法都加了 synchronized 同步锁，多线程环境下使用不会出现数据错乱（这是它和 StringBuilder 的核心区别）；<br> 可变字符序列：支持增、删、改、插等操作，且操作后对象本身不变；<br> 初始容量/自动扩容：默认初始容量是 16 个字符，当字符数超过容量时，会自动扩容（扩容为原容量 * 2+2）

// 1. 初始容量20
  StringBuffer sb = new StringBuffer(20); 
// 2. 追加 append
  sb.append("Hello");
  sb.append(" ").append("Java"); // 链式编程
  System.out.println("拼接后：" + sb); // 输出：Hello Java

// 3. 插入字符/字符串（insert）
  sb.insert(5, ", World"); // 在索引5的位置插入
  System.out.println("插入后：" + sb); // 输出：Hello, World Java

// 4. 替换(replace)
  sb.replace(0,5,"hi");

// 5. 修改指定索引的字符（setCharAt）
  sb.setCharAt(0, 'h'); // 把第一个字符改为h
  System.out.println("修改后：" + sb); // 输出：hello, World Java

// 6. 删除字符（delete）
  sb.delete(5, 12); // 删除索引5到11的字符（左闭右开）
  System.out.println("删除后：" + sb); // 输出：hello Java

// 7. 反转字符串（reverse）
  sb.reverse();
  System.out.println("反转后：" + sb); // 输出：avaJ olleh

// 8. String 和 StringBuilder 的相互转换
  String finalStr = sb.toString();
  StringBuilder sb1 = new StringBuilder(s1);

BigDecimal类

需要进行 精确运算 时使用 BigDecimal

double d1 = 1.0;
    double d2 = 0.9;
    double d = d1 - d2;
    System.out.println(d);//0.09999999999999998
/*字符串创建*/
    BigDecimal b1 = new BigDecimal("1.0");
    BigDecimal b2 = new BigDecimal("0.9");
    BigDecimal bd1 = b1.subtract(b2); //0.1
    BigDecimal bd2 = b1.add(b2); //1.9
    BigDecimal bd3 = b1.multiply(b2); //0.90
    System.out.println(bd1 + " " + bd2 + " " + bd3);

    BigDecimal r1 = new BigDecimal("1.4").
            subtract((new BigDecimal("0.5"))
            .divide(new BigDecimal("0.9"),2,BigDecimal.ROUND_HALF_UP));
    BigDecimal r2 = new BigDecimal("10").divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);//除不尽，必须加保留几位小数，否则会报错

集合

集合基础

集合与数组的区别数组的容量固定，集合容量可变。数组可以存储基本类型和引用类型，集合只能引用类型
关系

ArrayList 的常用方法

   ArrayList<String> array = new ArrayList<>();

// add 添加到集合末尾
   array.add("hello");
   array.add("word");
// add 指定位置，添加元素
   array.add("2,java"); //[hello, word, java]
// remove 删除指定元素
   System.out.println(array.remove("hello")); //true; 集合变为[word, java]
// set 修改指定索引处的元素，返回被修改的元素
   array.set(1,"javase"); 
// get(index) 返回指定索引处的元素
   array.get(0); //hello
// size 返回元素个数
  array.size();// 3

Collections 方法类

<span id="cls"></span> 集合工具类，定义了除了存取以外的集合常用方法。

List<Integer> list = new ArrayList<>();
    list.add(10);
    list.add(20);
    list.add(17);
    list.add(19);
/* sort排序 */
    Collections.sort(list);
    System.out.println(list.toString());
/* binarySearch */
    int idx = Collections.binarySearch(list, 17);
    System.out.println(idx);
/* copy */
    List<Integer> dest = new ArrayList<>();
    for (int i = 0; i < list.size(); i++) {
        dest.add(null); // 填充null作为占位符
    }//copy方法的不足：要求占位元素和复制元素个数相同
    Collections.copy(dest, list);

    /* 一般用Arrays.addAll(list) */
    List<Integer> dest2 = new ArrayList<>(list.size()); // 指定初始容量优化性能
    dest2.addAll(list);

/* reverse反转 */
    Collections.reverse(list);

/* shuffle打乱 */
    Collections.shuffle(list);

/* list → 数组 */
    Integer[] arr = list.toArray(new Integer[0]);
    System.out.println(Arrays.toString(arr));

/* 数组 → list */
    String[] names ={"Lily","Molly","June"};
    List<String> list2 = Arrays.asList(names);
//list2.add("hi");现在集合是一个受限集合，不能增删元素

Collection 集合

<span id="Collection"></span> 无序、无下标、不能重复

    Collection c = new ArrayList<>();
/* 添加元素 */
    c.add("apple");
    c.add("pear");
    c.add("hair");//["apple","pear","hair"]
/* 移除指定元素 */
    c.remove("hair");//["apple","pear"]
/* 清空 */
        //c.clear();
/* 判断是否包含/为空 */
    c.contains("apple"); //true
    c.isEmpty(); //false
/* 遍历 */
   Iterator it = c.iterator();
   while(it.hasNext()){
       String s = (String) it.next();
       System.out.println(s);
// c.remove(s);错误，ConcurrentModificationException并发修改异常,
//迭代器迭代过程中不能使用collection的方法
       it.remove();//✔

List 子接口

有序、有下标、元素可以重复

常用方法

List list = new ArrayList<>();
/* 添加元素 */
    list.add("apple");
    list.add("pear");
    list.add("hair");//["apple","pear","hair"]
/* 移除指定元素 */
    list.remove("hair");//["apple","pear"]
/* 返回子集合（含头不含尾） */
    List subList = list.subList(0,2);  //[apple, pear]
/* 判断是否包含/为空 */
    list.contains("apple"); //true
    list.isEmpty(); //false
/* 获取下标 */
    list.indexOf("pear");

/* 遍历(可以从前往后/从后往前) */
    ListIterator it = list.listIterator();
    while(it.hasNext()){
        String s = (String) it.next();
        System.out.println(s);
   }//从前往后
    while(it.hasPrevious()){
        String s = (String) it.previous();
        System.out.println(s);
    }//从后往前

List的实现类

ArrayList(效率高，线程不安全) (源码分析)[https://www.bilibili.com/video/BV1zD4y1Q7Fw?t=340.1&p=12]
Vector(线程安全，效率低)

   Vector vector = new Vector<>();
   vector.add("b");
   vector.add("c");
   vector.add("a");
   vector.add("a");
/* 枚举器 */
  Enumeration en = vector.elements();
   while(en.hasMoreElements()){
       String s =(String)en.nextElement();
       System.out.println(s);
   }
···略

LinkList（链表集合，增删快/改查慢）

LinkedList ll = new LinkedList<>();
ll.add("apple");
ll.add("banana");
ll.add("orange");
ll.remove("orange");
Iterator it = ll.iterator();

Set 子接口

<span id="Set"></span> 无序、无下标、不能重复

HashSet

HashSet hs = new HashSet<String>();
hs.add("a");
hs.add("b");
hs.remove("b");
hs.contains("a");
hs.isEmpty();

TreeSet 基于红黑树的集合<br> Comparator接口：自定义比较规则 <span id="Comparator"></span>

import java.util.*;

public class code2 {
    static class Person {
        int age;

        Person(int age) {
            this.age = age;
        }

        @Override
        public String toString() {
            return "Person{age=" + age + "}";
        }
    }

    public static void main(String[] args) {
        // 创建TreeSet，传入Comparator自定义比较规则（按age升序）
        TreeSet<Person> persons = new TreeSet<>(new Comparator<Person>() {
            @Override // 重写compare方法
            public int compare(Person p1, Person p2) {
                return p1.age - p2.age; // 按age升序排列
            }
        });
        /* Lambda 表达式 */
        /* TreeSet<Person> persons = new TreeSet<>((p1, p2) -> p1.age - p2.age); */

        persons.add(new Person(25));
        persons.add(new Person(18));
        persons.add(new Person(30));
        persons.add(new Person(18)); // age相同，TreeSet会去重，不会添加

        System.out.println("按age升序排列的Person集合：");
        for (Person p : persons) {
            System.out.println(p);
        }
    }
}

Map集合

Map(interface)
- 实现类
  - HashMap 运行效率高，线程不安全
  - Hashtable 运行效率低，线程安全。已被 ConcurrentHashMap 替代
    - Properties (Hashtable的子类，要求key和value都是String)，是开发中配置读写的标准工具。
- SortedMap(interface)
  - TreeMap(class) 红黑树存储

常用方法

Map<Integer,String> map = new HashMap<>();
//添加(key,value)
    map.put(2,"Molly");
    map.put(1,"Lily");
    map.put(3,"Star");
    map.put(7,"emm");
// 获取key所对应的值
    System.out.println(map.get(2));//Molly
//删除key
    map.remove(7);
//个数
    map.size();//3
//keySet
    for(Integer key : map.keySet()){
        System.out.println(key);
    }
//entrySet 映射对
    Set<Map.Entry<Integer,String>> entries = map.entrySet();
    for (Map.Entry<Integer,String> entry: entries){
        System.out.println(entry);
    }
//判断是否包含
    System.out.println(map.containsKey(3));
    System.out.println(map.containsValue("Star"));

System类

<span>System</span>

Calendar

//Calendar 是抽象类，不能直接 new，需通过 getInstance() 获取实例
    Calendar calendar = Calendar.getInstance();
    System.out.println(calendar.getTime().toInstant());

    int year =calendar.get(Calendar.YEAR);
    int month =calendar.get(Calendar.MONTH+1);
    int day =calendar.get(Calendar.DAY_OF_MONTH);

    System.out.println(year+" "+month+" "+day);
    ...

内部类

<span id="内部类"></span> 在类的内部定义一个完整的类。<br> 编译后可生成独立的字节码文件;内部类可访问外部类的私有成员。

成员内部类
- 初始化 class Outer{ class Inner{可以访问Outer对象} }<br>
- 创建对象 Outer.Inner oi = new Outer().new Inner();<br>
- 访问：当内外部类存在重名属性时，优先访问内部类属性，访问外部类 Outer.this.name;
静态内部类
- 初始化 class Outer{ **static** class Inner{可以访问Outer对象} }<br>
- 创建对象：Outer.Inner oi = new Outer.Inner();不需要先创建外部类对象<br> 类内访问：
- 访问外部类的属性
  
  静态内部类不能访问 non-static 的外部类成员<br> 先创建外部类对象 Outer outer = new Ounter();<br> 再 outer.name;
- 访问内部类的属性通过类名访问 Inner.name;
局部内部类
- 初始化
  
  在类的方法中写类class Outer{ public void function(){ class Inner{} } }<br> Inner i = new Inner(); i.show2(); 方法运行完毕，类就消失
- 内部类内访问局部变量 <span id="内部类内访问局部变量"></span> 变量必须是常量（相当于加上final修饰符）<br> 在内部类中调用变量才不能修改(final)，没有调用还可以修改

匿名内部类没有名字的内部类<br> 必须继承一父类/实现接口，减少代码量。

USB usb = new USB(){
  public void show(){
    sout("Usb is working...");
  }
}

相当于实现继承的局部内部类：

class Fan implements USB{
  void service(){
    sout("Usb is working...");
  }
}
USB Usb = new Fan();
Usb.service();

JVM

<span id="String"></span> String的不可变性

实现原理
```
 public final class String{
      private final char value[];
 }
```
1. String 类被 final 修饰，<u>无法被继承</u>；内部存储字符的 char[] value 数组也被 final 修饰，保证 <u> 该数组引用不可指向新数组</u>。
2. 数组的 private 封装char[] value 被 private 修饰，外部无法直接访问或修改这个数组。
3. 无修改方法，操作返回新对象String 没有提供修改内部数组的公开方法，所有字符串操作（如拼接、替换）都会返回新的 String 对象，原对象内容不变。
为什么这样设计？
1. 支撑常量池：保证常量池中的字符串可安全复用，大幅节省内存；
2. 适配哈希表：哈希值（hashCode）固定，作为 HashMap/HashSet 的键时稳定且高效；

<span id="内部类内"></span> 内部类内

局部内部类访问外部类的成员变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为 final

public void show(){
  String adress = "home";
  
  class Inner{
    public void show2(){
      sout...
    }
    Inner inner = new Inner();
    inner.show2();
  }
}

若没有final：<br> show 方法执行完后，局部变量 adress 立即消失；<br> Inner 对象在堆中不会立即消失，未消失的对象中的show2方法引用的address变量不存在，不能访问到；

解决方法：<br> 加上final，变成常量

力扣Leetcode Exercise

Tue, 20 Jan 2026 00:00:00 GMT

链表：7. 链表相交(面试02.07) 8. 环形链表II(142) <br>哈希表：6. 四数相加II(454) 8.三数之和(15) 9. 四数之和(18) <br>字符串 <br>双指针法

数组
- 快慢指针
- 滑动窗口
链表
哈希表
字符串
- KMP算法
二叉树

2026

1.23

数组

[x] 704. 二分查找

关于 <mark>>=/medal±1</mark> 的判断

关于能取到的范围, target 所在范围：
- 若 [left,right]，则 right 初始化为len-1， while(left<=right)； media > target 时，right = media-1；media < target 时，left = media + 1
  - 若 [left,right)，则 right 初始化为 len，while(left<right)； media > target 时，right = <mark>media</mark>；media < target 时，left = media + 1
[x] 59. 螺旋矩阵II <br>关于边界条件、循环不变式的确定。
- [x] 54. 螺旋矩阵
  1. 避免单行/列重复遍历
  2. 按层遍历，收缩边界

快慢指针

[x] 27. 移除元素
1. <mark>快慢指针</mark> O(n)
  
  slow代表下标， fast代表查询到的元素。遍历 fast 到 len
2. 相对指针
  
  最开始的思路，left指针检测当前 nums[left] == val，
  1. 如果是，就把 right 的值覆盖
  2. 如果不是，就后移
  在最开始和每一次覆盖之后，把所有 nums[right] == val 的值排除掉

<u>while(大循环){ while(小循环)每次把特殊情况处理完 }</u>

[x] 26. 删除有序数组中的重复项
[x] 844. 比较含退格的字符串最后的比较需要优化 / stack方法
[x] 283. 移动零 只遍历一遍数组
[x] 997.有序数组的平方 此题争议较大（原数组上怎么实现）
[x] 19. 删除链表的倒数第 N 个结点 ① 一次遍历法(最优解)：<u>快指针先走 N 步，快慢指针再一起走，直到快指针到达null</u><br> ② 两次遍历法：第一遍确定总个数 len，再 len-n 求出需要进行操作的节点序号(删除的前一个节点)。要添加 dummy 虚拟头节点。
[x] 160. 相交链表计算两链表长度的差值，

滑动窗口

<span id="滑动窗口"></span> 找连续字串、数组的最小/最好字串、子数组

暴力解法会把数组嵌套遍历两遍，时间复杂度O(n^2);<br> 滑动窗口的思想是直接把数组遍历两遍，时间复杂度O(2n)

[x] 3. 无重复字符的最长子串 HashMap存储区间内字母所在的位置；<br> 对于每次检测的字符:
1. 存在区间内 (idx>l)，把 l更新为idx+1
2. 不存在区间内，不含重复字符的数组长度 length++
[x] 904. 水果成篮 <br>含有1/2个不同数字的最长连续子数组长度。
[x] 209. 长度最小的子数组每一轮迭代，将 nums[r] 加到sum，如果 sum ≥ target，则更新 l，更新子数组的最小长度，l不断右移到 sum<target

链表

[x] 203. 移除链表元素<br> ①移除头节点 head 和移除其他节点有区别，②Solution：添加虚拟头节点<br> ① 头节点<br>

while(head!=null && head.val==val) {
    head = head.next;
}

其他节点，连续target值的处理

ListNode cur = head;
while(cur!=null && cur.next !=null) {
    if(cur.next.val == val){
        cur.next = cur.next.next; //处理连续target值
    } else {
        cur = cur.next;
    }
}

② <mark>虚拟头节点（哨兵）</mark>

ListNode dumpy = new ListNode();
    dumpy.next = head;

[x] 反转链表易
[x] 两两交换链表中的节点 <br>添加虚拟头节点 :操作当前节点，至少要指向当前的前一个节点 <br>① 做的复杂化了，是递归假象的 while 循环，优化：一次循环只交换一对 <br>② 递归很巧妙（跪）

快慢指针

哈希表/散列表

[x] 242. 有效的字母异位词桶计数法。
[x] 349. 两个数组的交集数据类型的转换，Set<Integer> → int[]<br> 包装类型流转化为基本数据类型数组：包装类型流 → 基本类型流 → 基本类型数组
```
   res.stream().mapToInt(Integer::intValue).toArray();
```
[x] 202. 快乐数 hash 空间复杂度是 O(n);改用快慢指针，空间复杂度O(1).
[x] 1. 两数之和

字符串

[x] 344. 反转字符串
[x] 541. 反转字符串II
[x] 28. 找出字符串中第一个匹配项的下标 strStr() <br>👆很简单的模拟题，但T28值得一提的 <u>KMP算法</u> <span id="KMP1"></span>
[x] 替换数字
[x] 151. 反转字符串中的单词 Java中的 split 两个string之间的空格＞1，会多增加一个空单词（""）删除尾部空格 s.strim();
[] 459. 重复的子字符串

KMP

<span id="KMP2"></span> 视频教程

对于两个字符数组的遍历
1. string[i] == patt[j] 时，i++ j++；
2. 否则当 j>0 时，j=next[j-1]指向前一个匹配的 next数值（可以跳过的匹配位数）
3. 否则，patt第一个字符就无法匹配，i++
<mark>next数组</mark> 匹配失败时，返回最后一个匹配字符，next代表子串中“相同前后缀的长度” <div style="display: flex; width: 70%; gap: 10px;"> <div style="flex: 1; text-align: center;"> <img src="/images/kpm.png" alt="项目标准" style="width: 100%;"> </div> </div>

二叉树

[x] 1022. 从根到叶的二进制数之和 <br>dfs + 递归
[]

    @media (prefers-color-scheme: dark) {
    mark {
    background-color: #BB8FCE;  
    color: #333333;  
    }
}

</style>

Stari's Blog

26summer

数据库复习

C1 绪论

数据库的基本概念

数据模型的组成要素 & 常用数据模型

⭐数据模型

⭐关系模型基本概念

数据库的三级模式

两种数据独立性

⭐关系的完整性约束

⭐码与相关概念

超码

候选码（码）

全码

主码

外码

主属性与非主属性

例

⭐C2 关系代数

⭐C3 SQL

对查询结果的处理

基本表 TABLE

视图 VIEW

⭐例题

⭐C4 数据库编程

嵌入式SQL

⭐游标 Cursor

异常处理

过程化SQL

⭐触发器

函数

存储过程

静态SQL vs 动态SQL

C5 关系数据规范化理论

⭐数据依赖：函数依赖

1. 平凡/非平凡函数依赖

2. 完全/部分函数依赖

3. 传递函数依赖

数据依赖：多值依赖

范式 & 规范化

二、1NF（第一范式）

定义

实例

三、2NF（第二范式）

四、3NF（第三范式）

五、BCNF（巴斯范式）

4NF（第四范式）

⭐Armstrong公理系统

Armstrong公理系统 - 基本规则

Armstrong公理系统 -扩充规则

函数依赖的逻辑蕴涵

函数依赖集的覆盖 & 等价

函数依赖集

3.1 函数依赖集的闭包 F^+

3.2 属性集的闭包 $A_F^+$

3.3 极小函数依赖集 / 最小依赖集 / 最小覆盖：F的最简形式

需满足 3 个条件：

计算算法

🌟例题

⭐例1：属性集闭包算法 -计算A关于F的闭包 $A_F^+$

⭐例：等价/最小函数依赖集 -属性集闭包算法

⭐例2：极小函数依赖集算法

⭐（补充3）例：判断冗余依赖

⭐例3：计算候选码

⭐模式分解

模式分解的三个理解

⭐无损连接

⭐保持函数依赖

🌟3NF模式分解

🌟BCNF 模式分解

多值依赖

⭐C6 数据库的安全性

⭐C7 数据库设计

⭐C8 ER/EER模型

C9 数据库恢复技术

事务 & ACID特性

COMMIT、ROLLBACK & 保存点 SAVEPOINT

三类故障及恢复方法

数据转储

⭐1. 可靠传输/流量控制与滑动窗口