This resume is also available in English.

二、寫一個服務第 3 / 4 篇 · 全部目錄

專欄 › 二、寫一個服務 › 第 7 篇

database/sql、交易與連線池

database/sql, Transactions and Connection Pools in Go

替訂單服務寫出資料庫版的 repository:理解 sql.DB 其實是連線池、正確關閉 rows、處理 NULL 與 ErrNoRows,用交易讓扣庫存與建立訂單一起成功或一起失敗,並調校連線池避免超賣與連線耗盡。

  • Go
  • Database
  • database/sql
  • Transactions
  • Connection Pool
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:sql.DB 不是一條連線,是一個連線池
  3. 第 2 步:建表,並正確地讀取資料
  4. 第 3 步:每一次呼叫都帶著 context
  5. 第 4 步:調校連線池
  6. 第 5 步:用交易讓多個寫入一起成功或一起失敗
  7. 第 6 步:併發下的正確性:超賣、鎖與隔離等級
  8. 第 7 步:接回服務
  9. 常見陷阱
  10. 重點整理
  11. 下一篇

上一篇〈分層架構與依賴注入〉我們把訂單服務拆成 handler、service、repository 三層,並讓 service 只依賴自己定義的 Repository 介面;這篇接著寫出那個介面的資料庫實作,讓訂單真正被保存下來。

這篇要解決什麼

記憶體版的 repository 有兩個致命問題:服務重新啟動資料就消失;多個服務執行個體之間無法共用資料。把資料放進關聯式資料庫是最自然的下一步,而 Go 標準函式庫的 database/sql 提供了一套與資料庫種類無關的介面,搭配各資料庫的驅動程式使用。

database/sql 的 API 不大,卻有不少「看起來能動、上線後才出事」的地方:

  • 以為 sql.Open 會連線,結果設定錯誤要到第一個請求才發現。
  • 忘了關閉 rows,連線一條條被佔住,最後整個服務卡在等待連線。
  • 沒有設定連線池上限,流量一大就把資料庫的連線數打滿。
  • 扣庫存與建立訂單分成兩個獨立的語句,中間出錯就留下扣了庫存卻沒有訂單的資料。
  • 先讀庫存、再寫回庫存,兩個請求同時進來就賣出不存在的商品。

這篇會一步一步處理這些問題。範例 SQL 以 PostgreSQL 的語法撰寫(佔位符是 $1、$2),換成 MySQL 時佔位符改成 ?,其餘觀念完全相同。因為重點是 database/sql 本身,程式片段都不綁定特定的驅動程式。

第 1 步:sql.DB 不是一條連線,是一個連線池

sql.Open(driverName, dsn) 回傳的 *sql.DB,名字容易讓人誤會。它不是一條資料庫連線,而是一個由 database/sql 管理的連線池:裡面可能有零到多條實體連線,每次執行查詢時從池裡借一條,用完再還回去。這帶來幾個直接的推論:

  1. sql.Open 不會真的連線。 它只驗證參數並建立池子,第一條連線要等到第一次查詢才建立。所以啟動時應該呼叫 PingContext 主動確認資料庫連得上,讓設定錯誤在啟動階段就失敗。
  2. 整個程式只需要一個 *sql.DB。 它可以安全地被多個 goroutine 同時使用,應該在組裝根建立一次,再注入給所有 repository。每個請求都 sql.Open 一次,等於每次都建一個新的池子,不但浪費,還會讓連線數失控。
  3. 不要頻繁呼叫 db.Close()。 它會關閉整個池子,只在程式結束時呼叫一次。

驅動程式透過空白匯入向 database/sql 註冊自己,例如 PostgreSQL 常用的 github.com/jackc/pgx/v5/stdlib 會註冊名為 pgx 的驅動。這個匯入應該只出現在組裝根(cmd/order/main.go)或專門負責資料庫的平台套件,業務程式碼只依賴 database/sql 的型別。

下面是開啟資料庫的輔助函式,放在共用的平台套件裡:

// 片段:internal/platform/database/database.go
package database

import (
	"context"
	"database/sql"
	"fmt"
	"time"
)

