Utiliser Pipeline dans l'opérateur de recherche dans MongoDB

1. Qu’est-ce que le pipeline d’agrégation
2. Qu’est-ce que l’opérateur $lookup dans MongoDB
3. Utiliser Pipeline dans l’opérateur $lookup pour joindre les conditions dans MongoDB

Ce tutoriel enseigne comment utiliser le pipeline dans l’opérateur lookup dans MongoDB. Avant de continuer, il est obligatoire d’avoir suffisamment de connaissances sur le pipeline d’agrégation et l’opérateur $lookup pour comprendre l’utilisation du pipeline dans l’opérateur $lookup lors de l’utilisation de MongoDB.

Si vous connaissez déjà ces concepts, vous pouvez passer rapidement aux deux derniers exemples de code de ce didacticiel.

Qu’est-ce que le pipeline d’agrégation

Il s’agit d’une procédure de collecte de données et de retour des résultats calculés. Ce processus collecte des données à partir de différents documents, les regroupe selon des conditions spécifiées et effectue divers types d’opérations sur les données groupées.

Par exemple, moyenne, somme, maximum et minimum. C’est comme les fonctions d’agrégation SQL.

Dans MongoDB, nous pouvons utiliser l’agrégation des trois manières suivantes.

1. Pipeline d’agrégation - contient différentes étapes pour transformer les documents fournis. Chaque étape accepte l’ensemble de documents et génère un autre ensemble de documents résultants qui sont ensuite transmis à l’étape suivante, et ce processus se poursuit jusqu’à l’étape finale.

2. Fonction de réduction de carte - Nous utilisons cette fonction pour agréger les résultats à grande échelle. Il a deux fonctions, map et reduce.

   La méthode map regroupe tous les documents tandis que la méthode reduce effectue des opérations sur des données groupées.

3. Agrégation à usage unique - la forme d’agrégation la plus simple utilisée pour effectuer des tâches d’agrégation, mais qui manque de certaines fonctionnalités par rapport à la méthode du pipeline d’agrégation. Nous utilisons ce type d’agrégation pour effectuer des tâches dans un document particulier, par exemple, compter les valeurs distinctes dans un ou plusieurs documents spécifiques.

Vous pouvez également lire ceci pour approfondir et connaître les pipelines d’agrégation.

Qu’est-ce que l’opérateur $lookup dans MongoDB

Cet opérateur est utilisé pour effectuer une jointure externe gauche pour fusionner des données d’un document à un autre au sein de la même base de données. Il filtre les documents d’une collection jointe pour un traitement ultérieur.

Nous pouvons également utiliser cet opérateur pour ajouter un champ supplémentaire à un document existant.

L’opérateur $lookup ajoute un nouvel attribut de tableau (champ) dont les valeurs (éléments) correspondent aux documents de la collection jointe. Ensuite, ces documents transformés sont passés à l’étape suivante.

L’opérateur $lookup a trois syntaxes différentes que nous pouvons utiliser en fonction des exigences du projet. Ce tutoriel utilise la syntaxe $lookup pour Conditions de jointure et sous-requêtes sur la collection jointe.

Pour pratiquer avec un exemple de code, préparons les exemples de collections avec des données.

Exemple de code :

db.createCollection('collection1');
db.createCollection('collection2');

db.collection1.insertMany([
    {"shopId": "001", "shopPosId": "001", "description": "description for 001"},
    {"shopId": "002", "description": "description for 002"},
    {"shopId": "003", "shopPosId": "003", "description": "description for 003"},
    {"shopId": "004", "description": "description for 004"}
]);

db.collection2.insertMany([
    {"shopId": "001", "shopPosId": "0078", "clientUid": "474192"},
    {"shopId": "002", "shopPosId": "0012", "clientUid": "474193"},
    {"shopId": "003", "shopPosId": "0034", "clientUid": "474194"},
    {"shopId": "004", "shopPosId": "0056", "clientUid": "474195"}
]);

Maintenant, nous pouvons exécuter les commandes suivantes pour voir les documents insérés dans chaque collection.

db.collection1.find();
db.collection2.find();

Utiliser Pipeline dans l’opérateur $lookup pour joindre les conditions dans MongoDB

Pour apprendre à utiliser le pipeline dans l’opérateur $lookup, joignons les documents de deux collections où la collection1.shopId est égale à la collection2.shopId, et la collection1 ne contient pas le champ shopPosId .

Seuls seront joints les documents des deux collections qui satisferont aux deux conditions. Voir l’exemple de code ci-dessous.

Exemple de code :

db.collection2.aggregate([
    {
        "$lookup": {
        "from": "collection1",
        "let": { "shopId": "$shopId" },
        "pipeline": [{
            "$match": {
                "$and": [
                    {"$expr": {"$eq": ['$shopId', '$$shopId'] }},
                    { "shopPosId": { "$exists": false } }
                ]
            }
         }],
         "as": "shopDescription"
        }
    }
]).pretty();

Production:

Avez-vous attentivement observé la sortie donnée ci-dessus ? Seuls les documents sont joints à partir des deux collections qui remplissent les deux conditions dans le pipeline (la collection1.shopId est égale à la collection2.shopId et la collection1 ne contient pas le champ shopPosId).

De plus, les documents qui ne correspondent pas à ces conditions ont un tableau vide nommé shopDescription (voir les cases rouges dans les résultats ci-dessus). Nous ne pouvons afficher que les documents résultants contenant un tableau shopDescription non vide (voir la requête suivante).

Exemple de code :

db.collection2.aggregate([
    {
        "$lookup": {
        "from": "collection1",
        "let": { "shopId": "$shopId" },
        "pipeline": [{
            "$match": {
                "$and": [
                    {"$expr": {"$eq": ['$shopId', '$$shopId'] }},
                    { "shopPosId": { "$exists": false } }
                ]
            }
         }],
         "as": "shopDescription"
        }
    },
    {
        "$match":{
            "shopDescription": { $exists: true, $not: {$size: 0} }
         }
    }
]).pretty();

Production: