┌─────────────────────────────────────────────────────────────┐
│                     普通 SQL 執(zhí)行流程                          │
├─────────────────────────────────────────────────────────────┤
│  客戶端 → 發(fā)送SQL語句 → 數(shù)據庫解析 → 編譯 → 優(yōu)化 → 執(zhí)行 → 返回  │
│  （每次都要重復上述全部步驟）                                    │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│                   存儲過程執(zhí)行流程                              │
├─────────────────────────────────────────────────────────────┤
│  第一次：客戶端 → CALL → 解析 → 編譯 → 優(yōu)化 → 執(zhí)行 → 返回      │
│  后續(xù)次：客戶端 → CALL → 直接執(zhí)行已編譯代碼 → 返回               │
│  （省去了解析、編譯、優(yōu)化步驟）                                  │
└─────────────────────────────────────────────────────────────┘

-- 不用存儲過程：客戶端需要發(fā)送多條SQL
SELECT balance FROM account WHERE id = 1;
-- 客戶端判斷余額是否足夠
UPDATE account SET balance = balance - 100 WHERE id = 1;
UPDATE account SET balance = balance + 100 WHERE id = 2;
INSERT INTO transfer_log VALUES (...);
-- 用存儲過程：一條命令搞定
CALL TransferMoney(1, 2, 100.00, @status);

-- 修改結束符（因為存儲過程內部有分號）
DELIMITER //
CREATE PROCEDURE 過程名([參數(shù)列表])
BEGIN
    -- SQL 語句和邏輯
END //
-- 恢復結束符
DELIMITER ;

CREATE PROCEDURE 過程名(
    IN    輸入參數(shù)名  數(shù)據類型,    -- 調用方傳入，過程內只讀
    OUT   輸出參數(shù)名  數(shù)據類型,    -- 過程內寫入，調用方獲取
    INOUT 雙向參數(shù)名  數(shù)據類型     -- 調用方傳入，過程內修改后調用方可獲取
)

DELIMITER //
CREATE PROCEDURE HelloWorld()
BEGIN
    SELECT 'Hello, Stored Procedure!' AS message;
END //
DELIMITER ;
-- 調用
CALL HelloWorld();

+---------------------------+
| message                   |
+---------------------------+
| Hello, Stored Procedure!  |
+---------------------------+

DELIMITER //
CREATE PROCEDURE GetUserById(IN p_id INT)
BEGIN
    SELECT id, username, email, create_time
    FROM users
    WHERE id = p_id;
END //
DELIMITER ;
-- 調用
CALL GetUserById(1);
CALL GetUserById(5);

DELIMITER //
CREATE PROCEDURE GetUserCount(OUT p_count INT)
BEGIN
    SELECT COUNT(*) INTO p_count FROM users;
END //
DELIMITER ;
-- 調用
CALL GetUserCount(@total);
SELECT @total AS user_count;

DELIMITER //
CREATE PROCEDURE Accumulate(INOUT p_counter INT, IN p_increment INT)
BEGIN
    SET p_counter = p_counter + p_increment;
END //
DELIMITER ;
-- 調用
SET @counter = 100;
CALL Accumulate(@counter, 50);
SELECT @counter;  -- 輸出 150
CALL Accumulate(@counter, 30);
SELECT @counter;  -- 輸出 180

DELIMITER //
CREATE PROCEDURE EvaluateScore(IN p_score INT, OUT p_level VARCHAR(20))
BEGIN
    IF p_score >= 90 THEN
        SET p_level = '優(yōu)秀';
    ELSEIF p_score >= 80 THEN
        SET p_level = '良好';
    ELSEIF p_score >= 60 THEN
        SET p_level = '及格';
    ELSE
        SET p_level = '不及格';
    END IF;
END //
DELIMITER ;
-- 調用
CALL EvaluateScore(85, @level);
SELECT @level;  -- 輸出：良好

