Comment ignorer les valeurs nulles lors de la désorganisation des documents MongoDB dans Go ?

Ignorer les valeurs nulles lors de la désorganisation d'un document MongoDB

Lors de la désorganisation d'un document MongoDB dans une structure Go contenant des champs de chaîne non nullables, rencontre null les valeurs contenues dans le document peuvent conduire à des erreurs. Pour résoudre ce problème, il est nécessaire de trouver un moyen d'ignorer ces valeurs nulles lors du démarchage.

Utilisation d'un décodeur personnalisé

Une approche pour gérer les valeurs nulles consiste à création d'un décodeur personnalisé pour le type de chaîne. Ce décodeur personnalisé reconnaîtrait les valeurs nulles et les gérerait en définissant le champ correspondant sur une chaîne vide, ignorant ainsi la valeur nulle :

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

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
    var err error
    switch vr.Type() {
    case bsontype.String:
        if str, err = vr.ReadString(); err != nil {
            return err
        }
    case bsontype.Null:
        if err = vr.ReadNull(); err != nil {
            return err
        }
    default:
        return fmt.Errorf("cannot decode %v into a string type", vr.Type())
    }

    val.SetString(str)
    return nil
}

Ce décodeur personnalisé peut ensuite être enregistré auprès d'un bsoncodec.Registry et appliqué à un objet mongo.Client :

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

Création d'un objet Null-Aware de type neutre Décodeur

Pour gérer les valeurs nulles pour plusieurs types, il est possible de créer un seul décodeur neutre en termes de type qui vérifie les valeurs nulles et, si rencontré, définit le champ correspondant à la valeur zéro de son tapez :

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")
    }
    if err := vr.ReadNull(); err != nil {
        return err
    }

    val.Set(d.zeroValue)
    return nil
}

Ce décodeur peut être enregistré auprès d'un bsoncodec.Registre pour des types spécifiques ou pour tous les types :

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

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)})
}

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!