Go连接MySQL/PostgreSQL必踩的7个坑：从零到生产级查询的完整链路拆解

第一章：Go数据库连接初始化与驱动选择

Go语言通过database/sql包提供统一的数据库操作接口，但实际通信依赖具体数据库驱动。选择合适的驱动是连接初始化的第一步，常见选项包括github.com/go-sql-driver/mysql（MySQL）、github.com/lib/pq（PostgreSQL）和github.com/mattn/go-sqlite3（SQLite）。驱动需显式导入，且不直接暴露API，仅完成注册即可被sql.Open识别。

驱动注册机制说明

所有标准驱动均在init()函数中调用sql.Register()完成自我注册。例如MySQL驱动内部执行：

func init() {
    sql.Register("mysql", &MySQLDriver{}) // 将"mysql"名称绑定到驱动实例
}

该注册使后续sql.Open("mysql", dsn)能正确匹配驱动，无需手动管理驱动实例。

初始化连接池

使用sql.Open仅创建连接池对象，不立即建立物理连接；首次执行查询（如db.Ping()）才触发真实连接：

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql" // 空导入触发init()
)

db, err := sql.Open("mysql", "user:pass@tcp(127.0.0.1:3306)/test?parseTime=true")
if err != nil {
    log.Fatal(err)
}
if err = db.Ping(); err != nil { // 验证连接可用性
    log.Fatal("无法连接数据库:", err)
}

连接池参数调优

建议显式配置关键参数以避免默认值引发性能问题：

参数	推荐值	说明
`SetMaxOpenConns`	20–50	最大打开连接数，过高易耗尽数据库资源
`SetMaxIdleConns`	10–20	空闲连接上限，减少频繁建连开销
`SetConnMaxLifetime`	30m	连接最大存活时间，规避网络中断导致的僵死连接

db.SetMaxOpenConns(30)
db.SetMaxIdleConns(10)
db.SetConnMaxLifetime(30 * time.Minute)

这些设置应在db.Ping()之后、业务逻辑使用前完成，确保连接池行为符合预期。

第二章：连接池配置与生命周期管理

2.1 连接字符串解析与DSN安全实践

连接字符串（Connection String）是数据库客户端与服务端建立通信的“数字钥匙”，其结构直接影响认证安全性与配置可维护性。

DSN标准格式解析

典型 PostgreSQL DSN：

postgresql://user:pass@host:port/dbname?sslmode=require&application_name=myapp

user:pass：明文凭据，禁止硬编码；应通过环境变量或密钥管理服务注入
sslmode=require：强制加密传输，避免凭证中间人窃取
application_name：便于审计追踪来源，非功能但关键

常见风险对照表

风险项	安全实践
密码明文暴露	使用 `PGPASSWORD` 环境变量 + `.pgpass` 文件（权限 `0600`）
未启用TLS	强制 `sslmode=verify-full` + 配置 `sslrootcert`
过长连接参数	采用 `service=prod_db` 引用 `~/.pg_service.conf`

安全初始化流程

graph TD
    A[读取 service 名] --> B[解析 ~/.pg_service.conf]
    B --> C[注入环境变量]
    C --> D[调用 libpq 连接]
    D --> E[握手验证证书链]

2.2 MaxOpenConns/MaxIdleConns/ConnMaxLifetime参数调优实战

数据库连接池的三个核心参数直接影响高并发下的稳定性与资源利用率：

MaxOpenConns：最大打开连接数，硬性上限，超限请求将阻塞或报错
MaxIdleConns：空闲连接保有量，过小导致频繁建连，过大浪费内存
ConnMaxLifetime：连接最大存活时间，规避长连接引发的网络僵死或服务端超时断连

db.SetMaxOpenConns(50)
db.SetMaxIdleConns(20)
db.SetConnMaxLifetime(30 * time.Minute)

此配置适用于中等QPS（~300）的Web服务：50上限防DB过载；20空闲连接覆盖突发流量波峰；30分钟轮换避免MySQL默认wait_timeout=28800s（8小时）导致的invalid connection错误。

参数	推荐初始值	风险场景	监控指标
MaxOpenConns	QPS × 平均查询耗时(s) × 2	连接耗尽、goroutine堆积	`sql.OpenConns`
MaxIdleConns	MaxOpenConns × 0.4	空闲连接泄漏、OOM	`sql.IdleConns`

