如何使用 PL/SQL 一次更新多行数据？

在数据库管理领域，尤其是面对大规模数据集时，同时更新多行数据的能力往往是区分一个应用性能高下的关键因素。作为 Oracle 数据库的核心过程化扩展，PL/SQL 一直是我们手中最强大的利剑。然而，站在 2026 年的视角回望，仅仅掌握基础的 UPDATE 语句已经远远不够了。在本文中，我们将超越传统的教科书式教学，深入探讨三种强大的 Oracle 技术——单个 UPDATE 语句、游标以及 MERGE 语句——并结合现代开发理念，分享我们在企业级项目中的实战经验、性能优化策略以及如何规避那些令人头疼的“坑”。

基础回顾：如何更新多行数据？

UPDATE 语句是我们更改已有数据的基础手段。但在深入复杂的批量处理之前，我们需要建立测试环境。我们将使用以下结构创建 Students 表，这将是我们后续演示的基础。

-- 创建学生表
CREATE TABLE Students (
    Student VARCHAR2(50),
    Subject VARCHAR2(50),
    Marks INT
);

-- 插入测试数据
INSERT INTO Students (Student, Subject, Marks)
SELECT * FROM (
    VALUES (‘John‘, ‘Math‘, 90), (‘John‘, ‘Science‘, 80), (‘John‘, ‘English‘, 95),
           (‘Jane‘, ‘Math‘, 85), (‘Jane‘, ‘Science‘, 75), (‘Jane‘, ‘English‘, 90)
);

1. 使用单个 UPDATE 语句：追求极致性能的首选

在 Oracle PL/SQL 中，最直接、最高效的方式永远是单个 UPDATE 语句。这就是所谓的“基于集合”的操作，它允许数据库引擎一次性优化并执行所有更改，而不是逐行处理。

基础语法与示例

语法很简单：指定表、设置新值、提供条件。

UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;

让我们将分数低于 90 分的学生的成绩提高 5 分：

UPDATE Students 
SET Marks = Marks + 5
WHERE Marks < 90;

深入分析：为何这是“黄金标准”？

在我们最近的多个高并发系统优化项目中，我们发现这种“集合操作”通常比游标快 10 到 100 倍。为什么？因为 Oracle 的优化器可以在执行前构建最优的执行计划，利用多线程并行处理，最小化上下文切换。在 2026 年，随着硬件性能的提升，这种差距变得更加明显。

进阶实战：批量绑定（BULK BIND）与数组处理

但是，你可能会问：“如果更新逻辑非常复杂，无法用简单的 SQL 表达怎么办？或者数据源不在表中，而在应用程序的数组中？” 这时候，我们就需要引入 FORALL 语句。

这是我们在处理数万条数据更新时的“杀手锏”。它结合了 PL/SQL 的灵活性和 SQL 的效率。

DECLARE
    -- 定义一个记录类型和嵌套表
    TYPE StudentList IS TABLE OF Students%ROWTYPE;
    v_students StudentList := StudentList();
BEGIN
    -- 假设我们从复杂的业务逻辑中计算出了需要更新的数据
    -- 这里为了演示，模拟填充数据（实际中可能来自 API 或复杂计算）
    v_students.EXTEND(2);
    v_students(1).Student := ‘John‘; v_students(1).Subject := ‘Science‘; v_students(1).Marks := 85;
    v_students(2).Student := ‘Jane‘; v_students(2).Subject := ‘Science‘; v_students(2).Marks := 80;

    -- 使用 FORALL 进行批量绑定更新
    -- 这会将所有的更新操作一次性发送给 SQL 引擎
    FORALL i IN 1..v_students.COUNT
        UPDATE Students
        SET Marks = v_students(i).Marks
        WHERE Student = v_students(i).Student
        AND Subject = v_students(i).Subject;

    COMMIT;
    DBMS_OUTPUT.PUT_LINE(‘批量更新完成！影响了 ‘ || SQL%ROWCOUNT || ‘ 行。‘);
END;
/

性能提示： 在我们处理百万级数据量的实践中，使用 FORALL 替代普通循环可以将执行时间从数分钟缩短到几秒钟。这减少了 PL/SQL 引擎和 SQL 引擎之间的上下文切换开销。

2. 使用游标：谨慎使用的双刃剑

游标提供了一种逐行遍历查询结果并执行更新的机制。虽然它在逻辑上很直观，但在 2026 年的今天，我们通常建议将其作为最后的手段，除非逻辑极其复杂无法向量化。

基础示例

DECLARE
    CURSOR update_cursor IS
        SELECT * FROM Students;
BEGIN
    FOR record IN update_cursor LOOP
        -- 这里可以包含非常复杂的业务逻辑判断
        UPDATE Students
        SET Marks = record.Marks * 2
        WHERE Student = record.Student AND Subject = record.Subject;
    END LOOP;
END;

现代视角的陷阱与对策

你可能已经注意到，上面的代码存在严重的性能问题。它在循环中执行了 N 次 UPDATE 语句（即“上下文切换”噩梦）。在大型数据集上，这会导致显著的 CPU 消耗和锁争用。

