企业官网建设流程全解析

MySQL 装好了，然后呢？这个困惑我以前见过很多次。很多新手在“下载、安装、登录成功”之后就卡住了，对着命令行窗口不知道下一句该敲什么。数据库学习和写业务代码不太一样，写代码至少能立刻看到运行结果，而 MySQL 装好之后，摆在你面前的只有一个mysql>提示符和一堆空数据库，正反馈来得太慢。

“每日学习 MySQL，新手快速入门”这个目标，真正的问题不在于背多少条 SQL，而在于你心里有没有一条完整的链路：安装 → 启动 → 建库 → 建表 → 写数据 → 查数据 → 复盘。只要这条链路通了，后面所有知识点都能长在这副骨架上。我这里想用一整篇博客，把这副骨架给你搭起来，顺便把新手最容易踩的坑提前标出来。

1. 先想清楚：新手学 MySQL，到底在学什么

1.1 为什么很多人学着学着就放弃了

我见过不少新手把 MySQL 当“单词表”在背：今天记一个SELECT，明天背一个UPDATE，后天研究GROUP BY。看起来每天都在学习，但学到后面发现两个问题：

一是记不住。数据库语法虽然不算难，但细节很多，ORDER BY和GROUP BY顺序搞混，WHERE和HAVING分不清，INNER JOIN和LEFT JOIN结果对不上，很快就乱了。

二是不知道学了有什么用。学编程语言时，写一个print("hello")就能看到输出，学数据库却没有这种即时反馈。你背了一堆语法，却没完整地跑通过一个“从建表到查询出结果”的流程，学习动力自然撑不住。

这里真正的问题不是“不够努力”，而是没有先建立主干。数据库知识是一棵树，不是一张清单。只有先让树长起来，叶子才有地方挂靠。

1.2 每日学习的最小闭环

我给新手的建议很简单：不要每天学十个知识点，而是每天只围绕一个最小闭环做练习。

什么是最小闭环？就是你手上有一套能跑通的流程：

1. 启动 MySQL 服务。
2. 用客户端登录。
3. 创建数据库。
4. 创建数据表。
5. 插入几行数据。
6. 写一条查询语句把数据查出来。

这套流程第一遍走通可能就要花掉一天，但它非常值得。因为只要你把这条链路跑通了，以后学到的新语法都是在往这套流程里加东西。今天学LIKE，就把它放进WHERE条件里；明天学联表，就把两张表连接起来查询；后天学事务，就把两条UPDATE包进一个事务里。

这样学习的效率，比漫无目的地看命令大全要高得多。你每天都能看到“操作有结果”，而不是“知识在脑子里变成一团乱麻”。

1.3 判断自己有没有入门的标准

不要用“会多少条命令”来衡量进度。两条标准更有意义：

1. 能否独立完成一个很小的业务场景，比如给自己做一个“学生成绩登记表”。
2. 遇到一个报错时，能不能大致判断它出在安装、登录、SQL 语法、权限还是数据本身。

后面的内容，就围绕这个标准展开。

2. 环境准备别贪多，跑通最小闭环比“装得更全”更重要

2.1 先选对版本：直接上 MySQL 8.0

新手选版本，不要犹豫，在 2025 年这个时间点，直接选 MySQL 8.0。原因很简单：8.0 是目前的主流版本，默认字符集已经是utf8mb4，对中文支持更友好，功能比 5.7 完整，社区资料也多。

5.7 并不是不能学，但它更适合“老项目维护”这个场景。如果你是在公司接手一个存量系统，登录上去一看是 5.7，那没办法，按 5.7 学。如果是从零开始学、准备找工作或者自己搭项目，直接学 8.0 更划算，没有必要在旧语法上多花时间。

安装完成后，先确认版本：

mysql --version

常见输出类似这样：

mysql Ver 8.0.41 for Linux on x86_64

看到 8.0.x，基本就没问题了。

