Fermer

février 24, 2020

Une introduction à MongoDB –


MongoDB est une base de données NoSQL multiplateforme et open source, utilisée par de nombreuses applications Web modernes basées sur Node pour conserver les données.

Dans ce didacticiel convivial pour les débutants, je vais vous montrer comment installer Mongo, puis commencez à l'utiliser pour stocker et interroger des données. Je vais également voir comment interagir avec une base de données Mongo à partir d'un programme Node, et souligner également certaines des différences entre Mongo et une base de données relationnelle traditionnelle (comme MySQL) en cours de route.

Qu'est-ce que MongoDB? [19659004] MongoDB est une base de données orientée document. Cela signifie qu'il n'utilise pas de tableaux et de lignes pour stocker ses données, mais plutôt des collections de documents de type JSON . Ces documents prennent en charge les champs intégrés, de sorte que les données associées peuvent y être stockées.

MongoDB est également une base de données sans schéma, nous n'avons donc pas besoin de spécifier le nombre ou le type de colonnes avant d'insérer nos données.

Voici un exemple de ce à quoi pourrait ressembler un document MongoDB:

 {
  _id: ObjectId (3da252d3902a),
  tapez: "Tutoriel",
  title: "Une introduction à MongoDB",
  auteur: "Manjunath M",
  balises: [ "mongodb", "compass", "crud" ],
  catégories: [
    {
      name: "javascript",
      description: "Tutorialss on client-side and server-side JavaScript programming"
    },
    {
      name: "databases",
      description: "Tutorialss on different kinds of databases and their management"
    },
  ],
  contenu: "MongoDB est une base de données multiplateforme, open source, NoSQL ..."
}

Comme vous pouvez le voir, le document comporte un certain nombre de champs (type titre etc.), qui stockent les valeurs («Tutoriel», «Une introduction à MongoDB», etc.). Ces valeurs peuvent contenir des chaînes, des nombres, des tableaux, des tableaux de sous-documents (par exemple, le champ catégories ), des coordonnées géographiques et plus encore.

Le nom du champ _id est réservé pour une utilisation comme clé primaire. Sa valeur doit être unique dans la collection, elle est immuable et elle peut être de tout type autre qu'un tableau.

Astuce: pour ceux qui se demandent ce que signifie "JSON-like", Mongo utilise en interne quelque chose appelé BSON (abréviation de Binary JSON). En pratique, vous n'avez pas vraiment besoin d'en savoir beaucoup sur BSON lorsque vous travaillez avec MongoDB.

Comme vous pouvez le deviner, un document dans une base de données NoSQL correspond à une ligne dans une base de données SQL. Un groupe de documents est connu sous le nom de collection qui est à peu près synonyme d'une table dans une base de données relationnelle.

Voici un tableau résumant les différents termes:

SQL Serveur MongoDB
Base de données Base de données
Tableau Collection
Ligne Document
Colonne Champ
Index Index

Si vous 'démarre un nouveau projet et ne savez pas s'il faut choisir Mongo ou une base de données relationnelle telle que MySQL, c'est peut-être le bon moment pour lire notre tutoriel SQL vs NoSQL: comment choisir .

Avec cela dit, allons-y et installons MongoDB.

Installation de MongoDB

Remarque: si vous souhaitez simplement suivre ce didacticiel sans installer de logiciel sur votre PC, il existe quelques services en ligne que vous peut utiliser. Le terrain de jeu Mongo par exemple, est un simple bac à sable pour tester et partager des requêtes MongoDB en ligne.

MongoDB est disponible en plusieurs éditions. Celui qui nous intéresse est l'édition communautaire de MongoDB.

La page d'accueil du projet contient une excellente documentation sur l'installation de Mongo, et je n'essaierai pas de le reproduire ici. Je vais plutôt vous proposer des liens vers des instructions pour chacun des principaux systèmes d'exploitation:

Si vous utilisez une version non Ubuntu de Linux, vous pouvez consulter cette page pour obtenir des instructions d'installation pour autres distributions. MongoDB est également normalement disponible via les canaux logiciels officiels de Linux, mais parfois cela entraînera une version obsolète.

