Interrogation de documents MongoDB

MongoDB interroge des documents à l'aide des méthodesfind()、findOne().

La méthode find() affiche tous les documents dans un format non structuré.

Syntaxe

Le format de syntaxe pour l'interrogation de données MongoDB est le suivant :

db.collection.find(query, projection)
  • query: Critères de requête utilisés pour trouver des documents. Par défaut{}, ce qui correspond à tous les documents.
  • projection(Facultatif) : Spécifie les champs à inclure ou à exclure dans les résultats renvoyés.

Trouver tous les documents :

Exemple

db.myCollection.find();

Trouver des documents par critères :

Exemple

db.myCollection.find({ age: { $gt: 25 } });

Trouver des documents par critères et renvoyer uniquement les champs spécifiés :

Exemple

db.myCollection.find(
    { age: { $gt: 25 } },
    { name: 1, age: 1, _id: 0 }
);

Si vous avez besoin de lire les données dans un format lisible, vous pouvez utiliser la méthode pretty(). Le format de syntaxe est le suivant :

>db.col.find().pretty()

La méthode pretty() affiche tous les documents de manière formatée.

Exemple

db.col.find().pretty()
{
        "_id" : ObjectId("56063f17ade2f21f36b03133"),
        "title" : "Tutoriel MongoDB",
        "description" : "MongoDB est une base de données NoSQL",
        "by" : "Tutoriel d'exemple",
        "url" : "http://www.example.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100
}

2. findOne()

La méthode findOne() est utilisée pour trouver un seul document dans une collection. Si plusieurs documents correspondants sont trouvés, elle ne renvoie que le premier.

Syntaxe :

db.collection.findOne(query, projection)
  • query: Critères de requête utilisés pour trouver des documents. Par défaut{}, ce qui correspond à tous les documents.
  • projection(Facultatif) : Spécifie les champs à inclure ou à exclure dans les résultats renvoyés.

Trouver un seul document :

db.myCollection.findOne({ name: "Alice" });
Trouver un seul document et renvoyer uniquement les champs spécifiés :
db.myCollection.findOne(
    { name: "Alice" },
    { name: 1, age: 1, _id: 0 }
);

Méthodes de requête avancées

1. Utilisation des opérateurs de comparaison

MongoDB prend en charge divers opérateurs de comparaison, tels que$gt、$lt、$gte、$lte、$eq、$neetc.

Trouver les documents où age est supérieur à 25 :

db.myCollection.find({ age: { $gt: 25 } });

2. Utilisation des opérateurs logiques

MongoDB prend en charge divers opérateurs logiques, tels que$and、$or、$not、$noretc.

Trouvez les documents où age est supérieur à 25 et city est "New York" :

Exemple

db.myCollection.find({
    $and: [
        { age: { $gt: 25 } },
        { city: "New York" }
    ]
});

3. Utilisation des expressions régulières

Les expressions régulières peuvent être utilisées pour les requêtes de correspondance de motifs.

Trouvez les documents où le nom commence par "A" :

db.myCollection.find({ name: /^A/ });

4. Projection

La projection est utilisée pour contrôler quels champs sont renvoyés dans les résultats de la requête. Vous pouvez utiliser soit le mode inclusion, soit le mode exclusion.

Renvoyer uniquement les champs name et age :

Exemple

db.myCollection.find(
    { age: { $gt: 25 } },
    { name: 1, age: 1, _id: 0 }
);

5. Tri

Vous pouvez trier les résultats de la requête.

Trier par age par ordre décroissant :

db.myCollection.find().sort({ age: -1 });

6. Limit et Skip

Vous pouvez limiter les résultats de la requête et ignorer un nombre spécifié de documents.

Retournez les 10 premiers documents :

db.myCollection.find().limit(10);

Ignorez les 5 premiers documents et retournez les 10 documents suivants :

db.myCollection.find().skip(5).limit(10);

Exemple

Trouvez les documents où age est supérieur à 25 et city est "New York", retournez uniquement les champs name et age, triez par age par ordre décroissant, et retournez les 10 premiers documents.

Exemple

db.myCollection.find(
    {
        $and: [
            { age: { $gt: 25 } },
            { city: "New York" }
        ]
    },
    { name: 1, age: 1, _id: 0 }
).sort({ age: -1 }).limit(10);

Comparaison de la clause WHERE entre MongoDB et RDBMS

Si vous êtes familier avec les données SQL conventionnelles, vous pouvez mieux comprendre les instructions de requête conditionnelle de MongoDB grâce au tableau suivant :

Opération Format Exemple Instruction similaire dans RDBMS
Égal à {<key>:<value>} db.col.find({"by":"Example"}).pretty() where by = 'Example'
Inférieur à {<key>:{$lt:<value>}} db.col.find({"likes":{$lt:50}}).pretty() where likes < 50
Inférieur ou égal à {<key>:{$lte:<value>}} db.col.find({"likes":{$lte:50}}).pretty() where likes <= 50
Supérieur à {<key>:{$gt:<value>}} db.col.find({"likes":{$gt:50}}).pretty() where likes > 50
Supérieur ou égal à {<key>:{$gte:<value>}} db.col.find({"likes":{$gte:50}}).pretty() where likes >= 50
Différent de {<key>:{$ne:<value>}} db.col.find({"likes":{$ne:50}}).pretty() where likes != 50

Conditions AND de MongoDB

La méthode find() de MongoDB peut accepter plusieurs clés, chaque clé étant séparée par une virgule, ce qui correspond à la condition AND en SQL conventionnel.

Le format de la syntaxe est le suivant :

>db.col.find({key1:value1, key2:value2}).pretty()

Exemple

L'exemple suivant utilise labyettitleclé pour interrogerExample TutorialMoyenTutoriel MongoDBdonnées

> db.col.find({"by":"Example", "title":"MongoDB 教程"}).pretty()
{
        "_id" : ObjectId("56063f17ade2f21f36b03133"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Example",
        "url" : "http://www.example.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100
}

L'exemple ci-dessus est similaire à l'instruction WHERE :WHERE by='Example Tutorial' AND title='MongoDB Tutorial'

Conditions OR MongoDB

Les instructions de condition OR de MongoDB utilisent le mot-clé$or, le format syntaxique est le suivant :

>db.col.find(
   {
      $or: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

Exemple

Dans l'exemple suivant, nous montrons comment interroger la clébyavec la valeur Example Tutorial ou la clétitleavec la valeurMongoDB Tutorialdocuments.

>db.col.find({$or:[{"by":"Example"},{"title": "MongoDB 教程"}]}).pretty()
{
        "_id" : ObjectId("56063f17ade2f21f36b03133"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Example",
        "url" : "http://www.example.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100
}
>

Combinaison de AND et OR

L'exemple suivant montre l'utilisation combinée de AND et OR, similaire à l'instruction SQL conventionnelle :'where likes>50 AND (by = 'Example Tutorial' OR title = 'MongoDB Tutorial')'

>db.col.find({"likes": {$gt:50}, $or: [{"by": "Example"},{"title": "MongoDB 教程"}]}).pretty()
{
        "_id" : ObjectId("56063f17ade2f21f36b03133"),
        "title" : "MongoDB 教程",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "Example",
        "url" : "http://www.example.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100
}
Autres extensions