Go 1.10 相比 Go 1.9 有哪些值得注意的改动？

package main

import (
    "bytes"
    "fmt"
)

func main() {
    data := []byte("Hello World Gopher")
    fmt.Printf("Original data: %s\n", data)

    // 使用 Split 切分字符串
    parts := bytes.Split(data, []byte(" ")) // 按空格切分

    // parts[0] 是 "Hello"
    // 在 Go 1.9 中，parts[0] 的 len 是 5，但 cap 可能是整个 data 的长度 (18)
    // 或者至少是到下一个分隔符之前的长度
    fmt.Printf("Part 0: %s, len=%d, cap=%d\n", parts[0], len(parts[0]), cap(parts[0]))

    // 尝试向第一个部分追加数据
    parts[0] = append(parts[0], '!', '!') // 追加 "!!"

    // 由于 parts[0] 的容量可能大于 5，append 操作可能会直接在底层数组上修改
    // 这可能会覆盖掉原始 data 中 " World" 的一部分
    fmt.Printf("After append to Part 0: %s\n", parts[0])
    fmt.Printf("Original data after append: %s\n", data) // 观察原始 data 是否被修改
}

Original data: Hello World Gopher
Part 0: Hello, len=5, cap=32
After append to Part 0: Hello!!
Original data after append: Hello!!orld Gopher

package main

import (
    "bytes"
    "fmt"
)

func main() {
    data := []byte("Hello World Gopher")
    fmt.Printf("Original data: %s\n", data)

    parts := bytes.Split(data, []byte(" "))

    // 在 Go 1.10+ 中，parts[0] 的 len 是 5，cap 也是 5
    fmt.Printf("Part 0: %s, len=%d, cap=%d\n", parts[0], len(parts[0]), cap(parts[0]))

    // 尝试向第一个部分追加数据
    parts[0] = append(parts[0], '!', '!') // 追加 "!!"

    // 由于 parts[0] 的 cap 等于 len，append 操作会触发底层数组的重新分配和复制
    // 新的底层数组与原始 data 无关
    fmt.Printf("After append to Part 0: %s\n", parts[0]) // parts[0] 变成了 "Hello!!"
    fmt.Printf("Original data after append: %s\n", data) // 原始 data 保持不变
}

Original data: Hello World Gopher
Part 0: Hello, len=5, cap=5
After append to Part 0: Hello!!
Original data after append: Hello World Gopher

type Connector interface {
    Connect(context.Context) (Conn, error) // 创建一个新的数据库连接
    Driver() Driver                        // 返回关联的 Driver
}

package mydriver

import (
    "context"
    "database/sql/driver"
)

type MyConfig struct {
    Host     string
    Port     int
    Username string
    Password string
    // ... 其他配置
}

type myConnector struct {
    cfg    MyConfig
    driver *myDriver // 引用 Driver 实现
}

func (c *myConnector) Connect(ctx context.Context) (driver.Conn, error) {
    // 使用 c.cfg 中的配置信息建立实际的数据库连接
    // ... 返回一个实现了 driver.Conn 的连接对象
    return connectToDatabase(ctx, c.cfg)
}

func (c *myConnector) Driver() driver.Driver {
    return c.driver
}

// 驱动可以提供一个函数来创建 Connector
func NewConnector(cfg MyConfig) driver.Connector {
    return &myConnector{cfg: cfg, driver: &theDriver} // theDriver 是 MyDriver 的实例
}

// MyDriver 仍然需要实现 driver.Driver，但 Open 方法可能变得简单或不再是主要入口
type myDriver struct{}
func (d *myDriver) Open(name string) (driver.Conn, error) {
        // 可能仍然支持 DSN，或者返回错误提示使用 Connector
        cfg, err := parseDSN(name)
        if err != nil { return nil, err }
        return connectToDatabase(context.Background(), cfg)
}

var theDriver myDriver // Driver 实例

// connectToDatabase 和 parseDSN 是具体的实现细节
func connectToDatabase(ctx context.Context, cfg MyConfig) (driver.Conn, error) { /* ... */ return nil, nil }
func parseDSN(name string) (MyConfig, error) { /* ... */ return MyConfig{}, nil }

package main

import (
    "database/sql"
    "log"

    "path/to/mydriver" // 引入你的驱动包
)

