QueryRow

一般情况下，我们使用 QueryRow() 来读取单条的数据。这是个可变参数的方法，具体语法如下：

func (db *DB) QueryRow(query string, args ...interface{}) *Row

它的参数可以为一个或者多个。参数只有一个的情况下，我们称之为纯文本模式，多个参数的情况下称之为 Prepare 模式。之所以称之为 Prepare 模式是因为当多个参数的情况下，QueryRow() 封装了 Prepare 方法的调用，也就是说，下面这段代码：

err := db.QueryRow(query, id).Scan(&article.ID, &article.Title, &article.Body)

等同于：

stmt, err := db.Prepare(query)
checkError(err)
defer stmt.Close()
err = stmt.QueryRow(id).Scan(&article.ID, &article.Title, &article.Body)

使用 QueryRow() 的 Prepare 模式不仅保证了安全性，更能提升可读性。

注意：使用 Prepare 模式会发送两个 SQL 请求到 MySQL 服务器上，而纯文本模式只有一个。

Query

一般情况下，我们使用 Query() 从数据库中读取多条数据，而前面的 QueryRow() 是读取单条的数据。语法如下：

func (db *DB) Query(query string, args ...interface{}) (*Rows, error)

调用方式与 QueryRow() 和 Exec() 一致，支持单一参数的纯文本模式，以及多个参数的 Prepare 模式。
Query() 和 Exec() 的区别在于Exec 只会返回插入的 ID 和影响行数，而 Query 会返回数据表里的内容（结果集），使用场景不同而已。

Scan方法

QueryRow() 会返回一个 sql.Row 结构体，通常我们使用链式调用的方式调用 sql.Row.Scan() 方法：

db.QueryRow(query, id).Scan(&article.ID, &article.Title, &article.Body)

Scan() 将查询结果赋值到我们的 article struct 中，传参应与数据表字段的顺序保持一致。
需要注意的是，返回的 sql.Row 是个指针变量，保存有 SQL 连接。当调用 Scan() 时，就会将连接释放。所以在每次 QueryRow 后使用 Scan 是必须的。

sql.Rows 对象

sql.Rows包含的方法如下：

func (rs *Rows) Close() error                            //关闭结果集
func (rs *Rows) ColumnTypes() ([]*ColumnType, error)    //返回数据表的列类型
func (rs *Rows) Columns() ([]string, error)             //返回数据表列的名称
func (rs *Rows) Err() error                      // 错误集
func (rs *Rows) Next() bool                      // 游标，下一行
func (rs *Rows) Scan(dest ...interface{}) error  // 扫描结构体
func (rs *Rows) NextResultSet() bool

结果集在检出完 err 以后，遍历数据之前，应调用 defer rows.Close() 来关闭 SQL 连接。
一般我们会使用 rows.Next() 来遍历数据，如：

var articles []Article
//2. 循环读取结果
for rows.Next() {
    var article Article
    // 2.1 扫码每一行的结果并赋值到一个 article 对象中
    err := rows.Scan(&article.ID, &article.Title, &article.Body)
    checkError(err)
    // 2.2 将 article 追加到 articles 的这个数组中
    articles = append(articles, article)
}
// 2.3 检测循环时是否发生错误
err = rows.Err()
checkError(err)

循环完毕需检测是否发生错误。
rows.Scan() 参数的顺序很重要，需要和查询的结果的 column 对应。

sql.Row 和 sql.Rows对象

QueryRow() 返回 Row 对象，这是基于 Rows 实现的。尽管在 Row 结构体当中含有一个 Rows 对象，但它最多只能存在一条数据：

type Row struct {
	err  error
	rows *Rows
}

而 Query() 则返回 sql.Rows 结构体，代表一个查询结果集，这里面包含从数据库里读取出来的（多条）数据和 SQL 连接：

type Rows struct {
	dc          *driverConn
	releaseConn func(error)
	rowsi       driver.Rows
	cancel      func()
	closeStmt   *driverStmt

	closemu sync.RWMutex
	closed  bool
	lasterr error

	lastcols []driver.Value
}

Query() 与 sql.Rows 需要注意的点

参考代码 – 查询多条数据