2.2 Windows、Linux、Docker 三条路线怎么选

本机学习，Windows 用户直接用 MySQL Installer 装.msi安装包。安装时选默认配置就能跑起来，不用一开始就调一堆参数。唯一要注意的是：安装到check requirements那一步如果卡住，大概率是系统缺少 Visual C++ 运行库或 .NET 相关组件，先去补依赖，再回头继续安装。

Linux 服务器上，常见方式有两种：

• 用包管理器安装：Ubuntu 用apt install mysql-server，CentOS/Rocky 用dnf install mysql-server。
• 用 Docker 起一个测试环境：

docker run -d --name mysql8 \ -p 3306:3306 \ -e MYSQL_ROOT_PASSWORD=你的密码 \ -v /data/mysql:/var/lib/mysql \ mysql:8.0

我特别推荐把 Docker 当作学习环境，因为它干净、可控、删掉重建都很快。但要注意：务必把容器内的数据目录/var/lib/mysql挂载到宿主机上，否则容器一旦删除，数据就全没了。

如果是在内网离线环境用二进制包安装（常见于 CentOS、Rocky 等系统），核心步骤是解压官方 tar 包、创建 mysql 用户、初始化数据目录、配置服务启动。不同发行版差异较大，安装前先确认系统的 glibc 版本和依赖库，否则容易在启动阶段报错。

2.3 安装后先做三件事

第一件事，确认服务已经启动。

# Windows 下查看服务状态 net start | findstr mysql # Linux 下查看 systemctl status mysql # 或是 mysql 服务名，如 mysqld

第二件事，登录测试。

mysql -u root -p

第三件事，确认端口。MySQL 默认端口是 3306，这一点后面排查连接问题时会反复用到。

SHOW VARIABLES LIKE 'port';

这三步走完，环境就算准备好了。不要急着去配多个数据库实例、弄主从复制、调 innodb 缓冲池，那些都是后话。

3. 每天二十分钟，把五类核心 SQL 练成肌肉记忆

3.1 建库建表：先弄懂字符集、字段类型和注释

很多人建表时只关心“表能不能建出来”，不关心字段类型选得对不对。这个习惯后面会付出代价。

先建一个库：

CREATE DATABASE school CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;

utf8mb4是目前最好的选择，它能存表情符号，也能兼容绝大多数中文场景。如果手上只有老库用的utf8，建议尽快改成utf8mb4。

再建一张学生表：

