Je suppose que votre tête est infestée de mangoustes ou est-elle monoise ?
Je ne suis pas major anglais, donc je n'ai aucune idée de ce qu'est le pluriel.
En tout cas, cela nous amène au sujet de cette conférence, la population mongoose.
Quelle est exactement la population mongoose et
comment est-elle utile dans notre application express ?
Parlons de ça ensuite.
Comme nous l'avons réalisé, les bases de données de documents, les bases de données NoSQL,
ne sont pas conçues avec des relations à l'esprit.
Tout ce dont vous avez besoin dans un document est entièrement stocké dans le document.
Eh bien, c'est à peu près la façon dont les choses fonctionnent avec les bases de données NoSQL comme MongoDB.
Vous n'avez donc pas de support pour les relations que vous
connaissez peut-être plus dans le monde de la base de données relationnelle.
Où vous avez des enregistrements, puis des enregistrements peuvent référencer d'autres enregistrements et ainsi de suite.
Et puis vous faites des jointures afin de joindre les informations des enregistrements et ainsi de suite.
Donc, ce type de support n'existe pas dans les bases de données NoSQL,
du moins dans une large mesure.
MongoDB a fait quelques pas dans cette direction, même avec les bases de données NoSQL.
Mais en général, les bases de données de documents s'attendent à ce que tous les documents soient autonomes.
Donc, ce qui signifie que toutes les informations requises sont dans le même document.
Maintenant, bien sûr, il y a des situations où vous avez d'autres documents qui
contenaient déjà l'information.
Vous voudrez peut-être extraire ces informations dans votre document existant,
plutôt que de les dupliquer.
C' est donc là que MongoDB ou Mongoose,
vous permet de stocker des références à d'autres documents dans un document courant.
La référence à l'autre document se fait à l'aide de l'ObjectID de cet
autre document.
Maintenant, si c'est le cas, alors Mongoose vous permet d'effectuer un moyen de
prendre les informations de l'autre document et de les inclure
dans le document correct en utilisant le soutien de la population mongoose.
C' est ce que nous allons discuter un peu plus en détail.
Mongoose lui-même, comme nous le réalisons, étant un module construit
sur MongoDB, n'a pas de support explicite pour les
jointures, la façon dont nous parlons de jointures dans le monde SQL.
Pour comprendre comment ce référencement de l'autre document dans un document nous aide et
comment il est réellement structuré, prenons un exemple.
Dans cet exemple, nous examinerons le document de plats que nous
avons utilisé dans notre exercice.
Dans les documents plats que nous stockons du côté serveur,
nous avons remarqué que nous stockons également les commentaires.
Et dans les commentaires, nous stockons également un champ auteur dans les commentaires.
Et le champ auteur contient explicitement le nom de la personne qui
a soumis ce commentaire spécifique.
Maintenant, puisque nous avons déjà un document utilisateur
dans notre base de données, comme nous l'avons vu dans ce module.
Nous avions étendu notre serveur expert pour soutenir les utilisateurs et ainsi,
vous pouvez enregistrer un utilisateur et que vous pouvez authentifier les utilisateurs et ainsi de suite.
Ainsi, le document utilisateur peut contenir des informations supplémentaires sur l'utilisateur déjà.
Et donc, quand un commentaire est posté par l'utilisateur,
au lieu de stocker le nom de l'utilisateur dans le commentaire lui-même,
pourquoi ne pas avoir une référence à l'utilisateur spécifique qui a posté le commentaire ?
Ceci est utile non seulement en termes de pouvoir
traiter le fait que ce commentaire est publié par l'utilisateur spécifique.
Plus tard, nous verrons que si vous avez besoin d'autoriser les utilisateurs à modifier ou
supprimer des documents, vous voudrez peut-être limiter le type
d'opération d'un utilisateur spécifique aux commentaires
que cet utilisateur spécifique a postés plus tôt.
Même si nous utilisons des sous-documents dans notre document Mongo.
Si nous pouvons référencer un autre document dans le sous-document en utilisant ObjectID,
alors Mongo nous aide à faire la population de cette
information de l'autre document dans le document actif.
C' est là que la population mongoose vient à notre secours.
Pour aller plus loin cette idée, permettez-moi de vous montrer un
exemple détaillé du schéma de commentaire que nous avons défini précédemment.
Donc, dans le CommentSchema, nous avons déjà le champ de notation et
le champ de commentaire que nous avons déjà spécifié là-bas.
Nous avions également l'habitude d'avoir le champ auteur plus tôt.
Pour le champ auteur précédemment, nous stockions l'auteur sous
forme de chaîne et, La valeur par défaut aussi pour l'auteur.
Maintenant, en stockant l'auteur comme une chaîne de type, si nous transformons maintenant
l'auteur en un type de Mongoose.schema.types.Objectid.
Donc, ce qui signifie que le champ auteur contiendra maintenant un ObjectID,
qui est une référence à un document utilisateur.
Comment vous assurer que cela fait référence à un document utilisateur ?
C' est donc là que cette propriété supplémentaire appelée ref, qui spécifie que
le schéma du document que vous faites référence ici est du type, l'utilisateur, le
schéma et le modèle que nous avons déjà ajouté précédemment.
Donc, dans ce cas, le schéma de commentaire est maintenant étendu pour stocker les informations de l'auteur,
mais les informations de l'auteur sont sous la forme d'un ObjectID.
Qui est une référence au document utilisateur qui est déjà stocké dans notre base de données.
Comment ça nous aide ?
C' est là que, comme je l'ai dit, la population mongoose vient à notre aide.
Alors, comment fonctionne la population mongoose ?
Avec la population mongoose, la façon dont la population mongoose fonctionne est qu'
elle remplace automatiquement les chemins spécifiés dans un document courant.
Qui fait référence à un autre document par l'information de cet autre document.
Ainsi, dans le schéma de commentaire, par exemple, vous avez un champ auteur qui
fait référence à l'ObjectID du document utilisateur qui se trouve déjà dans votre base de données.
Donc, avec la population mongoose, lorsque vous demandez à Mongoose de remplir ce document plat,
alors il remplira les informations sur l'auteur dans le champ commentaire
du document utilisateur.
Ainsi, les informations sur l'auteur spécifique qui y est référencé seront
récupérées et ajoutées dans votre document plat.
Et le document composé sera construit et ensuite renvoyé à vous.
Comment faire en sorte que cela se produise ?
C' est là que cette référence croisée avec l'ObjectID, comme nous l'avons vu, nous aide.
Comment la population se produit-elle réellement dans le code ? En
regardant comment nous pourrions remplir,
par exemple, le document des plats que nous venons de voir plus tôt.
Plus tôt, nous faisions des plats.Trouver pour trouver tous les plats dans notre base de données.
Maintenant, une fois que vous avez trouvé le document Plats, vous pouvez dire « remplir ».
Ensuite, fournissez dans le remplissage, en tant que paramètre,
le champ spécifique qui doit être rempli.
Donc, ici, nous spécifions comments.author.
Maintenant, l'attente est que le champ comments.author est
en fait un objet ObjectiID qui fait référence au document utilisateur.
Et c'est ainsi que nous avons déjà mis en place notre schéma de commentaires.
Donc, cet appel de remplissage que nous effectuons ici va aller
chercher à partir de la base de données chaque enregistrement de l'auteur individuel ou de l'enregistrement de l'utilisateur.
Et puis prenez ce document utilisateur et le
remplit dans le document plats pour construire le document composé à partir d'ici.
Et puis après cela, bien sûr,
il y a un traitement ultérieur des données que vous avez obtenues.
Et puis la réponse ou le retour des données au client peut avoir lieu à ce stade.
Mais bien sûr, laissez-moi vous avertir que cette opération de population
n'est pas une tâche facile pour le serveur.
Parce que chaque plat, vous devrez examiner chaque commentaire.
Ensuite, pour chaque commentaire, vous devez trouver leur ObjectID pour
l'utilisateur.
Ensuite, vous allez chercher ce document utilisateur
, puis le remplir dans le document plat.
Et puis, cela doit être répété pour
chaque commentaire contenu dans ce document Plats.
Cela signifie essentiellement que le côté serveur prendra beaucoup plus de temps
pour terminer la demande et renvoyer les informations vers le client.
Donc, je suggère que vous devriez utiliser populate très judicieusement.
Vous ne devriez l'utiliser que dans les circonstances où vous avez vraiment besoin de cette information.
Si, par exemple, vous construisez simplement le menu de votre restaurant.
Lorsque vous construisez simplement le menu de votre restaurant, il
se peut que vous n'ayez pas vraiment besoin de renseigner les informations sur l'auteur de chaque
commentaire dans le document de commentaire.
Parce que lorsque vous ne faites que rendre le menu de votre restaurant,
vous n'allez pas montrer les commentaires pour ce plat spécifique.
Mais au lieu de cela, si l'utilisateur examine un plat spécifique et
veut voir les commentaires à ce stade,
vous pouvez exécuter une requête côté serveur.
Et puis récupérez les informations de commentaire avec les autres informations d'auteur
renseignées et obtenez-vous cela pour une utilisation dans notre côté client.
Encore une fois, peupler est une merveilleuse façon de faire les choses quand
il est nécessaire, mais l'utiliser de façon très judicieuse, seulement lorsque vous avez vraiment besoin de l'information.
Donc, cette flexibilité qui
nous fournit est le fait que nous n'avons pas besoin de remplir quand nous n'avons pas à le faire.
Mais nous pouvons remplir l'information quand nous en avons vraiment besoin.
Avec cette compréhension rapide de la population mongoose,
passons à l'exercice où nous allons modifier le schéma Discs,
le schéma des commentaires dans le schéma Discs.
Et puis utilisez Mongoose populate pour remplir les informations dans nos plats
lorsque nous retournons les informations sur le plat côté serveur.
En outre, cela implique également que lorsqu'un commentaire est ajouté à un plat spécifique,
l'auteur des informations du commentaire doit être capturé côté serveur.
Maintenant, il se trouve que la façon dont nous avons développé nos serveurs,
nous avons déjà cette information qui nous est fournie.
Lorsque nous authentifions l'utilisateur, les informations de l'utilisateur sont déjà chargées dans chaque
requête qui vient du côté client.
Et donc ils utilisent les informations de l'utilisateur qui nous sont disponibles.
Donc, lorsque nous postons le commentaire côté serveur, nous allons également
capturer l'ID de l'utilisateur, puis le stocker dans le champ auteur du schéma de commentaire.
Cela devrait être fait automatiquement côté serveur.
Le client ne doit pas être autorisé à remplir explicitement le champ auteur.
Mais le côté serveur devrait valider l'utilisateur et seulement pour
les utilisateurs qui sont connectés, vous leur permettrez, tout d'abord, de poster des commentaires.
Puis, lorsqu'ils publient des commentaires,
vous remplissez automatiquement le champ auteur de ce document de commentaire
en remplaçant le champ auteur par l'ObjectID de l'utilisateur.
Maintenant, dans l'exercice, vous me verrez faire ça.
Alors attention à cette chose spécifique dans l'exercice.
Avec cela, nous terminons cette conférence,
passons à l'exercice pour examiner l'utilisation de la population mongoose.
[ MUSIQUE]