问题

Question

问题

在Golang中处理一对多或多对多SQL关系时，将行映射到struct的最佳方式（高效，推荐，“类似于Go”）是什么？

以下面的示例设置为例，我试图详细介绍每种方法的优缺点，但是想知道社区的建议。

要求

与PostgreSQL配合使用（可以通用，但不包括MySQL / Oracle特定功能）
效率-无需强求每种组合
不使用ORM-理想情况下，仅使用database/sql和jmoiron/sqlx

示例

为清楚起见，我已删除错误处理

模型

type Tag struct {
  ID int
  Name string
}

type Item struct {
  ID int
  Tags []Tag
}

数据库

CREATE TABLE item (
  id                      INT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY
);

CREATE TABLE tag (
  id                      INT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
  name                    VARCHAR(160),
  item_id                 INT REFERENCES item(id)
);

方法1-选择所有项目，然后为每个项目选择标签

var items []Item
sqlxdb.Select(&items, "SELECT * FROM item")

for i, item := range items {
  var tags []Tag
  sqlxdb.Select(&tags, "SELECT * FROM tag WHERE item_id = $1", item.ID)
  items[i].Tags = tags
}

优点

简单
易于理解

缺点

数据库查询数量与项目数量成正比时效率低

方法2-构造SQL连接并手动遍历行

var itemTags = make(map[int][]Tag)

var items = []Item{}
rows, _ := sqlxdb.Queryx("SELECT i.id, t.id, t.name FROM item AS i JOIN tag AS t ON t.item_id = i.id")
for rows.Next() {
  var (
    itemID  int
    tagID   int
    tagName string
  )
  rows.Scan(&itemID, &tagID, &tagName)
  if tags, ok := itemTags[itemID]; ok {
    itemTags[itemID] = append(tags, Tag{ID: tagID, Name: tagName,})
  } else {
    itemTags[itemID] = []Tag{Tag{ID: tagID, Name: tagName,}}
  }
}
for itemID, tags := range itemTags {
  items = append(Item{
    ID: itemID,
    Tags: tags,
  })
}

优点

单个数据库调用和游标，可以在不占用过多内存的情况下进行循环

缺点

具有多个联接和结构上的许多属性的复杂且难以开发的
表现不太好；更多的内存使用量和处理时间，而不是更多的网络调用

方法3失败-sqlx结构扫描

尽管失败了，但我想包含这种方法，因为我发现这是我当前的效率与开发简便性相结合的目标。我的希望是通过在每个结构字段db上显式设置sqlx标签可以进行一些高级结构扫描

var items []Item
sqlxdb.Select(&items, "SELECT i.id AS item_id, t.id AS tag_id, t.name AS tag_name FROM item AS i JOIN tag AS t ON t.item_id = i.id")

不幸的是，由于missing destination name tag_id in *[]Item导致我误以为StructScan不够先进，无法递归遍历行（没有批评-这是一个复杂的场景）

可能的方法4-PostgreSQL数组聚合器和GROUP BY

虽然我确定这将不会起作用，但是我已经包含了这个未经测试的选项，以查看是否可以对其进行改进，从而可以起作用。

var items = []Item{}
sqlxdb.Select(&items, "SELECT i.id as item_id, array_agg(t.*) as tags FROM item AS i JOIN tag AS t ON t.item_id = i.id GROUP BY i.id")

我有空的时候会尝试在这里进行一些实验。

Answer 1

postgres中的sql：

create schema temp;
set search_path = temp;
create table item
(
  id INT generated by default as identity primary key
);

create table tag
(
  id      INT generated by default as identity primary key,
  name    VARCHAR(160),
  item_id INT references item (id)
);

create view item_tags as
select id,
  (
          select
            array_to_json(array_agg(row_to_json(taglist.*))) as array_to_json
          from (
                select tag.name, tag.id
                 from tag
                         where item_id = item.id
               ) taglist ) as tags
from item ;


-- golang query this maybe 
select  row_to_json(row)
from (
    select * from item_tags
) row;

然后golang查询此sql：

select  row_to_json(row)
from (
    select * from item_tags
) row;

并解组结构：

专业版：

postgres管理数据关系。使用sql函数添加/更新数据。
golang管理业务模型和逻辑。

这是简单的方法。

。

Answer 2

我可以建议我以前使用过的另一种方法。

在这种情况下，您可以在查询中为标签制作一个json并将其返回。

优点：您有1个对数据库的调用，该调用将聚合数据，而您要做的就是将json解析为一个数组。

缺点：有点难看。随时为我ash。

type jointItem struct {
  Item 
  ParsedTags string
  Tags []Tag `gorm:"-"`
}

var jointItems []*jointItem
db.Raw(`SELECT 
  items.*, 
  (SELECT CONCAT(
            '[', 
             GROUP_CONCAT(
                  JSON_OBJECT('id', id,
                             'name', name 
                  )
             ), 
            ']'
         )) as parsed_tags 
   FROM items`).Scan(&jointItems)

for _, o := range jointItems {
var tempTags []Tag
   if err := json.Unmarshall(o.ParsedTags, &tempTags) ; err != nil {
      // do something
   }
  o.Tags = tempTags
}

编辑：代码的行为可能很奇怪，因此我发现在移动时最好使用临时标签数组，而不要使用相同的结构。

Answer 3

您可以使用https://github.com/jackskj/carta中的carta.Map（）它会自动跟踪多个关系。

有效地将一对多多对多数据库映射到Golang中的结构

问题

要求

示例

3 个答案: