Comment gérer les valeurs nulles lors de la désorganisation de documents MongoDB dans Go ?

Gérer les valeurs nulles lors de la désorganisation des documents MongoDB

Ignorer les valeurs nulles pendant le processus de désorganisation des documents MongoDB dans les structures Go est un besoin courant. Dans cet article, nous explorerons une solution utilisant des décodeurs personnalisés dans le pilote mongo-go-driver.

Décodeur de chaîne personnalisé

Dans un premier temps, traitons les valeurs nulles pour les chaînes. Nous définissons un décodeur personnalisé qui interprète les valeurs nulles comme des chaînes vides :

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
}

Utilisation du décodeur personnalisé

Pour utiliser ce décodeur personnalisé pour un client spécifique, nous l'enregistrons auprès du registre du client :

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

Décodeur de type neutre pour toute valeur nulle

Une approche plus complète consiste à créer un décodeur de type neutre qui gère les valeurs nulles pour tout 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
}

Pour chaque type pour lequel nous voulons que les valeurs nulles soient ignorées, nous pouvons utiliser ce décodeur. Par exemple, pour les chaînes et les entiers :

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)

Avec cette configuration, les valeurs des types spécifiés seront définies sur leurs valeurs zéro respectives lorsque des valeurs nulles sont rencontrées lors de la désorganisation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!