MySQL存储过程与函数的核心区别及选型指南-代码聚汇网

MySQL存储过程与函数的核心区别及选型指南

陈易铭·2026-09-01·阅读 83 GEO检测（免费）

MySQL存储过程函数数据库设计

|难度：普通|阅读约 35 分钟

最近在整理一个老项目的数据库层时，又被同事问到了那个经典问题："这个逻辑到底该写成存储过程还是函数？"说实话，这也是我在处理MySQL数据库设计时被问得最多的问题之一。很多人把存储过程和函数混着用，觉得"反正都是写在数据库里的SQL片段"，结果在后续维护和性能排查时才发现选错了。今天我想从实际项目的角度，把两者的差异、使用场景和判断方法一次讲透。

先说结论：存储过程和函数虽然都叫"存储例程"，但它们的设计初衷、语法约束和适用场景完全不同。函数本质上是一个"计算单元"，它要放进SQL表达式里参与运算；存储过程则是一个"执行单元"，它更像一段运行在数据库端的独立程序。这两者的差异会直接决定你在哪儿能用它、能做什么事、性能表现如何。这篇文章适合正在学习MySQL存储过程与函数区别的开发者，也适合在项目里纠结"到底该用哪个"的后端工程师。我会用实际案例和踩坑记录，把选型逻辑讲清楚。

1. 存储过程和函数到底差在哪：先纠正几个普遍误解

1.1 一句话版本的本质区别

很多初学者背面试题时会说："函数必须有返回值，存储过程可以没有；函数可以嵌套在SQL中使用……"这当然没错，但这些都是表面现象。真正的本质区别是它们在数据库设计中的"角色定位"不同。

函数（Function）是SQL表达式世界的一部分。你在 SELECT、WHERE、ORDER BY、CASE WHEN 这些地方写的 NOW()、COUNT()、DATE_FORMAT()，本质上都是函数调用。你自定义的函数，也是在扩展这个表达式体系，让它能完成你的业务计算。换句话说，函数生产的是一个"值"，它要参与其他SQL语句的计算流程。

存储过程（Stored Procedure）则是独立于SQL语句之外的一个"执行体"。它通过 CALL 语句来触发，它可以没有返回值，也可以带多个返回值（通过OUT参数或结果集），它可以包含多步数据操作（INSERT、UPDATE、DELETE、DDL甚至事务控制）。它更像是把一段业务流程搬到了数据库服务器内部执行。

1.2 "函数不能在数据库里改数据"是最大的误解

我见过太多人坚持"函数只用来做计算，存储过程才用来操作数据"。这句话有它的道理，但不够准确。准确的说法是：在MySQL里，函数体内确实可以执行 INSERT、UPDATE、DELETE 这样的DML操作，只要它不违反以下限制：

函数声明时必须标注 READS SQL DATA 或 MODIFIES SQL DATA（这决定了它在二进制日志和复制中的行为）。
函数内不能执行会改变会话状态或数据库整体状态的语句，比如 USE db、START TRANSACTION、COMMIT、ROLLBACK。
不能在函数里返回结果集（即不能执行普通的 SELECT * FROM ... 直接作为输出）。

但在实际项目中，我非常不建议在函数里写写改改。因为函数最核心的用途是"可组合的计算"，它会被反复调用，如果它同时还修改数据，那么排查问题的难度会呈指数级上升。你很难判断一个 UPDATE 到底是在应用的哪一层、被哪个函数间接触发的。

1.3 一个关键视角：调用者是"SQL语句"还是"应用程序代码"

我的判断方式很简单：看最终谁是调用者。

如果一个逻辑要被嵌进 SELECT、WHERE、ORDER BY 等SQL表达式里，那它必须是函数。比如你要算订单的折扣价、要格式化手机号、要根据经纬度算距离，这些都需要在查询结果里出现一个"计算后的值"，这个场景只有自定义函数能胜任，存储过程做不到。

如果一个逻辑是用来"执行动作"的，比如"批量结转订单状态""生成月末统计快照""插入一条带日志记录的订单"，那它应该是一个存储过程。因为你不会在 SELECT 里干这些事情，你只会单独调用它。

这个"调用者视角"比死记硬背语法差异可靠得多。当你纠结的时候，先问自己：我最终是想在SQL语句里得到一个值，还是想单独执行一段逻辑？

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 参数、返回值与事务：三个最容易踩的语法分水岭

2.1 参数方向：IN、OUT、INOUT 是存储过程的独有能力

这是两者语法上最直观的差异。存储过程的参数可以声明方向：

IN：入参，存储过程内部读取，但修改不影响外部变量。
OUT：出参，存储过程内部赋值，调用后外部可以读取。
INOUT：既可传入又可传出。

函数则简单粗暴：所有参数都是"只读传入"，且不允许在参数定义里加 IN、OUT、INOUT 关键字，写了就是语法错误。函数只能通过 RETURN 返回一个值。

这里有个实用价值：当你要在一段流程里同时返回多个业务结果（比如"影响行数+新生成的主键ID+错误码"），存储过程的 OUT 参数非常方便，而函数就得想办法拼一个JSON字符串或临时表来实现，远不如 OUT 参数直接。

2.2 返回值形态：标量 vs 结果集

函数只能返回一个标量值（INT、VARCHAR、DECIMAL、DATE 等），它的返回类型在 CREATE FUNCTION 时用 RETURNS 声明。

存储过程则没有返回值声明的强制要求。它可以通过以下方式给外部"递结果"：

OUT/INOUT 参数：精确输出一个或多个标量值。
SELECT 结果集：存储过程可以直接执行查询并把结果集返回给客户端。
其实也可以不用任何返回，纯粹执行动作。

这里有一个容易被忽略的细节：存储过程中的普通 SELECT 会直接把结果集发给客户端，不能用来把结果"赋值给变量"。要在存储过程中取查询结果，得用 SELECT ... INTO 变量 语法。而函数里压根不能发出普通 SELECT 的结果集，只能 SELECT ... INTO 到局部变量里，再加工后 RETURN。

2.3 事务控制：存储过程赢在"能扛事"

存储过程可以在体内使用 START TRANSACTION、COMMIT、ROLLBACK，这是它作为"业务流程载体"的核心优势。比如处理一张订单要同时更新订单主表、订单明细表、库存表、日志表，这四步操作必须在同一个事务里完成。把它们封装进一个存储过程，应用层只需要一行 CALL 处理订单(...)，事务边界被牢牢控制在这段过程体内，非常干净。

而函数是绝对不能使用事务控制语句的，包括 START TRANSACTION、COMMIT、ROLLBACK，甚至 SET autocommit 这类改变会话状态的语句也不行。原因在下一小节展开。

2.4 为什么函数不能用事务：一个容易被面试官追问的深度问题

从原理上讲，函数是嵌入在SQL表达式里执行的组件。MySQL的优化器和执行引擎调用函数时，默认你把数据库会话保持在一种"可继续查询"的稳定状态。如果函数内部突然来了一个 COMMIT，那当前整个事务的上下文就被它打断了，外层语句的执行就处于一个不可预知的中间状态。更严重的是在复制场景下，如果函数在语句执行中途提交了事务，主从复制的 binlog 记录会变得非常混乱。所以MySQL直接在语法层面禁掉了函数内的事务语句，这是一种"一刀切"的安全保护。

理解了这一点，你在规划存储例程时就会更清醒：凡是涉及多步写入、需要回滚保护的逻辑，一律往存储过程里放；函数只做无状态的计算和转换，别让函数去"办大事"。

3. SQL上下文里能不能用：调用方式决定了90%的选型

3.1 函数在表达式里的"可组合性"是存储过程替代不了的

函数可以被用在近乎所有SQL表达式可以出现的地方：

SELECT 优惠后价格(单价, 折扣) FROM 商品
WHERE DATEDIFF(NOW(), 下单时间) > 30
ORDER BY 计算积分(用户等级, 消费金额) DESC
GROUP BY DATE_FORMAT(创建时间, '%Y-%m')
还可以在 CASE、IF、UPDATE SET、INSERT INTO ... SELECT 中调用。

这种在SQL解析阶段就能参与的"表达能力"，是存储过程完全没有的。存储过程只能通过 CALL 单独执行，想把它塞进一条 SELECT 里？语法层面就直接拒绝。用大白话说：函数是"词典里的词"，可以嵌在任何句子里；存储过程是"一篇文章"，只能被整篇引用。

3.2 结果集流向的差异：一个直接给客户端，一个只能做表达式