DELIMITER //
CREATE PROCEDURE BatchUpdateStatus()
BEGIN
    DECLARE v_id INT;
    DECLARE v_done INT DEFAULT 0;
    -- 聲明游標
    DECLARE cur CURSOR FOR
        SELECT id FROM orders WHERE status = 'pending' AND create_time < DATE_SUB(NOW(), INTERVAL 30 DAY);
    -- 聲明結束處理器
    DECLARE CONTINUE HANDLER FOR NOT FOUND SET v_done = 1;
    OPEN cur;
    read_loop: LOOP
        FETCH cur INTO v_id;
        IF v_done = 1 THEN
            LEAVE read_loop;
        END IF;
        -- 將超過30天的待處理訂單自動取消
        UPDATE orders SET status = 'cancelled' WHERE id = v_id;
    END LOOP;
    CLOSE cur;
END //
DELIMITER ;
-- 調用
CALL BatchUpdateStatus();

DELIMITER //
CREATE PROCEDURE TransferMoney(
    IN p_from_id INT,
    IN p_to_id INT,
    IN p_amount DECIMAL(10,2),
    OUT p_status VARCHAR(50)
)
BEGIN
    -- 聲明異常處理：發(fā)生任何 SQL 異常時回滾
    DECLARE EXIT HANDLER FOR SQLEXCEPTION
    BEGIN
        ROLLBACK;
        SET p_status = '轉賬失?。喊l(fā)生異常';
    END;
    -- 余額校驗
    DECLARE v_balance DECIMAL(10,2);
    SELECT balance INTO v_balance FROM account WHERE id = p_from_id FOR UPDATE;
    IF v_balance < p_amount THEN
        SET p_status = '轉賬失?。河囝~不足';
    ELSE
        START TRANSACTION;
            UPDATE account SET balance = balance - p_amount WHERE id = p_from_id;
            UPDATE account SET balance = balance + p_amount WHERE id = p_to_id;
            INSERT INTO transfer_log(from_id, to_id, amount, transfer_time)
            VALUES (p_from_id, p_to_id, p_amount, NOW());
        COMMIT;
        SET p_status = '轉賬成功';
    END IF;
END //
DELIMITER ;

-- 遇到異常后繼續(xù)執(zhí)行后續(xù)語句
DECLARE CONTINUE HANDLER FOR SQLEXCEPTION SET @err = 1;
-- 遇到異常后退出當前 BEGIN...END 塊
DECLARE EXIT HANDLER FOR SQLEXCEPTION
BEGIN
    ROLLBACK;
    SELECT '執(zhí)行出錯' AS error_msg;
END;
-- 處理特定錯誤碼
DECLARE CONTINUE HANDLER FOR 1062  -- 重復鍵錯誤
    SET @duplicate = 1;

-- ========== 查看 ==========
-- 查看當前數(shù)據庫所有存儲過程
SHOW PROCEDURE STATUS WHERE Db = 'your_database';
-- 查看某個存儲過程的創(chuàng)建語句
SHOW CREATE PROCEDURE TransferMoney;
-- 從系統(tǒng)表查詢
SELECT * FROM information_schema.ROUTINES
WHERE ROUTINE_SCHEMA = 'your_database'
  AND ROUTINE_TYPE = 'PROCEDURE';
-- ========== 修改 ==========
-- MySQL 不支持 ALTER PROCEDURE 修改過程體
-- 只能先刪除再重新創(chuàng)建
DROP PROCEDURE IF EXISTS TransferMoney;
-- 然后重新 CREATE PROCEDURE ...
-- ========== 刪除 ==========
DROP PROCEDURE IF EXISTS GetUserById;

① DECLARE  →  聲明游標（綁定一條 SELECT 語句，此時不執(zhí)行）
② OPEN     →  打開游標（執(zhí)行 SELECT，將結果集加載到內存）
③ FETCH    →  逐行讀?。▽斍靶袛?shù)據存入變量，指針下移）
④ CLOSE    →  關閉游標（釋放結果集占用的內存）