Configuration après l'installation

Une fois MongoDB installé pour votre système, vous pouvez rencontrer cette erreur:

 dbpath (/ data / db) n'existe pas.
 Créez ce répertoire ou donnez le répertoire existant dans --dbpath.
 Voir http://dochub.mongodb.org/core/startingandstoppingmongo

Cela signifie que Mongo ne peut pas trouver (ou accéder) au répertoire qu'il utilise pour stocker ses bases de données. Il est assez facile d'y remédier:

 sudo mkdir -p / data / db
sudo chown -R `id -un` / data / db

La première commande crée le répertoire data / db . Le second définit les autorisations pour que Mongo puisse écrire dans ce répertoire.

Installer l'interface graphique de Compass

Nous utiliserons la ligne de commande dans ce tutoriel, mais MongoDB propose également un outil appelé Compass pour se connecter et gérer vos bases de données à l'aide d'une interface graphique.

Si vous êtes sous Windows, Compass peut être installé dans le cadre de l'installation principale de Mongo (sélectionnez simplement l'option appropriée dans l'assistant). Sinon, vous pouvez télécharger Compass pour votre système d'exploitation respectif ici .

Voici à quoi cela ressemble:

Mongo DB Compass GUI

Le Mongo Shell

Nous pouvons tester notre installation en ouvrant le shell Mongo. Vous pouvez le faire en ouvrant une fenêtre de terminal et en tapant mongo .

Remarque: cela suppose que / bin se trouve sur votre chemin. Si, pour une raison quelconque, ce n'est pas le cas, accédez au répertoire / bin et réexécutez la commande.

Si vous obtenez une erreur : impossible de se connecter au serveur erreur, vous devrez démarrer le serveur Mongo (dans une deuxième fenêtre de terminal) avec la commande mongod .

Une fois que vous êtes dans le shell Mongo, tapez db. version () pour voir la version de MongoDB que vous utilisez. Au moment d'écrire ces lignes, cela devrait produire 4.2.2 .

Veuillez noter que vous pouvez quitter le shell Mongo en exécutant quit () et le démon Mongo en appuyant sur Ctrl + C à tout moment.

Maintenant, familiarisons-nous avec quelques notions de base de MongoDB.

Opérations de base de la base de données

Entrez le shell Mongo si vous ne l'avez pas déjà fait (par en tapant mongo dans un terminal):

 [mj@localhost ~] $ mongo
MongoDB shell version v4.2.2
connexion à: mongodb: //127.0.0.1: 27017 /? compressors = disabled & gssapiServiceName = mongodb
Session implicite: session {"id": UUID ("08a624a0-b330-4233-b56b-1d5b15a48fea")}
Version du serveur MongoDB: 4.2.2

Commençons par créer une base de données avec laquelle travailler. Pour créer une base de données, MongoDB a une commande use DATABASE_NAME :

> use exampledb
passé à db exampledb

Pour afficher toutes les bases de données existantes, essayez show dbs :

> show dbs

admin 0.000GB
config 0.000GB
local 0,000 Go

Le exampledb n'est pas dans la liste car nous devons insérer au moins un document dans la base de données. Pour insérer un document, vous pouvez utiliser db.COLLECTION_NAME.insertOne ({"key": "value"}) . Voici un exemple:

> db.users.insertOne ({name: "Bob"})
{
   "reconnu": vrai,
   "insertId": ObjectId ("5a52c53b223039ee9c2daaec")
}

MongoDB crée automatiquement une nouvelle collection d'utilisateurs et insère un document avec la paire clé-valeur 'nom': 'Bob' . L'ObjectId renvoyé est l'ID du document inséré. MongoDB crée un ObjectId unique pour chaque document lors de la création, et il devient la valeur par défaut du champ _id .

Nous devrions maintenant pouvoir voir notre base de données:

> show dbs
admin 0.000GB
config 0.000GB
exampledb 0.000GB
local 0,000 Go

