How to marshal/unmarshal bson array with polymorphic struct with mongo-go-driver

Question

I'm struggling to marshal/unmarshal bson array with polymorphic struct with mongo-go-driver。I plan to save a struct discriminator into the marshaled data, and write a custom UnmarshalBSONValue function to decode it according to the struct discriminator. But I don't know how to do it correctly.

package polymorphism

import (
    "fmt"
    "testing"

    "code.byted.org/gopkg/pkg/testing/assert"

    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/bsontype"
)

type INode interface {
    GetName() string
}

type TypedNode struct {
    NodeClass string
}

type Node struct {
    TypedNode `bson:"inline"`
    Name      string
    Children  INodeList
}

func (n *Node) GetName() string {
    return n.Name
}

type INodeList []INode

func (l *INodeList) UnmarshalBSONValue(t bsontype.Type, data []byte) error {
    fmt.Println("INodeList.UnmarshalBSONValue")

    var arr []bson.Raw                // 1. First, try to decode data as []bson.Raw
    err := bson.Unmarshal(data, &arr) // error: cannot decode document into []bson.Raw
    if err != nil {
        fmt.Println(err)
        return err
    }
    for _, item := range arr { // 2. Then, try to decode each bson.Raw as concrete Node according to `nodeclass`
        class := item.Lookup("nodeclass").StringValue()
        fmt.Printf("class: %v\n", class)
        if class == "SubNode1" {
            bin, err := bson.Marshal(item)
            if err != nil {
                return err
            }
            var sub1 SubNode1
            err = bson.Unmarshal(bin, &sub1)
            if err != nil {
                return err
            }
            *l = append(*l, &sub1)
        } else if class == "SubNode2" {
            //...
        }
    }
    return nil
}

type SubNode1 struct {
    *Node     `bson:"inline"`
    FirstName string
    LastName  string
}

type SubNode2 struct {
    *Node `bson:"inline"`
    Extra string
}

With code above, I'm trying to decode INodeList data as []bson.Raw, then decode each bson.Raw as a concrete Node according to nodeclass. But it report error:

cannot decode document into []bson.Raw

at line

err := bson.Unmarshal(data, &arr).

So, how to do it correctly?

Answer 1

You need to pass a bson.Raw’s pointer to bson.Unmarshal(data, &arr) and then slice its value to an array of raw values like:

func (l *INodeList) UnmarshalBSONValue(t bsontype.Type, data []byte) error {
    fmt.Println("INodeList.UnmarshalBSONValue")

    var raw bson.Raw // 1. First, try to decode data as bson.Raw
    err := bson.Unmarshal(data, &raw)
    if err != nil {
        fmt.Println(err)
        return err
    }

    // Slice the raw document to an array of valid raw values
    rawNodes, err := raw.Values()
    if err != nil {
        return err
    }

    // 2. Then, try to decode each bson.Raw as concrete Node according to `nodeclass`
    for _, rawNode := range rawNodes {
        // Convert the raw node to a raw document in order to access its "nodeclass" field
        d, ok := rawNode.DocumentOK()
        if !ok {
            return fmt.Errorf("raw node can't be converted to doc")
        }
        class := d.Lookup("nodeclass").StringValue()

        // Decode the node's raw doc to the corresponding struct
        var node INode
        switch class {
        case "SubNode1":
            node = &SubNode1{}
        case "SubNode2":
            node = &SubNode2{}
        //...
        default:
            // ...
        }

        bson.Unmarshal(d, node)
        *l = append(*l, node)
    }

    return nil
}

Note that Note.Children must be a INodeList's pointer, and the inline fields must be a struct or a map (not a pointer):

type Node struct {
    TypedNode `bson:",inline"`
    Name      string
    Children  *INodeList
}

type SubNode1 struct {
    Node      `bson:",inline"`
    FirstName string
    LastName  string
}

type SubNode2 struct {
    Node  `bson:",inline"`
    Extra string
}