Retour aux fondamentaux : Penser en termes de documents

Penser en termes de

documents

Buzz MoschettiArchitecte d'entreprise, MongoDB

[email protected]

@buzzmoschetti

Avant de commencer

• Ce webinaire est enregistré

• Utilisez la fenêtre de discussion pour :

• obtenir une assistance technique ;

• poser des questions et obtenir des

réponses.

• L'équipe MongoDB répondra

rapidement aux questions en

temps réel.

• Les questions les plus courantes

seront examinées à la fin de ce

webinaire.

Thème 1 :

Pour établir une conception de

données efficace, il ne suffit pas

d'avoir une base de données

• Des structures facilement

compréhensibles

• Une harmonisation avec les logiciels

• Une connaissance des problèmes

hérités

Thème°2 :

Les solutions d'aujourd'hui

doivent prendre en compte les

besoins de demain• Fin de l'obligation de suivre une

configuration requise

• Possibilité de monter en charge de

façon économique

• Des solutions de cycles de vie plus

rapides

Thème°3 :

MongoDB vous donne le choix

RDBMS MongoDB

Base de données Base de données

Table Collection

Index Index

Ligne Document

Colonne Champ

Jointure Intégration et liaison

Terminologie

{

_id: “123”,

title: "MongoDB: The Definitive Guide",

authors: [

{ _id: "kchodorow", name: "Kristina Chodorow“ },

{ _id: "mdirold", name: “Mike Dirolf“ }

],

published_date: ISODate(”2010-09-24”),

pages: 216,

language: "English",

thumbnail: BinData(0,"AREhMQ=="),

publisher: {

name: "O’Reilly Media",

founded: 1980,

locations: ["CA”, ”NY” ]

}

}

Qu'est-ce qu'un document ?

// Java: maps

DBObject query = new BasicDBObject(”publisher.founded”, 1980));

Map m = collection.findOne(query);

Date pubDate = (Date)m.get(”published_date”); // java.util.Date

// Javascript: objects

m = collection.findOne({”publisher.founded” : 1980});

pubDate = m.published_date; // ISODate

year = pubDate.getUTCFullYear();

# Python: dictionaries

m = coll.find_one({”publisher.founded” : 1980 });

pubDate = m[”pubDate”].year # datetime.datetime

Les documents mènent à des constructions

de langages

9

Conception de données

traditionnelle• Données scalaires

uniformes et statiques

• Rectangles

• Représentation physique

de bas niveau

10

Conception de données

par document• Formes enrichies et

flexibles

• Objets

• Représentation

d'entreprise de niveau

supérieur

Exemple de

conception de schéma

12

Application de gestion de bibliothèques

• Clients/utilisateurs

• Livres

• Auteurs

• Éditeurs

13

Question :

Quelle est l'adresse d'un

client ?

Client + adresse : Tentative initiale

> db.patrons.find({ _id : “joe” })

{

_id: "joe“,

name: "Joe Bookreader”,

favoriteGenres: [ ”mystery”, ”programming” ]

}

> db.addresses.find({ _id : “joe” })

{

_id: "joe“,

street: "123 Fake St.",

city: "Faketon",

state: "MA",

zip: “12345”

}

Client + adresse : La méthode MongoDB


{

_id: "joe",

name: "Joe Bookreader",

favoriteGenres: [ ”mystery”, ”programming” ]

address: {

street: "123 Fake St. ",

city: "Faketon",

state: "MA",

zip: “12345”

}

}

Projection : renvoyez uniquement ce dont

vous avez besoin

> db.patrons.find({ _id : “joe” }, {“_id”: 0, ”address”:1})

{

address: {


city: "Faketon",

state: "MA",

zip: “12345”

}

}

> db.patrons.find({ _id : “joe” }, {“_id”: 0, “name”:1,

”address.state”:1})

{


address: {

state: "MA”

}

}

17

La sous-structure fonctionne parfaitement

avec le code

> addr = db.patrons.find({_id :“joe”},{“_id”: 0,”address”:1})

{

address: {


city: "Faketon",

state: "MA",

zip: “12345”

}

}

// Pass the whole Map to this function:

doSomethingWithOneAddress(addr);

// Somewhere else in the code is the actual function:

doSomethingWithOneAddress(Map addr)

{ // Look for state }

N'oubliez pas : les formes des documents

peuvent varier

> db.patrons.insert({ _id : “bob”,

name: ”Bob Nobooks",

address: {

street: ”139 W45 St. ",

city: ”NY",

state: ”NY",

country: ”USA”

}

}

> db.patrons.find({},{“_id”: 1, ”address”:1})

{ _id: “joe”,

address: {


city: "Faketon",

state: "MA",

zip: “12345”

}

}

{ _id: ”bob",

address: {

street: ”139 W45 St. ",

city: ”NY",

state: ”NY",

country: ”USA”

}

}

19

La sous-structure améliore l'agilité

> addr = db.patrons.find({_id :“bob”},{“_id”: 0,”address”:1})

{

address: {

street: ”139 W45 St. ",

city: ”NY",

state: ”NY",

country: ”USA”

}

}




{ // Look for state and optional country }

AUCUNE MODIFICATION

apportée aux requêtes

Seule l'implémentation

unique recherchant le

pays doit être modifiée

PAS DE DÉPENDANCES

DE DURÉE DE

COMPILATION lors du

transfert des mappages

20

Avantage par rapport aux rectangles

resultSet = select street, state, city, country, …

Map addr = processIntoMap(resultSet);




{ // Look for state and optional country }

Il faut modifier les requêtes

pour sélectionner de

nouvelles colonnes.

Il existe une dépendance

de durée de compilation

pour traiter de nouvelles

colonnes vers le mappage.

21

Montées en charge de la sous-structure pour

la modification

MongoDB

db.patrons.find({},

{”myAddress”:1,”yourAddress”:1,”brokerAddress”:1,

“momsAddress”:1, …})

Traditional SQL

resultSet = select mystreet, mystate, mycity, mycountry,

yourstreet, yourstate, yourcity, yourcountry, brokerstreet,

brokerstate, brokercity, brokercountry, momsstreet,

momsstate, momscity, momscountry, …

22

Relations un-à-un

• Les relations de type « Appartient à » sont souvent intégrées.

• Représentation holistique des entités avec leurs attributs et relations intégrés

• Performances de lecture exceptionnelles

Le plus important :

• Insistez sur la simplicité.

• Libérez du temps pour résoudre des problèmes de conception de schéma plus difficiles.

23

Question :

Quelles sont les adresses d'un

client ?

Un client et ses adresses

> db.patrons.find({ _id : “bob” })

{

_id: “bob",

name: “Bob Knowitall",

addresses: [

{street: "1 Vernon St.", city: "Newton", …},

{street: "52 Main St.", city: "Boston", …}

]

}

Un client et ses adresses

> db.patrons.find({ _id : “bob” })

{

_id: “bob",

name: “Bob Knowitall",

addresses: [

{street: "1 Vernon St.", city: "Newton", …},

{street: "52 Main St.", city: "Boston", …}

]

}


{

_id: "joe",


address: { street: "123 Fake St. ", city: "Faketon", …}

}

26

Options de migration

• Migrez tous les documents lorsque le schéma est

modifié.

• Migration à la demande

– L'extraction du document d'un client est une

modification.

– Les clients qui ne fréquentent pas la bibliothèque ne

sont jamais mis à jour.

• Ne rien faire

– La couche de code sait utiliser les champs pour une

ou plusieurs adresses

27

Laisser le code traiter les documents

Map d = collection.find(new BasicDBObject(”_id”,”bob”));

// Contract: Return either a List of addresses or a null

// if no addresses exist

// Try to get the new “version 2” shape:

List addrl = (List) d.get(”addresses”);

// If not there, try to get the old one:

if(addrl == null) {

Map oneAddr = (Map) d.get(”address”);

if(oneAddr != null) {

addrl = new List();

addrl.append(oneAddr);

}

}

// addrl either exists with 1 or more items or is null

28

Question :

qui a publié ce livre ?

29

Livre

• MongoDB : le guide absolu,

• par Kristina Chodorow et Mike Dirolf

• Date de publication : 24/09/2010

• Pages : 216

• Langue : anglais

• Éditeur : O’Reilly Media, CA

Livre avec éditeur intégré

> book = db.books.find({ _id : “123” })

{

_id: “123”,


authors: [ "Kristina Chodorow", "Mike Dirolf" ],


pages: 216,


publisher: {


founded: 1980,


}

}

N'oubliez pas la sous-structure !


{

_id: “123”,


authors: [

{ first: "Kristina”, last: “Chodorow” },

{ first: ”Mike”, last: “Dirolf” }

],


pages: 216,


publisher: {


founded: 1980,


}

}

32

Relation un à plusieurs via l'intégration

• Optimisée pour les performances de lecture des livres

• Nous acceptons la duplication de données

• Un index basé sur « publisher.name » permet :

– une recherche efficace de tous les livres du même

éditeur ;

– Une recherche efficace de tous les noms d'éditeurs

(différents).

• Cela ne veut pas dire qu'il n'existe pas de collection

d'éditeurs « principale » (depuis laquelle les données

sont copiées lors de la création d'un livre)

Éditeurs en tant qu'entités distinctes

> publishers = db.publishers.find()

{

_id: “oreilly”,


founded: 1980,


}

{

_id: “penguin”,

name: ”Penguin”,

founded: 1983,

locations: [ ”IL” ]

}

Livre unique avec éditeur associé

> book = db.books.find({ _id: “123” })

{

_id: “123”,

publisher_id: “oreilly”,


…

}

> db.publishers.find({ _id : book.publisher_id })

{

_id: “oreilly”,


founded: 1980,


}

Plusieurs livres avec éditeur associé

db.books.find({ pages: {$gt:100}} ).forEach(function(book) {

// Do whatever you need with the book document, but

// in addition, capture publisher ID uniquely by

// using it as a key in an object (Map)

tmpm[book.publisher.name] = true;

});

uniqueIDs = Object.keys(tmpm); // extract ONLY keys

db.publishers.find({"_id": {"$in": uniqueIDs } });

Produit cartésien = structure de votre choix

resultSet = “select B.name, B.publish_date, P.name, P.founded

from Books B, Publisher P

where P.name = B.publisher_name

and B.pages > 100”

B.Name B.publish_date P.name P.founded

More Jokes 2003 Random House 1843

Perl Tricks 1998 O’Reilly 1980

More Perl 2000 O’Reilly 1980

Starting Perl 1996 O’Reilly 1980

Flying Kites 1980 Random House 1843

Using Perl 2002 O’Reilly 1980

Bad Food 2011 Random House 1843

…Difficile à utiliser sans la clause ORDER BY




and B.pages > 100

order by P.name”;

B.Name B.publish_date P.name P.founded

Perl Tricks 1998 O’Reilly 1980

More Perl 2000 O’Reilly 1980

Using Perl 2002 O’Reilly 1980

Starting Perl 1996 O’Reilly 1980

Flying Kites 1980 Random House 1843

Bad Food 2011 Random House 1843

More Jokes 2003 Random House 1843

SQL repose sur le désassemblage




and B.pages > 100

order by P.name”;

prev_name = null;

while(resultSet.next()) {

if(!resultSet.getString(“P.name”).equals(prevName)) {

// “next” publisher name found. Process material

// accumulated and reset for next items.

makeNewObjects(); //etc.

prev_name = resultSet.getString(“P.name”)

}

}

39

Méthode « one-to-many » avec liaisons

• Optimisée pour une gestion efficace des données

pouvant évoluer

• Méthode familière pour organiser des entités de base

• Le code permet d'assembler des documentations

récupérées dans d'autres objets, et non pas de

désassembler un objet ResultSet unique.

– Il peut être plus simple de coder et de maintenir des requêtes

plus complexes lors d'un assemblage que lors d'un

désassemblage.

40

Question :

Quels sont tous les livres

publiés par un éditeur ?

Éditeur avec des livres associés

> publisher = db.publishers.find({ _id : “oreilly” })

{

_id: “oreilly”,


founded: 1980,

locations: [ "CA“, ”NY” ],

books: [“123”, “456”, “789”, “10112”, …]

}

> books = db.books.find({ _id: { $in : publisher.books } })

42

Question :

Qui sont les auteurs d'un livre

précis ?

Livres avec auteurs associés


{

_id: “123”,


…

authors: [

{ _id: “X12”, first: "Kristina”, last: “Chodorow” },

{ _id: “Y45”, first: ”Mike”, last: “Dirolf” }

],

}

> a2 = book.authors.map(function(r) { return r._id; });

> authors = db.authors.find({ _id : { $in : a2}})

{_id:”X12”,name:{first:"Kristina”,last:”Chodorow”},hometown: …

}

{_id:“Y45”,name:{first:”Mike”,last:”Dirolf”}, hometown: … }

44

Question :

Quels sont tous les livres qu'un

auteur a écrits ?

> db.authors.find({ _id : “X12” })

{

_id: ”X12",

name: { first: "Kristina”, last: “Chodorow” } ,

hometown: "Cincinnati",

books: [ {id: “123”, title : "MongoDB: The Definitive

Guide“ } ]

}

> db.books.find({ _id : “123” })

{

_id: “123”,


…

authors: [



],

}

Double lien entre les livres et les auteurs


{

authors: [



],

}

> db.books.ensureIndex({“authors._id”: 1});

> db.books.find({ “authors._id” : “X12” }).explain();

{

"cursor" : "BtreeCursor authors.id_1",

…

"millis" : 0,

}

Autre approche : Indexation du tableau

47

Comparaison entre intégration et liaison

• Intégration

– Parfait pour les performances de lecture

• « Pages d'accueil » d'applications Web et documentations pré-agrégées

• Structures complexes

– Idéal pour les conceptions immuables ou avec insertion seule

– Les insertions peuvent être plus lentes que les liaisons.

– L'intégrité des données externes (« not-belongs-to ») doit être gérée.

• Liaison

– Flexibilité

– L'intégrité des données est intégrée.

– Le travail est effectué durant les lectures.

• N'implique pas forcément davantage de travail que pour un RDBMS.

48

Question :

Quels sont les attributs

personnalisés pour chaque

auteur ?

> db.authors.find()

{

_id: ”X12",

name: { first: "Kristina”, last: “Chodorow” },

personalData: {

favoritePets: [ “bird”, “dog” ],

awards: [ {name: “Hugo”, when: 1983}, {name: “SSFX”,

when: 1992} ]

}

}

{

_id: ”Y45",

name: { first: ”Mike”, last: “Dirolf” } ,

personalData: {

dob: ISODate(“1970-04-05”)

}

}

Attribuer une structure dynamique à un nom

connu

> db.events.find()

{ type: ”click", ts: ISODate(“2015-03-03T12:34:56.789Z”,

data: { x: 123, y: 625, adId: “AE23A” } }


data: { x: 456, y: 611, adId: “FA213” } }

{ type: ”view", ts: ISODate(“2015-03-03T12:35:04.102Z”,

data: { scn: 2, reset: false, … } }


data: { x: 23, y: 32, adId: “BB512” } }

{ type: ”close", ts: ISODate(“2015-03-03T12:35:08.774Z”,

data: { snc: 2, logout: true, mostRecent: [ … ] } }


data: { x: 881, y: 913, adId: “F430” } }

Polymorphisme : Étude nécessaire

51

Question :

Quels livres traitent des bases

de données ?

Catégories en tant que tableau


{

_id: “123”,


categories: [“MongoDB”, “Databases”, “Programming”]

}

> db.book.ensureIndex({categories:1});

> db.books.find({ categories: “Databases” })

Catégories sous forme de chemin d'accès


{

_id: “123”,


category: “Programming/Databases/MongoDB”

}

> db.books.find({ category: ^Programming/Databases/* })

À venir dans la version 3.2 : la validation de

documents

> db.createCollection("books", { "validator":

{ $and: [

{ "title": {$type: “string”} },

{ "publishDate": {$type: “date”} },

{ $or: [

{ "thumbnail": {$exists: False}},

{ "thumbnail": {$type: “binary”}}

]

}

]

}

});

Validation de documents et schémas légers

> db.createCollection("books", { "validator":

{ $or: [

{ $and: [ { "v": 1},

{ "title": {$type: “string”} }

]

},

{ $and: [ { "v": 2},

{ "title": {$type: “string”} },

{ "publishDate": {$type: “date”} },

{ $or: [

{ "thumbnail": {$exists: False}},

{ "thumbnail": {$type: “binary”}}

]

}

]

}

]

});

56

Résumé

• La conception physique est différente dans MongoDB.

– Les principes de conception de données de base

restent toutefois les mêmes.

• L'important est la méthode employée par une application

pour accéder aux données ou les manipuler.

• La recherche et la capture sont liées aux relations 1:1.

• Utilisez une sous-structure pour améliorer l'alignement

des objets du code.

• Soyez polymorphe !

• Faites évoluer le schéma pour suivre l'évolution des

exigences.

Questions et réponses

Merci

Technology

Retour aux fondamentaux : Penser en termes de documents