DELIMITER //
CREATE PROCEDURE cursor_demo()
BEGIN
    -- 1. 聲明局部變量（用于存放每行數(shù)據）
    DECLARE v_id   INT;
    DECLARE v_name VARCHAR(50);
    DECLARE v_done INT DEFAULT 0;  -- 游標結束標志
    -- 2. 聲明游標（綁定 SELECT，注意：此時并不執(zhí)行查詢）
    DECLARE cur CURSOR FOR
        SELECT id, username FROM users WHERE status = 1;
    -- 3. 聲明結束處理器（FETCH 到末尾觸發(fā) NOT FOUND，將 v_done 置 1）
    --    注意：HANDLER 必須聲明在游標之后
    DECLARE CONTINUE HANDLER FOR NOT FOUND SET v_done = 1;
    -- 4. 打開游標（此時才真正執(zhí)行 SELECT 查詢）
    OPEN cur;
    -- 5. 循環(huán)讀取
    read_loop: LOOP
        FETCH cur INTO v_id, v_name;  -- 讀取當前行到變量，指針后移
        IF v_done = 1 THEN            -- 沒有更多行，退出循環(huán)
            LEAVE read_loop;
        END IF;
        -- 處理當前行的業(yè)務邏輯
        -- ...
    END LOOP read_loop;
    -- 6. 關閉游標（釋放資源）
    CLOSE cur;
END //
DELIMITER ;

DELIMITER //
CREATE PROCEDURE sp_send_notification_log()
BEGIN
    DECLARE v_user_id INT;
    DECLARE v_email   VARCHAR(100);
    DECLARE v_done    INT DEFAULT 0;
    DECLARE cur CURSOR FOR
        SELECT id, email FROM users WHERE is_active = 1;
    DECLARE CONTINUE HANDLER FOR NOT FOUND SET v_done = 1;
    OPEN cur;
    user_loop: LOOP
        FETCH cur INTO v_user_id, v_email;
        IF v_done = 1 THEN
            LEAVE user_loop;
        END IF;
        INSERT INTO notification_log(user_id, email, send_time, content)
        VALUES (v_user_id, v_email, NOW(), '系統(tǒng)有重要通知，請及時查看。');
    END LOOP user_loop;
    CLOSE cur;
END //
DELIMITER ;

DELIMITER //
CREATE PROCEDURE sp_update_user_points()
BEGIN
    DECLARE v_id      INT;
    DECLARE v_orders  INT;
    DECLARE v_done    INT DEFAULT 0;
    DECLARE cur CURSOR FOR
        SELECT u.id, COUNT(o.id) AS order_count
        FROM users u
        LEFT JOIN orders o ON u.id = o.user_id AND o.status = 'completed'
        GROUP BY u.id;
    DECLARE CONTINUE HANDLER FOR NOT FOUND SET v_done = 1;
    OPEN cur;
    point_loop: LOOP
        FETCH cur INTO v_id, v_orders;
        IF v_done = 1 THEN
            LEAVE point_loop;
        END IF;
        -- 根據完成訂單數(shù)量差異化增加積分
        IF v_orders >= 100 THEN
            UPDATE users SET points = points + 500 WHERE id = v_id;
        ELSEIF v_orders >= 50 THEN
            UPDATE users SET points = points + 200 WHERE id = v_id;
        ELSEIF v_orders >= 10 THEN
            UPDATE users SET points = points + 50 WHERE id = v_id;
        END IF;
    END LOOP point_loop;
    CLOSE cur;
END //
DELIMITER ;

DELIMITER //
CREATE PROCEDURE sp_sync_department_stats()
BEGIN
    DECLARE v_dept_id    INT;
    DECLARE v_emp_count  INT;
    DECLARE v_avg_salary DECIMAL(10,2);
    DECLARE v_done       INT DEFAULT 0;
    DECLARE dept_cur CURSOR FOR
        SELECT id FROM departments;
    DECLARE CONTINUE HANDLER FOR NOT FOUND SET v_done = 1;
    OPEN dept_cur;
    dept_loop: LOOP
        FETCH dept_cur INTO v_dept_id;
        IF v_done = 1 THEN
            LEAVE dept_loop;
        END IF;
        -- 對每個部門單獨做聚合查詢
        SELECT COUNT(*), IFNULL(AVG(salary), 0)
        INTO v_emp_count, v_avg_salary
        FROM employees
        WHERE department_id = v_dept_id;
        -- 更新統(tǒng)計表（存在則更新，不存在則插入）
        INSERT INTO department_stats(dept_id, emp_count, avg_salary, updated_at)
        VALUES (v_dept_id, v_emp_count, v_avg_salary, NOW())
        ON DUPLICATE KEY UPDATE
            emp_count  = v_emp_count,
            avg_salary = v_avg_salary,
            updated_at = NOW();
    END LOOP dept_loop;
    CLOSE dept_cur;