De même, vous pouvez confirmer que la collection a été créée à l'aide de la commande show collections :

> show collections
utilisateurs

Nous avons créé une base de données, ajouté une collection nommée utilisateurs et y avons inséré un document. Essayons maintenant de le supprimer. Pour supprimer une base de données existante, utilisez la commande dropDatabase () comme illustré ci-dessous:

> db.dropDatabase ()
{"abandonné": "exampledb", "ok": 1}

show dbs confirme que la base de données a bien été supprimée:

> show dbs
admin 0.000GB
config 0.000GB
local 0,000 Go

Pour plus d'opérations sur la base de données, veuillez consulter la page de référence MongoDB sur commandes de base de données .

Gestion des utilisateurs

Vous avez probablement déjà remarqué que MongoDB ne comporte aucun accès

Bien qu'il ne soit pas nécessaire de fournir un nom d'utilisateur et un mot de passe pour le développement, c'est quelque chose que vous devez modifier lorsque vous utilisez Mongo en production.

Voici les étapes pour créer un utilisateur de base de données avec des privilèges de lecture / écriture complets :

  • Assurez-vous d'avoir démarré le serveur Mongo sans aucun type de contrôle d'accès (généralement en tapant mongod ).
  • Ouvrez un shell en tapant mongo . [19659076] Depuis le shell, ajoutez un utilisateur avec le rôle readWrite à la base de données exampledb . Cela vous demandera d'entrer un mot de passe. De toute évidence, remplacez «manjunath» par le nom d'utilisateur souhaité:
    js
    use exampledb
    db.createUser (
    {
    user: «manjunath»,
    pwd: passwordPrompt (),
    rôles: [ { role: "readWrite" ]
    }
    )
  • Quittez le shell Mongo.
  • Arrêtez le serveur Mongo, puis redémarrez-le à l'aide de mongod --auth . Les clients qui se connectent à cette instance doivent maintenant s'authentifier.
  • Rouvrez un shell comme ceci: mongo --authenticationDatabase "exampledb" -u "manjunath" -p . Vous serez maintenant invité à entrer votre mot de passe.

Pour plus d'informations, veuillez consulter la documentation du projet sur l'activation du contrôle d'accès .

Opérations MongoDB CRUD

Comme vous le savez peut-être déjà, le CRUD acronyme signifie c reate, r ead, u pdate et d elete. Ce sont les quatre opérations de base de base de données que vous ne pouvez pas éviter lors de la création d'une application. Par exemple, toute application moderne aura la possibilité de créer un nouvel utilisateur, de lire les données utilisateur, de mettre à jour les informations utilisateur et, si nécessaire, de supprimer le compte utilisateur. Accomplissons cela au niveau de la base de données en utilisant MongoDB.

Opération de création

La création est la même que en insérant un document dans une collection. Dans la section précédente, nous avons inséré un seul document en utilisant la syntaxe db.collection.insertOne () . Il existe une autre méthode appelée db.collection.insertMany () qui vous permet d'insérer plusieurs documents à la fois. Voici la syntaxe:

> db.collection.insertMany ([...])

Créons une collection d'utilisateurs et remplissons-la avec des utilisateurs réels:

> use exampledb
> db.users.insertMany ([
   { name: "Tom",age:15, email: "tom@example.com" },
   { name: "Bob", age:35, email:"bob@example.com" },
   { name: "Kate", age: 27, email: "kate@example.com" },
   { name: "Katherine", age:65, email:"katherine@example.com"}
])

{
   "reconnu": vrai,
   "insertIds": [
      ObjectId("5e25bb58ba0cf16476aa56ff"),
    ObjectId("5e25bb58ba0cf16476aa5700"),
    ObjectId("5e25bb58ba0cf16476aa5701"),
    ObjectId("5e25bb58ba0cf16476aa5702")
   ]
}

La méthode insertMany accepte un tableau d'objets et, en retour, nous obtenons un tableau de ObjectId s.

Opération de lecture

Une opération de lecture est utilisée pour récupérer un document ou plusieurs documents d'une collection. La syntaxe de l'opération de lecture est la suivante:

> db.collection.find (requête, projection)

Pour récupérer tous les documents utilisateur, vous pouvez procéder comme suit:

> db.users.find (). Pretty ()
{
  "_id": ObjectId ("5e25bb58ba0cf16476aa56ff"),
  "nom": "Tom",
  "âge": 15,
  "email": "tom@example.com"
}
{
  "_id": ObjectId ("5e25bb58ba0cf16476aa5700"),
  "nom": "Bob",
  "âge": 35 ans,
  "email": "bob@example.com"
}
{
  "_id": ObjectId ("5e25bb58ba0cf16476aa5701"),
  "nom": "Kate",
  "âge": 27,
  "email": "kate@example.com"
}
{
  "_id": ObjectId ("5e25bb58ba0cf16476aa5702"),
  "nom": "Katherine",
  "âge": 65 ans,
  "email": "katherine@example.com"
}

Ceci correspond à la requête SELECT * FROM USERS pour une base de données SQL.

La jolie jolie méthode est une méthode du curseur et il y en a beaucoup d'autres aussi. Vous pouvez chaîner ces méthodes pour modifier votre requête et les documents qui sont renvoyés par la requête.

Vous devez peut-être filtrer les requêtes pour renvoyer un sous-ensemble de la collection, par exemple en recherchant tous les utilisateurs de moins de 30 ans. Vous pouvez modifier le requête comme celle-ci:

> db.users.find ({age: {$ lt: 30}})
{"_id": ObjectId ("5e25bb58ba0cf16476aa56ff"), "name": "Tom", "age": 15, "email": "tom@example.com"}
{"_id": ObjectId ("5e25bb58ba0cf16476aa5701"), "name": "Kate", "age": 27, "email": "kate@example.com"}

Dans cet exemple, $ lt est un opérateur de filtre de requête qui sélectionne les documents dont la valeur du champ âge est inférieure à 30. Il existe de nombreux filtres de comparaison et de requête logique disponibles. Vous pouvez voir la liste complète dans la documentation du sélecteur de requête .

Remarque: Dans Mongo, vous pouvez répliquer la requête comme de SQL à l'aide d'une expression régulière. Par exemple, SELECT * FROM utilisateurs WHERE name LIKE 'Kat%' se traduit par db.users.find ({name: /Kat.*/}) .

Update Operation

Une opération de mise à jour modifie les documents d'une collection. Semblable à l'opération de création, MongoDB propose différentes méthodes pour mettre à jour un document. Par exemple:

  1. db.collection.updateOne ()
  2. db.collection.updateMany ( .

Si vous devez ajouter un champ supplémentaire – par exemple, enregistrement – à tous les documents existants dans une collection, vous pouvez faire quelque chose comme ceci:

> db.users .updateMany ({}, {$ set: {registration: "incomplet"}})
{"reconnu": vrai, "matchedCount": 4, "modifiedCount": 4}

Le premier argument est un objet vide car nous voulons mettre à jour tous les documents de la collection. $ set est un opérateur de mise à jour qui définit la valeur d'un champ avec la valeur spécifiée. Vous pouvez vérifier que le champ supplémentaire a été ajouté à l'aide de db.users.find () .

Pour mettre à jour la valeur des documents qui correspondent à certains critères, updateMany () accepte un filtre objet comme premier argument. Par exemple, vous souhaiterez peut-être remplacer la valeur de l'enregistrement par complet pour tous les utilisateurs âgés de 18 ans et plus. Voici ce que vous pouvez faire:

> db.users.updateMany (
  {âge: {$ gt: 18}},
  {$ set: {registration: "complete"}
})

{"reconnu": vrai, "matchedCount": 3, "modifiedCount": 3}

Pour mettre à jour les détails d'enregistrement d'un seul utilisateur, vous pouvez procéder comme suit:

> db.users.updateOne (
 {email: "tom@example.com"},
 {$ set: {registration: "complete"}
})

{"reconnu": vrai, "matchedCount": 1, "modifiedCount": 1}

Opération de suppression

Une opération de suppression supprime un document de la collection. Pour supprimer un document, vous pouvez utiliser la méthode db.collection.deleteOne () et pour supprimer plusieurs documents, vous pouvez utiliser la méthode db.collection.deleteMany ( ) méthode.

Pour supprimer des documents en fonction de certains critères, vous pouvez utiliser les opérateurs de filtrage que nous avons utilisés pour l'opération de lecture et de mise à jour:

> db.users.updateOne (
 {email: "tom@example.com"},
 {$ set: {status: "dormant"}
})

{"reconnu": vrai, "matchedCount": 1, "modifiedCount": 1}

> db.users.deleteMany ({status: {$ in: [ "dormant", "inactive" ]}})

{"reconnu": vrai, "suppriméCompte": 1}

Ceci supprime tous les documents ayant le statut «dormant» ou «inactif».

Validation de schéma

Plus tôt dans ce didacticiel, lorsque j'ai dit que Mongo est une base de données sans schéma, j'ai simplifié quelque peu.

Il est sans schéma dans la mesure où nous n'avons pas besoin de spécifier le nombre ou le type de colonnes avant d'insérer nos données. Cependant, il est également possible de définir un schéma JSON et de l'utiliser pour appliquer des règles de validation pour nos données.

Créons une collection validatedUsers où nous pouvons utiliser la construction validator pour spécifiez qu'un nom est obligatoire et qu'un champ email correspond à un certain modèle:

> db.createCollection ("validatedUsers", {
  validateur: {
    $ jsonSchema: {
      requis: [ "name", "email" ],
      Propriétés: {
        Nom: {
          bsonType: "chaîne",
          description: "doit être une chaîne et est obligatoire"
        },
        email: {
          bsonType: "chaîne",
          modèle: "^. +  @. + $",
          description: "doit être un e-mail valide et est obligatoire"
        }
      }
    }
  }
})

{"ok": 1}

Maintenant, si nous essayons d'insérer des données incorrectes, nous recevrons une erreur de validation:

> db.validatedUsers.insertOne ({name: "Jim", email: "not-an-email"})

2020-01-22T09: 56: 56.918 + 0100 E QUERY & lsqb; js] exception non interceptée: WriteError ({
  "index": 0,
  "code": 121,
  "errmsg": "Échec de la validation du document",
  "op": {
    "_id": ObjectId ("5e280e5847eb18010666530c"),
    "nom": "Jim",
    "email": "not-an-email"
  }
}):
Erreur d'écriture({
  "index": 0,
  "code": 121,
  "errmsg": "Échec de la validation du document",
  "op": {
    "_id": ObjectId ("5e280e5847eb18010666530c"),
    "nom": "Jim",
    "email": "not-an-email"
  }
})
WriteError@src/mongo/shell/bulk_api.js: 458: 48
mergeBatchResults@src/mongo/shell/bulk_api.js: 855: 49
executeBatch@src/mongo/shell/bulk_api.js: 919: 13
Bulk/this.execute@src/mongo/shell/bulk_api.js: 1163: 21
DBCollection.prototype.insertOne@src/mongo/shell/crud_api.js: 264: 9
@ (shell): 1: 1