func OpenDB(ctx context.Context, driver, dsn string) (*sql.DB, error) {
	db, err := sql.Open(driver, dsn) // 只驗證參數,還沒有真的連線
	if err != nil {
		return nil, fmt.Errorf("open db: %w", err)
	}

	db.SetMaxOpenConns(20)                  // 同時最多 20 條連線(含使用中與閒置)
	db.SetMaxIdleConns(10)                  // 最多保留 10 條閒置連線備用
	db.SetConnMaxLifetime(30 * time.Minute) // 連線最長壽命,配合負載平衡器與資料庫端設定
	db.SetConnMaxIdleTime(5 * time.Minute)  // 閒置太久就關掉,離峰時把資源還給資料庫

	pingCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
	defer cancel()
	if err := db.PingContext(pingCtx); err != nil {
		db.Close()
		return nil, fmt.Errorf("ping db: %w", err)
	}
	return db, nil
}

連線池的四個設定在第 4 步會詳細說明,這裡先記住一件事:預設值不適合正式環境。 MaxOpenConns 預設是不限,MaxIdleConns 預設只有 2,連線也沒有壽命上限。程式中的數字只是示意,實際值要依資料庫規格與流量決定。

第 2 步:建表,並正確地讀取資料

訂單服務需要三張表。商品表存單價與庫存,訂單表存使用者、總額與狀態,訂單品項表記錄每筆訂單買了什麼、當時的單價是多少:

CREATE TABLE products (
    id    BIGSERIAL PRIMARY KEY,
    name  TEXT   NOT NULL,
    price BIGINT NOT NULL,                      -- 單位:分
    stock INT    NOT NULL CHECK (stock >= 0)
);

CREATE TABLE orders (
    id         BIGSERIAL PRIMARY KEY,
    user_id    BIGINT NOT NULL,
    total      BIGINT NOT NULL,
    status     TEXT   NOT NULL DEFAULT 'pending'
               CHECK (status IN ('pending', 'paid', 'cancelled')),
    paid_at    TIMESTAMPTZ,                     -- 尚未付款時是 NULL
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX orders_user_id_idx ON orders (user_id, id DESC);

CREATE TABLE order_items (
    order_id   BIGINT NOT NULL REFERENCES orders (id),
    product_id BIGINT NOT NULL REFERENCES products (id),
    qty        INT    NOT NULL CHECK (qty > 0),
    price      BIGINT NOT NULL,                 -- 下單當下的單價
    PRIMARY KEY (order_id, product_id)
);

幾個設計上的選擇值得一提:金額一律用整數的「分」;stock >= 0 這個 CHECK 約束是最後一道防線,即使程式有漏洞,資料庫也不會讓庫存變成負數;訂單狀態同樣用 CHECK 限制成 pending、paid、cancelled 三種;品項表另外記下單價,因為商品之後可能調價,訂單上的金額卻不該跟著變。

接著是讀取的 repository 方法:

// 片段:internal/order/repository.go(讀取)
package order

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
	"time"
)

// 為了聚焦在 database/sql,這裡的 Order 只保留 orders 表的欄位;
// 實際上它就是 order.go 裡的 Order(品項另外查 order_items),ErrNotFound 也定義在那裡。
type Order struct {
	ID        int64
	UserID    int64
	Total     int64               // 單位:分
	Status    string              // pending / paid / cancelled
	PaidAt    sql.Null[time.Time] // 尚未付款時是 NULL
	CreatedAt time.Time
}

type OrderRepo struct{ db *sql.DB }

func NewOrderRepo(db *sql.DB) *OrderRepo { return &OrderRepo{db: db} }

func (r *OrderRepo) Get(ctx context.Context, id int64) (Order, error) {
	var o Order
	err := r.db.QueryRowContext(ctx,
		`SELECT id, user_id, total, status, paid_at, created_at FROM orders WHERE id = $1`, id,
	).Scan(&o.ID, &o.UserID, &o.Total, &o.Status, &o.PaidAt, &o.CreatedAt)
	if errors.Is(err, sql.ErrNoRows) {
		return Order{}, ErrNotFound
	}
	if err != nil {
		return Order{}, fmt.Errorf("get order %d: %w", id, err)
	}
	return o, nil
}