graph TD
    A[应用发起SQL请求] --> B{连接池有空闲连接？}
    B -->|是| C[复用空闲连接]
    B -->|否且<MaxOpenConns| D[新建连接]
    B -->|否且已达上限| E[阻塞等待或超时失败]
    C & D --> F[执行后归还至idle队列]
    F --> G{超ConnMaxLifetime？}
    G -->|是| H[关闭并丢弃]

2.3 连接健康检查与自动重连机制实现

健康检查策略设计

采用双维度探测：TCP Keepalive（内核级） + 应用层心跳（自定义PING/PONG）。前者防中间设备静默断连，后者验证服务端业务可达性。

自动重连状态机

graph TD
    A[Disconnected] -->|connect()| B[Connecting]
    B -->|success| C[Connected]
    B -->|timeout/fail| D[Backoff]
    D -->|exponential delay| A
    C -->|heartbeat timeout| D

重连参数配置表

参数	默认值	说明
`initialDelayMs`	100	首次重试延迟（毫秒）
`maxRetries`	5	最大连续重试次数
`backoffMultiplier`	2.0	指数退避倍率

心跳检测代码示例

function startHeartbeat(socket) {
  const interval = setInterval(() => {
    if (socket.readyState === WebSocket.OPEN) {
      socket.send(JSON.stringify({ type: 'PING', ts: Date.now() }));
    }
  }, 30000); // 30s 间隔

  // 超时未收到 PONG 则触发断连
  socket.onmessage = (e) => {
    const data = JSON.parse(e.data);
    if (data.type === 'PONG') this.lastPong = Date.now();
  };
}

逻辑分析：心跳发送不阻塞主流程；lastPong 时间戳用于后续超时判定（如 Date.now() - lastPong > 45000 触发重连）；setInterval 确保周期性探测，避免单次失败导致误判。

2.4 多数据库实例隔离与上下文传播设计

在微服务架构中，同一进程需安全访问多个数据库实例（如主库、报表库、审计库），必须避免连接泄漏与上下文污染。

隔离核心机制

基于 ThreadLocal<DataSourceKey> 实现租户/场景级数据源路由键绑定
每次 DataSource.getConnection() 前动态解析当前上下文键
连接关闭时自动清理 ThreadLocal，防止内存泄漏

上下文传播保障

public class DbContext {
  private static final ThreadLocal<ContextHolder> HOLDER = ThreadLocal.withInitial(ContextHolder::new);

  public static void set(String dbKey, String traceId) {
    HOLDER.get().dbKey = dbKey; 
    HOLDER.get().traceId = traceId;
  }

  public static ContextHolder current() { return HOLDER.get(); }
}

逻辑分析：ContextHolder 封装数据库标识与链路追踪ID；set() 在业务入口（如Spring AOP切面）注入；current() 供数据源路由层读取。ThreadLocal.withInitial 确保线程首次访问即初始化，避免 null 异常。

组件	职责	隔离粒度
`RoutingDataSource`	根据 `DbContext.current().dbKey` 选择目标数据源	实例级
`ShardingSphere-JDBC`	透明代理多数据源，支持读写分离与分片	逻辑库级

graph TD
  A[HTTP Request] --> B[TraceFilter 设置 traceId]
  B --> C[AOP Before Advice 设置 dbKey]
  C --> D[MyBatis Executor 获取 Connection]
  D --> E[RoutingDataSource 查找对应 DataSource]
  E --> F[物理数据库连接]

2.5 连接泄漏检测与pprof诊断实战

连接泄漏常表现为 net/http 客户端未关闭响应体，或 database/sql 连接未归还池。以下是最小复现代码：

func leakyHandler(w http.ResponseWriter, r *http.Request) {
    resp, _ := http.Get("https://httpbin.org/delay/1")
    // ❌ 忘记 defer resp.Body.Close()
    io.Copy(w, resp.Body) // Body 未关闭 → 连接永不释放
}

逻辑分析：http.Get 返回的 *http.Response 持有底层 TCP 连接；若 Body 未显式关闭，net/http 不会复用连接，导致 http.DefaultClient.Transport.MaxIdleConnsPerHost 耗尽。

