How to Handle Null Values When Unmarshalling MongoDB Documents in Go?

Handling Null Values While Unmarshalling MongoDB Documents

Ignoring null values during the unmarshalling process of MongoDB documents into Go structs is a common need. In this article, we'll explore a solution using custom decoders in the mongo-go-driver.

Custom String Decoder

Initially, let's handle null values for strings. We define a custom decoder that interprets null values as empty strings:

import (
    "go.mongodb.org/mongo-driver/bson/bsoncodec"
    "go.mongodb.org/mongo-driver/bson/bsonrw"
)

type nullawareStrDecoder struct{}

func (nullawareStrDecoder) DecodeValue(dctx bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
    if !val.CanSet() || val.Kind() != reflect.String {
        return errors.New("bad type or not settable")
    }
    var str string
    switch vr.Type() {
    case bsontype.String:
        str, _ = vr.ReadString()
    case bsontype.Null:
        _ = vr.ReadNull()
    default:
        return fmt.Errorf("cannot decode %v into a string type", vr.Type())
    }

    val.SetString(str)
    return nil
}

Utilizing Custom Decoder

To use this custom decoder for a specific client, we register it with the client's registry:

clientOpts := options.Client().
    ApplyURI("mongodb://localhost:27017/").
    SetRegistry(
        bson.NewRegistryBuilder().
            RegisterDecoder(reflect.TypeOf(""), nullawareStrDecoder{}).
            Build(),
    )
client, err := mongo.Connect(ctx, clientOpts)

Type-Neutral Decoder for Any Null Value

A more comprehensive approach involves creating a type-neutral decoder that handles null values for any type:

import (
    "go.mongodb.org/mongo-driver/bson/bsoncodec"
    "go.mongodb.org/mongo-driver/bson/bsonrw"
    "reflect"
)

type nullawareDecoder struct {
    defDecoder bsoncodec.ValueDecoder
    zeroValue  reflect.Value
}

func (d *nullawareDecoder) DecodeValue(dctx bsoncodec.DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
    if vr.Type() != bsontype.Null {
        return d.defDecoder.DecodeValue(dctx, vr, val)
    }

    if !val.CanSet() {
        return errors.New("value not settable")
    }
    _ = vr.ReadNull()
    val.Set(d.zeroValue)
    return nil
}

For each type we want nulls to be ignored for, we can use this decoder. For example, for strings and integers:

customValues := []interface{}{
    "",       // string
    int(0),   // int
}

rb := bson.NewRegistryBuilder()
for _, v := range customValues {
    t := reflect.TypeOf(v)
    defDecoder, err := bson.DefaultRegistry.LookupDecoder(t)
    if err != nil {
        panic(err)
    }
    rb.RegisterDecoder(t, &nullawareDecoder{defDecoder, reflect.Zero(t)})
}

clientOpts := options.Client().
    ApplyURI("mongodb://localhost:27017/").
    SetRegistry(rb.Build())
client, err := mongo.Connect(ctx, clientOpts)

With this setup, values for the specified types will be set to their respective zero values when nulls are encountered during unmarshalling.

The above is the detailed content of How to Handle Null Values When Unmarshalling MongoDB Documents in Go?. For more information, please follow other related articles on the PHP Chinese website!