func (r *OrderRepo) ListByUser(ctx context.Context, userID int64, limit int) ([]Order, error) {
	rows, err := r.db.QueryContext(ctx,
		`SELECT id, user_id, total, status, paid_at, created_at
		   FROM orders WHERE user_id = $1
		  ORDER BY id DESC LIMIT $2`, userID, limit)
	if err != nil {
		return nil, fmt.Errorf("list orders: %w", err)
	}
	defer rows.Close() // 一定要關,否則這條連線永遠回不了連線池

	var out []Order
	for rows.Next() {
		var o Order
		if err := rows.Scan(&o.ID, &o.UserID, &o.Total, &o.Status, &o.PaidAt, &o.CreatedAt); err != nil {
			return nil, fmt.Errorf("scan order: %w", err)
		}
		out = append(out, o)
	}
	if err := rows.Err(); err != nil { // 迭代途中的錯誤(例如連線中斷)在這裡才會出現
		return nil, fmt.Errorf("iterate orders: %w", err)
	}
	return out, nil
}

單筆查詢:QueryRowContext

QueryRowContext 回傳的 *sql.Row 會把錯誤延後到 Scan 時才回報。查不到資料時 Scan 回傳 sql.ErrNoRows,這不是「出錯」,而是「沒有這筆資料」,所以 repository 把它翻譯成領域的 ErrNotFound,上層才能據此回 404。這正是上一篇提到的「repository 負責翻譯底層錯誤」:sql.ErrNoRows 絕不能漏出這一層。其他錯誤則用 %w 包上脈絡(查的是哪一筆)往上回傳。

*sql.Row 在 Scan 後會自動釋放連線,不需要額外關閉。

多筆查詢:rows 的三個規矩

QueryContext 回傳 *sql.Rows,它在整個迭代期間都佔著一條連線。使用時有三個規矩,缺一不可:

  1. 拿到 rows 後立刻 defer rows.Close()。 不關閉的話,這條連線永遠回不了池子。這是 Go 服務「跑一陣子就卡住」最常見的原因之一。rows.Next() 走到底時雖然會自動關閉,但只要中途 return(例如 Scan 出錯),沒有 defer 就會漏掉。
  2. 迴圈結束後檢查 rows.Err()。 rows.Next() 回傳 false 有兩種可能:資料讀完了,或是途中出錯(例如連線中斷)。只有 rows.Err() 能分辨,不檢查就可能把「讀到一半的資料」當成完整結果回傳。
  3. 迭代期間不要做慢的事。 在 for rows.Next() 迴圈裡呼叫外部 API 或做複雜運算,會讓連線被佔用很久。先把資料讀進 slice,關閉 rows 之後再處理。

NULL 怎麼處理

資料庫的 NULL 無法直接 Scan 進 Go 的 time.Time 或 string,會得到轉換錯誤。標準函式庫提供了 sql.NullString、sql.NullTime 等型別,Go 1.22 起還有泛型的 sql.Null[T],範例中的 PaidAt sql.Null[time.Time] 就是用它表示「尚未付款時是 NULL」。讀出來之後看 Valid 欄位判斷有沒有值。另一個做法是掃進指標(*time.Time),nil 就代表 NULL。如果某個欄位在業務上本來就不該是 NULL,應該在表上加 NOT NULL,而不是在程式裡到處處理空值。

永遠用佔位符

所有參數都透過 $1、$2 佔位符傳入,交給驅動程式處理,絕對不要用 fmt.Sprintf 把使用者輸入拼進 SQL 字串,那是 SQL 注入的直接來源。唯一的例外是欄位名稱或排序方向這類無法用佔位符的部分,這時要用白名單比對,只允許事先列出的幾個值。

第 3 步:每一次呼叫都帶著 context

database/sql 的每個操作都有帶 context 的版本:QueryContext、QueryRowContext、ExecContext、BeginTx、PingContext。不帶 context 的舊版本(Query、Exec)內部用的是 context.Background(),無法被取消,在服務程式裡應該完全避免。

帶著 context 的效果,正是〈context:取消、逾時與資料傳遞〉所描述的那條取消鏈:使用者關掉網頁、HTTP 連線中斷時,handler 的 r.Context() 被取消,這個訊號沿著 service 傳到 repository,正在等待資料庫回應的查詢會被中止,連線也會被釋放(驅動程式會盡力通知資料庫取消該查詢)。沒有這條鏈,一個已經沒人等的慢查詢仍會繼續佔著連線與資料庫資源。

除了從請求繼承的取消訊號,也可以替資料庫操作設定更嚴格的逾時。例如在 repository 方法裡用 context.WithTimeout 限制單一查詢的時間,避免某個缺少索引的查詢拖垮整個服務。逾時的值應該小於上游給的總時限,至於各層逾時怎麼搭配、什麼時候該重試,會在〈逾時、重試與熔斷〉完整討論。

