数据库接入 database/sql · gorm · sqlx

package main

import (
	"database/sql"
	"fmt"
	"log"
	"time"

	_ "github.com/go-sql-driver/mysql" // 空导入：注册驱动，只用它的副作用
)

func main() {
	// 连接串格式随驱动：mysql 是 user:pass@tcp(host:port)/db?parseTime=true
	dsn := "root:123456@tcp(127.0.0.1:3306)/app?parseTime=true&charset=utf8mb4"
	db, err := sql.Open("mysql", dsn)
	if err != nil {
		log.Fatal(err) // 注意：这里通常不会失败（Open 不连网）
	}
	defer db.Close() // Close 关闭句柄（不是立刻断开池里连接）

	// 关键：验证真的能连上，并配置连接池
	if err := db.Ping(); err != nil {
		log.Fatalf("连不上数据库: %v", err)
	}

	// 连接池参数（必须显式调优）
	db.SetMaxOpenConns(10)                // 同一时刻最多 10 个连接
	db.SetMaxIdleConns(5)                 // 空闲池保留 5 个
	db.SetConnMaxLifetime(time.Hour)      // 单连接最长活 1 小时，防 IP 切换/内存泄漏

	fmt.Println("数据库连接 OK")
}

type User struct {
	ID   int
	Name string
	Age  int
}

func getUserByID(db *sql.DB, id int) (*User, error) {
	var u User
	// QueryRow 只查一行；.Scan 严格按参数顺序取列
	err := db.QueryRow("SELECT id, name, age FROM users WHERE id = ?", id).
		Scan(&u.ID, &u.Name, &u.Age)
	if err == sql.ErrNoRows { // 没查到是「有意义的错误」，单独处理
		return nil, nil
	}
	if err != nil {
		return nil, err
	}
	return &u, nil
}

func listUsers(db *sql.DB) ([]User, error) {
	rows, err := db.Query("SELECT id, name, age FROM users ORDER BY id")
	if err != nil {
		return nil, err
	}
	defer rows.Close() // 循环结束后必须释放

	var users []User
	for rows.Next() { // 游标逐行前进
		var u User
		if err := rows.Scan(&u.ID, &u.Name, &u.Age); err != nil {
			return nil, err
		}
		users = append(users, u)
	}
	// 遍历完记得检查迭代错误（连接中途断掉等）
	return users, rows.Err()
}

// 单条 Exec
func insertUser(db *sql.DB, name string, age int) (int64, error) {
	res, err := db.Exec("INSERT INTO users(name, age) VALUES(?, ?)", name, age)
	if err != nil {
		return 0, err
	}
	id, err := res.LastInsertId() // 自增主键
	return id, err
}

// 批量插入用 Prepare：只解析一次 SQL，重复执行
func batchInsert(db *sql.DB, names []string) error {
	stmt, err := db.Prepare("INSERT INTO users(name) VALUES(?)")
	if err != nil {
		return err
	}
	defer stmt.Close()
	for _, n := range names {
		if _, err := stmt.Exec(n); err != nil {
			return err
		}
	}
	return nil
}

func transfer(db *sql.DB, fromID, toID, amount int) error {
	// 1. 开启事务
	tx, err := db.Begin()
	if err != nil {
		return err
	}
	// 2. 兜底回滚：正常 Commit 后，Rollback 是 no-op（不产生副作用）
	defer tx.Rollback()

	// 3. 所有操作走 tx
	if _, err := tx.Exec("UPDATE accounts SET balance = balance - ? WHERE id = ?", amount, fromID); err != nil {
		return err
	}
	if _, err := tx.Exec("UPDATE accounts SET balance = balance + ? WHERE id = ?", amount, toID); err != nil {
		return err
	}
	if _, err := tx.Exec("UPDATE accounts SET version = version + 1 WHERE id = ?", fromID); err != nil {
		return err
	}

	// 4. 提交
	return tx.Commit()
}

go get github.com/jmoiron/sqlx

package main

import (
	"fmt"
	"log"

	"github.com/jmoiron/sqlx"
	_ "github.com/go-sql-driver/mysql"
)

type User struct {
	ID   int    `db:"id"`
	Name string `db:"name"`
	Age  int    `db:"age"`
}

func main() {
	db := sqlx.MustConnect("mysql", "root:123456@tcp(127.0.0.1:3306)/app?parseTime=true")
	defer db.Close()

	// 多行 → Select（slice 由 sqlx 自动填充）
	var users []User
	if err := db.Select(&users, "SELECT id, name, age FROM users WHERE age > ?", 18); err != nil {
		log.Fatal(err)
	}
	fmt.Println(users)

	// 单行 → Get
	var u User
	if err := db.Get(&u, "SELECT * FROM users WHERE id = ?", 1); err != nil {
		log.Fatal(err)
	}
	fmt.Println(u)

	// Named 查询：用结构体/ map 字段名代替占位符 ?，参数映射进 SQL
	// 注意 Named 语法是 :name 而不是 ?
	rows, err := db.NamedQuery(
		"SELECT * FROM users WHERE name = :name",
		map[string]any{"name": "Tom"},
	)
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()
	for rows.Next() {
		row := struct{ ID int `db:"id"` }{}
		if err := rows.StructScan(&row); err != nil {
			log.Fatal(err)
		}
		fmt.Println(row)
	}
}

go get gorm.io/gorm gorm.io/driver/sqlite   # 或 gorm.io/driver/mysql 等

package main

import (
	"fmt"
	"log"

	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

// 模型 = 结构体 + tag；AutoMigrate 会照此自动建表
type User struct {
	gorm.Model           // 内嵌：ID、CreatedAt、UpdatedAt、DeletedAt 自动字段
	Name  string         `gorm:"size:255;not null"`
	Email string         `gorm:"uniqueIndex"`
	Age   int            `gorm:"default:0"`
}

type Profile struct {
	ID     uint
	UserID uint   // 外键
	Bio    string
}

type Order struct {
	ID      uint
	UserID  uint
	Total   float64
	Items   []OrderItem `gorm:"foreignKey:OrderID"`
}

type OrderItem struct {
	ID      uint
	OrderID uint
	Name    string
	Price   float64
}

func main() {
	db, err := gorm.Open(sqlite.Open("app.db"), &gorm.Config{})
	if err != nil {
		log.Fatal(err)
	}
	// 自动迁移：按模型建表/补列（框架管理运维便利，生产谨慎用）
	if err := db.AutoMigrate(&User{}, &Profile{}, &Order{}, &OrderItem{}); err != nil {
		log.Fatal(err)
	}

	// --- Create ---
	u := User{Name: "Tom", Email: "tom@example.com", Age: 30}
	if err := db.Create(&u).Error; err != nil { // u.ID 会被回填
		log.Fatal(err)
	}
	fmt.Println("新建用户 ID:", u.ID)

	// --- Read ---
	var first User
	db.First(&first, u.ID)              // 按主键
	db.First(&first, "name = ?", "Tom") // 条件
	var all []User
	db.Order("age desc").Limit(10).Find(&all) // 列表

	// --- Update ---
	db.Model(&first).Update("Age", 31)
	db.Model(&first).Updates(map[string]any{"Age": 32, "Name": "Tommy"})

	// --- Delete（软删除：gorm.Model 自带 DeletedAt，Delete 是标记删除） ---
	db.Delete(&first)

	// --- 事务 -------------------------------------------------------------
	err = db.Transaction(func(tx *gorm.DB) error {
		if err := tx.Create(&Order{Total: 99.9, Items: []OrderItem{{Name: "书", Price: 99.9}}}).Error; err != nil {
			return err // 返回 error 即回滚
		}
		if err := tx.Create(&Order{Total: 0}).Error; err != nil {
			return err
		}
		return nil // nil 即提交
	})
	if err != nil {
		log.Fatal(err)
	}

	// --- 关联：Preload 预加载 has-many ---
	var orders []Order
	db.Preload("Items").Find(&orders)
	fmt.Printf("共 %d 个订单，第一个含 %d 条明细\n", len(orders), len(orders[0].Items))
}

// MySQL：空导入一行即可切换
import _ "github.com/go-sql-driver/mysql"

// PostgreSQL：只换驱动与连接串
import _ "github.com/lib/pq"
// dsn = "host=localhost user=postgres password=x dbname=app sslmode=disable"
// 占位符从 ? 换成 $1、$2 ...

// SQLite：用于本地/测试
import _ "modernc.org/sqlite" // 纯 Go 实现，无 CGO
// dsn = "file:app.db"

// 达梦 DM8：官方/社区提供 Go 驱动，同样注册进 database/sql
import _ "dm" // 例：github.com/gentleming/dm 等
// dsn = "dm://SYSDBA:123456@localhost:5236?schema=APP"