Vous pouvez lire plus d'informations sur la validation de schéma dans la documentation du projet .

Un aperçu des pilotes MongoDB

Pour qu'une application puisse communiquer avec le serveur MongoDB, vous devez utiliser un côté client bibliothèque appelée pilote . Le pilote se trouve au-dessus du serveur de base de données et vous permet d'interagir avec la base de données à l'aide de l'API du pilote. MongoDB possède des pilotes officiels et tiers pour toutes les langues et tous les environnements populaires.

Les pilotes les plus populaires pour Node.js incluent le pilote natif MongoDB et Mongoose . Je vais brièvement discuter de ces deux éléments ici.

Pilote MongoDB Node.js

Ceci est le pilote officiel MongoDB pour Node.js . Le pilote peut interagir avec la base de données en utilisant des rappels, des promesses ou asynchrone… attendre .

Vous pouvez l'installer comme suit:

 npm install mongod

L'exemple ci-dessous montre comment connecter le pilote au serveur et répertorier tous les documents de la collection des utilisateurs .

Remarque: si vous vous êtes connecté au serveur Mongo à l'aide de un nom et un mot de passe, vous devrez spécifier ces détails dans votre code.

Nom et mot de passe

Si vous vous connectez au serveur Mongo à l'aide d'un nom et d'un mot de passe, vous devrez spécifier ces détails dans votre code .

 const MongoClient = require ('mongodb'). MongoClient;
