database/sql、交易與連線池
database/sql, Transactions and Connection Pools in Go
替訂單服務寫出資料庫版的 repository:理解 sql.DB 其實是連線池、正確關閉 rows、處理 NULL 與 ErrNoRows,用交易讓扣庫存與建立訂單一起成功或一起失敗,並調校連線池避免超賣與連線耗盡。
這篇的步驟
上一篇〈分層架構與依賴注入〉我們把訂單服務拆成 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 管理的連線池:裡面可能有零到多條實體連線,每次執行查詢時從池裡借一條,用完再還回去。這帶來幾個直接的推論:
sql.Open不會真的連線。 它只驗證參數並建立池子,第一條連線要等到第一次查詢才建立。所以啟動時應該呼叫PingContext主動確認資料庫連得上,讓設定錯誤在啟動階段就失敗。- 整個程式只需要一個
*sql.DB。 它可以安全地被多個 goroutine 同時使用,應該在組裝根建立一次,再注入給所有 repository。每個請求都sql.Open一次,等於每次都建一個新的池子,不但浪費,還會讓連線數失控。 - 不要頻繁呼叫
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,它在整個迭代期間都佔著一條連線。使用時有三個規矩,缺一不可:
- 拿到 rows 後立刻
defer rows.Close()。 不關閉的話,這條連線永遠回不了池子。這是 Go 服務「跑一陣子就卡住」最常見的原因之一。rows.Next()走到底時雖然會自動關閉,但只要中途return(例如Scan出錯),沒有defer就會漏掉。 - 迴圈結束後檢查
rows.Err()。rows.Next()回傳 false 有兩種可能:資料讀完了,或是途中出錯(例如連線中斷)。只有rows.Err()能分辨,不檢查就可能把「讀到一半的資料」當成完整結果回傳。 - 迭代期間不要做慢的事。 在
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 步:調校連線池
連線池裡的每一條連線,都會在幾種狀態之間轉換:
圖:連線在使用中與閒置之間來回;達到上限時新的請求只能排隊,閒置過久或壽命到期的連線會被關閉。
| 設定 | 作用 | 預設值 | 設定時的考量 |
|---|---|---|---|
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)就是讓這一組操作具有原子性:要嘛全部生效,要嘛全部不算數。
圖:交易從 BeginTx 開始佔用一條連線,所有語句都在這條連線上執行,最後 Commit 生效,任何一步出錯就 Rollback 全部還原。
db.BeginTx(ctx, opts) 回傳 *sql.Tx。它最重要的特性是綁定在一條連線上:交易內的所有語句都必須透過 tx.ExecContext、tx.QueryRowContext 執行,才會落在同一條連線、同一個交易裡。如果不小心在交易中途用了 db.ExecContext,那個語句會從池子另外借一條連線,不在交易之內,交易 Rollback 時它也不會被還原。
正確使用交易的固定套路是:
BeginTx之後立刻安排 Rollback,確保任何提早 return 的路徑都會結束交易、歸還連線。- 所有語句都用
tx執行。 - 全部成功才
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 步:併發下的正確性:超賣、鎖與隔離等級
交易保證了原子性,但並不自動保證「多個交易同時執行時」結果仍然正確。最典型的例子就是超賣。
圖:左邊兩個交易都讀到庫存 1 再各自寫回 0,兩筆訂單都成立;右邊把判斷交給資料庫,第二筆因條件不成立而影響 0 列。
直覺的寫法是:先 SELECT stock,在 Go 裡判斷夠不夠,再 UPDATE products SET stock = 新值。在預設的隔離等級下,兩個交易可能同時讀到相同的庫存,各自算出新值再寫回去,後寫的蓋掉先寫的,這叫做遺失更新。
有三種常見的解法:
- 條件式更新(本文採用):
UPDATE products SET stock = stock - $1 WHERE id = $2 AND stock >= $1。判斷與修改在同一個語句裡,由資料庫原子地完成;第二個交易會等第一個交易釋放列鎖,然後重新檢查條件,不成立就影響 0 列。這是最簡單、效能也最好的做法。用ExecContext時,透過RowsAffected()判斷是否為 0;用RETURNING搭配QueryRowContext時,則是得到sql.ErrNoRows。 - 悲觀鎖:
SELECT stock FROM products WHERE id = $1 FOR UPDATE,在交易內先把那一列鎖起來,其他交易要讀取並鎖定同一列時必須等待。適合判斷邏輯太複雜、無法寫進單一UPDATE條件的情況。 - 提高隔離等級:在
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,以及連上真實資料庫的整合測試。