CREATE TABLE student ( id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY COMMENT '主键ID', student_no VARCHAR(32) NOT NULL COMMENT '学号', name VARCHAR(64) NOT NULL COMMENT '姓名', gender TINYINT NOT NULL DEFAULT 0 COMMENT '性别：0未知 1男 2女', created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间', UNIQUE KEY uk_student_no (student_no) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='学生表';

这里有几个常见问题：

• 为什么主键用BIGINT而不是INT？对于学习项目来说INT其实够用，但生产环境里，如果数据量上来，INT很容易到达上限。直接养成用BIGINT的习惯，后面更稳。
• 为什么学号要加UNIQUE KEY？“学号”在现实业务里就是唯一的，如果允许重复，后面查数据时会出现大量模棱两可的结果。
• 为什么每个字段都加COMMENT？一周之后你再回来看这张表，就会感谢当时的自己。

还要提醒一个细节：字段名尽量避开 MySQL 的关键字，比如order、desc、group。如果确实躲不开，查询时必须用反引号包起来：

SELECT `order` FROM user_order;

最好在建表阶段就不要用这类名字，而不是指望每次查询都记得加反引号。

3.2 增删改：先 SELECT 再 UPDATE，先备份再 DELETE

INSERT 没有太多花样：

INSERT INTO student (student_no, name, gender) VALUES ('20240001', '张三', 1);

UPDATE 就需要注意了。热搜词里出现过“mysql update语法”，这里最容易犯的错误是：没写WHERE，导致整张表都被更新。这不是玩笑，生产事故里经常有人因为一行漏掉的WHERE把全表数据改崩。

UPDATE student SET gender = 2 WHERE student_no = '20240001';

一个更稳的习惯是：先SELECT确认要更新的行，再执行UPDATE。

-- 先查 SELECT id, gender FROM student WHERE student_no = '20240001'; -- 再更新 UPDATE student SET gender = 2 WHERE student_no = '20240001';

如果是要给某个数值字段加 5，比如库存：

UPDATE product SET stock = stock + 5 WHERE product_id = 1;

DELETE 也一样，不带WHERE就把全表删了。真出现这种情况，表本身还在，但数据没了。所以删除前先SELECT COUNT(*)看看会波及多少行。

还要区分三种不同的“删除”：

• DELETE FROM student WHERE id = 1;：删除一行，自增 id 不会回收。
• TRUNCATE TABLE student;：清空表，速度快，但自增 id 会重置。
• DROP TABLE student;：把整个表结构一起删掉，不要轻易用。

3.3 查询筛选：排序、模糊匹配、LIMIT 和 CASE WHEN

查询是学的重点，先看一个最小组合：

SELECT student_no, name FROM student WHERE gender = 1 ORDER BY created_at DESC LIMIT 10;

这行 SQL 覆盖了WHERE过滤、ORDER BY排序、LIMIT限制返回行数三个基础能力。

搜索热词里还有“mysql like”。LIKE 用来做模糊匹配：

SELECT * FROM student WHERE name LIKE '张%';

%匹配任意多个字符，_匹配一个字符。但要注意，LIKE '%张%'这种写法在前面加百分号时，通常用不上索引，数据量大以后查询会很慢。学习阶段无所谓，到了性能优化阶段就要尽量避免。

LIMIT 的完整语法是：

SELECT * FROM student LIMIT 10; -- 返回前 10 行 SELECT * FROM student LIMIT 10, 20; -- 跳过前 10 行，从第 11 行开始取 20 行

偏移量越大，分页查询越慢。所以不要写出LIMIT 1000000, 20这种查询。

CASE WHEN 用来做条件映射，比如把分数转换成文字等级：

SELECT name, CASE WHEN score >= 60 THEN '及格' ELSE '不及格' END AS result FROM score;

这类逻辑用代码也能做，但在 SQL 里做一次查询，比拉到应用程序里再判断更直接。它也是mysql case when这个搜索热词背后的常见需求。

3.4 联表和聚合：从单表到多表的关键一跃

单表查询熟练之后，下一个台阶是联表。很多新手在这里第一次感受到数据库和 Excel 之间的区别。

用一个学生、课程、成绩的例子：

SELECT s.name, c.course_name, sc.score FROM score sc JOIN student s ON sc.student_id = s.id JOIN course c ON sc.course_id = c.id;

JOIN的底层逻辑是把两张表按条件拼在一起，然后筛选结果。你不需要一开始就背齐所有 join 类型，先把INNER JOIN和LEFT JOIN搞清楚就够应付绝大多数场景。

聚合统计同样重要。比如统计每个学生的选课数和平均分：

SELECT student_id, COUNT(*) AS course_count, AVG(score) AS avg_score FROM score GROUP BY student_id HAVING course_count >= 3;

这里有一个高频困惑：WHERE和HAVING有什么区别？

• WHERE是在分组前过滤原始行。
• HAVING是在分组后过滤聚合结果。

所以上面这条 SQL 里，不能写成WHERE COUNT(*) >= 3，因为分组还没开始，COUNT(*)还不存在。

热搜词里还有“mysql 的 or 能去重吗”，顺带回答一下：OR 本身是条件表达式，它不负责去重，只负责筛选符合条件的行。如果查询结果出现重复行，通常是因为联表后产生了多条匹配记录。去重应该用DISTINCT或GROUP BY：

SELECT DISTINCT student_id FROM score WHERE score >= 60 OR course_id = 1;

4. 从会写 SQL 到会建表，是新手第一次真正质变

4.1 用“学生-课程-成绩”模型，把多表关系练明白

“学生-课程-成绩”是数据库学习里最经典的模型，也对应热搜词“学生课程成绩信息实体表设计 mysql”。

这个场景里有三个核心对象：学生、课程、成绩。学生和课程之间是多对多关系：一个学生可以选多门课，一门课可以有多个学生选。最终落表时，除了学生表、课程表，还需要一张中间表来记录“谁选了哪门课，考了多少分”。

这个设计背后的思路是：业务对象先梳理清楚，再来定表结构。一张表负责一个主体，不要把所有业务字段都堆进去。

学生表、课程表、成绩表的示意：

CREATE TABLE course ( id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY, course_name VARCHAR(100) NOT NULL, credit DECIMAL(3,1) NOT NULL DEFAULT 0.0 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE score ( id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY, student_id BIGINT UNSIGNED NOT NULL, course_id BIGINT UNSIGNED NOT NULL, score DECIMAL(5,2) NOT NULL, UNIQUE KEY uk_student_course (student_id, course_id) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

这个uk_student_course唯一键很关键，它的含义是：同一个学生不能在同一门课上录两次成绩。

4.2 字段设计：主键、唯一键、索引各解决什么问题

新手设计表结构时，经常把“该加哪些字段”理解成“想存什么就放什么”。实际上，字段设计要回答三个问题：

第一个问题是唯一性。哪根字段能唯一标识一条记录？答案是主键。主键通常用自增BIGINT，但要注意：如果以后要做分布式系统，自增 id 不够用，可能要考虑雪花算法生成的 id。

第二个问题是重复性。哪些非主键字段不允许重复？用唯一键约束。比如学号不能重复。如果一开始没加唯一约束，后来才发现数据里已经有重复值，那需要先清理数据，再补约束。这就是一个标准处理流程：

-- 1. 找出重复数据 SELECT student_no, COUNT(*) AS cnt FROM student GROUP BY student_no HAVING cnt > 1; -- 2. 清理或合并重复数据 -- 3. 加上唯一约束 ALTER TABLE student ADD UNIQUE KEY uk_student_no (student_no);

搜索热词里“mysql 设置唯一 已经有重复数据库”，对应的就是这种情况。核心原则是：先解决数据问题，再添加约束，否则约束根本加不上去。

第三个问题是效率。哪个字段经常出现在WHERE、JOIN、ORDER BY里？给这些字段加索引。但索引不是越多越好，因为每次 insert/update 时，索引也要跟着更新，索引多了写入会变慢。

4.3 业务系统里的库存和 WMS 表，更考验建模思维

搜索热词里还有“erp里面的库存管理”和“wms系统怎么设计数据库表”。这类系统确实比学生成绩表复杂，但它背后的基础建模思路是一样的：先把业务对象和业务事件分开。

库存管理系统，核心设计通常是“库存表 + 出入库流水表”。

• 商品表：描述商品本身，名称、规格、单位等。
• 仓库表：描述仓库位置。
• 库存表：记录某个商品在某个仓库里的当前数量。
• 出入库流水表：记录每一次入库、出库、盘点、调整的数量变化。

为什么不能只维护一张库存表？因为库存数量是结果，流水才是原因。没有流水，你无法回答“这个库存数是怎么来的”，也无法做审计和对账。

新手可以从这里得到的经验是：听到一个系统需求，不要急着建一堆表，先问自己，“这里有哪些业务对象？哪些是静态属性？哪些是会产生变化的业务事件？”把对象和事件拆开，表结构自然就清晰了。

5. 进阶不是背概念，存储过程、事务和锁的正确打开方式

5.1 存储过程：能封装逻辑，但也别什么都往里塞

存储过程是 MySQL 进阶绕不开的一块。它的作用是：把一组 SQL 语句封装成一个可复用的“程序”。

最基础的创建和调用长这样：

DELIMITER // CREATE PROCEDURE show_student_count() BEGIN SELECT COUNT(*) AS total FROM student; END // DELIMITER ; CALL show_student_count();

DELIMITER的作用是告诉 MySQL：分号不再代表语句结束，改用//作为结束标记。因为在存储过程内部，多条 SQL 语句之间要用分号分隔，如果不改DELIMITER，MySQL 会在第一条分号处就误认为语句结束了。热搜词里的“mysql中触发器中分隔符”指的也是这个概念。

在存储过程中，如果想主动抛出错误信息，可以用SIGNAL：

SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = '库存不足';

这会让调用方明确收到一个业务错误，而不是等到后面查出奇怪数据才发现问题。

但存储过程不是万能药。它的维护成本在于：逻辑存在数据库里，不好做版本管理，不好测试，稍复杂一点就容易写成“SQL 面条”。我的判断是：学习期应该写几个存储过程来理解它，生产环境里则要克制，只有在场景确实合适（比如固定流程的批量统计、初始化脚本）时才用。

5.2 触发器：一次写进去，每次自动执行

触发器比存储过程更“隐蔽”。它是在数据表上注册一段逻辑，当表发生INSERT、UPDATE、DELETE时自动执行。

创建语法里也涉及DELIMITER：

DELIMITER // CREATE TRIGGER trg_score_after_insert AFTER INSERT ON score FOR EACH ROW BEGIN INSERT INTO score_log (student_id, course_id, score, log_time) VALUES (NEW.student_id, NEW.course_id, NEW.score, NOW()); END // DELIMITER ;

NEW代表新插入的记录，OLD代表更新或删除前的记录。

触发器的价值是自动化，但它的问题也很突出：它是隐式执行的。如果某个报表数据一直不对，你很难第一时间想到“是不是有一个触发器在暗地里改写数据”。所以，学习阶段可以写几个触发器感受一下机制，生产环境要非常谨慎，尤其是在核心业务表上。

5.3 事务、锁和死锁：为什么并发写入会出事

事务是数据库多表操作的安全网。经典例子是把钱从一个账户转入另一个账户，两条UPDATE必须同时成功，不能发生“扣款成功但入账失败”的情况。

START TRANSACTION; UPDATE account SET balance = balance - 100 WHERE id = 1; UPDATE account SET balance = balance + 100 WHERE id = 2; COMMIT;

如果中间任何一条语句报错，可以执行ROLLBACK回滚，让所有修改都不生效。

MVCC、隔离级别这些概念，新手可以先不背，但有一个现象要提前知道：并发写入时，行锁和表锁会导致等待，严重时会出现死锁。

热搜词里有“mysql锁表”。理解锁并不难：InnoDB 默认在更新一行数据时会对该行加行锁，其他事务要更新同一行就得等它提交。如果两个事务各自锁了一行，又互相等待对方的锁，就形成死锁。

发现锁等待和死锁问题时，最简单的排查手段：

SHOW PROCESSLIST;

找到长时间停留在Waiting for lock的会话，再用KILL <线程ID>结束它。但更根本的解法是：让事务尽量短，减少大事务，避免一次性更新大量数据，所有更新都按统一的顺序执行。

6. 命令行、Workbench、Navicat：工具链怎么搭配更科学

6.1 命令行是打基础的最好老师

很多新手一上来就装图形化工具，然后用 GUI 点点点，觉得“这样也算会 MySQL 了”。这个判断我并不同意。GUI 确实提高效率，但它把很多细节藏起来了。

用命令行学习最大的好处是“被迫理解每一步你在做什么”：

mysql -u root -p

登录后，你能看到日志、错误信息、SQL 执行状态，这些都是数据库底层的真实反馈。学完基础增删改查之后，命令行未必是最终工作工具，但它一定是最能帮你建立理解的起点。

6.2 Workbench 和 Navicat：用 GUI 把表结构看清楚

MySQL Workbench 是官方提供的图形化工具，适合看表结构、跑查询、生成 ER 图。在 Workbench 里，通过Database -> Reverse Engineer可以连接已有数据库并生成实体关系图，这正好对应热搜词“mysql的表导出er关系图”。当表一多，用 ER 图检查外键关系和冗余字段，比写 SQL 看字段更直观。

Navicat 是很多公司里实际在用的第三方工具。安装第三方工具时，最常遇到的就是连接 MySQL 8.0 报 2059 错误。原因是 MySQL 8.0 默认使用caching_sha2_password认证插件，而较老的客户端或驱动不认识它。

在 MySQL 端有两种常见处理方式：

• 升级你的客户端或者驱动到支持 MySQL 8.0 的版本，这是更值得推荐的方式。
• 如果确实需要用老客户端，可以临时把用户认证方式改回mysql_native_password：

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '你的密码'; FLUSH PRIVILEGES;

但要注意，改认证插件只是为了兼容旧工具，不是常规推荐做法。

6.3 工具选择一句话总结

学习期：命令行为主，GUUU 为辅。熟练后：看表结构、看关系图用 Workbench 或 Navicat，写临时查询随便用哪个顺手，但生产维护时命令行和日志依然是最可靠的兜底。

如果你在学 Web 开发，还会遇到“JavaWeb 项目连接 MySQL”或“Node.js 连接 MySQL”这类问题。这个场景的关键不是 SQL 语法，而是驱动版本、连接 URL 和连接池配置。比如 JDBC URL 里通常要带上时区和编码参数：

jdbc:mysql://localhost:3306/school?useSSL=false&serverTimezone=Asia/Shanghai&characterEncoding=utf8

用户权限也要确认，不是root才有权限，而是连接用户必须拥有对应库表的SELECT、INSERT、UPDATE、DELETE权限。

7. 新手最容易卡住的报错，按这张排查顺序表来找

7.1 一个通用的五层排查法

遇到 MySQL 相关报错，不要慌，更不要一上来就卸载重装。先按“现象 → 输入 → 环境 → 权限 → 依赖/版本”的顺序排查。

这个顺序看上去简单，但非常有效。我发现大多数新手是反着来的：先怀疑版本问题，然后重装，重装还是不行，最后才发现只是端口被占用或者密码输错了。从一开始就按这个顺序排查，能省下很多冤枉时间。

7.2 几个新手里最常见的具体报错

连接时报 2059（Authentication plugin 'caching_sha2_password' cannot be loaded）

原因：MySQL 8.0 默认认证插件和旧客户端不兼容。处理方式见上文 6.2，优先升级工具或驱动；不得已时再修改用户认证方式。

Windows 下安装卡在 check requirements

原因：系统缺 Visual C++ 运行库、.NET Framework 或 PowerShell 相关组件。先去系统更新或补装依赖，再重新运行安装程序。不要把罪全怪到 MySQL 安装包上。

安装完成后启动服务报错

常见原因按频率排序：

1. 端口 3306 被其他程序占用。
2. 数据目录没有正确初始化，或者权限不对。
3. 配置文件my.ini/my.cnf里写了不支持的参数。
4. 系统缺少 MySQL 依赖的动态库。

先看错误日志，Windows 下在 MySQL 数据目录的.err文件里，Linux 下在/var/log/mysql或journalctl -u mysql里。日志会把真正的失败原因写得很清楚。

Linux 下 MySQL 能连，但其他机器连不上

原因通常不是 MySQL 本身，而是防火墙、bind-address限制或用户只授权了localhost。

查看监听地址：

SHOW VARIABLES LIKE 'bind_address';

如果被限制在 127.0.0.1，外部机器当然连不上。再检查 MySQL 用户表：

SELECT host, user, plugin FROM mysql.user;

如果 root 用户只允许 localhost 连接，要么新建一个允许局域网访问的用户，要么显式授权。

第三方工具突然提示类似 task may only be disposed 的异常

这类问题大多出在工具自身状态或数据库连接被异常中断。常见处理方式是：关闭工具，检查数据库服务是否正常，重启客户端后再连接。如果复现频繁，升级工具版本，或者检查是否有连接被反复建立和关闭。

sqoop 等数据工具连不上 MySQL

这已经偏向数据工程场景了。排查重点通常是驱动包有没有放对位置、JDBC URL 有没有写错、MySQL 的加密方式和权限是否允许该主机访问。这里更依赖版本匹配，建议先看驱动官方文档，而不是直接改 MySQL 配置。

8. 把“每日学习”变成一张能坚持的路线图

8.1 先给自己安排一个两周的主线

每一天不需要学很多。下面这条路线图是学习示例，你可以根据自己的节奏调整，但主干建议保留：

• 第 1 天：安装 MySQL，启动服务，登录成功。
• 第 2 天：创建数据库，建第一张表，插入 3 条数据。
• 第 3 天：练习 SELECT 查询，重点掌握 WHERE、ORDER BY、LIMIT。
• 第 4 天：练习 UPDATE 和 DELETE，强烈建议先 SELECT 验证再执行。
• 第 5 天：练习 LIKE、CASE WHEN、常用聚合函数。
• 第 6 天：建第二张表，练习两张表 JOIN。
• 第 7 天：复习前六天内容，把每一个练习用自己的话写笔记。
• 第 8 天：重新设计一个完整的“学生课程成绩”模型，从建库到查询全部自己来。
• 第 9 天：给成绩表加唯一约束，练习清理重复数据。
• 第 10 天：做分页查询和排序练习，体会索引对查询速度的影响。
• 第 11 天：简单写一个存储过程，理解 DELIMITER 和过程调用。
• 第 12 天：练习事务，把两条 UPDATE 放进同一个事务里，观察回滚效果。
• 第 13 天：用 Workbench 生成 ER 图，检查表之间的关系。
• 第 14 天：找一个小项目需求，比如记账本、图书管理或商品库存，自己完成数据库设计。

这套路线的核心不是“第几天必须学会什么”，而是每天都有产出。哪怕只是在一张测试表里反复读写，也比只看教程不动手强得多。

8.2 每天只做四件事，效果反而更好

每天花二十分钟就够了，但要保证这二十分钟里做的是这四件事：

1. 验证昨天：把昨天学的重点写一遍，看是否还记得。
2. 学一个新语法：只学一个，不要贪多。
3. 写一个小例子：不用多复杂，三条 SQL 都行，但一定要在当前库里跑通。
4. 记录一个问题：不管有没有遇到报错，都写一句话。有报错就写“今天遇到 xx 问题，按 xx 排查解决了”，没报错就写“今天验证了 xx 功能”。

为什么要记录问题？因为数据库知识太容易“看着都会、一写就错”。你记下的每个问题，都是下一次快速排查的素材。一个月过去后，这份日志本身就会变成你最有效的学习资料。

8.3 什么时候算真正入门

真正入门的标志，不是“学过 MySQL”，而是“敢说自己能独立使用 MySQL 解决一个小问题”。

具体来说：

• 不打开 GUI，只靠命令行就能建库、建表、写入、查询。
• 看到一个业务需求，能先拆出表和表之间的关系。
• 报错出现时，能判断问题出在输入、环境、权限还是版本上。

这三个能力都有了，说明你已经不是“新手背命令”的阶段，可以开始接触性能优化、备份恢复、主从复制这些更深的话题了。

我把这篇内容写到这里，最想留给你的一句话是：MySQL 不难，难的是让知识长成一条能跑通的链路。先把这个最小闭环建立起来，剩下的，都是时间问题。