启用 pprof 后，访问 /debug/pprof/goroutine?debug=2 可定位阻塞在 net/http.(*persistConn).readLoop 的 goroutine。

指标	健康阈值	风险信号
`goroutines`		> 2000（持续增长）
`http_connections`	波动平稳	单调递增且不回落

graph TD
    A[HTTP 请求] --> B{resp.Body.Close?}
    B -->|否| C[连接滞留 idle list]
    B -->|是| D[连接可复用/归还]
    C --> E[MaxIdleConnsPerHost 触顶]
    E --> F[新建连接失败：dial tcp: too many open files]

第三章：SQL查询执行与结果处理

3.1 Query/QueryRow/Exec方法语义辨析与错误处理范式

核心语义差异

方法	适用场景	返回值类型	自动关闭资源
`Query`	多行结果集（如 SELECT）	`*sql.Rows`	否（需显式 `Close()`）
`QueryRow`	单行单列/单行多列结果	`*sql.Row`	是（内部自动处理）
`Exec`	DML/DDL（INSERT/UPDATE/DELETE/DROP）	`sql.Result`	是（无游标）

典型错误处理范式

// ✅ 推荐：Query + defer rows.Close() + 显式 err 检查
rows, err := db.Query("SELECT id, name FROM users WHERE age > $1", 18)
if err != nil {
    log.Fatal("query failed:", err) // 不可忽略
}
defer rows.Close() // 防止资源泄漏

for rows.Next() {
    var id int
    var name string
    if err := rows.Scan(&id, &name); err != nil {
        log.Fatal("scan failed:", err) // Scan 错误独立判断
    }
}
if err := rows.Err(); err != nil { // 检查迭代过程中的潜在错误
    log.Fatal("rows iteration error:", err)
}

Query 调用后必须检查返回的 err（如连接中断、SQL语法错误），再检查 rows.Err()（如类型不匹配、网络中断导致的读取失败）。QueryRow 和 Exec 的 err 已涵盖全部语义错误，无需额外扫描级校验。

3.2 Scan与Struct扫描的零拷贝优化与类型映射陷阱

Go 的 database/sql 中 Rows.Scan() 默认执行值拷贝，而 sqlx.StructScan() 在反射映射时更易触发隐式内存分配。零拷贝优化需绕过 interface{} 中间层，直接绑定底层字节视图。

零拷贝实践：使用 `sql.RawBytes`

var name sql.RawBytes
err := row.Scan(&name) // 不分配新字符串，name 指向驱动内部缓冲区
if err != nil {
    return err
}
// 注意：row.Close() 后 name 数据可能失效！

sql.RawBytes 是 []byte 别名，Scan 时不复制数据，但生命周期依赖 Rows；须确保在 Rows.Next() 迭代期间使用，否则触发悬垂引用。

常见类型映射陷阱

Go 类型	数据库类型	风险点
`int`	`BIGINT`	32/64 位平台不一致导致截断
`*string`	`NULL TEXT`	`nil` 指针解引用 panic
`time.Time`	`DATE`	时区丢失、精度截断

安全映射建议

优先使用显式类型（如 int64, sql.NullString）
自定义 Scanner 接口实现零拷贝解析逻辑
避免 struct{ Name string } 直接 Scan，改用字段级 &s.Name 显式地址传递

3.3 大数据集流式处理与内存溢出防护策略

面对TB级日志流，盲目加载将触发java.lang.OutOfMemoryError: Java heap space。核心在于分治+背压+释放。

流式分块读取（Spark Structured Streaming）

df = spark.readStream \
  .format("kafka") \
  .option("kafka.bootstrap.servers", "k1:9092") \
  .option("subscribe", "logs") \
  .option("startingOffsets", "latest") \
  .option("maxOffsetsPerTrigger", "10000") \  # 关键：限速防积压
  .load()

maxOffsetsPerTrigger强制每批次最多消费1万条，避免单批次内存暴涨；配合foreachBatch实现按批聚合与及时落盘。

内存防护三原则

✅ 启用spark.sql.adaptive.enabled=true动态优化执行计划
✅ 设置spark.memory.fraction=0.6（堆内60%供执行+存储）
❌ 禁用collect()等全量拉取操作