当你执行 CALL 存储过程()，数据库可能返回一个或多个结果集。这在需要"查询后还要继续加工"的场景里很别扭，因为你必须先把结果集取回客户端，再在应用层做第二次查询或处理。

函数则会老老实实地融入SQL语句的求值流程。举例来说，如果你要查"过去30天每个用户的订单总金额，并给超过1000的用户标记为VIP"，你可以写：

sql复制SELECT 
    user_id,
    SUM(amount) AS total_amount,
    会员等级(total_amount) AS level_mark
FROM orders
WHERE order_time > NOW() - INTERVAL 30 DAY
GROUP BY user_id;

这里的 会员等级(total_amount) 虽然只是个比喻，但如果它是自定义函数，你就可以在一个查询里把"聚合计算"和"业务标记"同时完成，最后结果直接是一张表。存储过程做不到这种"SQL语义内联"。

3.3 函数里能调用存储过程吗？反过来的情况又如何？

先说"函数里调用存储过程"：MySQL的语法允许在函数里写 CALL 存储过程(...)，但前面说过，如果这个存储过程内部包含 SELECT 返回结果集或事务语句，那么函数在调用时会报错或产生不可控行为。所以实践中我几乎不会这么做，一旦出现，我就会考虑把逻辑整个改写成存储过程。

再说"存储过程里调用函数"：这是非常常见且推荐的用法。存储过程可以在体内任意调用自定义函数，来获得"表达式计算"的能力。例子：

sql复制CREATE PROCEDURE 生成会员汇总()
BEGIN
    INSERT INTO 会员汇总表(user_id, level, total_amount)
    SELECT 
        user_id,
        会员等级(SUM(amount)),  -- 调用自定义函数
        SUM(amount)
    FROM orders
    GROUP BY user_id;
END

所以最佳实践清楚得很：存储过程管流程和事务，函数管计算和转换，函数嵌套在存储过程里，存储过程不反过来嵌套进函数。这个方向一旦搞反，后面会遇到很多诡异错误。

4. 性能与运维的现实账本：预编译、网络往返与版本管理

4.1 MySQL对存储例程的"预编译缓存"到底能省多少

很多人选存储过程是因为听说"预编译，性能好"。这话得分开看。

在MySQL 8.0之后，存储例程的缓存机制经历了多次调整，不同版本差异很大。但总体原则没有变：存储过程和函数确实可以减少重复SQL文本的解析开销。你可以把一段访问频率极高的复杂SQL塞进一个存储过程，客户端每次只需要一行 CALL，数据库端复用执行计划逻辑，省去重复解析、权限检查、以及反复从客户端发送长串SQL带来的网络开销。

但在实际测试中，我发现对于没有循环、没有游标、没有递归的简单查询型例程，存储过程和直接写SQL的性能差异往往在噪声范围内。存储过程的真正性能优势体现在"需要多次SQL交互"的复杂流程。比如一段逻辑要先查A表、根据结果循环更新B表、再插入C表，如果放应用层，可能产生几十次网络往返；封装成存储过程后，所有操作都在数据库进程内部完成，网络消耗直接归零。这才是它的核心价值。

4.2 函数在WHERE条件里滥用是性能灾难的开始

很多初学者尝到了自定义函数的甜头后，会不自觉地写这样的查询：

sql复制SELECT * FROM orders
WHERE FORMAT_AMOUNT(amount) = '1,234.56';

假如 orders 表有几十万行，MySQL必须逐行调用这个函数，把 amount 格式化后和字符串比较。结果是这个查询几乎不可能用到 amount 列上的索引，因为索引的值是原始数值，而你的比较键是"函数处理后的字符串"。这类"在WHERE左边套函数"的写法，是SQL调优里的大忌。

我的经验是：函数用于SELECT投影（输出列）和ORDER BY/GROUP BY里的辅助计算时，性能风险相对可控；一旦进入WHERE条件并参与过滤，必须慎重评估表的规模和索引情况。如果实在需要按函数结果过滤，更优雅的做法是新增一个冗余列，在写入时用触发器或存储过程计算好，再在这个新列上建索引。

4.3 版本控制和变更脚本：存储例程是"共享的代码资产"还是"维护噩梦"