提示:context 被取消時,Scan 或 rows.Err() 會回傳 context.Canceled 或 context.DeadlineExceeded(可能被驅動程式包裝過)。用 errors.Is(err, context.Canceled) 判斷,這類錯誤通常代表客戶端已經離開,不需要當成伺服器錯誤來告警。

第 4 步:調校連線池

連線池裡的每一條連線,都會在幾種狀態之間轉換:

新建連線 使用中 InUse 請求排隊等待 已達 MaxOpenConns 閒置 Idle 關閉 未達上限就新建 有人歸還就取得 歸還:rows.Close、 Commit、Rollback 下一個查詢直接取用 db.Stats() 可觀察: InUse、Idle、 WaitCount、WaitDuration 閒置超過 ConnMaxIdleTime、閒置數超過 MaxIdleConns, 或使用時間達 ConnMaxLifetime,連線就會被關閉

圖:連線在使用中與閒置之間來回;達到上限時新的請求只能排隊,閒置過久或壽命到期的連線會被關閉。

設定作用預設值設定時的考量
SetMaxOpenConns同時存在的連線數上限(使用中加閒置)不限所有服務執行個體的總和不能超過資料庫允許的連線數
SetMaxIdleConns最多保留多少閒置連線備用2太小會頻繁建立與關閉連線;通常設成與 MaxOpen 相同或略小
SetConnMaxLifetime一條連線最長可以用多久不限讓連線定期更換,配合資料庫或負載平衡器的連線逾時、容錯移轉
SetConnMaxIdleTime閒置多久就關閉不限離峰時把連線還給資料庫,降低資源佔用

MaxOpenConns 怎麼抓

這個值不是越大越好。資料庫能同時有效處理的查詢數,受限於它的 CPU 核心數與磁碟;連線開得遠超過這個量,查詢只會在資料庫內部互相搶資源,整體反而變慢。一個實務上的思考方式是:

  • 先確認資料庫的連線上限,例如假設它允許 200 條連線,保留一部分給管理工具與遷移程式。
  • 再算服務會有幾個執行個體,例如 4 個,每個執行個體的上限就大約是 (200 − 保留) ÷ 4。
  • 自動擴展時執行個體數會變多,要用最大的執行個體數來算。

以上數字都只是示意。真正的答案來自量測:觀察 db.Stats() 回傳的 sql.DBStats。

指標意義異常時代表什麼
OpenConnections目前總連線數長期貼著上限,代表池子不夠或有連線沒歸還
InUse / Idle使用中與閒置的數量InUse 持續偏高但流量不高,懷疑有 rows 沒關
WaitCount / WaitDuration因為池子滿了而等待的次數與累計時間持續成長代表請求在排隊等連線
MaxIdleClosed / MaxLifetimeClosed因閒置數或壽命被關閉的連線數MaxIdleClosed 很高代表 MaxIdleConns 太小,連線不斷重建

把這些數字定期輸出成指標,是〈可觀測性:日誌、指標、追蹤〉會做的事。現在先知道:當服務變慢時,「是在等資料庫執行,還是在等池子給連線」是兩個完全不同的問題,WaitDuration 能幫你分辨。

第 5 步:用交易讓多個寫入一起成功或一起失敗

下單這件事包含三個寫入:扣商品庫存、新增訂單、新增訂單品項。如果扣完庫存之後、寫入訂單之前程式出錯,資料就會停在「庫存少了、訂單卻不存在」的狀態。交易(transaction)就是讓這一組操作具有原子性:要嘛全部生效,要嘛全部不算數。

整段交易都在同一條連線上(*sql.Tx),直到 Commit 或 Rollback 才歸還 BeginTx 取得一條連線 扣庫存 UPDATE products 新增訂單 INSERT orders 新增品項 INSERT items Commit 全部一起生效 任一步出錯 Rollback:所有修改一起還原 庫存不會被扣、訂單不會只寫一半 傳給 BeginTx 的 context 被取消時,database/sql 也會自動 Rollback 這個交易。

圖:交易從 BeginTx 開始佔用一條連線,所有語句都在這條連線上執行,最後 Commit 生效,任何一步出錯就 Rollback 全部還原。

db.BeginTx(ctx, opts) 回傳 *sql.Tx。它最重要的特性是綁定在一條連線上:交易內的所有語句都必須透過 tx.ExecContext、tx.QueryRowContext 執行,才會落在同一條連線、同一個交易裡。如果不小心在交易中途用了 db.ExecContext,那個語句會從池子另外借一條連線,不在交易之內,交易 Rollback 時它也不會被還原。