防护手段	触发时机	GC影响
堆外内存缓存	Shuffle阶段	低
溢写磁盘（spill）	执行内存超限时	中
流控反压（backpressure）	输入速率突增时	无

graph TD
    A[数据源] --> B{速率监控}
    B -->|超阈值| C[触发反压]
    B -->|正常| D[限速消费]
    C & D --> E[微批处理]
    E --> F[溢写/落盘]
    F --> G[GC友好释放]

第四章：事务管理与并发一致性保障

4.1 显式事务控制与Savepoint嵌套回滚实现

在复杂业务流程中，单一 ROLLBACK 会丢失全部中间状态。SAVEPOINT 提供细粒度回滚能力。

Savepoint 创建与释放语义

SAVEPOINT sp_name：在当前事务内建立命名保存点
ROLLBACK TO SAVEPOINT sp_name：回退至该点，后续操作仍可提交
RELEASE SAVEPOINT sp_name：显式移除保存点（非必需，事务结束自动清理）

嵌套回滚典型场景

BEGIN;
INSERT INTO orders VALUES (1001, 'pending');
SAVEPOINT order_saved;

UPDATE inventory SET stock = stock - 5 WHERE item_id = 'A001';
SAVEPOINT inventory_updated;

INSERT INTO payments VALUES (2001, 1001, 'failed'); -- 模拟失败
ROLLBACK TO SAVEPOINT inventory_updated; -- 仅撤销支付插入，保留订单与库存变更

COMMIT; -- 订单+库存更新生效，支付不写入

逻辑分析：事务未整体回滚，而是精准撤回 payments 插入操作；inventory_updated 保存点后所有语句被丢弃，但 order_saved 及其前操作保留在事务上下文中。参数 sp_name 区分作用域，避免命名冲突。

保存点	生效范围	是否影响 COMMIT
`order_saved`	`INSERT orders` 后	否（仅用于回滚锚点）
`inventory_updated`	`UPDATE inventory` 后	否

graph TD
    A[START Transaction] --> B[INSERT orders]
    B --> C[SAVEPOINT order_saved]
    C --> D[UPDATE inventory]
    D --> E[SAVEPOINT inventory_updated]
    E --> F[INSERT payments FAIL]
    F --> G[ROLLBACK TO inventory_updated]
    G --> H[COMMIT]

4.2 Context超时与取消在事务中的穿透式应用

在分布式事务中，context.Context 不仅承载超时与取消信号，更需穿透整个调用链——从 HTTP 入口、服务编排、数据库操作到消息投递。

数据同步机制中的上下文传递

必须确保 ctx 在事务各阶段不丢失或被无意替换：

func Transfer(ctx context.Context, from, to string, amount float64) error {
    // 1. 上游超时直接终止整个事务流
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()

    if err := debit(ctx, from, amount); err != nil {
        return fmt.Errorf("debit failed: %w", err)
    }
    if err := credit(ctx, to, amount); err != nil {
        return fmt.Errorf("credit failed: %w", err)
    }
    return nil
}

逻辑分析：WithTimeout 基于传入 ctx 创建子上下文，所有下游操作（如 debit/credit）若接收并使用该 ctx，将自动响应超时或取消。关键参数：ctx（继承父取消链）、5*time.Second（硬性截止窗口，覆盖 DB 执行+网络延迟）。

事务阶段对 Context 的响应能力对比

阶段	支持取消	超时感知	备注
HTTP Handler	✅	✅	原生支持 `ctx.Request.Context()`
SQL Exec	✅	⚠️	依赖驱动（如 `pq` 支持 `context`）
Kafka Produce	✅	✅	`sarama` v1.30+ 原生支持

graph TD
    A[HTTP Request] -->|ctx.WithTimeout| B[Transfer Service]
    B --> C[Debit DB]
    B --> D[Credit DB]
    C --> E[Kafka Event]
    D --> E
    E -->|ctx.Done| F[Rollback Hook]

4.3 读写分离场景下的事务一致性边界分析

在主从架构中，事务的“写后即读”一致性并非天然成立。数据库写入主库后，需经复制延迟（Replication Lag）才能同步至从库，此时读请求若路由到从库，可能读取到过期数据。

数据同步机制

MySQL 的 binlog + relay log 异步复制是典型路径，其延迟受网络、从库负载、大事务等因素影响。