1. 在每一次 for rows.Next() 后，都记得要检测下是否有错误发生，调用 rows.Err() 可获取到错误；
2. 使用 rows.Next() 遍历数据，遍历到最后内部遇到 EOF 错误，会自动调用 rows.Close() 将 SQL 连接关闭；
3. 使用 rows.Next() 遍历时，如遇错误，SQL 连接也会自动关闭；
4. rows.Close() 可调用多次，使用 rows.Close() 可保证 SQL 连接永远是关闭的。defer rows.Close() 需在检测 err 以后调用，否则会让运行时 panic ；
5. 牢记在获取到结果集后，必须执行 defer rows.Close()。这样做能防止有时你在函数里过早 return ，或者其他操作忘记关闭资源，这是一个值得培养的良好习惯；
6. 如果你在循环中执行 Query() 并获取 Rows 结果集，请不要使用 defer ，而是直接调用 rows.Close()，因为 defer 不会立刻执行，而是在函数执行结束后执行；

Prepare 和 Stmt

sql.DB.Prepare() 方法会返回一個 sql.Stmt 对象，与 Stmt 相关的方法如下：

stmt.Exec()
stmt.Query()
stmt.QueryRow()
stmt.Close()

注意与 sql.DB 下的方法区分。

做单独的语句查询时，谨记调用 defer stmt.Close() 来关闭 SQL 连接。
使用 Prepare 语句会发送两次请求到数据库服务器上，第一次是调用 Prepare() 语句时，第二次是调用以上提到的四个 Stmt 方法时：

Prepare 语句可有效防范 SQL 注入攻击。
以下常见的 DB 查询方法中，调用在传参一个以上时，底层皆会使用 Prepare 来发送请求：

func (db *DB) Exec(query string, args ...interface{}) (Result, error)
func (db *DB) Query(query string, args ...interface{}) (*Rows, error)
func (db *DB) QueryRow(query string, args ...interface{}) *Row

sql.Tx 事务

使用以下可以开启事务：

func (db *DB) Begin() (*Tx, error)
func (db *DB) BeginTx(ctx context.Context, opts *TxOptions) (*Tx, error)

Begin() 和 BeginTxt() 方法返回一个 sql.Tx 结构体，他支持以上提到的几种查询方法：

func (tx *Tx) Exec(query string, args ...interface{}) (Result, error)
func (tx *Tx) ExecContext(ctx context.Context, query string, args ...interface{}) (Result, error)
func (tx *Tx) Query(query string, args ...interface{}) (*Rows, error)
func (tx *Tx) QueryContext(ctx context.Context, query string, args ...interface{}) (*Rows, error)
func (tx *Tx) QueryRow(query string, args ...interface{}) *Row
func (tx *Tx) QueryRowContext(ctx context.Context, query string, args ...interface{}) *Row

// 预编译 Prepare
func (tx *Tx) Stmt(stmt *Stmt) *Stmt
func (tx *Tx) StmtContext(ctx context.Context, stmt *Stmt) *Stmt
func (tx *Tx) Prepare(query string) (*Stmt, error)
func (tx *Tx) PrepareContext(ctx context.Context, query string) (*Stmt, error)

使用这同一个 sql.Tx 对数据库进行操作，就会在同一个事务中提交。
当使用 sql.Tx 的操作方式操作数据后，需要使用 sql.Tx 的 Commit() 方法提交事务，如果出错，则可以使用 sql.Tx 中的 Rollback() 方法回滚事务，保持数据的一致性，下面是这两个方法的定义：

func (tx *Tx) Commit() error
func (tx *Tx) Rollback() error

例如：

func (s Service) DoSomething() (err error) {
    // 1. 创建事务
    tx, err := s.db.Begin()
    if err != nil {
        return
    }
    // 2. 如果请求失败，就回滚所有 SQL 操作，否则提交
    //    defer 会在当前方法的最后执行
    defer func() {
        if err != nil {
            tx.Rollback()
            return err
        }
        err = tx.Commit()
    }()

    // 3. 执行各种请求
    if _, err = tx.Exec(...); err != nil {
        return err
    }
    if _, err = tx.Exec(...); err != nil {
        return err
    }
    // ...
    return nil
}

Demo

---