正確使用交易的固定套路是:

  1. BeginTx 之後立刻安排 Rollback,確保任何提早 return 的路徑都會結束交易、歸還連線。
  2. 所有語句都用 tx 執行。
  3. 全部成功才 Commit,並檢查 Commit 的錯誤。Commit 也可能失敗(例如違反延遲檢查的約束、連線中斷),失敗時交易已經被資料庫丟棄。

在 Commit 成功之後再呼叫 Rollback 是安全的,它只會回傳 sql.ErrTxDone,什麼都不會發生。這就是為什麼很多程式直接寫 defer tx.Rollback()。下面把這個套路包成一個 WithTx 輔助函式,並用它實作下單:

// 片段:internal/order/repository.go(交易)
package order

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
)

var ErrOutOfStock = errors.New("out of stock")

// WithTx 開一個交易執行 fn;fn 回傳錯誤就 Rollback,否則 Commit。
func WithTx(ctx context.Context, db *sql.DB, opts *sql.TxOptions, fn func(*sql.Tx) error) (err error) {
	tx, err := db.BeginTx(ctx, opts)
	if err != nil {
		return fmt.Errorf("begin tx: %w", err)
	}
	defer func() {
		if p := recover(); p != nil {
			_ = tx.Rollback()
			panic(p)
		}
		if err != nil {
			if rbErr := tx.Rollback(); rbErr != nil && !errors.Is(rbErr, sql.ErrTxDone) {
				err = errors.Join(err, fmt.Errorf("rollback: %w", rbErr))
			}
		}
	}()

	if err = fn(tx); err != nil {
		return err
	}
	if err = tx.Commit(); err != nil {
		return fmt.Errorf("commit: %w", err)
	}
	return nil
}

func (r *OrderRepo) PlaceOrder(ctx context.Context, userID int64, items []Item) (int64, error) {
	var orderID int64
	err := WithTx(ctx, r.db, nil, func(tx *sql.Tx) error {
		var total int64
		for i, it := range items {
			// 條件式扣庫存:庫存不足時不會更新任何一列,順便以資料庫裡的單價為準
			err := tx.QueryRowContext(ctx,
				`UPDATE products SET stock = stock - $1
				  WHERE id = $2 AND stock >= $1
				RETURNING price`,
				it.Qty, it.ProductID).Scan(&items[i].Price)
			if errors.Is(err, sql.ErrNoRows) {
				return fmt.Errorf("product %d: %w", it.ProductID, ErrOutOfStock)
			}
			if err != nil {
				return fmt.Errorf("reserve product %d: %w", it.ProductID, err)
			}
			total += items[i].Price * int64(it.Qty)
		}

		if err := tx.QueryRowContext(ctx,
			`INSERT INTO orders (user_id, total, status) VALUES ($1, $2, 'pending') RETURNING id`,
			userID, total).Scan(&orderID); err != nil {
			return fmt.Errorf("insert order: %w", err)
		}

		for _, it := range items {
			if _, err := tx.ExecContext(ctx,
				`INSERT INTO order_items (order_id, product_id, qty, price) VALUES ($1, $2, $3, $4)`,
				orderID, it.ProductID, it.Qty, it.Price); err != nil {
				return fmt.Errorf("insert item: %w", err)
			}
		}
		return nil
	})
	if err != nil {
		return 0, err
	}
	return orderID, nil
}

這段程式的幾個重點

  • WithTx 把交易的生命週期集中在一處。 呼叫者只需要寫「交易裡要做什麼」,不必每次都重寫 Begin、Rollback、Commit 的樣板。fn 回傳錯誤就 Rollback;fn 裡發生 panic 也會先 Rollback 再把 panic 往上拋;Rollback 本身失敗時用 errors.Join 把兩個錯誤一起回傳,不會吃掉任何一個。
  • context 被取消時交易會自動 Rollback。 database/sql 會監看傳給 BeginTx 的 context,一旦取消就 Rollback 並釋放連線。這是額外的安全網,不是省略 Rollback 的理由。
  • 單價以資料庫為準。 扣庫存的 UPDATE ... RETURNING price 同時取回單價並寫回 items,總額由伺服器依資料庫裡的價格計算,不相信客戶端送來的金額。
  • 錯誤分類清楚。 庫存不足回傳領域錯誤 ErrOutOfStock,service 與 handler 可以用 errors.Is 判斷,回應 409 之類的狀態碼;其他錯誤包上脈絡往上拋。

