MongoDB imbriquée de recherche avec 3 niveaux

J'ai besoin de récupérer la totalité de l'objet unique de la hiérarchie à partir de la base de données au format JSON. En fait la proposition au sujet de toute autre solution pour arriver à ce résultat serait très appriciated. J'ai décidé d'utiliser MongoDB avec ses $recherche de soutien.

Donc, j'ai trois collections:

partie

{ "_id" : "2", "name" : "party2" }
{ "_id" : "5", "name" : "party5" }
{ "_id" : "4", "name" : "party4" }
{ "_id" : "1", "name" : "party1" }
{ "_id" : "3", "name" : "party3" }

adresse

{ "_id" : "a3", "street" : "Address3", "party_id" : "2" }
{ "_id" : "a6", "street" : "Address6", "party_id" : "5" }
{ "_id" : "a1", "street" : "Address1", "party_id" : "1" }
{ "_id" : "a5", "street" : "Address5", "party_id" : "5" }
{ "_id" : "a2", "street" : "Address2", "party_id" : "1" }
{ "_id" : "a4", "street" : "Address4", "party_id" : "3" }

addressComment

{ "_id" : "ac2", "address_id" : "a1", "comment" : "Comment2" }
{ "_id" : "ac1", "address_id" : "a1", "comment" : "Comment1" }
{ "_id" : "ac5", "address_id" : "a5", "comment" : "Comment6" }
{ "_id" : "ac4", "address_id" : "a3", "comment" : "Comment4" }
{ "_id" : "ac3", "address_id" : "a2", "comment" : "Comment3" }

J'ai besoin de récupérer toutes les parties avec toutes les adresses correspondantes et l'adresse des observations dans le cadre de l'enregistrement. Mon agrégation:

db.party.aggregate([{
    $lookup: {
        from: "address",
        localField: "_id",
        foreignField: "party_id",
        as: "address"
    }
},
{
    $unwind: "$address"
},
{
    $lookup: {
        from: "addressComment",
        localField: "address._id",
        foreignField: "address_id",
        as: "address.addressComment"
    }
}])

Le résultat est assez bizarre. Certains enregistrements sont ok. Mais la Fête avec _id 4 est manquant (il n'y a pas d'adresse). Il y a aussi de la Partie deux _id 1 dans le jeu de résultats (mais avec des adresses différentes):

{
    "_id": "1",
    "name": "party1",
    "address": {
        "_id": "2",
        "street": "Address2",
        "party_id": "1",
        "addressComment": [{
            "_id": "3",
            "address_id": "2",
            "comment": "Comment3"
        }]
    }
}{
    "_id": "1",
    "name": "party1",
    "address": {
        "_id": "1",
        "street": "Address1",
        "party_id": "1",
        "addressComment": [{
            "_id": "1",
            "address_id": "1",
            "comment": "Comment1"
        },
        {
            "_id": "2",
            "address_id": "1",
            "comment": "Comment2"
        }]
    }
}{
    "_id": "3",
    "name": "party3",
    "address": {
        "_id": "4",
        "street": "Address4",
        "party_id": "3",
        "addressComment": []
    }
}{
    "_id": "5",
    "name": "party5",
    "address": {
        "_id": "5",
        "street": "Address5",
        "party_id": "5",
        "addressComment": [{
            "_id": "5",
            "address_id": "5",
            "comment": "Comment5"
        }]
    }
}{
    "_id": "2",
    "name": "party2",
    "address": {
        "_id": "3",
        "street": "Address3",
        "party_id": "2",
        "addressComment": [{
            "_id": "4",
            "address_id": "3",
            "comment": "Comment4"
        }]
    }
}

Merci de m'aider avec cela. Je suis assez nouveau à l'MongoDB, mais je sens qu'il peut faire ce que je besoin d'elle.

OriginalL'auteur Yuriy | 2016-03-15

  1. 34

    La cause de votre 'troubles' est la deuxième étape d'agrégation - { $unwind: "$address" }. Il supprime l'enregistrement de partie avec _id: 4 (parce que son adresse de tableau est vide, comme vous le mentionnez) et produit des deux enregistrements pour les parties _id: 1 et _id: 5 (parce que chacun d'eux dispose de deux adresses).

    • Pour empêcher la suppression de parties sans adresses, vous devez définir preserveNullAndEmptyArrays option de $détendez-vous stade de true.

    • Pour empêcher la duplication des parties de ses différentes adresses, vous devez ajouter $group agrégation étape de votre pipeline. Aussi, l'utilisation $ scène avec $filter opérateur à exclure vide enregistrements d'adresses en sortie.

    db.party.aggregate([{
  $lookup: {
    from: "address",
    localField: "_id",
    foreignField: "party_id",
    as: "address"
  }
}, {
  $unwind: {
    path: "$address",
    preserveNullAndEmptyArrays: true
  }
}, {
  $lookup: {
    from: "addressComment",
    localField: "address._id",
    foreignField: "address_id",
    as: "address.addressComment",
  }
}, {
  $group: {
    _id : "$_id",
    name: { $first: "$name" },
    address: { $push: "$address" }
  }
}, {
  $project: {
    _id: 1,
    name: 1,
    address: {
      $filter: { input: "$address", as: "a", cond: { $ifNull: ["$$a._id", false] } }
    } 
  }
}]);
    Réservoir Shad! Il y a un petit problème avec l'enregistrement 4: { "_id": "4", "name": "party4", "address": [{ "addressComment": [] }] } Comme vous pouvez le voir - adresse doit être nul mais c'est un enregistrement vide à la place... Peut-on ignorer l'adresse si sa addressComment est vide? Dans d'autres cas, cette adresse sera considéré comme un record.
    En fait je vois que la solution fonctionne comme prévu en fonction de la description de nouvelles "preserveNullAndEmptyArrays" champ $pour détendre l'opération (depuis 3.2). Maintenant, nous pouvons sauter le "$projet" de l'étape, et définir cette "$détendre" au lieu de la simple: $unwind: {path: "$address",preserveNullAndEmptyArrays: true}.Je vais accepter votre réponse, je vous remercie pour un accès rapide et claire de la réponse!
    J'ai pas mal de question similaire. Ici, OP code n'a qu'une propriété appelée name dans party de collecte, et donc que vous avez utilisé $first pour l'obtenir en $group. Supposons que j'ai 10+ propriétés, puis, est-il possible d'obtenir automatiquement toutes les propriétés sans mentionner chacun individuellement?
    Comment ajouter une clause group pour "addressComment" si il y avait différents commentaires pour le même id d'adresse? Comme mentionné cette requête fonctionne bien pour le groupement des à "adresse".

    OriginalL'auteur Shad

  2. 2

    Avec mongodb 3.6 et au-dessus de $recherche de la syntaxe, il est assez simple de rejoindre champs imbriqués sans l'aide de $détendez-vous.

    db.party.aggregate([
  { "$lookup": {
    "from": "address",
    "let": { "partyId", "$_id" },
    "pipeline": [
      { "$match": { "$expr": { "$eq": ["$party_id", "$$partyId"] }}},
      { "$lookup": {
        "from": "addressComment",
        "let": { "addressId", "$_id" },
        "pipeline": [
          { "$match": { "$expr": { "$eq": ["$address_id", "$$addressId"] }}}
        ],
        "as": "address"
      }}
    ],
    "as": "address"
  }},
  { "$unwind": "$address" }
])

    OriginalL'auteur Anthony Winzlet