Golang通用数据库单条记录转json

Question

我想从数据库中检索记录并将其编码为 json。 我有大约 30 个不同的表，所以我想要适用于所有这些表的通用函数。我使用 xorm 进行数据库访问。

我已经设法创建了检索数据的 DRY 函数，这主要归功于这个 question & answer

这有效，可以将所有记录编码为 json:

type user struct {
   Id   int64  `json:"id"`
   Name string `json:"name"`
}
// type post
// etc.

type tableRecord struct {
    PrimaryKey string
    Data       interface{}
}

var ListOfTables = map[string]tableRecord{
    "users":{"id", &[]user{}},  // type user is struct for xorm with json annotation
    //"posts":{"post_id", &[]post{}},
    // etc.. 
}

for tableName, rec := range ListOfTables {
    err := xorm.Find(rec.Data)
    if err != nil {
        log.Print(err)
    }

    out, err := json.Marshal(rec.Data)
    if err != nil {
        log.Print(err)
    }
    log.Print(string(out)) // this yields json array
}

但是，我很难将单个记录编码为 json。 我四处寻找迭代接口(interface){}的方法，它包含一个 slice ，found this和类似的话题。尝试过:

switch reflect.TypeOf(reflect.ValueOf(rec.Data).Elem().Interface()).Kind() {
case reflect.Slice:
    s := reflect.ValueOf(reflect.ValueOf(rec.Data).Elem().Interface())
    for i := 0; i < s.Len(); i++ {
        entry := s.Index(i)
        log.Printf("%v\n", entry) // prints {1 John Doe}
        // log.Print(reflect.ValueOf(entry))
        data, err := json.MarshalIndent(entry, " ", "  ")
        if err != nil {
            log.Print(err)
        }
        log.Println(string(data)) // prints {} empty
    }
}  

当然，如果我指定 rec.Data 是 *[]user 它可以工作，但是我必须为每个表重写这样的代码，这是不是我想要的。

switch t := rec.Data.(type) {
case *[]user:
    for _, entry := range *t {
        // log.Printf("loop %v", entry)
        data, err := json.MarshalIndent(entry, " ", "  ")
        if err != nil {
            log.Print(err)
        }
        log.Println(string(data)) // yields needed json for single record
    }
}

或者也许有一种完全不同的、更好的方法来解决这个问题——数据库的任何记录到 json。

更新 现在的问题是，Xorm 需要结构吗？我将不得不阅读 xorm 的可能性和限制。

slice := record.Slice()
log.Print(reflect.TypeOf(slice))

err = env.hxo.In(record.PrimaryKey(), insertIds).Find(slice) // or &slice
if err != nil {
    log.Print(err) // Table not found
}

// this works
var slice2 []*user
err = env.hxo.In(record.PrimaryKey(), insertIds).Find(&slice2)
if err != nil {
    log.Print(err) // 
}

Answer 1

所以正如我在评论中提到的，如果您希望能够从 tableRecord.Data 字段中获取单个元素，最简单的方法就是将字段类型更改为它需要的类型实际上是:

type tableRecord struct {
    PrimaryKey string
    Data       []interface{} // slice of whatever
}

通过这种方式，您可以编写非常通用的内容:

for tbl, record := range records {
    fmt.Printf("First record from table %s\n", tbl)
    b, _ := json.MarshalIndent(record[0], " ", "  ")
    fmt.Println(string(b))
    fmt.Prinln("other records...")
    b, _ = json.MarshalIndend(record[1:], " ", "  ")
    fmt.Println(string(b))
}

不过，如果我是你，我会考虑在我的数据库类型中实现一个接口(interface)。类似的东西:

type DBType interface {
    PrimaryKey() string
    TableName() string // xorm can use this to get the table name
    Slice() []DBType // can return []user or whatever
}

所以你真的不再需要 tableRecord 类型了，可以只使用像这样的 var:

listOfTables := []DBType{user{}, ...}
for _, tbl := range listOfTables {
    data := tbl.Slice()
    // find data here
    fmt.Printf("First record from table %s\n", tbl.TableName())
    b, _ := json.MarshalIndent(data[0], " ", "  ")
    fmt.Println(string(b))
    fmt.Prinln("other records...")
    b, _ = json.MarshalIndend(data[1:], " ", "  ")
    fmt.Println(string(b))
}

---

所以我的回答/评论中缺少的 TL;DR:

• 从类型 []user{}(或 []DBTable)到 []interface{} 的转换不会行不通，因为您无法在单个表达式中将 slice 中的所有元素进行转换。您必须创建第二个类型为 []interface{} 的 slice 并像这样复制值:

  slice := userVar.Slice() 数据:=制作([]接口(interface){}，len( slice )) 对于我:=范围 slice { data[i] = slice[i]//将类型复制到 interface{} slice } 返回表记录{userVar.PrimaryKey(), 数据}

我已经创建了一个小型工作示例来说明如何使用上述接口(interface)。

DEMO

为避免太多困惑，您可以更改 Slice 函数以立即返回一个 []interface{}:

func(v T) Slice() []interface{
    return []interface{
        &T{},
    }
}

Slice 的实现有什么问题是这样的:

func (u *user) Slice() []DBTable {
    u = &user{} // you're re-assigning the receiver, losing all state!
    return []DBTable{u}
}

接收器是指针类型，因此您所做的任何重新分配都会影响调用 func 的变量。那不是一个好主意。只需使用值接收器，或者，如果你想确保接口(interface)只在指针变量上实现(一个常见的技巧，例如 gRPC 使用的)是像这样实现函数:

func(*user) Slice() []DBTable{
    return []DBTable{&user{}}
}

这个技巧的一个很好的例子可以在使用 Protocol Buffer 时生成的 pb.go 文件中找到。消息类型将具有如下功能:

func(*MsgType) ProtoMessage() {}