交易要短

交易從 Begin 到 Commit 之間會佔住一條連線,期間更新過的資料列也會被鎖住,其他想更新同一列的交易只能等待。所以交易內只做資料庫操作,不要在交易裡呼叫外部 HTTP API、發送訊息或等待使用者輸入。例如「建立訂單後呼叫支付服務」就不應該放在同一個交易裡:支付服務慢個幾秒,這段時間內同一商品的所有下單請求都會卡在列鎖上。跨服務的一致性要用另外的方法處理,〈分散式交易:Saga 與 Outbox〉會專門討論。

第 6 步:併發下的正確性:超賣、鎖與隔離等級

交易保證了原子性,但並不自動保證「多個交易同時執行時」結果仍然正確。最典型的例子就是超賣。

先讀後寫:兩筆都成立 條件式更新:資料庫把關 交易 A 交易 B 交易 A 交易 B 讀到庫存 1 讀到庫存 1 寫回庫存 0 也寫回庫存 0 條件扣減成功 等待 A 的列鎖 Commit 影響 0 列 庫存只有 1 件,卻成立兩筆訂單 (後寫的蓋掉先寫的,稱為遺失更新) stock >= qty 的條件在資料庫裡判斷, 只有一筆成功,另一筆回 ErrOutOfStock

圖:左邊兩個交易都讀到庫存 1 再各自寫回 0,兩筆訂單都成立;右邊把判斷交給資料庫,第二筆因條件不成立而影響 0 列。

直覺的寫法是:先 SELECT stock,在 Go 裡判斷夠不夠,再 UPDATE products SET stock = 新值。在預設的隔離等級下,兩個交易可能同時讀到相同的庫存,各自算出新值再寫回去,後寫的蓋掉先寫的,這叫做遺失更新。

有三種常見的解法:

  1. 條件式更新(本文採用):UPDATE products SET stock = stock - $1 WHERE id = $2 AND stock >= $1。判斷與修改在同一個語句裡,由資料庫原子地完成;第二個交易會等第一個交易釋放列鎖,然後重新檢查條件,不成立就影響 0 列。這是最簡單、效能也最好的做法。用 ExecContext 時,透過 RowsAffected() 判斷是否為 0;用 RETURNING 搭配 QueryRowContext 時,則是得到 sql.ErrNoRows。
  2. 悲觀鎖:SELECT stock FROM products WHERE id = $1 FOR UPDATE,在交易內先把那一列鎖起來,其他交易要讀取並鎖定同一列時必須等待。適合判斷邏輯太複雜、無法寫進單一 UPDATE 條件的情況。
  3. 提高隔離等級:在 BeginTx 傳入 &sql.TxOptions{Isolation: sql.LevelSerializable},讓資料庫偵測衝突並讓其中一個交易失敗。程式必須準備好重試被拒絕的交易。
隔離等級可以避免代價
Read Committed(PostgreSQL 預設)讀到其他交易未提交的資料同一交易內兩次讀取可能不同,可能遺失更新
Repeatable Read(MySQL InnoDB 預設)上述問題,加上同一交易內重複讀取結果不變各資料庫實作細節不同,衝突時可能需要重試
Serializable結果等同於依序執行衝突的交易會失敗,必須重試,吞吐量較低

死鎖

當兩個交易以不同順序鎖定同樣的資料列時,就可能互相等待對方釋放,形成死鎖。資料庫會偵測到並強制讓其中一個失敗。以下單為例,如果一筆訂單先扣商品 1 再扣商品 2,另一筆剛好反過來,就有機會死鎖。簡單的預防方式是固定鎖定順序:在交易開始前把品項依 ProductID 排序。即使做了預防,碰到死鎖或序列化失敗時,整個交易重試一次通常就能成功,但重試必須是重新執行整個交易,而不是只重試失敗的那個語句。

超賣是電商系統最常見的併發問題之一,當庫存搬到獨立的 inventory 服務、或改用快取扣減之後,會出現更多變形,〈併發常見問題:從資料競爭到超賣〉會整理完整的情境與對策。

第 7 步:接回服務

