Inclure le package .NuGet “MongoDB.Driver” dans son projet.
Plusieurs packages sont installés:
MongoDB.Drive, MongoDB.BSON et MongoDB.Driver.Core.
L’objet principal pour ouvrir une connection est MongoClient.
Pour entrer certains paramètres de connexion, il faut utiliser une connectionString.

var connectionString = "mongodb://localhost:27017";
var client = new MongoClient(connectionString);
var db = client.GetDatabase("test");
var col = db.GetCollection("person");

Représentation des documents

Pour représenter des documents en .NET, on utilise l’objet BsonDocument;

var doc = new BsonDocument
{
    { "name", "Jones" }
};

Pour ajouter une valeur:

doc.Add("age", 30);

Pour affecter une valeur:

doc["profression"] = "hacker";

Pour définir un tableau:

var nestedArray = new BsonArray();
nestedArray.Add(new BsonDocument("color", "red));
doc.Add("array", nestedArray);

Représentation POCO

Permet de mapper du POCO vers du Bson.
On peut utiliser directement des structures et préciser des attributs pour préciser des éléments sur des membres:
Par exemple:

class Person
{
    public ObjectId Id {get; set;}

    [BsonElement("name")]
    public string Name {get; set;}

    [BsonRepresentation(BsonType.String)]
    public int Age {get; set;}
}

Il est possible de préciser des données par code:

Par exemple:

BsonClassMap.RegisterClassMap<Person>(cm => *
{
    cm.AutoMap();
    cm.MapMember(x => x.Name).SetElementName("name");
});

Pour ajouter une convention qui permet d’indiquer que "name" doit être mappé vers le membre
Person.Name (avec une majuscule):

var conventionPack = new ConventionPack();
conventionPack.Add(new CamelCaseElementNameConvention());
ConventionRegistry.Register("camelcase", conventionPack, t => true);

insertOne

Pour insérer une valeur dans une collection:

var client = new MongoClient();
var db = client.GetDatabase("test");
var col = db.GetCollection<BsonDocument>("people");
var doc = new BsonDocument
{
    { "Name": "Smith" },
    { "Age": 30 },
};

Pour insérer un seul document:

await col.InsertOneAsync(doc);

Pour insérer plusieurs documents.

await col.InsertManyAsync();

Avec un classe mappée:

var person = class Person
{
    public ObjectId Id {get; set;}
    public string Name {get; set;}
    public int Age {get; set;}
};
var doc = new Person{ };
await col.InsertOneAsync(doc);

ATTENTION: on peut pas insérer 2 fois le même objet à cause de "_id" qui est valué.

Il faut que "_id" n’est pas de valeur.

find

find() permet de retourner plusieurs lignes comme le Shell:
Il faut passer par l’intermédiaire d’un curseur, on entoure l’utilisation du curseur avec un try...finally pour exécuter le close même en cas d’exception.

var col = db.GetCollection<BsonDocument>("people");
using (var cursor = qawait col.Find(new BsonDocument()).ToCursorAsync())
{
    while (await cursor.MoveNextAsync())
    {
        foreach (var doc in cursor.Current)
        {
            Console.WriteLine(doc);
        }
    }
}

Pour traiter une liste directement:

var list = await col.Find(new BsonDocument()).ToListAsync();

Avec un ForEach:

var list = await col.Find(new BsonDocument()).ForEachAsync(doc => ConsoleWriteLine(doc));

Avec des critères de sélection:

var filter = new BsonDocument("Name", "Smith");
var list = await col.Find(filter).ToListAsync();

Il est possible de passer du code Bson directement:

var list = await col.Find({ "Name" : "Smith" }).ToListAsync();

Pour entrer plus de conditions:

var filter = new BsonDocument("$and", new BsonArray
{
    new BsonDocument("Age", new BsonDocument("$lt", 30)), 
    new BsonDocument("Name", "Smith"),
});

var filter = builder.And(builder.Lt("Age", 30) & builder.Eq("Name", "Smith"));

Il est possible d’utiliser directement des POCO:

var col = db.GetCollection<Person>("people");

En utilisant des lambda expressions:

var list = await col.Find(x => x.Age < 30 && x.Name != "Smith").ToListAsync();

Skip

Permet de sauter des valeurs:

var list = await col.Find(new BsonDocument())
    .Limit(1)
    .Skip(1)
    .ToListAsync();

Sort

Pour trier des éléments:

var list = await col.Find(new BsonDocument())
    .Sort(new BsonDocument("{ Age : 1 }")
    .ToListAsync();

ou

var list = await col.Find(new BsonDocument())
    .Sort(new BsonDocument("Age", 1)
    .ToListAsync();

ou

var col = db.GetCollection<BsonDocument>("people");
var list = await col.Find(new BsonDocument())
    .Sort(Builders<BsonDocument>.Sort.Ascending("Age"))
    .ToListAsync();

En utilisant POCO;

var col = db.GetCollection<Person>("people");
var list = await col.Find(new BsonDocument())
    .Sort(Builders<Person>.Sort.Ascending("Age").Descending("Name"))
    .ToListAsync();

ou

var list = await col.Find(new BsonDocument())
    .SortBy(x => x.Age)
    .ToListAsync();

ou

var list = await col.Find(new BsonDocument())
    .Sort(Builders<Person>.Sort.Ascending(x => x.Age))
    .ToListAsync();

Projections

var list = await col.Find(new BsonDocument())
    .Project("{ Name : 1, _Id: 0}")
    .ToListAsync();

ou

var col = db.GetCollection<Person>("people");
var list = await col.Find(new BsonDocument())
    .Project<Person>(Builders<Person>.Projection.Include("Name").Exclude("_Id"))
    .ToListAsync();

ou

var col = db.GetCollection<Person>("people");
var list = await col.Find(new BsonDocument())
    .Project(x => x.Name)
    .ToListAsync();

Replace

var result = await col.ReplaceOneAsync(
    new BsonDocument("_Id", 5)
    new BsonDocument("_Id", 5).Add("x", 30)
);

Si on utilise les "_Id", il faut répéter le séquence.

var result = await col.ReplaceOneAsync(
    new BsonDocument("x", 5)
    new BsonDocument("x", 30)
);

Pour savoir si l’update a fait quelque chose, il faut regarder le résultat dans "result".
En ajoutant une option:

var result = await col.ReplaceOneAsync(
    new BsonDocument("x", 5)
    new BsonDocument("x", 30)
    new UpdateOptions { IsUpsert = true }
);

Update

Même type de syntaxe:

var result = await col.UpdateOneAsync(
    Builders<BsonDocument>.Filter.Eq("x", 5),
    new BsonDocument("$inc", new BsonDocument("x", 10))
);

ou

var result = await col.UpdateOneAsync(
    Builders<BsonDocument>.Filter.Eq("x", 5),
    Builders<BsonDocument>.Update.Inc("x", 10)
);

ou

var result = await col.UpdateOneAsync(
    x => x.X > 5,
    Builders<BsonDocument>.Update.Inc("x", 10)
);

UpdateMany permet de modifier plusieurs lignes.

Delete

Pour supprimer seulement 1 élément:

var result = await col.DeleteOneAsync(x => x.X > 5);

Ou pour supprimer plusieurs documents:

var result = await col.DeleteManyAsync(x => x.X > 5);

FindOneAndUpdate

Permet de faire une mise à jour si on trouve l’élément.

var result = await col.FindOneAndUpdateOneAsync(
    x => x.X > 5,
    Builders<BsonDocument>.Update.Inc("x", 10)
);

Le résultat contient le document qui a été modifié.
On peut rajouter des options:

var result = await col.FindOneAndUpdateOneAsync(
    x => x.X > 5,
    Builders<BsonDocument>.Update.Inc("x", 10),
    new FindOneAndUpdateOptions<Widget, Widget>
    {
         ReturnDocument = ReturnDocument.After
    }
);

Par défaut, on renvoie le document avant modification. L’option "ReturnDocument" permet de renvoyer le document après la modification.

Sort

Pour trier les éléments avant de les modifier:

var result = await col.FindOneAndUpdateOneAsync(
    x => x.X > 5,
    Builders<BsonDocument>.Update.Inc("x", 10),
    new FindOneAndUpdateOptions<Widget, Widget>
    {
        ReturnDocument = ReturnDocument.After,
        Sort = Builders<Widget>.Sort.Descending(x => x.X),
    }
);

Opérations CRUD et mongo Shell

Les mots clé en mongo équivalent à:
– Create: insert
– Read: find
– Update: update
– Delete: remove

Pour effectuer des opérations CRUD en mongodb, on utilise pas une string comme en SQL mais directement des fonctions de l’API.
Le mongo Shell est un shell Javascript ce qui signifie qu’il est possible d’écrire du Javascript directement dans le Shell.
Les raccourcis sont compatibles avec les raccourcis EMACS (Ctrl + A, Ctrl + E etc…).
Pour avoir de l’aide:
taper “help”

Assignation de variable:

x = 1; y = "abc";

z = { "a" : 1 } permet de créer un dictionaire. Pour accéder à une valeur, il suffit de faire z.a ou z["a"]. Il faut privilégier z["a"] qui permet d’accéder au type de la valeur.

Par exemple:

x = { "a" : 1 };
y = "a";
x[y]++;
print(x.a);

Le résultat est 2.

Afficher une valeur

print(x.a)

BSON

Les données stockées dans une base Mongo sont sous forme de données binaires: BSON pour binary JSON.
Il est possible de faire des affectations de dictionnaires et de documents intégrés (“embedded document”):

obj = { "a" : 1, "b" : "hello", "c" : [ "apples", "tomatoes" ] }

Mais il est aussi possible d’affecter des données plus fortement typées en utilisant des constructeurs:
– NumberInt(1) pour des entiers codés en 16bits ou NumberLong(3) pour des entiers codés en 64 bits.
– new Date() est de type ISODate().

Par exemple:

obj = { "a" : 1, "b" : ISODate("2012-10"), "c" : NumberLong(42) }

Fonction "insert"

Permet d’insérer un document dans une collection:

db.people.insert([ document ])

Dans le syntaxe db.people.insert():
– "db" est le base de données,
– "people" est une collection et
– "insert()" est une fonction sur la collection.

Une collection comporte toujours un champ "_id" qui est inséré par défaut. La valeur est censé être unique à l’échelle de toutes les bases (espèce de GUID).

Fonction "findOne"

Permet de retourner la 1ère valeur de la collection:

db.people.findOne()

Il est possible de rajouter des arguments:

db.people.findOne( { "name" : "jones" } )

On peut préciser plusieurs conditions dans le premier argument de la fonction:
Par exemple:

db.score.find( { "student" : 19 , "type" : "essay" } );

Permet de remonter tout le document avec des valeurs avec des champs tels que "student" 19 ET les "types" “essay”.

Le 2ème argument de la fonction FIND indique les champs à remonter et les champs à exclure:
Par exemple:

db.score.find( { "student" : 19 , "type" : "essay" }, { "score" : true } );

Dans ce cas on va remonter seulement les champs “score” et "_id" (qui est automatiquement remonté).
Pour exclure le champ "_id", il faut préciser:

db.score.find( { "student" : 19 , "type" : "essay" }, { "score" : true, "_id" : false } );

Fonction "find"

Fonctionne comme la fonction "findOne".
db.people.find() permet d’afficher tout le contenu de la collection.

On peut améliorer l’affichage en écrivant:

db.people.find().pretty()

Opérateurs "$gt" et "$lt"

Permet d’avoir des conditions telles que:
– "$gt": strictly greater than
– "$lt": strictly less than
– "$lte": less or equal than
– "$gte": greater or equal than
Par exemple:

db.people.find( { score : { $gt : "95" } } );

Avec plusieurs conditions:

db.people.find( { score : { $gt : "95", "$lt" : 100 }, type : "essay" } );

Utilisation des opérateurs de comparaison sur les chaînes de caractères

Il est possible d’utiliser les opérateurs "$gt" et "$lt" pour les chaînes de caractères:
Par exemple:

db.people.find( { name : { $gt : "B", $lt : "D" } } );

Permet de retourner les noms dont la première lettre est supérieure à "B" et inférieure à "D".
En fait on utilise l’ordre des caractères dans le codage UTF-8 pour savoir moment ordonner les lettres.
Il est possible d’utiliser des types différents dans les champs. Cependant si un champ "name" d’un document est une valeur numérique, il ne sera pas retourné par la requête précédente.

Opérateur $exists

Permet d’indiquer si un champ à l’intérieur d’un document existe ou non.
Par exemple:

db.people.find( { profession : { $exists : true }});

Permet d’indiquer si le champ “profession” existe.
A l’opposé pour chercher les documents où le champ n’existe pas:

db.people.find( { profession : { $exists : false }});

Opérateur $type

Permet de faire un recherche en fonction du type d’un champ.
Par exemple:

db.people.find( { name : { $type : 2}});

Les codes des types sont à retrouver sur http://bsonspec.org/spec.html
Le type 2 correspond au type “string”.

Opérateur $regex

Permet d’indiquer une expression régulière pour faire une recherche.
Par exemple:
db.people.find( { name : { $regex : "a"}}); pour avoir un champ "name" contenant “a”.
db.people.find( { name : { $regex : "e$"}}); pour avoir un champ "name" se terminant avec “e”.
db.people.find( { name : { $regex : "^A"}}); pour avoir un champ "name" commençant par “A”.

Opérateur $or

Opérateur logique:

db.people.find( { $or : [ { name : { $gt : "C" } }, { age : { $exists : true } } ] } );

db.scores.find( { $or : [ { score : { $lt : 50 } }, { score : { $gt : 90 } } ] } ) ;

Opérateur $and

Opérateur logique utilisable pour les conditions d’une requête FIND:
Par exemple:

db.people.find( { $and : [ { name : { $gt : "C" } }, { name : { $regex : "a" } } ] } );

Équivalent à:

db.people.find( { name : { $gt : "C" , $regex : "a" } } );

db.scores.find( { score : { $gt : 50 }, score : { $lt : 60 } } );

db.scores.find( { score : { $lt : 60 } } );

db.scores.find( { score : { $gt : 50 , $lt : 60 } } );

Recherche à l’intérieur d’un tableau

Si un document est de type:

{ "name" :"George", "favorites": [ "ice cream", "pretzels"]}

Pour chercher à l’intérieur du tableau il suffit de faire:

db.accounts.find( { favorites: "pretzels" })

Opérateur $all

Permet d’indiquer que tous les éléments dans un tableau doivent être présents pour que le document soit remonté.
Par exemple:

db.accounts.find( { favorites: { $all : [ "pretzels", "beer" ] } } )

Il faut que le tableau contienne "pretzels" ET "beer", l’ordre n’a pas d’importance.

Opérateur $in

Même chose que l’opérateur $all mais il suffit qu’un seul élément dans le tableau soit présent dans le document pour qu’il soit retourné.
Par exemple:

db.accounts.find( { favorites: { $in : [ "pretzels", "beer" ] } } )

Les documents dont le tableau contient "pretzels" OU "beer" seront remontés.

Notation avec un point "."

Cette notation permet de designer un champ d’un document lorsque celui-ci est composé de document intégré (embedded document).
Un document intégré est de ce type:

name : "richard"
email : { "work" : "richard.lord@work.com",
"personal" : richard.lord@home.com}

Le champ “email” est un document intégré (embedded document).
Si on fait une requête sur ce document, on est obligé d’indiquer tous les champs dans le bon ordre sinon le document contenant se sera pas retourner.
Par exemple:

db.people.find( { email : { "work" : "richard.lord@work.com"} } );

Ne retournera aucun résultat.

db.people.find( { email : { "personal" : "richard.lord@home.com", "work" : "richard.lord@work.com" } } );

Ne retournera aucun résultat.
Pour faire une requête seulement sur le champ "work" il faut utiliser la notation:

db.people.find( { "email.work" : "richard.lord@work.com" } );

Curseur

Permet de parcourir les résultats de la fonction code class=”cs”>”find()”.

cur = db.people.find()

Pour avoir la valeur suivante:

cur.next()

Pour savoir si il existe une valeur suivante:

cur.hasNext()

Ce qui permet de faire une boucle WHILE:

while (cur.hasNext()) printjson(cur.next());

Pour limiter le nombre d’éléments dans le curseur:

cur.limit(5)

Pour ordonner les éléments dans le curseur:
cur.sort( { name: -1 } ); pour afficher dans l’ordre décroissant du champ "name".
Pour sauter 2 documents:

cur.sort( { name: -1 } ).limit(3).skip(2);

Fonction "count"

code class=”cs”>count() permet de compter le nombre de valeurs:

long count = dbCollection.count();

La syntaxe du Shell pour la fonction "count" est similaire à celle de "find":

db.people.count( { "name" : "john" } );

Fonction "update"

Pour faire des mises à jour.

Par exemple:

dbCollection.update( { name : "Smith" }, { name : "Thompson", salary:50000 })

Cette ligne va remplacer tous les champs du document avec le name ="Smith". Si d’autres champs sont présents, ils seront tous remplacés par le seul champ "salary".
Dans l’exemple: db.people.update( { name : "john" }, { $set : { profession : 1 }} );
Si aucun document ne correspond à "name" = " john", aucune mise à jour ne sera effectuée.

Paramètre $set

Permet de rajouter de nouveaux champs sans effacer les anciens:
Par exemple:

db.people.update( { name : "john" }, { $set : { profession : 1 }} );

Si aucun document ne correspond à "name" = " john", aucune mise à jour ne sera effectuée.

Paramètre $unset

Permet de supprimer un champ d’un document.

La syntaxe est similaire à $set:

db.people.update( { name : "john" }, { $unset : { profession : 1 }} );

Cette ligne va supprimer le champ "profession" du document avec "name" = "john".

Manipulation de tableau

Si on a un tableau d’éléments:

a : [ 1, 2, 3, 4]

Pour modifier la valeur d’un élément du tableau:

db.arrays.update( { _id : 0 }, { $set : { "a.2" : 5 } } )

Permet de modifier la 3e valeur du tableau

a : [ 1, 2, 5, 4]

$push

Permet de rajouter une valeur à la fin du tableau

db.arrays.update( { _id : 0 }, { $push : { a : 6 } } )

Le résultat est:

a : [ 1, 2, 5, 4, 6]

$pop

Permet de supprimer une valeur à gauche avec 1 comme valeur:

db.arrays.update( { _id : 0 }, { $pop : { a : 1 } } )

Le résultat est:

a : [ 1, 2, 5, 4]

Ou supprimer une valeur à droite avec -1:

db.arrays.update( { _id : 0 }, { $pop : { a : -1 } } )

Le résultat est:

a : [ 2, 5, 4]

$pushAll

Permet de rajouter un autre tableau à la suite d’un tableau:

db.arrays.update( { _id : 0 }, { $pushAll : { a : [7, 8, 9] } } )

Le résultat est:

a : [ 2, 5, 4, 7, 8, 9]

$pull

Permet de supprimer une valeur quelque soit sa position dans le tableau

db.arrays.update( { _id : 0 }, { $pull : { a : 5 } } )

Le résultat est:

a : [ 2, 4, 7, 8, 9]

$pullAll

Permet de supprimer une liste de valeurs quelque soit leur position

db.arrays.update( { _id : 0 }, { $pushAll : { a : [2, 4, 8] } } )

Le résultat est:

a : [ 7, 9]

$addToSet

Permet de rajouter un élément dans le tableau s’il n’existe pas déjà. La fonction est idempotente (plusieurs exécutions de la ligne ne rajoutera pas la valeur si elle est déjà présente).

db.arrays.update( { _id : 0 }, { $addToSet : { a : 5 } } )

Le résultat est:

a : [ 7, 9, 5]

Paramètre $upsert

Si la valeur est à false, la commande "update" ne rajoute pas d’entrées si aucun document ne correspond au critère de sélection. Si vraie alors un document est rajoutée même si il n’existe pas à l’origine.

db.people.update( { name : "john" }, { $set : { profession : 1 }, { $upsert : true } } );

Permettra de rajouter le document avec name="john" et profession = 1 même s’il n’existe pas.

Pour utiliser "$upsert" il faut que la valeur du champ soit parfaitement indiquée.

Par exemple:

db.people.update( { age : { $gt : 50 } }, { $set : { name : "john" }, { upsert : true } } );

Cette ligne ne permet pas de déterminer la valeur du champ “age” donc il ne rajoutera pas le champ "age". En revanche, il va rajouter le champ "name".

Paramètre $multi

Si faux, la modification s’effectue seulement sur le premier élément qui correspond aux critères de sélection. Si vraie, alors tous les documents satisfaisant le critère de sélection seront mis à jour.

db.people.update( {}, { $set : { title : "Dr" }, { $multi : true } } );

Permettra de rajouter l’élément "title" à tous les documents de la collection.

Pausing yielding

La mise à jour de plusieurs lignes ne se fait pas de façon atomique. Seul l’écriture des champs est faite de façon atomique. Le pausing yielding consiste, dans le cas où plusieurs opérations de mise à jour sont faites sur les mêmes documents, à permettre la mise à jour de plusieurs documents pour la première opération, puis de plusieurs documents pour la 2ème opération. Ensuite de revenir à la première opération et de permettre la mise à jour d’autres documents et ainsi de suite…

Paramètre $inc

Pour incrémenter une valeur numérique:

db.scores.update( { "score" : { $lt : 70 } }, { $inc : { score : 20} }, { multi : true} )

Permet de rajouter 20 points aux scores inférieurs à 70.

Fonction "remove"

Permet de supprimer des données.
Cette fonction a la même syntaxe que "find".
Contrairement à “update” qui met à jour par défaut seulement le premier document qui correspond aux critères, “remove” supprime tous les documents qui correspondent aux critères.
Par exemple:

db.collection.remove({});

Supprime tous les documents de la table.

db.collection.remove({"id", "alice"});

Permet de supprimer les documents dont le champ "id" est "alice".
La suppression avec "remove" se fait de ligne à ligne contrairement à "drop".
Comme l’update, la suppression de lignes avec "remove" n’est pas atomique.

Fonction "drop"

Permet de supprimer toutes les valeurs d’une collection sans parcourir les lignes une à une.
Plus efficace que "remove" pour supprimer toutes les valeurs.

getLastError

Pour obtenir la dernière erreur survenue:

db.runCommand( { getLastError : 1 } )

Le résultat est un document avec pour élément “err” contenant le message de son erreur.
Cette commande permet aussi de donner un feedback sur certaines commandes sans forcément même si il n’y a pas eu d’erreurs.

Driver .NET

Formation MongoDB M101N: semaine 2 – Driver .NET

Quelques caractéristiques:
– “Rich documents”: on peut stocker davantages que de simples valeurs,
– “Prejoin” en utilisant des documents intégrés (embedded documents),
– Pas de jointures en MongoDB,
– Pas de contraintes,
– Pas de transactions,
– Pas de schéma conceptuel.

Le principe général d’une base MongoDB est d’avoir des schémas de données proches de l’application.

Les bases relationnelles sont conçues pour:
– Interdire de modifier la base en introduisant des anomalies,
– Minimise le redesign de la base quand le schéma conceptuel grossit,
– Il permet d’éviter d’être influencer par certains patterns d’accès.

MongoDB ne pousse pas à utiliser un pattern par rapport à un autre. Ensuite il faut éviter d’introduire des anomalies à la création de données.

Exemple d’articles d’un blog

Par exemple, pour afficher les articles d’un blog, on peut stocker tous les éléments de l’article:
– titre,
– auteur,
– contenu,
– date,
– mots clé.

Tous les commentaires:
– auteur du commentaire,
– email,
– contenu du commentaire.

Tous ces éléments peuvent être stockés dans la même collection en utilisant des documents intégrés (embedded document).

Si on utilise un schéma proche de celui qu’on aurait utilisé dans une base relationnelle, on aurait:
– une collection pour les articles avec un ID, titre, corps, auteur et date,
– une collection pour les commentaires avec un ID, un ID d’article (clé étrangère), auteur, adresse email et l’ordre d’affichage du commentaire,
– une collection pour les tags avec un ID, un tag et un ID d’article (clé étrangère).

Ce type de schéma impose de
– maintenir une relation entre les 3 collections en utilisant des clés étrangères,
– maintenir l’ordre dans la collection des commentaires,
– d’utiliser 3 fichiers sur le disque, 1 fichier par collection.
– d’accèder à 3 collections pour afficher un article.

Cette organisation est plus lourde que de considérer une collection pour stocker tous les éléments.

Contraintes

Un des avantages de la base relationnelle est de garantir d’avoir des données consistantes en utilisant des clés étrangères. MongoDB ne garantit pas d’avoir des clés étrangères consistantes.
Le fait d’utiliser des documents intégrés garantit que les documents sont liés entre eux: si tous les commentaires sont directement dans la collection d’articles, par construction ils appartiennent à l’article.

Transactions

Pas de transactions en MongoDB mais les opérations sont atomiques.
Quand on insère des documents dans une collection, ils ne seront visibles que si le document est ajouté entièrement. En revanche, l’ajout de plusieurs documents n’est pas atomiques.
Le fait d’utiliser des documents intégrés permet de garantir la consistance des données.

En utilisant MongoDB, il faut:
– être restrictif en utilisant des documents intégrés ce qui permet d’insérer des données de façon consistante.
– implémenter des “locks” au niveau software
– tolérer une inconsistance dans les données.

Relations entre les objets logiques

Relations un vers un

Par exemple un employé et un CV, un employé n’a qu’un CV.
On peut stocker les infos dans 2 collections:

Employee:
- _ID,
- Name,
- Resume_ID

Resume 
- _ID,
- Jobs: [] (array)
- Education: []

Ou alors on inclut le CV directement dans la collection "Employee" sous forme de document intégré.

Pas de restrictions pour les relations un vers un, il faut juste avoir en tête:
– La fréquence d’accès aux données: si on accède très souvent au CV d’un employé ou si on accède seulement aux informations de l’employé.
– La taille des éléments: les informations du CV seront peut être plus volumineuse que celles de l’employé lui-même.
– La limite de 16mb d’un document intégré: un document intégré ne peut dépasser 16mb.

Relations un vers plusieurs

Par exemple, une ville et une personne. Une ville contient plusieurs personnes.

Plusieurs schémas sont possibles:
1ere solution:

City:
- name,
- area;
- people: [] (array)

Ce schéma n’est pas possible car il y a beaucoup trop de personnes pour une ville, le tableau serait trop grand.

2e solution:

People:
- name,
- city : { name; area; }

Le problème avec ce schéma est de multiplier les données relatives à la ville dans tous les documents des personnes.

3e solution: 2 collections:

People:
- name;
- city: "NYC"

City:
- _ID: "NYC" 
- area

La 3e solution est la meilleure puisqu’on ne duplique pas les informations.

La 1ère solution aurait pu être choisi si il n’y avait pas beaucoup de personnes.

Pour les relations un vers plusieurs, l’important est de savoir l’ordre de grandeur du plusieurs:
– dans le cas d’un grand nombre: il faut considérer une collection différente
– dans le cas d’un nombre pas très élevé: il est préférable de privilégier un document intégré.

Plusieurs vers plusieurs

Par exemple, des livres et des auteurs.
Dans ce cas, il y a peu de livres pour un auteur et inversement, il a peu d’auteurs pour un livre. Donc il peut considérer 2 collections:

Books:
- _ID, 
- title, 
- authors: [ author_ID ]

Author: 
- _ID 
- Author_name, 
- books: [ books_ID ]

On peut inclure des références vers les auteurs dans la collection livre dans un tableau.

On peut aussi inclure directement les livres dans la collection auteur mais la contrainte est pour les livres qui ont plusieurs auteurs.

Dans le cas d’étudiants et de professeurs:

Un professeur possède beaucoup d’étudiants, on peut utiliser des documents intégrés en incluant un tableau de professeur dans la collection d’étudiants. Ce schéma peut poser problème si des étudiants sont aussi des professeurs.

Index multi-clé

Permet d’utiliser des index pour des relations plusieurs vers plusieurs.

Si on considère 2 collections telles que:

Students: 
- _ID, 
- name, 
- teachers: [ teacher_ID ] (tableau de teacher ID)

Teachers: 
- _ID 
- name,

Si on veut lister les professeurs d’un étudiant, on peut le faire directement. En revanche, si on veut les étudiants d’un professeur, on aura besoin d’un index multi-clé.

db.students.ensureIndex({ 'teachers':1 })

Pour avoir tous les étudiants d’un professeur:

db.students.find({ 'teachers': { $all: [ 0, 1 ] } })

Pour savoir comment l’index est utilisé:

db.students.ensureIndex({ 'teachers':1 }).explain()

Avantages d’utiliser des documents intégrés

– Permet d’améliorer les performances en lecture
– Effectuer un seul aller-retour avec la base de données
La base utilise des disques durs dont le temps d’accès est long mais qui ont une bande passante élevée: on met du temps à attendre l’information mais on peut charger rapidement beaucoup d’information en même temps. Il est donc préférable d’avoir des informations rapprochées pour les charger d’un coup.

Arbres

Par exemple, si on considère des produits et des catégories. Les catégories appartiennent à d’autres categories.
On peut proposer ce schéma:

Products: 
- Category, 
- Product_name

Category: 
- _ID 
- Category_name 
- ancestors: [ category_ID ]

Ainsi tous les ascendants de la categorie se trouvent dans le tableau “ancestors”.

Si on veut les descendants d’un categorie, il suffit de faire:

db.category.find({ ancestors: 35 })