Aller au contenu

Modélisation de données#

  • Concevez votre schéma en fonction des besoins de l'utilisateur.
  • Combinez des objets en un seul document si vous les utilisez ensemble. Autrement séparez-les (mais assurez-vous de ne pas avoir besoin de joindre).
  • Dupliquez les données (mais limitées) car l’espace disque est bon marché par rapport au temps de calcul.
  • Faire des jointures en écriture, pas en lecture.
  • Optimisez votre schéma pour la plupart des cas d'utilisation fréquents.
  • Faire une agrégation complexe dans le schéma.

Exemple d'un site/blog#

Le site Web a les exigences suivantes.

  • Chaque message a le titre, la description et l'URL uniques.
  • Chaque message peut avoir un ou plusieurs tags.
  • Chaque message porte le nom de son éditeur et le nombre total de goûts.
  • Chaque message a des commentaires donnés par les utilisateurs avec leur nom, message, données- temps et aime.
  • Sur chaque post, il peut y avoir zéro ou plus de commentaires. Dans le schéma SGBDR, la conception pour les exigences ci-dessus aura au minimum trois tables.

Exemple - avec une BDD relationnelle#

Exemple - avec une BDD NoSQL#

{
  _id: POST_ID
  title: TITLE_OF_POST,
  description: POST_DESCRIPTION,
  by: POST_BY,
  url: URL_OF_POST,
  tags: [TAG1, TAG2, TAG3],
  likes: TOTAL_LIKES,
  // ...
}

Exemple - avec une BDD NoSQL (suite)#

{
  // ...,
  comments: [
    {
      user:'COMMENT_BY',
      message: TEXT,
      dateCreated: DATE_TIME,
      like: LIKES
    },
    {
      user:'COMMENT_BY',
      message: TEXT,
      dateCreated: DATE_TIME,
      like: LIKES
    }
  ]
}

Création d'une base de données#

use DATABASE_NAME

Exemple :

>use mydb
switched to db mydb

Pour retrouver la bdd actuelle :

>db
mydb

Pour lister toutes les BDD :

>show dbs
local   0.78125GB
test    0.23012GB

Pour qu'une bdd existe, il faut insérer au moins un document dedans.

>db.movie.insert({"name":"tutorials point"})
>show dbs
local    0.78125GB
mydb     0.23012GB
test     0.23012GB

MongoDB - Drop Database#

db.dropDatabase()

Créer une collection#

>use test
switched to db test
>db.createCollection("mycollection")
{ "ok" : 1 }
>
>show collections
mycollection
system.indexes
>db.createCollection("mycol", { capped : true, autoIndexID : true, size :
6142800, max : 10000 } )
{ "ok" : 1 }
>

N.B: mongodb crée une collection automatiuement lorsqu'on insere un document (voir plus haut)

> db.movie.insert({"name":"tutorials point"})
> show collections

Suppression de collection#

db.COLLECTION_NAME.drop()

Example#

First, check the available collections into your database mydb.

>use mydb
switched to db mydb
>show collections
mycol
mycollection
system.indexes
tutorialspoint
>
> db.mycollection.drop()

Types de données#

  • String: This is the most commonly used datatype to store the data. String in MongoDB must be UTF-8 valid.
  • Integer: This type is used to store a numerical value. Integer can be 32 bit or 64 bit depending upon your server.
  • Boolean: This type is used to store a boolean (true/ false) value.
  • Double: This type is used to store floating point values.
  • Min/Max Keys: This type is used to compare a value against the lowest and highest BSON elements.
  • Arrays: This type is used to store arrays or list or multiple values into one key.
  • Timestamp: ctimestamp. This can be handy for recording when a document has been modified or added.
  • Object: This datatype is used for embedded documents.
  • Null: This type is used to store a Null value.
  • Symbol: This datatype is used identically to a string; however, it's generally reserved for languages that use a specific symbol type.
  • Date: This datatype is used to store the current date or time in UNIX time format. You can specify your own date time by creating object of Date and passing day, month, year into it.
  • Object ID: This datatype is used to store the document’s ID.
  • Binary data: This datatype is used to store binary data.
  • Code: This datatype is used to store JavaScript code into the document.
  • Regular expression: This datatype is used to store regular expression.

Insertion de document#

>db.COLLECTION_NAME.insert(document)
>db.mycol.insert({
_id: ObjectId(7df78ad8902c),
title: 'MongoDB Overview',
description: 'MongoDB is no sql database',
by: 'tutorials point',
url: 'http://www.tutorialspoint.com',
tags: ['mongodb', 'database', 'NoSQL'],
likes: 100
})

N.B: il est possible d'insérer plusieurs documents en une fois en passant un array à la fonction insert()

>db.post.insert([{ ... }, { ... }])

N.B: il est également possible d'utiliser la méthode save. Si aucun _id n'est spécifié, elle se comportera de la même façon que insert()

- Requêtes de documents#

>db.COLLECTION_NAME.find()

Pour rendre le resultat sexy

>db.mycol.find().pretty()

Équivalences avec les RDBMS : égalité#

Opération Syntaxe
Egalité {<key>:<value>}
Inférieur à {<key>:{$lt:<value>}}
Inférieur ou égal à {<key>:{$lte:<value>}}
Supérieur à {<key>:{$gt:<value>}}
Supérieur ou égal à {<key>:{$gte:<value>}}
Différent de {<key>:{$ne:<value>}}
// where by = 'tutorials point'
> db.mycol.find({"by":"tutorials point"}).pretty()
> db.mycol.find({"age":{$gte: 18}}).pretty() 

Composition : ET#

Il suffit de passer plusieurs clés séparées par ","

>db.mycol.find({key1:value1, key2:value2}).pretty()

Il suffit de passer plusieurs clés séparées par ","

Composition : OU#

>db.mycol.find(
  {
    $or: [
      {key1: value1}, {key2:value2}
    ]
  }
).pretty()

Ex:

>db.mycol.find(
  {
    $or: [
      {"by":"tutorials point"},
      {"title": "MongoDB Overview"}
    ]
  }
).pretty()

Composition : ET + OU#

>db.mycol.find({"likes": {$gt:10}, $or: [{"by": "tutorials point"}, {"title": "MongoDB Overview"}]}).pretty()