如何在Go DRY中扫描数据库行？

怎么入门Golang编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《如何在Go DRY中扫描数据库行？》，涉及到，有需要的可以收藏一下

我在数据库中有一个包含用户帐户信息的表。我有一个名为“用户定义”的结构。

type user struct {
  id        uint
  username  string
  password  string
  firstname string
  lastname  string
  address1  string
  address2  string
  .... a bunch more fields ...
}

为了获取个人用户帐户，我定义了一个方法

func (user *user) getbyid(db *sql.db, id uint) error {
  query := `select 
            ...a whole bunch of sql ...
            where id = $1
            ... more sql ...
            limit 1`
  row := db.queryrow(query, id)
  err := row.scan(
    &user.id,
    &user.username,
    &user.password,
    &user.firstname,
    &user.lastname,
    ... some 20 more lines of fields read into the struct ...
  )
  if err != nil {
    return err
  }
  return nil
}

系统中有几个地方需要获取用户信息作为更大查询的一部分。也就是说，我正在获取一些其他类型的对象，但也获取与其相关的用户帐户。

这意味着，我必须一遍又一遍地重复整个 rows.scan(&user.username, &user...) 事情，它需要整个页面，而且很容易出错，如果我更改了用户表结构我必须在很多地方更改代码。我怎样才能让这个更干燥？

编辑：我不确定为什么将其标记为重复项，但由于需要进行此编辑，我将尝试再解释一次。我不是问如何将一行扫描到结构中。我已经知道如何做到这一点，正如上面的代码清楚地显示的那样。我问的是如何构造结构体扫描代码，这样我就不必每次扫描相同类型的结构体时都重复同一页扫描代码。

编辑：另外，是的，我知道 sqlstruct 和 sqlx 以及类似的库。我故意避免这些，因为它们依赖于具有详细记录的性能问题的反射包。我打算使用这些技术扫描数百万行（不是数百万用户，但这个问题扩展到其他记录类型）。

编辑：所以，是的，我知道我应该编写一个函数。我不确定这个函数应该接受什么作为参数以及它应该返回什么结果。假设我想要容纳的另一个查询如下所示

SELECT
    s.id,
    s.name,
    ... more site fields ...
    u.id,
    u.username,
    ... more user fields ...
FROM site AS s
JOIN user AS u ON (u.id = s.user_id)
JOIN some_other_table AS st1 ON (site.id = st1.site_id)
... more SQL ...

我有一个嵌入用户结构的站点结构方法。我不想在这里重复用户扫码。我想调用一个函数，它将原始数据的用户部分扫描到用户结构中，就像在上面的用户方法中一样。

解决方案

为了消除扫描 *sql.rows 结构所需步骤的重复，您可以引入两个接口。描述 *sql.rows 和 *sql.row 的已实现行为的一个。

// this interface is already implemented by *sql.rows and *sql.row.
type row interface {
    scan(...interface{}) error
}

还有一个抽象行的实际扫描步骤。

// have your entity types implement this one
type rowscanner interface {
    scanrow(row) error
}

rowscanner 接口的示例实现如下所示：

type user struct {
    id       uint
    username string
    // ...
}

// implements rowscanner
func (u *user) scanrow(r row) error {
    return r.scan(
        &u.id,
        &u.username,
        // ...
    )
}

type userlist struct {
    items []*user
}

// implements rowscanner
func (list *userlist) scanrow(r row) error {
    u := new(user)
    if err := u.scanrow(r); err != nil {
        return err
    }
    list.items = append(list.items, u)
    return nil
}

通过这些接口，您现在可以使用这两个函数来干燥所有实现 rowscanner 接口的类型的行扫描代码。

func queryrows(query string, rs rowscanner, params ...interface{}) error {
    rows, err := db.query(query, params...)
    if err != nil {
        return err
    }
    defer rows.close()

    for rows.next() {
        if err := rs.scanrow(rows); err != nil {
            return err
        }
    }
    return rows.err()
}

func queryrow(query string, rs rowscanner, params ...interface{}) error {
    return rs.scanrow(db.queryrow(query, params...))
}

// example
ulist := new(userlist)
if err := queryrows(querystring, ulist, arg1, arg2); err != nil {
    panic(err)
}

// or
u := new(user)
if err := queryrow(querystring, u, arg1, arg2); err != nil {
    panic(err)
}

如果您想要扫描复合类型，但希望避免重复枚举其元素的字段，那么您可以引入一个返回类型字段的方法，并在需要时重用该方法。例如：

func (u *User) ScannableFields() []interface{} {
    return []interface{}{
        &u.Id,
        &u.Username,
        // ...
    }
}

func (u *User) ScanRow(r Row) error {
    return r.Scan(u.ScannableFields()...)
}

// your other entity type
type Site struct {
    Id   uint
    Name string
    // ...
}

func (s *Site) ScannableFields() []interface{} {
    return []interface{}{
        &p.Id,
        &p.Name,
        // ...
    }
}

// Implements RowScanner
func (s *Site) ScanRow(r Row) error {
    return r.Scan(s.ScannableFields()...)
}

// your composite
type UserWithSite struct {
    User *User
    Site *Site
}

// Implements RowScanner
func (u *UserWithSite) ScanRow(r Row) error {
    u.User = new(User)
    u.Site = new(Site)
    fields := append(u.User.ScannableFields(), u.Site.ScannableFields()...)
    return r.Scan(fields...)
}

// retrieve from db
u := new(UserWithSite)
if err := queryRow(queryString, u, arg1, arg2); err != nil {
    panic(err)
}

以上就是《如何在Go DRY中扫描数据库行？》的详细内容，更多关于的资料请关注golang学习网公众号！