一致性边界判定逻辑

以下伪代码体现应用层兜底策略：

def read_with_consistency(key, max_lag_ms=100):
    # 查询主库获取最新GTID或位点
    master_pos = db_master.execute("SELECT @@global.gtid_executed")
    # 轮询从库确认同步进度
    for slave in slaves:
        slave_pos = slave.execute("SELECT @@global.gtid_received")
        lag = calc_lag_ms(master_pos, slave_pos)  # 依赖GTID集合差集与时间戳映射
        if lag <= max_lag_ms:
            return slave.get(key)  # 选择延迟达标从库
    return db_master.get(key)  # 降级主库读

该函数通过 GTID 追踪复制进度，max_lag_ms 是业务可容忍的陈旧性阈值；calc_lag_ms 需结合 performance_schema.replication_applier_status_by_coordinator 中的 LAST_PROCESSED_TRANSACTION_ORIGINAL_COMMIT_TIMESTAMP 实现精准估算。

组件	同步模式	一致性保障等级	典型延迟范围
MySQL Async	异步	最终一致	10ms–5s+
MySQL Semi-sync	半同步	强于异步	50–200ms
PostgreSQL Logical Replication	逻辑流式	可配同步级别	20–500ms

graph TD
    A[应用发起写请求] --> B[主库执行并提交]
    B --> C[主库写入binlog]
    C --> D[从库IO线程拉取binlog]
    D --> E[从库SQL线程重放事务]
    E --> F[应用读请求：是否满足GTID同步边界？]
    F -->|是| G[路由至从库]
    F -->|否| H[强制路由至主库]

4.4 乐观锁与CAS更新在Go中的标准实现模式

核心原理：Compare-and-Swap（CAS）

CAS 是原子操作：仅当当前值等于预期旧值时，才将内存位置更新为新值，返回是否成功。

Go 中的标准实现路径

sync/atomic 包提供 CompareAndSwapInt64、CompareAndSwapPointer 等系列函数
atomic.Value 适用于任意类型安全读写（但不直接支持 CAS 更新逻辑）
自定义结构体 + unsafe.Pointer + atomic.CompareAndSwapPointer 构建强一致性状态机

典型原子计数器实现

type AtomicCounter struct {
    value int64
}

func (c *AtomicCounter) Increment() int64 {
    for {
        old := atomic.LoadInt64(&c.value)
        new := old + 1
        if atomic.CompareAndSwapInt64(&c.value, old, new) {
            return new // 成功退出
        }
        // 失败则重试（无锁自旋）
    }
}

逻辑分析：循环中先读取当前值（LoadInt64），计算新值，再用 CompareAndSwapInt64 原子比对并更新。参数 &c.value 为内存地址，old 是期望旧值，new 是目标值；返回 true 表示更新成功。该模式避免互斥锁开销，适合高并发低冲突场景。

CAS 适用性对比

场景	是否推荐 CAS	原因
高频读 + 偶发写	✅	无锁、低延迟
写竞争激烈（>30%）	❌	自旋浪费 CPU，应改用 `sync.Mutex`
需要多字段协同更新	❌	CAS 仅保障单字操作原子性

第五章：生产环境可观测性与性能调优总结

核心指标闭环验证机制

在某电商大促保障项目中，团队将 P99 接口延迟、JVM Old Gen GC 频率（>5min/次触发告警）、Kafka 消费滞后（Lag > 10000）三项指标设为黄金信号。通过 Prometheus + Grafana 实现秒级采集，并联动 Alertmanager 自动创建 Jira 工单；当 GC 频率突增时，系统自动触发 jstack + jmap 快照采集脚本，3 分钟内完成堆内存分析并定位到未关闭的 Logback AsyncAppender 队列堆积问题。

日志-指标-链路三源关联实践

采用 OpenTelemetry 统一采集后，在日志平台（Loki）中嵌入 trace_id 字段，指标（Prometheus）打标 service_name 和 deployment_version，链路（Jaeger）注入 pod_ip 和 request_id。一次支付超时故障中，通过 trace_id tr-7f3a9b2c 在 Grafana 中下钻查看对应时间段的 Redis 连接池耗尽指标，再跳转至 Loki 查看该 trace 下所有服务日志，最终确认是 Spring Boot Actuator 端点被恶意扫描导致连接泄漏。

