golang sql体系及orm实现

// 创建数据库
func Open(driverName, dataSourceName string) (*DB, error) {
    // 首先根据驱动类型获取数据库驱动, 导入mysql驱动时，会自动在drivers中注册，_ "github.com/go-sql-driver/mysql"
    driversMu.RLock()
    driveri, ok := drivers[driverName]
    driversMu.RUnlock()
    if !ok {
        return nil, fmt.Errorf("sql: unknown driver %q (forgotten import?)", driverName)
    }
    // 若驱动实现了对应的连接器 connector，则获取之并进行 db 实例创建
    if driverCtx, ok := driveri.(driver.DriverContext); ok {
        connector, err := driverCtx.OpenConnector(dataSourceName)
        if err != nil {
            return nil, err
        }
        return OpenDB(connector), nil
    }
    // 默认使用 dsn 数据库连接器，进行 db 创建
    return OpenDB(dsnConnector{dsn: dataSourceName, driver: driveri}), nil
}

const maxBadConnRetries = 2
// 执行查询类 sql
func (db *DB) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error) {
    var rows *Rows
    var err error
    var isBadConn bool

    // 最多可以因为 BadConn 类型的错误重试两次
    for i := 0; i < maxBadConnRetries; i++ {
        // 执行 sql，此时采用的是 连接池有缓存连接优先复用 的策略
        rows, err = db.query(ctx, query, args, cachedOrNewConn)
        // 属于 badConn 类型的错误可以重试
        isBadConn = errors.Is(err, driver.ErrBadConn)
        if !isBadConn {
            break
        }
    }
    // 重试了两轮 badConn 错误后，第三轮会采用
    if isBadConn {
        return db.query(ctx, query, args, alwaysNewConn)
    }
    return rows, err
}

func (dc *driverConn) releaseConn(err error) {
    dc.db.putConn(dc, err, true)
}

import (
    // 注册 mysql 数据库驱动
    _ "github.com/go-sql-driver/mysql"
)

// mysql#driver.go, This variable can be replaced with -ldflags like below:
// go build "-ldflags=-X github.com/go-sql-driver/mysql.driverName=custom"
var driverName = "mysql"
func init() {
    if driverName != "" {
        sql.Register(driverName, &MySQLDriver{})
    }
}
// MySQL 版本的数据库驱动
type MySQLDriver struct{}

type connector struct {
    cfg               *Config // immutable private copy.
    encodedAttributes string  // Encoded connection attributes.
}

// Connect implements driver.Connector interface.
// Connect returns a connection to the database.
func (c *connector) Connect(ctx context.Context) (driver.Conn, error) {
    // New mysqlConn
    mc := &mysqlConn{
        maxAllowedPacket: maxPacketSize,
        maxWriteSize:     maxPacketSize - 1,
        closech:          make(chan struct{}),
        cfg:              cfg,
        connector:        c,
	}
	// ...
}

// Driver implements driver.Connector interface.
// Driver returns &MySQLDriver{}.
func (c *connector) Driver() driver.Driver {
    return &MySQLDriver{}
}

type mysqlConn struct {
    // 缓冲区数据
    buf              buffer
    // 网络连接
    netConn          net.Conn
    rawConn          net.Conn    // underlying connection when netConn is TLS connection.
    result           mysqlResult // sql 执行结果
	// ...
}

func (mc *mysqlConn) Close() (err error) {
    // Makes Close idempotent
    if !mc.closed.Load() {
        err = mc.writeCommandPacket(comQuit)
    }
    mc.cleanup()
    return
}

func (mc *mysqlConn) Query(query string, args []driver.Value) (driver.Rows, error) {
    return mc.query(query, args)
}

func (mc *mysqlConn) query(query string, args []driver.Value) (*textRows, error) {
    handleOk := mc.clearResult()
    // 连接已关闭？
    if mc.closed.Load() {
        mc.cfg.Logger.Print(ErrInvalidConn)
        return nil, driver.ErrBadConn
    }
	// ...
}

type mysqlStmt struct {
    // 关联的 mysql 连接
    mc         *mysqlConn
    // 预处理语句的标识 id
    id         uint32
    // 预处理状态中多少待填充参数
    paramCount int
}

import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)
var (
    dsn := "root:123456@tcp(127.0.0.1:3306)/douban_datahub?charset=utf8mb4&parseTime=True&loc=Local"
    db *gorm.DB
    dbOnce sync.Once
)
func getDB() (*gorm.DB, error) {
    var err error
    dbOnce.Do(func(){
        // 创建 db 实例
        db, err = gorm.Open(mysql.Open(dsn),&gorm.Config{})
    })
    return db,err
}

// go-gorm/mysql/mysql.go
func Open(dsn string) gorm.Dialector {
    dsnConf, _ := mysql.ParseDSN(dsn)
    return &Dialector{Config: &Config{DSN: dsn, DSNConfig: dsnConf}}
}

// 在gorm.Open中，当dialector不为空时，会调用config.Dialector.Initialize(db)，对应实现在 go-gorm/mysql/mysql.go中
func (dialector Dialector) Initialize(db *gorm.DB) (err error) {
    if dialector.DriverName == "" {
        dialector.DriverName = DefaultDriverName
    }
	// connPool 初始化
    if dialector.Conn != nil {
        db.ConnPool = dialector.Conn
    } else {
        db.ConnPool, err = sql.Open(dialector.DriverName, dialector.DSN)
        if err != nil {
        return err
        }
    }
    // register callbacks
    callbackConfig := &callbacks.Config{
        CreateClauses: CreateClauses,
        QueryClauses:  QueryClauses,
        UpdateClauses: UpdateClauses,
        DeleteClauses: DeleteClauses,
    }
    // ...完成 crud 类操作 callback 函数的注册
    callbacks.RegisterDefaultCallbacks(db, callbackConfig)
	return
}