END //
DELIMITER ;

-- ? 用游標逐行更新（慢，不推薦）
-- 聲明游標 → 循環(huán) FETCH → 逐條 UPDATE ...
-- ? 用一條集合 SQL 批量更新（快，推薦）
UPDATE orders
SET status = 'cancelled'
WHERE status = 'pending'
  AND create_time < DATE_SUB(NOW(), INTERVAL 30 DAY);

-- 內置函數(shù)的使用方式
SELECT LENGTH(username), UPPER(email) FROM users;
-- 自定義存儲函數(shù)可以做到完全一樣的事
SELECT fn_mask_phone(phone), fn_get_age_group(age) FROM users;
SELECT * FROM users WHERE fn_is_vip(id) = 1;

DELIMITER //
CREATE FUNCTION 函數(shù)名(參數(shù)1 數(shù)據類型, 參數(shù)2 數(shù)據類型, ...)
RETURNS 返回值類型
[特性關鍵字]
BEGIN
    -- 函數(shù)體（只有 IN 參數(shù)，沒有 OUT/INOUT）
    RETURN 返回值;
END //
DELIMITER ;

SET GLOBAL log_bin_trust_function_creators = 1;

-- 存儲過程：必須用 CALL，不能嵌入 SQL
CALL sp_get_user_by_id(1);
-- 存儲函數(shù)：像內置函數(shù)一樣隨處可用
SELECT fn_mask_phone('13812345678');                -- 直接查詢
SELECT id, fn_mask_phone(phone) FROM users;         -- SELECT 字段中
SELECT * FROM users WHERE fn_get_age_group(age) = '青年';  -- WHERE 條件中
INSERT INTO report SELECT fn_calc_score(id) FROM users;    -- INSERT...SELECT 中

DELIMITER //
CREATE FUNCTION fn_mask_phone(p_phone VARCHAR(20))
RETURNS VARCHAR(20)
DETERMINISTIC
BEGIN
    -- 13812345678 → 138****5678
    IF p_phone IS NULL OR LENGTH(p_phone) != 11 THEN
        RETURN p_phone;  -- 不符合格式，原樣返回
    END IF;
    RETURN CONCAT(
        LEFT(p_phone, 3),
        '****',
        RIGHT(p_phone, 4)
    );
END //
DELIMITER ;
-- 使用：直接嵌入 SELECT
SELECT id, username, fn_mask_phone(phone) AS masked_phone FROM users;

DELIMITER //
CREATE FUNCTION fn_get_age_group(p_age INT)
RETURNS VARCHAR(10)
DETERMINISTIC
BEGIN
    DECLARE v_group VARCHAR(10);
    CASE
        WHEN p_age < 18 THEN SET v_group = '未成年';
        WHEN p_age < 30 THEN SET v_group = '青年';
        WHEN p_age < 50 THEN SET v_group = '中年';
        ELSE                  SET v_group = '老年';
    END CASE;
    RETURN v_group;
END //
DELIMITER ;
-- 使用：嵌入 ORDER BY 和 GROUP BY 也沒問題
SELECT fn_get_age_group(age) AS age_group, COUNT(*) AS cnt
FROM users
GROUP BY fn_get_age_group(age);

DELIMITER //
CREATE FUNCTION fn_get_user_total_amount(p_user_id INT)
RETURNS DECIMAL(12,2)
READS SQL DATA
BEGIN
    DECLARE v_total DECIMAL(12,2) DEFAULT 0.00;
    SELECT IFNULL(SUM(amount), 0.00)
    INTO v_total
    FROM orders
    WHERE user_id = p_user_id
      AND status = 'completed';
    RETURN v_total;
