Actuellement, j'apprends à créer des api reposantes avec golang et mongodb. En fait, je suis débutant dans les deux. J'utilise mongodb-go-driver et j'apprends à utiliser le filtre quand on veut pour utiliser la fonction find () . Mais j'en ai que je ne comprends pas. Quelle est la différence entre filter: = bson.M {"_ id": "abcd"} et filter: = bson.M {{"_ id": "abcd"}} ? Merci
4 Réponses :
Reportez-vous au code source, https: //github.com/mongodb/mongo-go-driver/blob/master/bson/primitive/primitive.go
bson.D , en interne est primitive.D , qui est [] primitive.E , qui est une struct < / code>. bson.M , en interne est primitive.M , qui est map [string] interface {} . Vous mettez clé / valeur dans bson.M mais utilisez le document (struct) dans bson.D .
Il vaut mieux l'expliquer en utilisant 2 paramètres, par exemple recherchez a = 1 et b = 2 . Votre syntaxe sera: bson.M {"a": 1, "b": 2} ou bson.D {{"a": 1}, {"b": 2 }}
//Filter Part
if filter != nil {
if len(filter.Status) > 0 {
query = append(query, bson.M{"status": bson.M{"$in": filter.Status}})
}
}
d.Shared.BsonToJSONPrint(query)
//Getting Total count
totalCount, err := col.Find(func() bson.M {
if query != nil {
if len(query) > 0 {
return bson.M{"$and": query}
}
}
return bson.M{}
}
var user []models.User
var findQuery []bson.M
coll := db.C(constants.USERTABLE)
if name != nil {
if len(name) > 0 {
query = append(query, bson.M{"name": bson.M{"$in": name}})
}
}
if status != nil {
if len(status) > 0 {
query = append(query, bson.M{"status": bson.M{"$in": status}})
}
}
findQuery = append(findQuery, bson.M{"$match": func() bson.M {
if query != nil {
if len(query) > 0 {
return bson.M{"$and": query}
}
}
return bson.M{}
}()})
shared.BsonToJSONPrint(query)
err = coll.Pipe(findQuery).All(&user)
if err != nil {
return nil, err
}
return user, nil
}
Le client décode le résultat en un document bson.D par défaut, celui-ci est représenté sous forme de tableau, ce qui n'est pas la forme de document que nous voulons.
Pour écraser ce comportement, vous devez décoder en bson.M , qui est une simple carte et a la même forme que le document dans la base de données
res := collection.FindOne(ctx, p.Where)
if res.Err() == mongo.ErrNoDocuments {
return nil, nil
}
if res.Err() != nil {
return nil, res.Err()
}
var document bson.M = make(bson.M) // important
err = res.Decode(document)
p>
filter: = bson.M {{"_ id": "abcd"}}ne compile pas, donc je ne sais pas ce que vous demandez. Peut-être voulez-vous direfilter: = [] bson.M {{"_ id": "abcd"}}? C'est une tranche, une tranche de "filtres", le plus souvent utilisée lors de la spécification des étapes d'une agrégation MongoDB.@RiefSapthana. Je pense que vous vouliez dire
filter: = bson.D {{"_ id": "abcd"}}. Utilisezbson.D {{}}lorsque l'ordre est important, par exemple, plusieurs champs dans le filtre de requête. Soit unbson.Doubson.Mcomme filtres, mongo engine est suffisamment intelligent pour vous donner le même résultat.Merci @simagix @icza, que signifient les doubles accolades
bson.D {{}}?bson.Ma-t-il la formebson.M {{}}?J'ai obtenu un exemple comme celui-ci
filter: = bson.M {"_ id": id}et cefilter: = bson.D {{"name", "Ash"}} alors pourquoibson.Dutiliser des doubles accolades{{}}? Qu'est-ce que ça veut dire?