性能调优决策树

以下为实际应用中的调优路径判断依据：

触发条件	诊断工具	典型根因	生产操作
CPU 持续 >85% 且 load > 16	async-profiler + flame graph	正则回溯（`.*+`误用）、JSON 序列化深度递归	热点方法限流 + Jackson @JsonIdentityInfo
内存使用率 >90% 且 OOM Killer 激活	jcmd VM.native_memory summary	JNI 直接内存泄漏（Netty PooledByteBufAllocator 未 release）	启用 `-XX:NativeMemoryTracking=detail` + jemalloc 分析

灰度发布可观测性增强

在微服务灰度发布中，为 v2.3 版本 Pod 注入 canary:true 标签，并在 Prometheus 中定义如下分组查询：

rate(http_request_duration_seconds_count{job="api-gateway", canary="true"}[5m]) 
/ 
rate(http_request_duration_seconds_count{job="api-gateway"}[5m])

结合 Kibana 的 A/B 对比看板，发现灰度流量中 /order/submit 路径错误率上升 3.2%，进一步追踪发现新版本中 Redis Pipeline 批量写入未处理部分失败响应，导致订单状态不一致。

基础设施层协同优化

某金融客户将 Kubernetes Node 节点从 c5.4xlarge 升级至 m6i.4xlarge 后，观察到 gRPC 流式接口吞吐下降 18%。通过 eBPF 工具 bpftrace 抓取 socket write 调用栈，发现新实例类型启用 Intel Speed Select 技术导致 CPU 频率动态波动，最终通过 cpupower frequency-set -g performance 锁定频率并配合 kubelet --cpu-manager-policy=static 解决。

可观测性成本治理

对 127 个微服务实施标签精简策略：移除 git_commit_id（改由 CI/CD pipeline 注入 version label）、合并 env 与 region 为 location=prod-us-east，使 Prometheus 存储空间月均降低 41%，同时将 Loki 日志保留策略从 90 天压缩为 30 天热数据 + 180 天冷归档（S3 Glacier IR），年存储成本下降 $217,000。

真实故障复盘片段

2023年Q4某次数据库连接池雪崩事件中，Datadog APM 显示 DBCP2.getConnection() 平均耗时从 2ms 暴增至 4.2s，但 MySQL Threads_connected 仅 120（远低于 max_connections=500）。进一步检查发现 HikariCP 的 connection-timeout=30000 与业务层 @Transactional(timeout=30) 冲突，导致连接获取超时后事务强制回滚，引发下游重试风暴。最终通过将连接池 timeout 设为 1500ms 并增加熔断器隔离解决。

持续验证自动化流水线

在 GitLab CI 中集成 chaos engineering 模块：每次发布前自动执行 kubectl exec -n prod payment-service-0 -- kill -SIGUSR1 触发 JVM 内存 dump，并调用 Pyroscope API 验证火焰图采样正常；同时运行 k6 run --vus 50 --duration 30s ./load-test.js 对关键路径压测，若 p95 延迟增长超 20% 则阻断部署。

关键配置基线清单

生产环境必须强制校验的 7 项配置已在 Ansible Playbook 中固化：

JVM -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -Xms4g -Xmx4g
Kafka Consumer enable.auto.commit=false, max.poll.records=100
Nginx keepalive_timeout 65; proxy_read_timeout 30; client_max_body_size 10M
Istio Sidecar holdApplicationUntilProxyStarts=true, proxyConcurrency=2
PostgreSQL shared_buffers=256MB, work_mem=8MB, max_connections=300
Redis maxmemory-policy allkeys-lru, timeout 300, tcp-keepalive 60
Spring Boot management.endpoint.health.show-details=when_authorized, logging.level.com.myapp=INFO

多云环境统一视图构建

使用 Thanos Querier 聚合 AWS EKS、Azure AKS、阿里云 ACK 三套集群的 Prometheus 数据，通过 label cloud_provider 区分来源；在 Grafana 中创建跨云对比面板，监控同一微服务在不同云厂商节点上的网络延迟分布（利用 node-exporter node_network_receive_bytes_total 与 node_network_transmit_bytes_total 计算丢包率），发现 Azure 网络层存在隐式 QoS 限速，推动其调整 NSG 规则优先级。