END //
DELIMITER ;
-- 使用：在 WHERE 中篩選高價值用戶
SELECT id, username, fn_get_user_total_amount(id) AS total_amount
FROM users
WHERE fn_get_user_total_amount(id) > 10000
ORDER BY total_amount DESC;

DELIMITER //
CREATE FUNCTION fn_fibonacci(n INT)
RETURNS BIGINT
DETERMINISTIC
BEGIN
    IF n <= 0 THEN RETURN 0; END IF;
    IF n = 1  THEN RETURN 1; END IF;
    RETURN fn_fibonacci(n - 1) + fn_fibonacci(n - 2);
END //
DELIMITER ;
-- 使用前需設置最大遞歸深度（默認為0，即不允許遞歸）
SET max_sp_recursion_depth = 20;
SELECT fn_fibonacci(10);  -- 輸出 55

-- 查看所有存儲函數(shù)
SHOW FUNCTION STATUS WHERE Db = 'your_database';
-- 查看函數(shù)定義
SHOW CREATE FUNCTION fn_mask_phone;
-- 從系統(tǒng)表查詢
SELECT ROUTINE_NAME, ROUTINE_TYPE, DTD_IDENTIFIER, ROUTINE_DEFINITION
FROM information_schema.ROUTINES
WHERE ROUTINE_SCHEMA = 'your_database'
  AND ROUTINE_TYPE = 'FUNCTION';
-- 刪除函數(shù)
DROP FUNCTION IF EXISTS fn_mask_phone;

DELIMITER //
CREATE TRIGGER trigger_name
{BEFORE | AFTER} {INSERT | UPDATE | DELETE}
ON table_name
FOR EACH ROW
BEGIN
    -- 觸發(fā)器邏輯
END //
DELIMITER ;

-- 在 BEFORE INSERT 中預處理數(shù)據
SET NEW.username   = LOWER(NEW.username);   -- 用戶名統(tǒng)一轉小寫
SET NEW.create_time = NOW();                 -- 自動填充創(chuàng)建時間

-- 操作日志表
CREATE TABLE operation_log (
    id           INT AUTO_INCREMENT PRIMARY KEY,
    table_name   VARCHAR(50)  NOT NULL,
    operation    VARCHAR(20)  NOT NULL,
    record_id    INT,
    operate_time DATETIME     NOT NULL,
    detail       TEXT
);
DELIMITER //
CREATE TRIGGER trg_users_after_insert
AFTER INSERT ON users
FOR EACH ROW
BEGIN
    INSERT INTO operation_log(table_name, operation, record_id, operate_time, detail)
    VALUES (
        'users',
        'INSERT',
        NEW.id,
        NOW(),
        CONCAT('新增用戶：', NEW.username, '，郵箱：', NEW.email)
    );
END //
DELIMITER ;

DELIMITER //
CREATE TRIGGER trg_users_after_update
AFTER UPDATE ON users
FOR EACH ROW
BEGIN
    -- 只有 status 字段變更時才寫日志，避免無效日志
    IF OLD.status != NEW.status THEN
        INSERT INTO operation_log(table_name, operation, record_id, operate_time, detail)
        VALUES (
            'users',
            'UPDATE',
            NEW.id,
            NOW(),
            CONCAT('用戶[', NEW.username, ']狀態(tài)變更：', OLD.status, ' → ', NEW.status)
        );
    END IF;
END //
DELIMITER ;

DELIMITER //
CREATE TRIGGER trg_orders_before_insert
BEFORE INSERT ON orders
FOR EACH ROW
BEGIN
    -- 校驗：訂單金額不能為負數(shù)
    IF NEW.amount <= 0 THEN
        SIGNAL SQLSTATE '45000'
            SET MESSAGE_TEXT = '訂單金額必須大于0';
    END IF;
    -- 自動填充創(chuàng)建時間
    IF NEW.create_time IS NULL THEN
        SET NEW.create_time = NOW();
    END IF;
    -- 自動生成訂單號
    IF NEW.order_no IS NULL OR NEW.order_no = '' THEN
        SET NEW.order_no = CONCAT(
            'ORD',
            DATE_FORMAT(NOW(), '%Y%m%d%H%i%s'),
            LPAD(NEW.user_id, 6, '0')
        );
    END IF;
