Share
Prêt à continuer à vous familiariser avec MongoDB, l’une des technologies les plus cool pour les développeurs Web? Dans cette seconde partie de la série, nous passons des bases aux requêtes avancées - avec opérateurs conditionnels - et MapReduce.
Plus tôt, nous avions abordé les bases de et comment commencer à utiliser mongoDB, l’un des meilleurs logiciels de mise en œuvre de NoSQL. Nous avons examiné comment l’installer, créer une base de données de base, puis effectuer les opérations de base correspondantes:
En plus de cela, nous avons commencé à regarder comment commencer à interagir avec mongoDB de manière plus puissante, en utilisant des sélecteurs. Les sélecteurs nous permettent d’avoir un contrôle beaucoup plus fin et d’approfondir nos recherches pour trouver les données que nous voulons vraiment..
C’est très bien de commencer, mais lorsque vous voulez écrire une vraie application, vous devez aller beaucoup plus loin. Eh bien, c'est toujours un commencer série après tout, mais je veux vous enthousiasmer sur les possibilités de travailler de manière documentaire. Je souhaite vous enthousiasmer pour utiliser cette technologie exceptionnelle, la personnaliser et l’utiliser aussi puissamment que possible pour créer des applications fantastiques..
Aujourd'hui, nous allons développer les requêtes de la dernière fois et apprendre deux aspects clés de mongoDB:
Auparavant, nous examinions les requêtes de base et nous présentions les sélecteurs. Nous allons maintenant entrer dans des requêtes plus avancées, en nous basant sur le travail précédent de deux manières:
Chacune de celles-ci nous fournit successivement un contrôle plus fin sur les requêtes que nous pouvons écrire et, par conséquent, les informations que nous pouvons extraire de nos bases de données mongoDB.
Comme leur nom l'indique, les opérateurs conditionnels sont des opérateurs permettant de regrouper des requêtes qui précisent les conditions auxquelles la requête doit correspondre lors de l'extraction de données de la base de données. Il y en a plusieurs, mais aujourd'hui, je vais me concentrer sur 9 domaines clés. Ceux-ci sont:
Regardons chacun à son tour. Ouvrez votre terminal et préparez-vous à utiliser la base de données d'origine de la première partie de cette série (pré-modifications). Pour faciliter ce tutoriel, nous allons apporter une légère modification à la base de données. Nous allons attribuer à chaque document de notre collection un attribut d'âge. Pour ce faire, exécutez la requête de modification suivante:
Accentsconagua
db.nettuts.update ("_ id": ObjectId ("4ef224be0fec2806da6e9b27"), "$ set": "age": 18); db.nettuts.update ("_ id": ObjectId ("4ef224bf0fec2806da6e9b28"), "$ set": "age": 45); db.nettuts.update ("_ id": ObjectId ("4ef224bf0fec2806da6e9b29"), "$ set": "age": 65); db.nettuts.update ("_ id": ObjectId ("4ef224bf0fec2806da6e9b2a"), "$ set": "age": 43); db.nettuts.update ("_ id": ObjectId ("4ef224bf0fec2806da6e9b2b"), "$ set": "age": 22); db.nettuts.update ("_ id": ObjectId ("4ef224bf0fec2806da6e9b2c"), "$ set": "age": 45); db.nettuts.update ("_ id": ObjectId ("4ef224bf0fec2806da6e9b2d"), "$ set": "age": 33); Tout va bien, vous pouvez lancer un 'trouver tout' et vous aurez la sortie suivante:
db.nettuts.find (); "_id": ObjectId ("4ef224be0fec2806da6e9b27"), "age": 18 ans, "dob": "21/04/1978", "premier": "matthew", "genre": "m", "couleur de cheveux": "marron", "dernier": "setter", "nationalité": "australien", "occupation": "développeur" "_id": ObjectId ("4ef224bf0fec2806da6e9b28"), "age": 45 ans, "dob": "26/03/1940", "premier": "james", "genre": "m", "poil_colour": "brun", "dernier": "caan", "nationalité": "américain", "profession ":" actor " " _id ": ObjectId (" 4ef224bf0fec2806da6e9b29 ")," age ": 65 ans," dob ":" 03/06/1925 "," premier ":" arnold "," genre ":" m "," hair_colour ":" marron "," dernier ":" schwarzenegger "," nationalité ":" américain "," profession ":" acteur " " _id ": ObjectId (" 4ef224bf0fec2806da6e9b2a ")," age ":," age ": 43, "dob": "21/04/1978", "premier": "tony", "genre": "m", "hair_colour": "marron", "dernier": "curtis", "nationalité": "américain", "profession": "développeur" "_id": ObjectId ("4ef224bf0fec2806da6e9b2b"), "age": 22 ans, "dob": "22/11/1958", "premier": "jamie lee" , "genre": "f", "cheveux _colour ":" brown "," last ":" curtis "," nationalité ":" américain "," occupation ":" acteur " " _id ": ObjectId (" 4ef224bf0fec2806da6e9b2c ")," age ": 45," dob ":" 14/03/1933 "," premier ":" michael "," genre ":" m "," poil_colour ":" brun "," dernier ":" caine "," nationalité ":" anglais " , "profession": "actor" "_id": ObjectId ("4ef224bf0fec2806da6e9b2d"), "age": 33 ans, "dob": "09/12/1934", "premier": "judi", "genre" : "f", "hair_colour": "blanc", "dernier": "dench", "nationalité": "anglais", "occupation": "actrice" Trouvons maintenant tous les acteurs de moins de 40 ans. Pour cela, lancez la requête suivante:
db.nettuts.find ("age": "$ lt": 40); Après avoir exécuté cette requête, vous verrez la sortie suivante:
"_id": ObjectId ("4ef224be0fec2806da6e9b27"), "age": 18 ans, "dob": "21/04/1978", "premier": "matthew", "genre": "m", "couleur de cheveux": "marron", "dernier": "setter", "nationalité": "australien", "occupation": "développeur" "_id": ObjectId ("4ef224bf0fec2806da6e9b2b"), "age": 22, "dob": "22/11/1958", "premier": "jamie lee", "genre": "f", "poil_colour": "brun", "dernier": "curtis", "nationalité": "américain", " occupation ":" actor " " _id ": ObjectId (" 4ef224bf0fec2806da6e9b2d ")," age ": 33," dob ":" 09/12/1934 "," premier ":" judi "," genre ":" f "," hair_colour ":" blanc "," dernier ":" dench "," nationalité ":" anglais "," occupation ":" actrice " Qu'en est-il de ceux qui ont moins de 40 ans inclus? Exécutez la requête suivante pour renvoyer ce résultat:
db.nettuts.find ("age": "$ lte": 40); Ceci retourne la liste suivante:
"_id": ObjectId ("4ef224be0fec2806da6e9b27"), "age": 18 ans, "dob": "21/04/1978", "premier": "matthew", "genre": "m", "couleur de cheveux": "marron", "dernier": "setter", "nationalité": "australien", "occupation": "développeur" "_id": ObjectId ("4ef224bf0fec2806da6e9b2b"), "age": 22, "dob": "22/11/1958", "premier": "jamie lee", "genre": "f", "poil_colour": "brun", "dernier": "curtis", "nationalité": "américain", " occupation ":" actor " " _id ": ObjectId (" 4ef224bf0fec2806da6e9b2d ")," age ": 33," dob ":" 09/12/1934 "," premier ":" judi "," genre ":" f "," hair_colour ":" blanc "," dernier ":" dench "," nationalité ":" anglais "," occupation ":" actrice " Trouvons maintenant tous les acteurs âgés de plus de 47 ans. Exécutez la requête suivante pour trouver cette liste:
db.nettuts.find ('age': '$ gt': 47); Vous obtiendrez alors le résultat suivant:
"_id": ObjectId ("4ef224bf0fec2806da6e9b29"), "age": 65 ans, "dob": "03/06/1925", "first": "arnold", "gender": "m", "hair_colour": "brun", "dernier": "schwarzenegger", "nationalité": "américain", "profession": "acteur" Qu'en est-il de 40 inclus?
db.nettuts.find ('age': '$ gte': 47); Comme il n'y a qu'une personne sur 47 ans, les données retournées ne changent pas.
Qu'en est-il de trouver des informations sur la base d'une liste de critères? Ces premiers ont été ok, mais peut-être assez trivial. Voyons maintenant quelles personnes parmi nous sont des acteurs ou des développeurs. Nous allons le découvrir avec la requête suivante (pour faciliter la lecture, nous avons limité les clés renvoyées aux noms et prénoms):
db.nettuts.find ('occupation': '$ in': ["acteur", "développeur"], "premier": 1, "dernier": 1); Cette requête donne le résultat suivant:
"_id": ObjectId ("4ef224be0fec2806da6e9b27"), "premier": "matthew", "last": "setter" "_id": ObjectId ("4ef224bf0fec2806da6e9b28"), "premier": "premier": "james" ":" caan " " _id ": ObjectId (" 4ef224bf0fec2806da6e9b29 ")," first ":" arnold "," last ":" schwarzenegger "" "" id "()," ObjectId ". "tony", "last": "curtis" "_id": ObjectId ("4ef224bf0fec2806da6e9b2b"), "premier": "jamie lee", "dernier": "curtis" "_id": ObjectId ("4ef224bf0fec280)" ")," premier ":" michael "," dernier ":" caine " Vous pouvez voir que nous pouvons obtenir l'inverse de cela en utilisant nin $tout aussi simplement.
Rendons cela un peu plus amusant et combinons certains des opérateurs. Disons que nous voulons rechercher toutes les personnes, hommes ou développeurs, qui ont moins de 40 ans..
Maintenant, c'est un peu bouchée, mais avec les opérateurs que nous avons utilisés jusqu'à présent - assez facilement réalisables. Travaillons à travers et vous verrez. Regardez la requête ci-dessous:
db.nettuts.find ($ or: ["gender": "m", "occupation": "developer"], "age": "$ gt": 40, "premier": 1 , "dernier": 1, "profession": 1, "dob": 1);
Vous pouvez voir que nous avons stipulé que le genre peut être un homme ou que la profession peut être un développeur dans le $ ou condition et ensuite ajouté un et état de l'âge étant supérieur à 4.
Pour cela, nous obtenons les résultats suivants:
"_id": ObjectId ("4ef22e522893ba6797bf8cb6"), "first": "matthew", "last": "setter", "dob": "21/04/1978", "occupation": "developer" " _id ": ObjectId (" 4ef22e522893ba6797bf8cb9 ")," premier ":" tony "," dernier ":" curtis "," dob ":" 21/04/1978 "," occupation ":" développeur " Maintenant, je suis sûr que vous ne serez pas satisfait de cela. Je vous ai promis un peu plus de complexité et de fonctionnalités avancées. Commençons donc par utiliser des expressions régulières. Supposons que nous souhaitions rechercher les utilisateurs dont le prénom commence par «ma» ou «to» et qui est le nom de famille commençant par «se» ou «de». Comment ferions-nous cela?
Examinez la requête suivante en utilisant une expression régulière:
db.nettuts.find ("premier": / (ma | to) * / i, "dernier": / (se | de) / i); Compte tenu de cela, les résultats seront:
"_id": ObjectId ("4ef22e522893ba6797bf8cb6"), "first": "matthew", "last": "setter", "dob": "21/04/1978", "gender": "m", "hair_colour ":" brown "," occupation ":" developer "," nationalité ":" australian " " _id ": ObjectId (" 4ef22e532893ba6797bf8cbc ")," premier ":" judi "," dernier ":" dench ", "dob": "09/12/1934", "genre": "f", "hair_colour": "blanc", "occupation": "actrice", "nationalité": "anglais" Regardons cette requête d'un peu plus près. Tout d'abord, nous effectuons une regex sur le prénom.
"premier": / (ma | à) * / i
//je indique que nous effectuons une regex insensible à la casse.
(ma | à) * indique que le début de la chaîne de prénom doit être 'ma' ou 'à'.
Si vous n'êtes pas familier, le * à la fin correspondra à quoi que ce soit par la suite. Ainsi, lorsque vous le mettez ensemble, nous associons les prénoms précédés de «ma» ou «to». Dans le regex pour le nom de famille, vous pouvez voir que nous avons fait la même chose, mais pour le nom de famille.
Pas vraiment sûr? Essayons un autre. Pourquoi ne pas le combiner avec l’un des opérateurs conditionnels? Disons que nous voulons trouver toutes les personnes portant le prénom de James ou Jamie qui sont des actrices américaines. Comment ferions-nous cela? Eh bien, voyons comment nous le ferions ci-dessous:
db.nettuts.find ("premier": / (jam? e *) * / i, "sexe": "f", "profession": "acteur", "nationalité": "américain"); Les expressions rationnelles ci-dessus correspondent à des combinaisons telles que: james, jamie, jamee, etc. Le point d'interrogation correspond à un caractère, que ce soit a-z, A-Z ou 0-9. Ensuite, comme auparavant, le * correspond à tout ce qui vient après le 'e'. À partir de là, nous utilisons les opérateurs conditionnels d’avant pour limiter davantage les résultats obtenus. Il convient de noter que, comme nous utilisons l'opérateur insensible à la casse, les requêtes n'utiliseront pas d'index. Mais pour les besoins de cet exemple, c'est bien.
Le résultat de la requête ci-dessus est:
"_id": ObjectId ("4ef22e522893ba6797bf8cba"), "premier": "jamie lee", "dernier": "curtis", "dob": "22/11/1958", "genre": "f", " hair_colour ":" brown "," occupation ":" acteur "," nationalité ":" américain " MapReduce est le grand papa de l'analyse de données. Au cas où vous n'en auriez pas entendu parler, MapReduce est un processus dans lequel l'agrégation de données peut être fractionnée et mise en cluster sur un cluster d'ordinateurs afin de réduire le temps nécessaire à la détermination d'un résultat agrégé sur un ensemble de données..
Il est composé de deux parties: Carte et Réduire. La carte crée les travaux qui peuvent ensuite être répartis dans les nœuds de travail pour exécuter le composant Réduire. Réduire calcule ensuite la réponse pour cette partie du travail qui lui a été confiée et renvoie le résultat qui peut être combiné avec les autres parties pour former la réponse finale.
Si vous voulez une description plus précise, voici ce que Wikipedia en dit:
MapReduce est une structure permettant de traiter des problèmes hautement distribuables sur d'énormes ensembles de données utilisant un grand nombre d'ordinateurs (nœuds), appelés collectivement cluster (si tous les nœuds utilisent le même matériel) ou une grille (si les nœuds utilisent un matériel différent). Le traitement informatique peut se produire sur des données stockées dans un système de fichiers (non structuré) ou dans une base de données (structurée).
"Carte" étape: le nœud maître prend l'entrée, le partitionne en sous-problèmes plus petits et les distribue aux nœuds de travail. Un nœud travailleur peut effectuer cette opération à son tour, ce qui conduit à une arborescence à plusieurs niveaux. Le noeud de travail traite le problème le plus petit et renvoie la réponse à son noeud principal..
"Réduire" étape: le nœud maître collecte ensuite les réponses à tous les sous-problèmes et les combine d'une manière ou d'une autre pour former la sortie - la réponse au problème qu'il tentait à l'origine de résoudre..
Regardons un exemple simple. Nous allons analyser notre ensemble de données simple et trouver le nombre total de toutes les femmes du groupe. Certes, il s’agit d’un exemple très simpliste, mais il jettera les bases d’une compréhension pratique du fonctionnement de MapReduce..
Ici, nous allons créer une fonction de carte qui agrège les informations de notre ensemble de données en fonction du sexe de la personne et émet un nombre de 1 pour chaque personne..
var map = function () emit (genre: this.gender, count: 1);
Cela retournera une sortie similaire à celle-ci:
'f': 1
Notre fonction de réduction va extraire la sortie de la fonction de carte et l'utiliser pour garder un total cumulé du nombre pour chaque sexe. Regardez la fonction de réduction ci-dessous.
var réduction = fonction (clé, valeurs) var résultat = nombre: 0; values.forEach (function (value) result.count + = value.count;) renvoie le résultat;
Maintenant, nous les mettons ensemble en appelant le mapReduce fonctionner dans notre base de données actuelle. Nous passons dans le carte et réduire les variables que nous avons créées précédemment en appelant notre carte et réduire fonctions et spécifiez le nom de la collection dans laquelle le résultat sera stocké; dans ce cas 'le sexe'. Rappelons simplement que le résultat de l'appel de la fonction mapReduce est une collection de notre base de données actuelle; que nous pouvons parcourir tout comme nous le ferions toute autre collection. Regardez le code ci-dessous:
var res = db.nettuts.mapReduce (map, reduction, out: 'gender');
Lorsque la réduction de la carte est terminée, nous pouvons y accéder comme une collection normale, en exécutant la commande trouverfonctionner comme nous le faisons ci-dessous.
db.gender.find (); "_id": "genre": "f", "valeur": "compte": 2 "_id": "genre": "m", "valeur": "compte" : 5
Ici, nous avons maintenant un total cumulé par sexe; 2 pour les femmes et 5 pour les hommes - ce qui est en corrélation avec notre ensemble de données. Mais si nous voulions filtrer par les femmes du groupe. Eh bien, pas grand chose. Nous n'avons qu'à utiliser la clause query pour nous permettre de le faire. Heureusement pour nous, cela vous semblera familier. Regardez la requête ci-dessous.
var res = db.nettuts.mapReduce (map, réduire, out: 'sexe', requête: "gender": "f");
Maintenant, lorsque nous afficherons le résultat, cela ressemblera à celui ci-dessous:
db.gender.find (); "_id": "genre": "f", "valeur": "nombre": 2
Il existe un certain nombre d'autres paramètres que vous pouvez transmettre à la fonction mapReduce pour personnaliser davantage la sortie..
Cela a été une couverture éclair de certains des sujets les plus complexes de mongoDB. Mais j'espère que cela vous a donné encore plus de goût de ce qui est possible en utilisant ce formidable outil..
Nous avons examiné les opérateurs conditionnels: $ lt, $ gt, $ lte, $ gte, $ in, $ nin, $ not et parcourez une introduction à MapReduce. J'espère que vous en avez tiré beaucoup et que vous en apprendrez plus sur le formidable outil qu'est mongoDB.
