Files
bj_power/test/internal/db/db.go
T

265 lines
6.3 KiB
Go
Raw Normal View History

// Package db 直连三个库做 L2 落库断言:
// MES PostgreSQL(bj_power_mes)、WMS PostgreSQL(bj_power_wms)、工位终端 SQLite(workstation.db)。
// 只读查询,不写库、不删测试数据。
package db
import (
"context"
"database/sql"
"fmt"
"strings"
"github.com/jackc/pgx/v5/pgtype"
"github.com/jackc/pgx/v5/pgxpool"
_ "modernc.org/sqlite"
)
// Target 目标库。
type Target string
const (
MES Target = "MES"
WMS Target = "WMS"
WS Target = "工位终端"
)
// DB 三库连接集合。
type DB struct {
mes *pgxpool.Pool
wms *pgxpool.Pool
ws *sql.DB
}
// Open 建连并 Ping 三库;任一失败返回错误清单,已成功的连接仍保留可用。
func Open(ctx context.Context, mesDSN, wmsDSN, sqlitePath string) (*DB, []error) {
d := &DB{}
var errs []error
if p, err := pgxpool.New(ctx, mesDSN); err != nil {
errs = append(errs, fmt.Errorf("MES 库建连:%w", err))
} else if err := p.Ping(ctx); err != nil {
errs = append(errs, fmt.Errorf("MES 库 Ping:%w", err))
p.Close()
} else {
d.mes = p
}
if p, err := pgxpool.New(ctx, wmsDSN); err != nil {
errs = append(errs, fmt.Errorf("WMS 库建连:%w", err))
} else if err := p.Ping(ctx); err != nil {
errs = append(errs, fmt.Errorf("WMS 库 Ping:%w", err))
p.Close()
} else {
d.wms = p
}
// 工位终端与业务服务共用同一文件,只读方式打开,避免与运行中的终端抢写锁。
if s, err := sql.Open("sqlite", "file:"+sqlitePath+"?mode=ro&_pragma=busy_timeout(5000)"); err != nil {
errs = append(errs, fmt.Errorf("工位终端 SQLite 建连:%w", err))
} else if err := s.PingContext(ctx); err != nil {
errs = append(errs, fmt.Errorf("工位终端 SQLite Ping:%w", err))
_ = s.Close()
} else {
d.ws = s
}
return d, errs
}
func (d *DB) Close() {
if d.mes != nil {
d.mes.Close()
}
if d.wms != nil {
d.wms.Close()
}
if d.ws != nil {
_ = d.ws.Close()
}
}
// Ready 某库是否可用。
func (d *DB) Ready(t Target) bool {
switch t {
case MES:
return d.mes != nil
case WMS:
return d.wms != nil
case WS:
return d.ws != nil
}
return false
}
// normalizeArgs 兼容「调用方把参数打包成 []any 整体传入」的写法:
// Scalar/Rows 是变参,若只收到一个 []any 则展开;单个 nil 视为无参数。
// (2026-11-08 断链核实:此前 scenario1 直接传 []any{code},pgx 收到的是
// 单个切片而非展开后的元素,导致查询失败/空值,进而误判为数据缺失。)
func normalizeArgs(args []any) []any {
if len(args) == 1 {
switch v := args[0].(type) {
case []any:
return v
case nil:
return nil
}
}
return args
}
// scalarString 把数据库标量统一转成可比对的字符串。
// pgx v5 把 NUMERIC 解成 pgtype.Numeric 结构体,直接 fmt.Sprint 会得到
// "{2 0 false finite true}" 这类不可比对文本(RUN20261108-05 的 S1-10/S1-16
// 库存汇总断言即由此误判为失败),故按 Int * 10^Exp 还原成十进制文本。
func scalarString(v any) string {
switch n := v.(type) {
case pgtype.Numeric:
return numericString(n)
case *pgtype.Numeric:
if n == nil {
return "<nil>"
}
return numericString(*n)
}
return fmt.Sprint(v)
}
func numericString(n pgtype.Numeric) string {
if !n.Valid || n.NaN || n.InfinityModifier != pgtype.Finite || n.Int == nil {
return "<nil>"
}
s := n.Int.String()
neg := strings.HasPrefix(s, "-")
if neg {
s = s[1:]
}
switch {
case n.Exp > 0:
s += strings.Repeat("0", int(n.Exp))
case n.Exp < 0:
k := int(-n.Exp)
if len(s) <= k {
s = strings.Repeat("0", k-len(s)+1) + s
}
s = s[:len(s)-k] + "." + s[len(s)-k:]
s = strings.TrimRight(s, "0")
s = strings.TrimSuffix(s, ".")
}
if neg && s != "0" {
s = "-" + s
}
return s
}
// Scalar 返回单值(统一转字符串,便于断言比较)。无行返回 "" 且 err=nil。
func (d *DB) Scalar(ctx context.Context, t Target, query string, args ...any) (string, error) {
args = normalizeArgs(args)
switch t {
case MES, WMS:
p := d.mes
if t == WMS {
p = d.wms
}
if p == nil {
return "", fmt.Errorf("%s 库未连接", t)
}
var v any
err := p.QueryRow(ctx, query, args...).Scan(&v)
if err != nil {
if strings.Contains(err.Error(), "no rows") {
return "", nil
}
return "", err
}
return scalarString(v), nil
case WS:
if d.ws == nil {
return "", fmt.Errorf("%s 库未连接", t)
}
var v any
err := d.ws.QueryRowContext(ctx, query, args...).Scan(&v)
if err != nil {
if err == sql.ErrNoRows {
return "", nil
}
return "", err
}
return scalarString(v), nil
}
return "", fmt.Errorf("未知目标库 %s", t)
}
// Rows 返回多行(列名 → 字符串值),用于逐行核对落库字段。
func (d *DB) Rows(ctx context.Context, t Target, query string, args ...any) ([]map[string]string, error) {
args = normalizeArgs(args)
out := []map[string]string{}
switch t {
case MES, WMS:
p := d.mes
if t == WMS {
p = d.wms
}
if p == nil {
return nil, fmt.Errorf("%s 库未连接", t)
}
rows, err := p.Query(ctx, query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
fields := rows.FieldDescriptions()
for rows.Next() {
vals, err := rows.Values()
if err != nil {
return nil, err
}
m := make(map[string]string, len(fields))
for i, f := range fields {
m[f.Name] = scalarString(vals[i])
}
out = append(out, m)
}
return out, rows.Err()
case WS:
if d.ws == nil {
return nil, fmt.Errorf("%s 库未连接", t)
}
rows, err := d.ws.QueryContext(ctx, query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
cols, err := rows.Columns()
if err != nil {
return nil, err
}
for rows.Next() {
buf := make([]any, len(cols))
ptr := make([]any, len(cols))
for i := range buf {
ptr[i] = &buf[i]
}
if err := rows.Scan(ptr...); err != nil {
return nil, err
}
m := make(map[string]string, len(cols))
for i, c := range cols {
m[c] = fmt.Sprint(buf[i])
}
out = append(out, m)
}
return out, rows.Err()
}
return nil, fmt.Errorf("未知目标库 %s", t)
}
// Count 便捷计数。
func (d *DB) Count(ctx context.Context, t Target, query string, args ...any) (int, error) {
s, err := d.Scalar(ctx, t, query, args...)
if err != nil {
return 0, err
}
if s == "" || s == "<nil>" {
return 0, nil
}
var n int
_, err = fmt.Sscan(s, &n)
return n, err
}