END //
DELIMITER ;

DELIMITER //
CREATE TRIGGER trg_orders_after_delete
AFTER DELETE ON orders
FOR EACH ROW
BEGIN
    -- 被刪除的數(shù)據自動歸檔到備份表
    INSERT INTO orders_archive(
        id, user_id, amount, status, create_time, archived_at
    )
    VALUES (
        OLD.id,
        OLD.user_id,
        OLD.amount,
        OLD.status,
        OLD.create_time,
        NOW()
    );
END //
DELIMITER ;

DELIMITER //
-- 訂單狀態(tài)只能單向流轉：pending → paid → shipped → completed
-- 已完成或已取消的訂單不允許再修改狀態(tài)
CREATE TRIGGER trg_orders_before_update
BEFORE UPDATE ON orders
FOR EACH ROW
BEGIN
    IF OLD.status = 'completed' AND NEW.status != 'completed' THEN
        SIGNAL SQLSTATE '45000'
            SET MESSAGE_TEXT = '已完成的訂單不允許修改狀態(tài)';
    END IF;
    IF OLD.status = 'cancelled' THEN
        SIGNAL SQLSTATE '45000'
            SET MESSAGE_TEXT = '已取消的訂單不允許再操作';
    END IF;
END //
DELIMITER ;

以執(zhí)行一條 UPDATE orders SET status='paid' WHERE id=1 為例：
┌──────────────────────────────────────────────────────────────────┐
│  1. BEFORE UPDATE 觸發(fā)器執(zhí)行                                      │
│     → 可以通過 SET NEW.xxx 修改即將寫入的值                        │
│     → 可以通過 SIGNAL 拋錯阻止本次操作（整個語句回滾）              │
├──────────────────────────────────────────────────────────────────┤
│  2. 實際執(zhí)行 UPDATE 語句（數(shù)據寫入磁盤）                            │
├──────────────────────────────────────────────────────────────────┤
│  3. AFTER UPDATE 觸發(fā)器執(zhí)行                                       │
│     → 數(shù)據已確定寫入，適合做日志記錄、數(shù)據同步                      │
│     → 若此處拋錯，整個事務（含 UPDATE）一起回滾                    │
└──────────────────────────────────────────────────────────────────┘

-- 查看當前數(shù)據庫所有觸發(fā)器
SHOW TRIGGERS FROM your_database;
-- 查看特定表的觸發(fā)器
SHOW TRIGGERS FROM your_database LIKE 'orders';
-- 查看觸發(fā)器定義
SHOW CREATE TRIGGER trg_users_after_insert;
-- 從系統(tǒng)表查詢（可獲取更詳細的信息）
SELECT TRIGGER_NAME, EVENT_MANIPULATION, EVENT_OBJECT_TABLE,
       ACTION_TIMING, ACTION_STATEMENT
FROM information_schema.TRIGGERS
WHERE TRIGGER_SCHEMA = 'your_database';
-- 刪除觸發(fā)器
DROP TRIGGER IF EXISTS trg_users_after_insert;

2005年的架構：
┌─────────┐      ┌──────────────────┐
│  客戶端  │ ──→  │   單體應用 + DB   │  ← 業(yè)務邏輯大量放在存儲過程中
└─────────┘      └──────────────────┘
2020年的架構：
┌─────────┐      ┌─────────┐  ┌─────────┐  ┌─────────┐
│  客戶端  │ ──→  │ 服務A   │  │ 服務B   │  │ 服務C   │
└─────────┘      └────┬────┘  └────┬────┘  └────┬────┘
                      │            │            │
                  ┌───┴───┐   ┌───┴───┐   ┌───┴───┐
                  │  DB-A  │  │  DB-B  │  │  DB-C  │
                  └───────┘   └───────┘   └───────┘