最佳实践：可更新游标（WHERE CURRENT OF）

如果你必须使用游标，请务必使用“WHERE CURRENT OF”子句。这直接利用游标定位的行指针进行更新，省去了再次扫描表的过程。

DECLARE
    CURSOR c_students IS
        SELECT * FROM Students
        FOR UPDATE; -- 必须锁定行
BEGIN
    FOR rec IN c_students LOOP
        -- 仅在必要时更新
        IF rec.Marks < 80 THEN
            UPDATE Students
            SET Marks = Marks + 10
            WHERE CURRENT OF c_students; -- 直接定位，无需再次匹配主键
        END IF;
    END LOOP;
    COMMIT; -- 提交后释放锁
END;

警告： 游标会持有锁。在使用显式游标更新时，务必确保事务尽可能短，否则在并发环境下极易造成死锁或阻塞其他业务。

3. 使用 MERGE 语句：数据同步的终极武器

MERGE 语句（也称为 UPSERT）是处理“存在则更新，不存在则插入”场景的神器。在数据仓库同步和微服务数据聚合场景中，这是我们不二的选择。

经典应用场景

假设我们有一个包含最新成绩的临时表 New_Scores，我们需要将其合并到主表中。

-- 创建源表
CREATE TABLE New_Scores AS SELECT * FROM Students WHERE 1=0;

-- 模拟新数据
INSERT INTO New_Scores VALUES (‘John‘, ‘Math‘, 95); -- 更新
INSERT INTO New_Scores VALUES (‘Mike‘, ‘History‘, 70); -- 插入

-- 使用 MERGE
MERGE INTO Students target
USING New_Scores source
ON (target.Student = source.Student AND target.Subject = source.Subject)
WHEN MATCHED THEN
    UPDATE SET target.Marks = source.Marks
WHEN NOT MATCHED THEN
    INSERT (Student, Subject, Marks)
    VALUES (source.Student, source.Subject, source.Marks);

2026年工程化视角：容错与幂等性

在现代分布式系统中，数据可能会被重复发送。MERGE 语句天然具有幂等性，这意味着无论你运行它多少次，结果都是一致的。这为我们构建健壮的 ETL 管道提供了保障。我们建议在所有数据同步接口中优先考虑 MERGE 而非单独的 INSERT/UPDATE 逻辑。

4. 现代开发工作流与 AI 辅助（2026特辑）

作为身处 2026 年的开发者，我们不仅需要掌握 SQL 本身，还需要掌握如何利用现代化的工具链来提升数据库开发的效率和质量。这就是我们所说的“氛围编程”——让 AI 成为你的虚拟 DBA 伙伴。

利用 Cursor / GitHub Copilot 进行 PL/SQL 开发

我们在编写复杂的 PL/SQL 存储过程时，通常会使用 AI IDE（如 Cursor）来辅助。关键在于如何提问：

• 上下文注入：不要只说“帮我写个更新”。要说：“这是一个 Oracle 19c 数据库，我有两个表 A 和 B，需要根据列 ID 匹配更新 A 的值，但要注意处理 NULL 值，请使用 MERGE 语句。”
• 迭代优化：生成代码后，你可以继续问：“这个游标在高并发下有死锁风险吗？请改写成批量更新的形式。”

监控与可观测性

仅仅执行更新是不够的。在现代 DevSecOps 理念下，我们需要了解这些更新对系统的影响。我们建议在 PL/SQL 块中集成日志记录和指标追踪。

DECLARE
    v_start_time TIMESTAMP;
    v_row_count NUMBER;
BEGIN
    v_start_time := SYSTIMESTAMP;

    UPDATE Students SET Marks = Marks + 1 WHERE Marks > 60;
    v_row_count := SQL%ROWCOUNT;

    -- 记录操作日志（可接入企业级监控平台）
    DBMS_APPLICATION_INFO.SET_MODULE(‘STUDENT_UPDATE‘, ‘BATCH_INCREMENT‘);
    DBMS_APPLICATION_INFO.SET_ACTION(‘ROWS: ‘ || v_row_count);

    COMMIT;
    DBMS_OUTPUT.PUT_LINE(‘执行耗时: ‘ || (SYSTIMESTAMP - v_start_time) || ‘ | 影响行数: ‘ || v_row_count);
END;

通过这种方式，我们将数据库操作变成了可观测的指标，这对于在云原生环境中排查性能瓶颈至关重要。

总结

在本文中，我们探索了在 PL/SQL 中更新多行数据的三种核心技术。

• 首选方案：为了极致的性能，请始终优先考虑使用单个 UPDATE 语句或结合 FORALL 进行批量绑定。
• 谨慎使用：游标虽然灵活，但在处理大规模数据时往往伴随着性能陷阱，如果非用不可，请务必使用 WHERE CURRENT OF 优化锁定策略。
• 同步神器：对于复杂的同步场景，MERGE 语句提供了最简洁且幂等的解决方案。

最后，不要忘记拥抱 2026 年的开发工具链。结合 AI 辅助编程和完善的可观测性监控，我们不仅能写出高效的代码，更能确保系统的长期稳定性和可维护性。现在，去优化你的数据库代码吧！