sql连接错误的db.Query扫描列错误

错误

Scan error on column index 1, name "url": unsupported Scan, storing driver.Value type []uint8 into type *[]handle.Movie

我想达到这个结果

[{1 aaa[https//you…，https//you…]，2 bbb[https/you…]}]

我想得到一个电影，是由分类协会通过切片链接

-----------------------------PS---------------------------------

这就是我想做的

func Connected() []Category {
    db := ConnectDB()
    defer db.Close()

    //sql
    query := `SELECT c.id, c.name, m.id, m.url FROM categories c left join movies m on c.id = m.category_id ORDER BY c.id ASC`
    rows, err := db.Query(query)
    if err != nil {
        log.Fatal(err)
    }

    var sli []Category
    var c Category 

    var m Movie

    for rows.Next() {
        if err := rows.Scan(&c.ID, &c.Name, &m.ID, &m.Url); err != nil {

            log.Fatal(err)
        }
        m.CategoryID = c.ID
        l := len(sli)
        if l > 0 && sli[l-1].ID == c.ID {
            sli[l-1].Movies = append(sli[l-1].Movies, m)

        } else {
            if len(c.Movies) != 0 {
                c.Movies = remove(c.Movies, c.Movies[0])
            }

            c.Movies = append(c.Movies, m)
            sli = append(sli, c) 


        }
    }
    return sli
}



func remove(ints []Movie, search Movie) []Movie {
    result := []Movie{}
    for _, v := range ints {
        if v != search {
            result = append(result, v)
        }
    }
    return result
}

---

谢谢大家

我看到您试图将单个URL存储到电影结构数组中，这是不可能的。 您的查询可能会返回每个类别的所有URL，但每个URL都在一行中，您应该自己聚合它们。 正如我所知，您应该将数据扫描到Golang默认类型，而不是自定义结构。将数据映射到自定义结构是另一回事

这是一个示例代码，但我没有访问您的数据库的权限，因此我无法测试它，但它应该可以按照您的需要工作

type Movie struct {
ID         int
Url        string
CategoryID uint
}

type Category struct {
ID     int
Name   string
Movies []Movie
}


func Connected() []Category { 
db := ConnectDB()
defer db.Close()

//sql
query := `SELECT c.id, c.name, m.id, m.url FROM categories c left join movies m on c.id = m.category_id 
ORDER BY c.id ASC`

rows, err := db.Query(query)
if err != nil {
    log.Fatal(err)
}

var sli []Category
var v1 Category
var m Movie
for rows.Next() {
    if err := rows.Scan(&v1.ID, &v1.Name, &m.ID, &m.Url); err != nil {
        log.Fatal(err)
    }
    m.CategoryID = v1.ID
    l := len(sli)
    if l > 0 && sli[l - 1].ID == v1.ID {
        sli[l - 1].Movies = append(sli[l - 1].Movies, m)
    } else {
        v1.Movies = append(v1.Movies, m)
        sli = append(sli, v1)
    }
}
fmt.Println(sli[0].Movies)
return sli
}

---

您使用的是什么db驱动程序？还请注意，虽然您想要的结果与查询的列匹配，但与您声明的

类别

数据结构不匹配。也就是说，看起来您想要的是每个类别都有一个相关电影Url的片段，但是您在

类别中拥有的内容。movies

字段是一个

Movie

值的片段，这些值是具有比

Url

更多字段的结构。。。那么是哪一个呢？在您的示例中，索引逻辑依赖于类别ID

从1开始，并且
是连续的，没有间隙，这在大多数情况下（如果不是全部的话）是错误的启发。我认为类别ID如何并不重要，我按类别ID对结果进行排序，因此我希望以顺序方式获得它们。您是对的，我想，我完全误读了你的代码。我道歉。
type Movie struct {
ID         int
Url        string
CategoryID uint
}

type Category struct {
ID     int
Name   string
Movies []Movie
}


func Connected() []Category { 
db := ConnectDB()
defer db.Close()

//sql
query := `SELECT c.id, c.name, m.id, m.url FROM categories c left join movies m on c.id = m.category_id 
ORDER BY c.id ASC`

rows, err := db.Query(query)
if err != nil {
    log.Fatal(err)
}

var sli []Category
var v1 Category
var m Movie
for rows.Next() {
    if err := rows.Scan(&v1.ID, &v1.Name, &m.ID, &m.Url); err != nil {
        log.Fatal(err)
    }
    m.CategoryID = v1.ID
    l := len(sli)
    if l > 0 && sli[l - 1].ID == v1.ID {
        sli[l - 1].Movies = append(sli[l - 1].Movies, m)
    } else {
        v1.Movies = append(v1.Movies, m)
        sli = append(sli, v1)
    }
}
fmt.Println(sli[0].Movies)
return sli
}