const url = 'mongodb: // localhost: 27017 / exampledb';

// Avec authentification:
// const url = 'mongodb: // :  @localhost: 27017 / exampledb';
// Lectures complémentaires: https://docs.mongodb.com/manual/reference/connection-string/

(async () => {
  laisser le client;

  essayez {
    client = attendre MongoClient.connect (url, {
      useNewUrlParser: true,
      useUnifiedTopology: true
    });

    const db = client.db ('exampledb');
    const collection = db.collection ('utilisateurs');
    const utilisateurs = attendre collection.find (). toArray ();
    console.log (utilisateurs);
  } catch (err) {
    console.log (err.stack);
  }

  si (client) {
    client.close ();
  }
}) ();

Le MongoClient.connect renvoie une promesse. Toute erreur est détectée par le bloc catch et toutes les actions de la base de données vont à l'intérieur du bloc try . Si vous consultez la documentation du pilote Mongo vous verrez que l'API est assez similaire à ce que nous avons utilisé dans le shell.

Mongoose Driver

Un autre pilote Node.js populaire pour MongoDB est Mongoose . Mongoose est construit sur le pilote officiel MongoDB. À l'époque de la sortie de Mongoose, il comportait des tonnes de fonctionnalités que le pilote natif MongoDB ne possédait pas. Une caractéristique importante était la possibilité de définir une structure de schéma qui serait mappée sur la collection de la base de données. Cependant, les dernières versions de MongoDB ont adopté certaines de ces fonctionnalités sous la forme de schémas JSON et de validation de schémas.