从运维角度讲，存储过程和函数都把业务逻辑下沉到了数据库，这意味着它们和应用代码一起组成了"程序的一部分"。但很多团队的git仓库里只管应用代码，数据库里的例程完全没有版本控制。等到某天DBA手工改了一个存储过程，应用侧代码没动，结果上线后数据对不上，排查半天才发现"问题出在数据库里改了逻辑"。

我个人的实践经验是，在使用存储例程较多的系统里，必须把所有的存储过程和函数定义保存为独立的SQL脚本文件，放到版本控制里管理，目录结构类似：

code复制db/
├── procedures/
│   ├── 01_order_processing.sql
│   └── 02_monthly_report.sql
└── functions/
    ├── 01_calc_discount.sql
    └── 02_format_phone.sql

每次变更都走和代码一样的Review和发布流程。这样既能保留存储例程的便利性，又不至于变成"无人维护的黑盒"。

5. 什么时候选存储过程，什么时候选函数：我的一套判断框架

5.1 一张决策表解决90%的情况

与其记一堆规则，不如直接看这张表。我把这些年在项目里的选型逻辑浓缩成了一张决策表，碰到实际问题时先对号入座。

判断维度	倾向使用存储过程	倾向使用函数
调用位置	应用层单独执行 `CALL`	要嵌进 `SELECT`/`WHERE`/`ORDER BY` 等表达式
返回值	多返回值、结果集或无需返回	必须返回一个标量值
事务需求	需要事务控制，多表写入流程	严格禁止事务控制
数据操作	包含多步DML、DDL、游标循环	主要做查询计算、字符串处理、数学运算
日志与安全	需要把逻辑限制在DB内部	无状态计算，可以在任何SQL环境复用
性能侧重点	减少应用与数据库交互次数	减少代码重复，增强SQL表达力
测试复杂度	依赖数据库上下文，适合集成测试	可以当作纯函数进行单元测试

这张表大部分时候能直接给出答案。如果两个维度都匹配，那就再看下一条判断原则。

5.2 选存储过程的典型场景：事务性业务流程、批量操作、数据归档

我把存储过程最适合的场景归纳为三类：

事务性业务流程：比如"下单主流程"，涉及订单表、库存表、账户余额表、流水表的多步写入，必须保证原子性。封装进存储过程后，事务边界在数据库内部，应用层只需要调用一次，即使中途失败也能回滚干净。
批量数据处理：比如"月末全量对账"、"每日凌晨的报表预计算"、"把临时表数据清洗后写进正式表"。这些操作通常要遍历大量数据，用游标和循环在存储过程里做，比在应用层一条条发SQL快很多，而且不会产生成千上万次网络交互。
数据归档与清理：按照日期把历史数据搬到归档表、删除过期日志等，这些逻辑通常带条件和循环，放在存储过程里也更好控制进度和日志记录。

这类场景的共同点是：调用方根本不关心中间步骤，只关心最终结果是否正确。中间怎么查、怎么算、怎么更新的，都在存储过程内部完成。

5.3 选函数的典型场景：可复用的计算逻辑、格式化逻辑、查询中的派生列

函数适合做纯计算、纯转换、无副作用的事情。举例：

根据订单金额和用户等级计算积分
根据出生日期计算年龄
格式化手机号、身份证号脱敏
把金额转换为大写中文
根据经纬度计算两点距离
根据产品编码解析出品类名称

这些逻辑如果在每个查询里都重写一遍，不仅代码冗长，还容易不一致。我把它们写成自定义函数，让所有SQL都有统一的"表达语言"。等业务变化时，只需要改函数定义，所有用到它的查询自动跟着变。

5.4 在微服务架构下被重新审视的"存储逻辑下沉"

现代的微服务或中台架构里，"逻辑放数据库还是放应用层"一直有争议。我的观点是：不要走极端。把复杂的业务规则都塞进应用代码里，数据库只当"存数据的桶"，会导致大量数据传输到应用层计算，性能差；反过来，什么逻辑都下沉到数据库，又会造成数据库CPU飙升，且难以水平扩展。

务实做法是区分边界：涉及多行数据强一致性和事务语义的，用存储过程是合理的；涉及字段间转换和计算表达的，用自定义函数是合理的；剩下的复杂业务编排、调用外部服务、多系统协同，放应用层。

6. 一个综合实例：订单状态统计与批量流转的两种实现

6.1 需求场景

假设有一个电商系统，需要实现两个功能：

