Mangouste remplir vs objet de nidification

Est-il une différence de performances (temps de traitement de la requête) entre l'utilisation de La mangouste de la population et d'objet direct de l'inclusion ? Quand chacun doit-il être utilisé ?

Mangouste population exemple:

var personSchema = Schema({
  _id     : Number,
  name    : String,
  stories : [{ type: Schema.Types.ObjectId, ref: 'Story' }]
});

var storySchema = Schema({
  _creator : { type: Number, ref: 'Person' },
  title    : String,
});

Mangouste objet de nidification exemple:

var personSchema = Schema({
  _id     : Number,
  name    : String,
  stories : [storySchema]
});

var storySchema = Schema({
  _creator : personSchema,
  title    : String,
});
InformationsquelleAutor Marius Cotofana | 2014-06-07
  1. 110

    La première chose à comprendre au sujet de la mangouste de la population, c'est qu'il n'est pas de la magie, mais juste d'une méthode pratique qui vous permet de récupérer des informations liées sans le faire tout vous-même.

    Le concept est essentiellement pour une utilisation lorsque vous décidez que vous allez avoir besoin de placer les données dans une collection à part plutôt que d'intégrer les données, et vos principales considérations devrait être de généralement sur la taille de document ou lorsque cette information est sujette à de fréquentes mises à jour qui permettrait de faire l'entretien de données incorporée lourd.

    Le "pas de la magie" la partie est essentiellement ce qui se passe dans les coulisses, c'est que lorsque vous "de référence" d'une autre source, le remplir de fonction fait une requête supplémentaire/requêtes de la "relative" de la collection afin de les "fusionner" ces résultats de l'objet parent que vous avez récupéré. Vous pourriez le faire vous-même, mais la méthode est là pour des raisons de commodité afin de simplifier la tâche. L'évidence de la "performance" est que il n'y a pas un seul aller-retour à la base de données (MongoDB exemple) afin de récupérer toutes les informations. Il y a toujours plus d'un.

    Comme un exemple, prenez deux collections:

    { 
    "_id": ObjectId("5392fea00ff066b7d533a765"),
    "customerName": "Bill",
    "items": [
        ObjectId("5392fee10ff066b7d533a766"),
        ObjectId("5392fefe0ff066b7d533a767")
    ]
}

    Et les objets:

    { "_id": ObjectId("5392fee10ff066b7d533a766"), "prod": "ABC", "qty": 1 }
{ "_id": ObjectId("5392fefe0ff066b7d533a767"), "prod": "XYZ", "qty": 2 }

    Le "meilleur", ce qui peut être fait par une "référence" du modèle ou de l'utilisation de la remplir (sous le capot) est-ce:

    var order = db.orders.findOne({ "_id": ObjectId("5392fea00ff066b7d533a765") });
