Requête de document MongoDB Golang

Ce chapitre présente l'utilisation des requêtes de documents MongoDB en Golang.

Tutoriels préalables

• Tutoriel MongoDB

Astuce : Si vous n'êtes pas familier avec la syntaxe de requête MongoDB, veuillez d'abord lire le tutoriel MongoDB. La syntaxe d'expression utilisée pour les opérations MongoDB en Golang est la même.

Préparer les données de test

Insérez un lot de données de documents dans la collection coll.

docs := []interface{}{
    bson.D{
        {"item", "journal"},
        {"qty", 25},
        {"size", bson.D{
            {"h", 14},
            {"w", 21},
            {"uom", "cm"},
        }},
        {"status", "A"},
    },
    // ... (autres données de documents)
}

result, err := coll.InsertMany(context.Background(), docs)

Requête de tous les documents

cursor, err := coll.Find(
    context.Background(),
    bson.D{}, // Définir la condition de requête vide
)

Conditions de requête d'égalité

Similaire à la correspondance d'égalité en SQL.

cursor, err := coll.Find(
    context.Background(),
    bson.D{{"status", "D"}},   // Condition équivalente : status = D
)

Opérateur de requête in

Similaire à la requête in en SQL.

cursor, err := coll.Find(
    context.Background(),
    bson.D{{"status", bson.D{{"$in", bson.A{"A", "D"}}}}}) // Condition équivalente : status in ('A', 'D')

Conditions de requête et

Similaire à l'expression logique et en SQL.

cursor, err := coll.Find(
    context.Background(),
    bson.D{ // Condition équivalente : status='A' and qty < 30 
        {"status", "A"},
        {"qty", bson.D{{"$lt", 30}}},
    })

Conditions de requête ou

Similaire à l'expression logique ou en SQL.

cursor, err := coll.Find(
    context.Background(),
    bson.D{ // Condition équivalente : status = "A" OU qty < 30
        {"$or", // Utilisation de l'opérateur $or
            bson.A{ // Définition du type de tableau bson.A
                bson.D{{"status", "A"}},
                bson.D{{"qty", bson.D{{"$lt", 30}}}},
            }},
    })

Exemple de requête composite

cursor, err := coll.Find(
    context.Background(),
    bson.D{ // Condition équivalente : status = "A" AND ( qty < 30 OR item LIKE "p%")
        {"status", "A"},
        {"$or", bson.A{
            bson.D{{"qty", bson.D{{"$lt", 30}}}},
            bson.D{{"item", primitive.Regex{Pattern: "^p", Options: ""}}},
        }},
    })

Parcourir les résultats de la requête

Exemple 1

// Rechercher les documents où le nom est 'Bob'
cursor, err := coll.Find(context.TODO(), bson.D{{"name", "Bob"}}, opts)
if err != nil {
	log.Fatal(err)
}

// Définir un tableau de documents de type bson.M, où bson.M est une structure de données clé-valeur similaire à une map
var results []bson.M
// Utiliser la fonction All pour récupérer tous les résultats de la requête et enregistrer les résultats dans la variable results.
if err = cursor.All(context.TODO(), &results); err != nil {
	log.Fatal(err)
}

// Parcourir le tableau de résultats
for _, result := range results {
	fmt.Println(result)
}

Explication : L'exemple utilise le type bson.M pour stocker les données des documents. Vous pouvez personnaliser un type struct tant que les champs correspondent au document.

Exemple 2

// Définir une variable de type struct pour enregistrer le résultat de la requête
var result struct {
    Value float64
}

// Définir la condition de requête de document name = 'pi'
filter := bson.D{{"name", "pi"}}
// Créer un objet contexte et définir le délai de requête à 5 secondes
ctx, cancel = context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

// Requérir une seule donnée en fonction de la condition, et utiliser la fonction Decode pour enregistrer le résultat dans la variable result
err = collection.FindOne(ctx, filter).Decode(&result)

// Vérifier les erreurs de requête
if err == mongo.ErrNoDocuments {
    // Document non trouvé
    fmt.Println("Document n'existe pas")
} else if err != nil {
    log.Fatal(err)
}
// Autre traitement

Astuce : Pour une syntaxe d'expression de requête MongoDB plus sophistiquée, veuillez vous référer au tutoriel MongoDB.