Json 如何组合相关数据

我需要一些代码组织方面的理论/实践帮助

我在

PostgreSQL

数据库中有这样的表。该表显示了组织之间的关系

| ORGANIZATION_ID | ORGANIZATION_NAME | PARENT_ORGANIZATION_ID | ORGANIZATION_RANG | TREE_ORGANIZATION_ID | TREE_ORGANIZATION_ NAME |
|-----------------|-------------------|------------------------|-------------------|----------------------|-------------------------|
| 1               | Google            |                        | 1                 | \1                   | \Google                 |
| 2               | Nest              | 1                      | 2                 | \1\2                 | \Google\Nest            |
| 3               | Verily            | 1                      | 2                 | \1\3                 | \Google\Verily          |
| 4               | Calico            |                        | 1                 | \4                   | \Calico                 |
| 5               | ATAP              | 4                      | 2                 | \4\5                 | \Calico\ATAP            |

在我的Go应用程序中，我为这个表创建

struct

，然后进行SQL查询

type Organization struct {
    ID int `json:"organization_id"`
    Name string `json:"organization_name"`
    Rang int `json:"organization_rang"`
    Children []Organization `json:"children"`
}

var GetOrganizations = func(responseWriter http.ResponseWriter, request *http.Request) {
    rows,err := db.Query("select * from ORG")
    if err != nil {
        fmt.Println(err)
        return
    }

    defer rows.Close()

    var organizations []Organization

    for rows.Next() {
        var organization Organization

        err = rows.Scan(&organization.ID, &organization.Name, &organization.Rang)
        if err != nil {
            fmt.Println(err)
            return
        }

        organizations = append(organizations, organization)
    }

    utils.Response(responseWriter, http.StatusOK, organizations)
}

我需要作出这样的回应。您建议在我当前的代码中重新组织什么

[
    {
        "organization_id": 1,
        "organization_name": "Google",
        "organization_rang": 1,
        "children": [
            {
                "organization_id": 2,
                "organization_name": "Nest",
                "organization_rang": 2,
                "children": null
            },
            {
                "organization_id": 3,
                "organization_name": "Verily",
                "organization_rang": 2,
                "children": null
            }
        ]
    },
    {
        "organization_id": 4,
        "organization_name": "Calico",
        "organization_rang": 1,
        "children": [
            {
                "organization_id": 2,
                "organization_name": "Nest",
                "organization_rang": 2,
                "children": null
            }
        ]
    }
]

编辑：

@例如，我添加了名为

Telsa

的新记录。正如您所看到的，它的父对象是

Nest

object

| ORGANIZATION_ID | ORGANIZATION_NAME | PARENT_ORGANIZATION_ID | ORGANIZATION_RANG | TREE_ORGANIZATION_ID | TREE_ORGANIZATION_ NAME |
|-----------------|-------------------|------------------------|-------------------|----------------------|-------------------------|
| 1               | Google            |                        | 1                 | \1                   | \Google                 |
| 2               | Nest              | 1                      | 2                 | \1\2                 | \Google\Nest            |
| 3               | Verily            | 1                      | 2                 | \1\3                 | \Google\Verily          |
| 4               | Calico            |                        | 1                 | \4                   | \Calico                 |
| 5               | ATAP              | 4                      | 2                 | \4\5                 | \Calico\ATAP            |
| 6               | Tesla             | 2                      | 3                 | \1\2\6               | \Google\Nest\Tesla      |

代码的结果：

[
    {
        "organization_id": 1,
        "organization_name": "Google",
        "organization_rang": 1,
        "children": [
            {
                "organization_id": 3,
                "organization_name": "Verily",
                "organization_rang": 2,
                "children": null
            },
            {
                "organization_id": 2,
                "organization_name": "Nest",
                "organization_rang": 2,
                "children": [
                    {
                        "organization_id": 6,
                        "organization_name": "Tesla",
                        "organization_rang": 3,
                        "children": null
                    }
                ]
            }
        ]
    },
    {
        "organization_id": 2,
        "organization_name": "Nest",
        "organization_rang": 2,
        "children": [
            {
                "organization_id": 6,
                "organization_name": "Tesla",
                "organization_rang": 3,
                "children": null
            }
        ]
    },
    {
        "organization_id": 4,
        "organization_name": "Calico",
        "organization_rang": 1,
        "children": [
            {
                "organization_id": 5,
                "organization_name": "ATAP",
                "organization_rang": 2,
                "children": null
            }
        ]
    }
]