func main() {
    cfg := mydriver.MyConfig{
        Host:     "localhost",
        Port:     5432,
        Username: "user",
        Password: "password",
    }
    connector := mydriver.NewConnector(cfg)

    db := sql.OpenDB(connector) // 使用 Connector 打开数据库
    defer db.Close()

    err := db.Ping()
    if err != nil {
        log.Fatal(err)
    }
    log.Println("Connected!")
    // ... 使用 db 进行数据库操作
}

package mydriver

import (
    "context"
    "database/sql/driver"
    "sync"
)

// 解析后的配置结构
type MyConfig struct {
    // 例如: host, port, user, password 等字段
}

// Connector 持有解析后的配置，实现 driver.Connector 接口
type myConnector struct {
    cfg    *MyConfig       // 关键：保存解析后的配置，供后续 Connect 使用
    driver driver.Driver   // 关联的驱动实例
}

func (c *myConnector) Connect(ctx context.Context) (driver.Conn, error) {
    // 使用预先解析好的 cfg 创建连接，无需再次解析 DSN！
    return connectToDatabase(ctx, c.cfg)
}

func (c *myConnector) Driver() driver.Driver {
    return c.driver
}

// 驱动实现 DriverContext 接口
type myDriver struct {
    // 可选：缓存 Connector，避免相同 DSN 重复解析（根据需求决定是否添加）
    connectors sync.Map // map[string]*myConnector
}

// 确保实现 DriverContext 接口
var _ driver.DriverContext = (*myDriver)(nil)

// OpenConnector 实现 DriverContext 接口，仅解析一次 DSN
func (d *myDriver) OpenConnector(name string) (driver.Connector, error) {
    // 可选：缓存 Connector（根据业务需求）
    if v, ok := d.connectors.Load(name); ok {
        return v.(*myConnector), nil
    }

    // 解析 DSN（仅在此处执行一次）
    cfg, err := parseDSN(name)
    if err != nil {
        return nil, err
    }

    // 创建 Connector 并缓存（可选）
    connector := &myConnector{cfg: cfg, driver: d}
    d.connectors.Store(name, connector)
    return connector, nil
}

// Open 方法仅用于兼容旧版本，实际使用 DriverContext 时不会被调用
func (d *myDriver) Open(name string) (driver.Conn, error) {
    // 当驱动未实现 DriverContext 时，sql.Open 会调用此方法
    // 此处逻辑仅为兼容，实际可简化或报错
    connector, err := d.OpenConnector(name)
    if err != nil {
        return nil, err
    }
    return connector.Connect(context.Background()) // 复用 Connect 逻辑
}

// --- 辅助函数 ---
func parseDSN(name string) (*MyConfig, error) {
    // 具体解析逻辑（例如解析连接字符串为 MyConfig）
    return &MyConfig{}, nil
}

func connectToDatabase(ctx context.Context, cfg *MyConfig) (driver.Conn, error) {
    // 使用 cfg 创建真实连接（例如 TCP 连接、认证等）
    return &myConn{}, nil
}

// 实现 driver.Conn 的空结构（具体方法需实现）
type myConn struct{ 
    driver.Conn 
    // 实现 Query, Exec, Close 等方法...
}

// 全局驱动实例
var theDriver myDriver

type SessionResetter interface {
    ResetSession(ctx context.Context) error
}

package mydriver

import (
    "context"
    "database/sql/driver"
)

type myConn struct {
    // ... 连接相关的字段 ...
    sessionInitialized bool
    tempData           string
}

// 确保 myConn 实现了 SessionResetter
var _ driver.SessionResetter = (*myConn)(nil)

func (c *myConn) ResetSession(ctx context.Context) error {
    // 在连接被复用前调用
    if c.sessionInitialized {
            // 执行清理操作，例如：
            // _, err := c.exec("RESET SESSION VARIABLES", nil) // 假设有这样的 SQL
            // if err != nil { return err }
            c.tempData = "" // 清理会话相关的临时状态
            c.sessionInitialized = false
            // log.Printf("Session reset for connection %p", c)
    }
    return nil
}

// ... 其他 driver.Conn 接口方法的实现 ...
func (c *myConn) Prepare(query string) (driver.Stmt, error) { /* ... */ return nil, nil }
func (c *myConn) Close() error { /* ... */ return nil }
func (c *myConn) Begin() (driver.Tx, error) { /* ... */ return nil, nil }

// 在执行某些操作后，可能会设置会话状态
func (c *myConn) doSomethingThatSetsSessionState() {
    c.sessionInitialized = true
    c.tempData = "some session specific data"
}