order.items = db.items.find({ "_id": { "$in": order.items } ).toArray();

    Il y a donc clairement "au moins" deux requêtes et les opérations afin de "joindre" des données.

    À ancrer le concept est essentiellement la MongoDB réponse à la façon de traiter avec ne supportant pas les "jointures"1. De sorte que, plutôt que de diviser les données normalisées des collections, vous essayez d'incorporer la "relative" des données directement dans le document qui l'utilise. Les avantages sont qu'il y a un seul "lire" opération de récupération de la "relative" de l'information, et aussi un seul point de "écrire" opérations à la fois la mise à jour "parent" et "enfant" entrées, bien que souvent pas possible d'écrire "beaucoup" d'enfants à la fois, sans traitement "listes" sur le client ou une autre d'accepter les "plusieurs" opérations d'écriture, et de préférence en "batch" en cours de traitement.

    De données au lieu ressemble à ça ( par rapport à l'exemple ci-dessus ):

    { 
    "_id": ObjectId("5392fea00ff066b7d533a765"),
    "customerName": "Bill",
    "items": [
        { "_id": ObjectId("5392fee10ff066b7d533a766"), "prod": "ABC", "qty": 1 },
        { "_id": ObjectId("5392fefe0ff066b7d533a767"), "prod": "XYZ", "qty": 2 }
    ]
}

    Donc récupérer les données est juste une question de:

    db.orders.findOne({ "_id": ObjectId("5392fea00ff066b7d533a765") });

    Les avantages et les inconvénients de les deux, toujours dépendra en grande partie sur le modèle d'utilisation de votre application. Mais un coup d'œil:

    Intégration

    • Total de la taille du document avec des données embarquées ne dépasse généralement pas les 16 mo de stockage (BFILS limite) ou autrement ( comme une ligne directrice ) avoir des tableaux qui contiennent plus de 500 entrées.

    • De données qui est incorporé n'a généralement pas besoin de fréquentes modifications. Donc, vous pourriez vivre avec "répétition" qui vient de la dé-normalisation qui n'entraîne pas la nécessité de mettre à jour ces "doublons" avec la même information à travers de nombreux parents des documents à invoquer un changement.

    • Des données fréquemment utilisées en association avec le parent. Ce qui signifie que si votre "lecture/écriture" cas sont à peu près toujours besoin de "lecture/écriture" à la fois le parent et l'enfant, alors il est logique d'intégrer les données pour les opérations atomiques.

    Référencement

    • Les données associées est toujours dépasser les 16 MO BFILS limite. Vous pouvez toujours envisager une approche hybride de "écopage", mais la limite matérielle du document principal ne peut pas être violée. Des cas fréquents sont "post" et "commentaires" où "commentaire" l'activité devrait être très grande.

    • Liés à besoins en matière de données régulièrement mise à jour. Ou essentiellement le cas où vous êtes "normaliser" parce que les données sont "partagés" entre de nombreux parents et la "relative" des données est changé assez souvent qu'il serait peu pratique pour mettre à jour les éléments imbriqués dans chaque "parent" où cet "enfant" élément se produit. Le cas est plus facile de simplement référence de l'enfant, et faire le changement d'une fois.

    • Il y a une séparation claire entre les lectures et les écritures. Dans le cas où peut-être vous n'allez pas toujours exiger que "relative" de l'information lors de la lecture du "parent", ou autrement ne pas avoir besoin de toujours modifier le "parent" lors de l'écriture de l'enfant, il pourrait être une bonne raison de séparer le modèle de référence. De plus, si il y a un désir général de mettre à jour de nombreux "sous-documents" à la fois dans lequel ces "sous-documents" sont en fait des références à une autre collection, puis assez souvent la mise en œuvre est plus efficace lorsque les données sont dans une collecte séparée.

    Donc en fait il y a beaucoup plus de discussion de la "avantages/inconvénients" pour l'une ou l'autre position sur la MongoDB documentation sur La Modélisation Des Données, qui couvre les différents cas d'utilisation et des façons de l'aborder, soit à l'aide de l'incorporation ou la référence de modèle est pris en charge par la méthode peupler.

    J'espère que le "point de points" sont de l'utilisation, mais généralement recommandation est de considérer les modes d'utilisation des données de votre application et de choisir ce qui est meilleur. Avoir l'option "option" incorporer "devrait" être la raison pour laquelle vous avez choisi MongoDB, mais il va vraiment être la façon dont votre application "utilise les données" qui fait de la décision de la méthode qui lui convient quelle partie de vos données de la modélisation (comme il n'est pas "tout ou rien") le meilleur.

    1. Remarque que, puisque c'était écrit à l'origine MongoDB introduit la $recherche opérateur qui, en effet, effectuer des "jointures" entre les collections sur le serveur. Pour les fins de la discussion générale, ici, au whist "mieux" dans la plupart des cas que les multiples "requête" frais généraux engagés par populate() et "plusieurs requêtes" en général, il y a toujours un "surcharge importante" engagés avec toute $recherche opération.

    Le principe de base de la conception est "embedded" moyens "déjà là" par opposition à "chercher ailleurs". Essentiellement, la différence entre "dans votre poche" et "sur l'étagère", et, dans I/O conditions généralement plus comme "sur l'étagère dans la bibliothèque centre-ville", et notamment loin de réseau en fonction des demandes.

    • Quant à la note finale, j'ai trouvé cette mangouste question où un indice de référence semble attribut vitesse plus à remplir que de $recherche... je comprends la surcharge de requêtes multiples, mais confus au sujet de la performnace...
    InformationsquelleAutor Neil Lunn