Outre le schéma, d'autres fonctionnalités sophistiquées de Mongoose incluent les modèles validateurs ] et middleware la méthode de peuplement plugins et ainsi de suite. Vous pouvez en savoir plus à ce sujet dans les documents Mongoose.

Vous pouvez installer Mongoose comme ceci:

 npm install mongoose

Voici l'équivalent mangouste de l'exemple précédent:

 const mongoose = require ('mongoose');

fonction asynchrone run () {
  attendre mongoose.connect ('mongodb: // localhost: 27017 / exampledb', {
    useNewUrlParser: true,
    useUnifiedTopology: true
  });

  const userSchema = new mongoose.Schema ({nom: chaîne, âge: chaîne, courriel: chaîne});
  const User = mongoose.model ('User', userSchema);

  const utilisateurs = attendre User.find ();
  console.log (utilisateurs);
  mongoose.connection.close ();
}

run (). catch (error => console.log (error.stack));

Dans Mongoose, tout commence par un schéma . Chaque schéma est mappé sur une collection MongoDB et définit la forme des documents de cette collection.

Conclusion

MongoDB est une solution de base de données NoSQL populaire qui convient aux exigences de développement modernes. Dans ce didacticiel, nous avons couvert les bases de MongoDB, du shell Mongo et de certains des pilotes populaires disponibles. Nous avons également exploré les opérations de base de données courantes et les actions CRUD dans le shell Mongo. Il est maintenant temps pour vous de partir et d'essayer ce que nous avons couvert ici et plus encore. Si vous voulez en savoir plus, je vous recommande de créer une API REST avec MongoDB et Node pour vous familiariser avec les opérations et méthodes de base de données courantes.


Fondateur de Storylens – Une plate-forme de création de site Web sans code basée sur Composants JavaScript.

Le meilleur outil 2023 pour ta croissance Instagram !



Source link