-- MySQL 的存儲過程語法
DELIMITER //
CREATE PROCEDURE ...
BEGIN
    DECLARE v INT;
    ...
END //
-- Oracle 的存儲過程語法（PL/SQL）
CREATE OR REPLACE PROCEDURE ...
IS
    v NUMBER;
BEGIN
    ...
END;
-- SQL Server 的存儲過程語法（T-SQL）
CREATE PROCEDURE ...
AS
BEGIN
    DECLARE @v INT;
    ...
END

// MyBatis —— 用 XML 或注解寫 SQL，邏輯在 Java 中
@Mapper
public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User findById(int id);
}
// JPA —— 連 SQL 都不用寫
public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByAgeGreaterThan(int age);
}

┌─────────────────────────────────────────────────────────────┐
│              什么時候用存儲過程？                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ? 用：                                                    │
│     ? 大批量數(shù)據處理（ETL、定時任務）                           │
│     ? 對性能要求極致的數(shù)據庫操作                               │
│     ? 需要嚴格權限控制，不允許直接操作表                        │
│     ? 數(shù)據庫平臺固定，不考慮遷移                               │
│                                                             │
│  ? 不用：                                                   │
│     ? 常規(guī) CRUD 業(yè)務邏輯                                     │
│     ? 微服務架構項目                                          │
│     ? 需要頻繁迭代的業(yè)務                                      │
│     ? 需要跨數(shù)據庫平臺的項目                                  │
│     ? 團隊沒有熟悉存儲過程的 DBA                              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

// 調用帶輸入輸出參數(shù)的存儲過程
try (Connection conn = dataSource.getConnection();
     CallableStatement cs = conn.prepareCall("{CALL GetUserCount(?)}")) {
    // 注冊輸出參數(shù)
    cs.registerOutParameter(1, Types.INTEGER);
    // 執(zhí)行
    cs.execute();
    // 獲取輸出參數(shù)
    int count = cs.getInt(1);
    System.out.println("用戶總數(shù)：" + count);
}

<!-- Mapper XML -->
<select id="getUserCount" statementType="CALLABLE" resultType="map">
    {CALL GetUserCount(#{count, mode=OUT, jdbcType=INTEGER})}
</select>

// Mapper 接口
@Mapper
public interface UserMapper {
    void getUserCount(Map<String, Object> params);
}
// 使用
Map<String, Object> params = new HashMap<>();
userMapper.getUserCount(params);
System.out.println(params.get("count"));

@Autowired
private JdbcTemplate jdbcTemplate;
public int getUserCount() {
    SimpleJdbcCall call = new SimpleJdbcCall(jdbcTemplate)
        .withProcedureName("GetUserCount");
    Map<String, Object> result = call.execute();
    return (Integer) result.get("p_count");
}

@Entity
@NamedStoredProcedureQuery(
    name = "User.getUserCount",
    procedureName = "GetUserCount",
    parameters = {
        @StoredProcedureParameter(mode = ParameterMode.OUT, name = "p_count", type = Integer.class)
    }
)
public class User { ... }
// 調用
StoredProcedureQuery query = entityManager.createNamedStoredProcedureQuery("User.getUserCount");
query.execute();
Integer count = (Integer) query.getOutputParameterValue("p_count");

-- 推薦：動詞 + 名詞，前綴表明類型
sp_transfer_money        -- sp = stored procedure
sp_get_user_by_id
sp_batch_cancel_orders
sp_calculate_monthly_report
-- 不推薦
proc1
my_procedure
test

DELIMITER //
CREATE PROCEDURE sp_example(
    IN  p_user_id  INT,          -- 參數(shù)用 p_ 前綴
    OUT p_result   VARCHAR(50)
)
COMMENT '示例存儲過程：簡要說明功能'
BEGIN
    -- 局部變量用 v_ 前綴
    DECLARE v_count INT DEFAULT 0;
    DECLARE v_status VARCHAR(20);
    -- 業(yè)務邏輯...
    -- 1. 每個步驟加注釋
    -- 2. 適當?shù)腻e誤處理
    -- 3. 避免嵌套過深（建議不超過3層）
END //
DELIMITER ;