資料庫版的 repository 滿足 service 定義的 Repository 介面之後,接回服務只需要改組裝根:在 cmd/order/main.go 用 database.OpenDB 開啟連線池、defer db.Close(),再把 order.NewMemoryRepository() 換成以 db 建立的資料庫版本。service 與 handler 一行都不用改,這就是上一篇花力氣分層的回報。

還有幾件伴隨資料庫而來的工作:

  • 結構遷移(migration):表結構的變更應該寫成有版本號的遷移檔,跟程式碼一起進版本控制,由部署流程或專門的工具依序執行,而不是手動在資料庫上下指令。
  • 交易邊界放在哪一層:本文把交易放在 repository 的 PlaceOrder 方法裡,因為「扣庫存加建立訂單」對這個服務來說是一個不可分割的儲存操作。如果 service 需要把多個 repository 的操作放進同一個交易,可以讓 repository 方法接受一個同時被 *sql.DB 與 *sql.Tx 滿足的小介面(兩者都有 ExecContext、QueryContext、QueryRowContext),由 service 透過 WithTx 決定範圍,但要小心不要讓 database/sql 的型別擴散到商業規則裡。
  • 啟動順序:資料庫連不上時,PingContext 失敗讓程式直接結束,交給部署平台重新啟動;健康檢查端點也可以回報資料庫狀態,這部分會在〈Docker 與 Kubernetes 部署(單一服務)〉談到探針時再細說。

常見陷阱

  • 忘了 defer rows.Close()。 連線無法歸還,跑一陣子後所有請求都卡在等待連線,db.Stats().InUse 持續貼著上限。
  • 沒檢查 rows.Err()。 迭代途中的錯誤被當成「資料讀完了」,回傳不完整的結果。
  • 把 sql.ErrNoRows 當成系統錯誤。 查無資料應該翻譯成領域的 ErrNotFound,回 404,而不是 500 加上告警。
  • 在交易中用了 db 而不是 tx。 那個語句跑在另一條連線、不在交易內;在連線池上限很小時,甚至會因為交易佔著唯一的連線、db 又在等連線而永遠卡住。
  • 忘了 Rollback。 某個錯誤路徑提早 return,交易沒結束,連線與列鎖都一直被佔著。BeginTx 之後立刻 defer 處理。
  • 用不帶 context 的 Query、Exec。 客戶端離開了查詢仍在跑,無法設定逾時。
  • 用 fmt.Sprintf 組 SQL。 SQL 注入的直接來源,參數一律用佔位符。
  • 連線池用預設值上線。 MaxOpenConns 不限,流量尖峰時會把資料庫連線數打滿,影響所有共用該資料庫的服務。
  • 每個請求都 sql.Open。 一個程式只要一個 *sql.DB,在組裝根建立後注入。
  • 先讀後寫地扣庫存。 併發時會遺失更新而超賣,改用條件式更新或 SELECT ... FOR UPDATE。
  • 在交易裡呼叫外部服務。 交易被拉長,列鎖被長時間持有,整條下單路徑都跟著變慢。

重點整理

  • *sql.DB 是連線池,不是連線;sql.Open 不會連線,啟動時用 PingContext 確認;整個程式只建一個並注入給各 repository。
  • 單筆用 QueryRowContext,把 sql.ErrNoRows 翻譯成領域錯誤;多筆用 QueryContext,立刻 defer rows.Close(),迴圈後檢查 rows.Err()。
  • NULL 用 sql.Null[T] 或指標處理;參數一律用佔位符,絕不拼接字串。
  • 所有資料庫呼叫都用帶 context 的版本,讓取消與逾時沿著呼叫鏈生效。
  • 正式環境一定要設定 MaxOpenConns、MaxIdleConns、ConnMaxLifetime、ConnMaxIdleTime,並用 db.Stats() 觀察等待次數與時間。
  • 交易用 BeginTx 開始,綁定在一條連線上,所有語句都要用 tx 執行;defer 處理 Rollback,成功才 Commit 並檢查錯誤。
  • 交易要短,只放資料庫操作,不呼叫外部服務。
  • 防止超賣用條件式更新、SELECT ... FOR UPDATE 或更高的隔離等級;固定鎖定順序以減少死鎖,衝突時重試整個交易。

下一篇

現在訂單服務有了 HTTP 入口、分層結構與資料庫,但我們還沒有任何方法確認它真的是對的,也無法放心地重構。〈測試:表格驅動、httptest、整合測試〉會替每一層寫出對應的測試,包含不啟動伺服器就能測 handler 的 httptest,以及連上真實資料庫的整合測試。