---

如果我正确理解了您想要做的事情，这里有一个未优化的示例，它是用sqlite完成的，但在postgres中也可以使用：

package main

import (
    "database/sql"
    "encoding/json"
    "fmt"
    "log"
    "sort"

    _ "github.com/mattn/go-sqlite3"
)

type Organization struct {
    ID       int             `json:"organization_id"`
    Name     string          `json:"organization_name"`
    Rang     int             `json:"organization_rang"`
    Children []*Organization `json:"children"`
}

func main() {
    db, err := sql.Open("sqlite3", "./database")
    if err != nil {
        log.Fatal(err)
    }

    defer db.Close()

    rows, err := db.Query("select ORGANIZATION_ID,ORGANIZATION_NAME,ORGANIZATION_RANG,PARENT_ORGANIZATION_ID from ORG")
    if err != nil {
        log.Fatal(err)
    }

    defer rows.Close()

    orgs := map[int]*Organization{}

    for rows.Next() {
        organization := &Organization{}
        var parentID sql.NullInt64

        if err = rows.Scan(&organization.ID, &organization.Name, &organization.Rang, &parentID); err != nil {
            log.Fatal(err)
        }

        if parentID.Valid {
            if parentOrg, ok := orgs[int(parentID.Int64)]; ok {
                parentOrg.Children = append(parentOrg.Children, organization)
            } else {
                orgs[int(parentID.Int64)] = &Organization{ID: int(parentID.Int64)}
                orgs[int(parentID.Int64)].Children = append(orgs[int(parentID.Int64)].Children, organization)
            }
        }

        if _, ok := orgs[organization.ID]; ok {
            orgs[organization.ID].Name = organization.Name
            orgs[organization.ID].Rang = organization.Rang
            continue
        }

        orgs[organization.ID] = organization
    }

    IDs := []int{}
    for k := range orgs {
        IDs = append(IDs, k)
    }
    sort.Ints(IDs)

    organizations := []Organization{}
    for _, ID := range IDs {
        if len(orgs[ID].Children) > 0 && orgs[ID].Rang == 1 {
            organizations = append(organizations, *orgs[ID])
        }
    }

    content, err := json.MarshalIndent(organizations, "", "  ")
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(string(content))
}

我明白了：

[
  {
    "organization_id": 1,
    "organization_name": "Google",
    "organization_rang": 1,
    "children": [
      {
        "organization_id": 2,
        "organization_name": "Nest",
        "organization_rang": 2,
        "children": null
      },
      {
        "organization_id": 3,
        "organization_name": "Verily",
        "organization_rang": 2,
        "children": null
      }
    ]
  },
  {
    "organization_id": 4,
    "organization_name": "Calico",
    "organization_rang": 1,
    "children": [
      {
        "organization_id": 5,
        "organization_name": "ATAP",
        "organization_rang": 2,
        "children": null
      }
    ]
  }
]

---

如何从一个包含6列的表中选择*..

，并将其扫描到3个字段中而不出错？如果您可以使用第三个库，那么您可以保持结构基本相同。@mkopriva您好！你是对的。SQL查询必须是

从组织中选择*组织ID、组织名称、组织范围

。当前代码带有returnme5记录，在最后的响应中，我有一个带有5对象的数组，这不是我想要的。在我的案例中，您将如何实现嵌套？@nvcnvn您好！这个ORM到底能帮我什么忙？你能给我举个实例吗？你好！非常感谢。事实上，我只需要对那些有厌学儿童的顶级组织做出回应。必须存在仅包含

Google

和

Calico

对象的数组。每件事物都有其自身的特点。你明白我的意思吗？对于此任务，我需要在您的代码中更改什么？你有什么想法吗？看起来你的代码只适用于固定嵌套级别（rang）。您是否可以仅为测试向

Nest

对象添加一些子对象？在我的例子中，嵌套级别（rang）不是常数。具有子对象的对象在主数组中重复。例如，如果将一些子对象添加到

Nest

对象，则会注意到该对象在主数组中重复。你对此有什么想法吗？如果你想知道它是否适用于多个级别的儿童，答案是肯定的，试试看，你就会明白。这是一个简单的答案，基于我从你所抛弃的东西中所理解的，所以你必须调整这个脚本以完全符合你的需要。你能再次查看我的帖子吗？我添加有关上一个代码结果的信息。不幸的是，它不能正常工作。那么应该怎么做呢？