给定一个订单金额和用户等级，计算该订单返给用户的积分（规则：普通用户按金额的1%返积分，VIP用户按2%）。
每天凌晨把"已发货超过7天且用户未确认收货"的订单，自动流转为"已完成"状态，并写入操作日志表。

这两个需求一个典型地适合自定义函数，一个典型地适合存储过程。

6.2 用函数实现积分计算

首先创建积分计算函数：

sql复制DELIMITER $$

CREATE FUNCTION 计算订单积分(
    p_amount DECIMAL(10,2),
    p_user_level VARCHAR(10)
)
RETURNS INT
DETERMINISTIC
READS SQL DATA
BEGIN
    DECLARE v_rate DECIMAL(3,2);
    DECLARE v_points INT DEFAULT 0;

    IF p_user_level = 'VIP' THEN
        SET v_rate = 0.02;
    ELSE
        SET v_rate = 0.01;
    END IF;

    SET v_points = FLOOR(p_amount * v_rate);
    RETURN v_points;
END$$

DELIMITER ;

这个函数可以立刻用在一个真实的订单查询里：

sql复制SELECT 
    order_id,
    user_id,
    amount,
    计算订单积分(amount, 'VIP') AS points
FROM orders
WHERE order_id = 12345;

想继续算总积分？直接嵌套在聚合查询里：

sql复制SELECT 
    user_id,
    SUM(计算订单积分(amount, user_level)) AS total_points
FROM orders
WHERE order_time >= '2025-01-01'
GROUP BY user_id;

这就是函数的威力：它不仅是一个"可复用的值计算器"，还能参与SQL的分组和聚合逻辑，让查询语言直接表达业务规则。

6.3 用存储过程实现订单状态流转

与此同时，状态流转这个需求必须处理多步更新+日志记录，放存储过程里才稳妥：

sql复制DELIMITER $$

CREATE PROCEDURE 自动确认收货()
BEGIN
    DECLARE v_order_id INT;
    DECLARE v_done INT DEFAULT 0;

    DECLARE cur CURSOR FOR
        SELECT order_id
        FROM orders
        WHERE status = 'SHIPPED'
          AND ship_time <= NOW() - INTERVAL 7 DAY;
    DECLARE CONTINUE HANDLER FOR NOT FOUND SET v_done = 1;

    START TRANSACTION;

    OPEN cur;
    read_loop: LOOP
        FETCH cur INTO v_order_id;
        IF v_done THEN
            LEAVE read_loop;
        END IF;

        UPDATE orders
        SET status = 'COMPLETED'
        WHERE order_id = v_order_id;

        INSERT INTO order_log(order_id, action, create_time)
        VALUES (v_order_id, 'AUTO_COMPLETED', NOW());
    END LOOP;
    CLOSE cur;

    COMMIT;
END$$

DELIMITER ;

调用它只需要一行：

sql复制CALL 自动确认收货();

我把整个"查未确认订单->逐个更新状态->写日志"的过程封装在了一个事务里，任何一个订单更新失败，所有操作都会回滚，不会出现"改了状态但没写日志"的脏数据。

6.4 从这个案例能抽出什么判断方法

两个需求其实都不复杂，但解法完全不同：

积分计算需要嵌入到很多SELECT查询里，需要参与聚合运算，所以必须是函数。
自动收货需要多步写操作且必须保证事务安全，所以必须是存储过程。

当你下次遇到类似需求，只要心里默念一遍："这是要查出一个值，还是执行一个动作？"答案自然就浮出水面了。

7. 实战中容易忽视的坑与调试技巧

7.1 函数里的SELECT INTO：你以为的"查询赋值"有时会翻车

在存储过程和函数里，SELECT ... INTO 是给变量赋值的标准写法。但很多人不知道，当 SELECT 查不到任何行时，SELECT ... INTO 并不会给变量置空，而是会触发 NOT FOUND 错误码 1329，在存储过程里如果没有声明 CONTINUE HANDLER，整个流程会直接报错中止。

我在一个旧项目里就遇到过：函数正常返回99%的情况，可一旦传参导致某些维度没有数据，函数就神秘地返回NULL或直接报错。排查到最后发现是 SELECT COUNT(*) INTO v_count FROM ... 在0行数据时行为不如预期。

所以我的建议是：在函数里做可能查不到数据的赋值前，要么先用 IF EXISTS 判断，要么用聚合函数（COUNT、MAX）来兜底，因为聚合函数即使查不到记录也会返回一行统计值，不会触发 NOT FOUND。

7.2 权限管理与"强制函数绑定"的问题

自定义函数的授权非常容易被忽略。MySQL里函数和存储过程的权限是分开管理的：

执行权限：EXECUTE ON FUNCTION 库.函数名 TO '用户'@'host'
创建权限：CREATE ROUTINE
修改权限：ALTER ROUTINE

如果你的应用账号只有 SELECT、INSERT、UPDATE、DELETE 权限，那它默认可以调用那些定义者带 SQL SECURITY DEFINER 的存储例程，但前提是定义者本身具备相关权限。如果定义者授权不正确，你会在应用日志里看到一堆 PROCEDURE ... does not exist 或 EXECUTE command denied to user 的诡异报错。

实践中我通常会把数据库账号分为迁移账号（只有DDL和存储例程管理权限）和运行时账号（只保留DML和执行存储例程权限），从权限层面就杜绝"应用账号能随意改库结构"的风险。

7.3 二进制日志与复制模式下的函数"确定性"声明

如果在开启了二进制日志的主从复制环境中使用自定义函数，还有一个隐藏很深的坑：函数必须声明为 DETERMINISTIC、NO SQL 或 READS SQL DATA 三者之一，否则从库在回放函数调用时会拒绝执行。原因是从库无法判断这个函数在每台机器上是否会产生相同结果，为了主从数据一致，MySQL直接设置了一道安全门槛。

我以前在测试环境从来没遇过这个错误，因为本地没开 log_bin；可一部署到生产主从环境，某个定时任务里的存储过程突然大面积报错，查了半天才发现是创建函数时少写了 DETERMINISTIC 声明。所以我写函数时有一套固定的"声明模板"：

sql复制CREATE FUNCTION 时间计算(...) 
RETURNS DATETIME
DETERMINISTIC
NO SQL
BEGIN
    ...
END

如果函数确实会查询数据库表，就把 NO SQL 换成 READS SQL DATA。这样在任何开启复制或二进制日志的环境里都能安全部署。

7.4 一个小技巧：用条件处理程序让存储过程更像"服务"

很多存储过程在实际运行时，需要把错误信息优雅地返回给应用，而不是直接抛一个晦涩的MySQL错误码。我习惯在存储过程里声明一个 OUT p_error_message VARCHAR(500)，然后用 DECLARE EXIT HANDLER FOR SQLEXCEPTION 捕获异常：

sql复制CREATE PROCEDURE 更新订单状态(...)
BEGIN
    DECLARE EXIT HANDLER FOR SQLEXCEPTION
    BEGIN
        ROLLBACK;
        SET p_error_message = '订单更新失败，已回滚';
    END;

    START TRANSACTION;
    UPDATE ...
    COMMIT;
    SET p_error_message = 'OK';
END

这种做法的好处是应用层拿到一个可靠的错误码和错误描述，不用自己解析数据库异常，业务代码也会干净很多。

7.5 测试存储过程与函数时的"临时表陷阱"

在本地用函数或存储过程做测试时，我经常踩到临时表的坑：存储过程里创建的临时表，在存储过程执行完会自动消失，这是MySQL的设计行为。可有些同事会把"临时表"当成"中间表"来用，在过程执行完后还想查临时表数据，结果总是查不到。如果确实需要跨过程保留中间数据，应该使用真正的普通表，并加上 session_id 字段做隔离，用完再清理。

函数里的临时表更麻烦，因为函数不能像存储过程那样自由控制多次调用间的状态。我的原则是：函数内的数据处理尽量用局部变量和表达式完成，不要引入临时表，否则并发调用时会产生大量元数据锁竞争，性能急剧下降。

从我这些年的实践来看，存储过程与函数之间的选择，其实没有想象中那么复杂。先判断"是得到一个值还是执行一件事"，再考虑事务、性能和维护成本，方案通常就自己浮现出来了。如果你刚开始接触这块，建议先从自定义函数练手，因为它简单、直观、能立即嵌进现有SQL；当你对数据库逻辑的把握更稳了，再把多步骤的写入流程收拢进存储过程里。一路用下来，你会发现自己写出的代码不仅整洁，还在关键时刻救过业务的场。希望这篇文章能帮你少走一些我当年走过的弯路。