MongoDB THE NOSQL DATABASE Készítette: Hugyák Tamás v2.1.1
Fontosabb információk E-mail: hugyak@dev.mik.uni-pannon.hu Weboldal: http://desoft.hu/oktatas/mongodb/tartalom MongoDB weboldala: http://www.mongodb.org/ Query és update selectorok: http://desoft.hu/downloads/mongodb_selectors.pdf
A NoSQL világa...
Igények Mire van szüksége a világnak ma? rövid válaszidők magas rendelkezésre állás nagy mennyiségű adat feldolgozása horizontális skálázhatóság
Skálázhatóság Egy rendszer skálázható, ha: az erőforrásokat növelve a rendszer teljesítménye a hozzáadott erőforrásokkal arányosan nő. A teljesítmény lehet: egyszerre feldolgozható kérések száma, feldolgozott adathalmazok vagy adatelemek mérete, késleltetés, stb. Két fő típusa: vertikális skálázhatóság (scale up): a rendszer kiválasztott elemének bővítése új erőforrással (pl.: processzor, memória) horizontális skálázhatóság (scale out): a rendszer bővítése új számítógéppel (sok olcsó gépből nagy teljesítmény érhető el)
CAP-tétel A tételt 1999-ben Eric Brewer publikálta. A NoSQL rendszerek tervezését befolyásoló egyik legfontosabb eredmény az úgynevezett CAP-tétel, amely az elosztott rendszerek által nyújtott garanciákra ad formális korlátot. Egy elosztott rendszer a CAP rövidítésben szereplő konzisztencia (consistency), rendelkezésre állás (availability) és partíció tolerancia (partition tolerance) tulajdonságok közül egyidejűleg legfeljebb kettőt garantálhat teljesen.
CAP-tétel - konzisztencia Egy elosztott rendszer akkor konzisztens, ha bármely időpillanatban egy adategység értékét bármely csomóponttól lekérdezve ugyanazt az értéket kapjuk. Fontos megjegyezni, hogy az elosztott rendszerek konzisztenciája nem egyezik meg a tranzakciókezelésnél használt ACID tulajdonságokban definiált konzisztenciával, ezért NoSQL-ben az atomi (atomic) kifejezést használják rá. Definíció szerint atomi konzisztencia esetén az elosztott rendszernek külső szemlélő számára úgy kell tűnnie, mintha a műveleteit egy csomóponton sorban egymás után hajtotta volna végre azok átlapolódása nélkül. Ehhez léteznie kell a műveletek egy olyan teljes sorrendezésének, ahol a külső szemlélő számára úgy tűnik, hogy minden művelet egy pillanat alatt végrehajtódott.
CAP-tétel - rendelkezésre állás Egy elosztott rendszer rendelkezésre áll, ha minden működő csomóponthoz érkező kérésre válaszol, tehát a csomópontokon futtatott algoritmusoknak véges idő alatt be kell fejeződniük. A formális definíció nem korlátozza a futási időt, viszont gyakorlati alkalmazások során a késleltetésnek kiemelt szerepe van. A rendelkezésre állás százalékban kifejezhető érték, amely megmutatja, hogy az adott rendszer X időtartamból mekkora Y időtartamban tudott válaszokat szolgáltatni, azaz volt elérhető.
CAP-tétel - partíció tolerancia Egy hálózat egyik csomópontjából a másikba küldött üzenetekből tetszőleges számú elveszhet. Egy nem összefüggő hálózatban a hálózat egyik komponenséből a másikba küldött minden üzenet elveszik. Minden üzenetvesztési szekvencia modellezhető a hálózat ideiglenes partíciójával, majd újraegyesülésvel. A partíció oka lehet a hálózat hibája, valamint a csomópontok hardveres vagy szoftveres hibái. A patíció tolerancia a másik két tulajdonság tükrében értelmezhető: Konzisztencia követelményhez szükséges, hogy a rendszer műveletei akkor is atomiak legyenek, amikor az azokat megvalósító algoritmusok üzeneteiből tetszőleges elveszhet. Rendelkezésre álláshoz azt kell biztosítani, hogy a csomópontok minden, a kliensektől érkező kérésre érvényes választ adjanak annak ellenére, hogy tetszőlegesen sok üzenet elveszhet.
CAP-tétel - partíció tolerancia folyt. Egy rendszer tehát akkor partíció toleráns, ha a kérésre hálózati partíció esetén is helyes választ ad (helyes válasz: a rendszer végrehajtja a kért írást vagy olvasást; a művelet atomicitásának garantálása nem kötelező). Ha egy rendszer nem pratíció toleráns, akkor a hálózat partíciója esetén semmilyen garanciát nem nyújt a konzisztenciára és a rendelkezésre állásra. Amikor a hiba megszűnik, és a partíciók újra egyesülnek, a rendszernek képesnek kell lennie az adatokat szinkronba hozni, hogy megszakítás nélkül folytatható legyen az adatbázis működése. A partíció tolerancia elengedhetetlen a nagyméretű elosztott rendszerekben.
CAP-tétel - példa C+A: A konzisztenciát és a hozzáférhetőséget tartják szem előtt ezek a rendszerek, a hálózat szétesése esetén működésképtelenné válnak. (MySQL, PostgreSQL, MariaDB) A+P: Ezek a rendszerek a lehetőségekhez képest mindig elérhetőek, és jól működnek a hálózat szétesése esetén is, cserébe feladják a konzisztens működést. (Cassandra, CouchDB, Riak) C+P: Konzisztens működés várható el ezektől a rendszerektől, és a hálózat elválása esetén is működnek, de cserébe romlik a hozzáférhetőség. (BigTable, Hbase, MongoDB, Redis)
NoSQL Not only SQL adatbázis szoftverek gyűjtőneve ismérveik: elsősorban nem táblázatokban tárolják az adatokat nem SQL nyelvet használnak lekérdezésre kevés műveletet támogatnak nagyobb sebesség, jobb skálázhatóság ACID működést nem feltétlenül tudnak Mikor használatosak? gyakran módosuló adatszerkezeteknél eltérő entitásokkal rendelkező adatstruktúráknál
NoSQL adatbázisok fajtái 1. kulcs-érték tárolók (key-value stores) kulcsok és hozzájuk rendelt értékek tárolása attribútum-attribútumérték párok a kulcsok szabadon választhatóak vagy adatbázis által generálhatóak legegyszerűbb adatmodell korlátozott lekérdezések: jellemzően csak kulcs szerint adatok tárolása a memóriában -> nagyon gyors működés különbség a cache rendszerekhez képest: az adatokat háttértáron is eltárolják Pl.: Memcached, Redis, Riak, Berkeley DB
NoSQL adatbázisok fajtái 2. oszlopcsaládok oszlopalapú relációs adatbázisok (column-based, column-oriented) egyes attribútumok különböző értékei egy fizikai szervezésben kevés oszlopot és sok sort érintő elemzések hatékonyabbak az egyes csoportokban (blokkokban) azonos típusú adatokat tárolnak oszlopcsaládok (column families) hierarchikus nem relációs adatmodell logikailag oszlopalapon szervezett adatok kulcs-érték párokból álló sorok kulcs -> érték tárolás, ahol kulcs az elsődleges kulcs, míg érték az oszlopnevekkulcsaik párosai Pl.: BigTable, HBase, Cassandra (Facebook)
NoSQL adatbázisok fajtái 2. oszlopcsaládok folytatás... oszlopalapú relációs adatbázisok: oszlopalapú NoSQL adatbázisok (oszlopcsaládok):
NoSQL adatbázisok fajtái 3. dokumentumtárolók (document stores) szemistrukturált adatok (JSON, XML) szemistrukturált (félstrukturált) adatok: Ha az adatok tárolása által meghatározott struktúra nem jól illeszkedik az adatok információtartalma által meghatározott struktúrához. laza módon strukturált adathalmazok tárolása a dokumentumok kulcs-érték párokból épülnek fel a dokumentumok bármilyen strukturával rendelkezhetnek Pl.: CouchDB, MongoDB, Elasticsearch
NoSQL adatbázisok fajtái 4. gráf adatbázisok (graph databases) gráfok hatékony tárolása (komplex, sok összefüggést tartalmazó adathalmazok) gráfokműveletek gyors végrehajtása tulajdonsággráfokat tárolnak: a csomópontokhoz és élekhez tulajdonságok köthetőek, rendszerint kulcs-érték párok formájában kevésbé skálázhatóak a gazdag adatmodell miatt Pl.: Neo4j, Infinite Graph
Mi is az a MongoDB?
Mi is valójában a MongoDB? Egy NoSQL (Not Only SQL), dokumentum-orientált DBMS, mely a relációs és a kulcs-érték alapú adatbázisok legjobb feature-jeit egyesíti. A dokumentum-alapú adatmodell gazdag és hierarchikus adatstruktúrát reprezentál különböző több táblás join-ok végrehajtása nélkül. Az év adatbázisa, 2014. (http://www.db-engines.com)
Mi is valójában a MongoDB? Document Database kulcs-érték alapú, JSON-stílusú adattárolás, mely egyszerű és extrém gyors sokrétű adatstruktúrával rendelkezik flexibilis, dynamic schema, "schemaless" beágyazott dokumentumok és tömbök kulcs-érték alapú lekérdezések, manipulációk, CRUD dokumentumok tárolása "collection"-ben
Mi is valójában a MongoDB? High Performance a beágyazás gyors írást és olvasást tesz lehetővé indexelés bármely attribútumon vagy beágyazott dokumentum attribútumán "fire-and-forget": nincs eredmény az írás (beszúrás, frissítés) sikerességéről adatok a memóriában és a diszken
Mi is valójában a MongoDB? Scalability & High Availability replikáció a szerverek között (master-slave vagy primary-secondary) automatikus failover kezelés load balancing (terheléselosztás) horizontális skálázás aka sharding automatikus "sharding" (az elosztott collection-ök között) lehetővé teszi a cluster skálázását lineárisan (új szerver hozzáadása)
Features Document-Oriented Storage (JSON-style documents) Full Index support (index on any attributes) Replication & High Availability (scalability) Querying (rich, document-based queries) Fast In-Place Updates (atomic modifiers) Map/Reduce (flexible aggregation & data processing) GridFS (store files of any size in database) GeoJSON (coordinates in 2d) Aggregation Framework Ease of use :)
A MongoDB-ről részletesen
Terminológia database table Relációs adatbázisok database collection MongoDB row column index Table joins primary key aggregation document or BSON document field index embedded documents and linking primary key aggregation pipeline
Embedded documents Fajtái: subdocument { "_id" : ObjectId("..."), "name" : { "first" : "Péter", "middle" : "István", "last" : "Kovács }, //... }
Embedded documents array of embedded documents { "_id" : ObjectId("..."), "title : Halálos iramban, release_date : 2009, actors" : [ { name" : Vin Diesel }, { name" : Paul Walker }, { name" : Michelle Rodriguez }, ], //... }
MongoDB főbb komponensei mongod: adatbázis szerver, kezeli az adat kéréseket (CRUD) és adatformákat, ill. a háttérfolyamatokat menedzseli mongo: adatbázis kliens, interaktív JavaScript shell a MongoDB számára, lehetővé teszi az adatok lekérdezését és manipulációját, ill. szerver oldali szkriptelést mongodump: adatbázis adatok exportálása bináris fájlba mongorestore: bináris adatbázis adatok importálása mongoexport: az adatbázisban tárolt adatok exportálása JSON vagy CSV formátumban mongoimport: lehetővé teszi JSON, CSV vagy TSV fájlok importálását az adatbázisba
Exportálás, importálás JSON, CSV, TSV: mongoimport --db <db_name> --collection <coll_name> --file <file_path> mongoexport --db <db_name> --collection <coll_name> --out <file_name> Binary files: mongorestore --db <db_name> --collection <coll_name> <file_name> mongodump --db <db_name> --collection <coll_name>
Adattípusok double: 23.8 integer: 69 string: "Hello World" object: {"name" : "Zoltán"} array: [ ] Object id (MongoID): ObjectId("507f1f77bcf86cd799439011") boolean: true, false date: new Date('Jun 23, 1954') vagy ISODate() NULL: null undefined regular expression: /^a.*$/i
Példa dokumentum { "_id": ObjectID("4bd9e8e17cefd644108961bb"), "title": "Adventures in Databases", "url": "http://example.com/databases.txt", "author": "msmith", "tags": ["databases", "mongodb", "indexing"], "comments": [ { "user": "bjones", "text": "Interesting article!" }, { "user": "blogger", "text": "Another related article is at..." } ] } ObjectID avagy MongoID
MongoID 12 bájt hosszú, 24 karakter automatikusan generálódik alapértelmezetten minden egyes dokumentumnál az _id mezőt képezi, automatikusan generálódik dokumentum beszúrásakor primary key (elsődleges kulcs) unique (minden egyes érték csak egyszer fordulhat elő) indexelt (gyors elérés) létrehozása: new ObjectId() => automatikusan generálja az értékét érték kinyerése (2.2-es verzió óta): objidvaltozo.valueof() => "507f1f77bcf86cd799439011"
MongoDB a gyakorlatban
MongoDB letöltése http://www.mongodb.org/downloads
Alapvető shell parancsok show dbs (adatbázisok kilistázása) use <db_name> (<db_name> nevezetű adatbázisba belépés vagy <db_name> nevezetű adatbázis létrehozása) show collections (collection-ök kilistázása az aktuális adatbázisban) db (az aktuális adatbázis nevének kiiratása) db.<collection>.* (* lekérdezés vagy CRUD futtatása a <collection> nevezetű collection-ön) pl.: db.users.find() db.createcollection("<coll_name>") (<coll_name> nevezetű collection létrehozása az aktuális adatbázisba) db.<collection>.drop() (<collection> törlése) help exit (kilépés)
CRUD
CRUD Az adattárolás 4 alapvető műveletének összefoglaló neve. Create (írás) Read (olvasás) Update (frissítés) Delete (törlés)
CRUD - Create db.<collection>.insert( <document> ) a <document> egy JSON dokumentum vagy egy tömb, mely JSON dokumentumokat tartalmaz a "_id" ObjectId-t nem kötelező megadni, automatikusan generálja az adatbázis példa: db.products.insert({ "item" : "pen", "qty" : 50 }); db.products.insert([ { "item" : "pen", qty" : 50 }, { "item" : "eraser", "qty" : 100 }, { "item" : "pencil", "qty" : 20 } ]); ha nem ObjectId elsődleges kulcsot szeretnénk: db.products.insert({ "_id" : 15, "item" : "pen", "qty" : 50 });
CRUD - Read db.<collection>.find( <criteria>, <projection> ) <criteria>: opcionális, ha nincs megadva, akkor a collection összes dokumentumát visszaadja, az SQL-es WHERE feltételnek felel meg egy JSON tömböt kell megadni feltételnek, melyre az összes megadott mező-érték párra illeszkedő doc-okat szűri ki eredményül cursor-t ad vissza példa: db.users.find({ "first_name" : "Péter", "age" : 18}); // az összes olyan JSON objektumot szolgáltatja vissza, // ahol a keresztnév "Péter" ÉS a kor 18 db.users.find({}); // a collection összes felhasználóját adja vissza
CRUD - Read Query Selectors $gt: > {"age" : {'$gt' : 18}} $gte: >= $in: minden egyes érték szerepel a tömbben, {"field" : {'$in' : [<value1>, <value2>,...]}} $lt: < $lte: <= $ne:!= {"qty" : {'$ne' : 300}} $nin: a megadott értékek nem szerepelnek a tömbben, {"age" : {'$nin' : [5, 15] }} $in: a megadott érték(ek) szerepel(nek) a tömbben, { likes" : { $in' : [ futni"] }} $or: a tömbben megadott elemek legalább egyike illeszkedik a doc megfelelő mezőinek értékére, {'$or' : [ {"qty" : {'$lt' : 20}}, {"sale" : true} ]} $and: a tömbben megadott összes elemre illeszkedik a doc megfelelő mezőinek értékei, {'$and' : [ {"qty" : {'$lt' : 20}}, {"sale" : true} ]}
CRUD - Read Projection: db.<collection>.find( <criteria>, <projection> ) az adott doc-nak vagy doc-oknak mely mezőit adja vissza SQL-ben a SELECT záradéknak felel meg 1 vagy true: csak a megadott mezőt vagy mezőket adja vissza az _id attribútummal 0 vagy false: a megadott mezőt vagy mezőket nem tartalmazva adja vissza az adatokat példa: db.user.find({"age" : 20}, {"email" : 1, "name" : true}); // eredmény: { "_ id" : ObjectId(...), "email" : "jani@freemail.hu", "name" : "Jani" }
CRUD - Read Cursor iterátornak tekinthető, a visszaadott dokumentumok bejárására szolgál pl.: var users = db.users.find(), user ; while( users.hasnext() ){ user = users.next(); print("kor: " + user.age); } db.users.find().foreach( function( doc ) { print("név: " + doc.name); } );
CRUD - Read db.<collection>.findone( <criteria>, <projection> ) csak egy JSON objektumot ad vissza eredményül több találat esetén a legelsőt szolgáltatja vissza pl.: db.users.findone({"email " : "tamas.hugyak@outlook.com"}, {"name" : 1});
CRUD - Read db.<collection>.count( <criteria> ) A megszámlálás függvénye. a <criteria>-nak megfelelő doc-ok számát adja vissza pl.: db.users.count({"age" : 21}); // => 3
CRUD - Read sort( <sort> ) <sort>: JSON doc, melyben a megadott mezők a rendezés alapját adják, az érték pedig a rendezés módját, mely lehet A-Z vagy Z-A a find() függvény meghívása után használjuk, cursor függvény { "field" : 1 }: ASC rendezés, ascending { "field" : -1 }: DESC rendezés, descending pl.: db.users.find({"age" : {$gt : 18}}).sort( { " name.first" : 1, "age" : -1} );
CRUD - Read limit( <value> ) <value>: egy integer érték, mely azt adja meg, hogy hány eredmény dokumentumot adjon vissza a lekérdezés pl.: db.users.find({"age" : {$gt : 18}}).limit( 5 ); // csak az első 5 user-t adja vissza
CRUD - Read skip( <value> ) <value>: egy integer érték, melynek megfelelő első <value> dokumentumot nem adja vissza eredményül lapozáshoz használjuk pl.: db.users.find(). skip( 5 ). limit( 15 ); // 15 felhasználót listáz ki az 5-től
CRUD - Update db.<collection>.update( <criteria>, <update>, <params> ) a <criteria>-nak megfelelő doc-ot vagy doc-okat frissíti az <update> JSON-ban megadott adatokkal <criteria>: opcionális, lehet {} is Alapértelmezetten csak az első kritéria találatot frissíti!!! <params>: { "upsert" : true } esetén ha nincs találat a keresett kritériára, akkor egy új doc-ot szúr be a collection-be { "multi" : true } esetén az összes kritériának megfelelő doc-ot frissít az adatbázis pl.: db.users.update( {"age" : 18}, {'$inc' : {"points" : 1}}, {"multi" : true} )
CRUD - Update Update Operators $inc: megnöveli vagy csökkenti az adott mezőt, { $inc : { "points" : -5 } } $set: adott mező értékét módosítja, { $set : { "name" : "Julcsi" } } $unset: adott mezőt vagy mezőket törli a dokumentumból, { $unset : { " name" : "", "gender" : "" } $pull: a megadott mezőt vagy mezőket törli a tömbből, { $pull : { "votes" : 7 } } $push: a megadott értéket a tömbbe helyezi, { $push : { "scores" : 89 } } $: a kritériának megfelelő doc-ok embedded array első elemét módosítja, { $set : { "grades.$" : 82 } }
CRUD - Delete db.<collection>.remove( <criteria>, <justone> ) a <criteria>-nak megfelelő doc-ot vagy doc-okat törli a collection-ből <criteria>: opcionális, JSON object <justone>: opcionális, ha 1 vagy true az értéke, akkor csak a kritériának megfelelő legelső találatot törli pl.: db.users.remove( { "name.first" : /^G/ } ) // ahol a name embedded JSON first mezőjének értéke G betűvel kezdődik
Példa feladatok Kérdezd le az összes, 18 éves vagy annál idősebb felhasználót. db.users.find({ "age" : { $gte : 18 } }) Kérdezd le az összes olyan kutyát, amely hímnemű és a neve B betűvel kezdődik. db.dogs.find({ "gender" : "male", "name" : /^B/ }) Kérdezd le az összes olyan felhasználót, akinek van Cirmi nevezetű macskája. (user obj.: {..., "cats" : ["Cirmi","Mirci"],...}) db.users.find({ "cats" : { $in : ["Cirmi"] } }) Kérdezd le azoknak a felhasználóknak a nevét, akik nem szeretik a csokit.(user obj.: {..., "likes" : ["csoki","mozi"],...}) db.users.find({ "likes" : { $nin: ["chocolate"] } }, { "name" : 1 }) Kérdezd le az első három legtöbbet eladott termék árát és nevét. db.products.find({},{ "name" : 1, "price" : 1 }). sort({ "sales" : -1 }).limit( 3 )
Példa feladatok Kérdezd le azon egereket, melyeknek a genotípusa X35K86-os vagy a szemük színe piros. db.mice.find({ $or : [ { "genotype" : "X35K86" }, { "eye_color" : "red" } ] }) Kérdezd le azt az elemet, melynek az azonosítója: 507f1f77bcf86cd799439011 és az azonosítóján kívül kérd le az összes mezőjét. db.items.findone({ "_id " : ObjectId("507f1f77bcf86cd799439011") }, { "_id" : 0 }) Minden 1992-ben született felhasználónak növeld meg a pontszámát 3-mal. db.users.update({ "birth.year" : 1992 }, { $inc : { "points" : 3 } }, { "multi" : true } ) Módosítsd az ffgaba@gmail.com e-mail című felhasználó jogosultságát adminra, nullázd le a pontjait és hagyj neki üzenetet, hogy: "Admin vagy!". db.users.update( { "email" : "ffgaba@gmail.com" }, { $set : { "role" : "admin", "points" : 0 }, $push : { "messages" : [ "Admin vagy!" ] } } )
Példa feladatok Növeld meg Magyarországon Veszprém megye lakosainak számát 13 fővel a születések száma miatt. db.countries.update( { "country_name" : "Magyarország", "counties.county_name" : "Veszprém" }, { $inc : { "counties.$.population" : 13 } } ) Hány 1992-ben született férfi felhasználó szereti a kézilabdát? db.users.count({ "birth.year" : 1992, "gender": "male", "likes" :{ $in : [ "handball" ] } }) Töröld ki az összes inaktív felhasználói fiókot az adatbázisból. db.users.remove({ "active" : false }) Töröld ki az összes spam üzenetet a spam_messages collection-ből. db.spam_messages.remove()
Group by
Group by db.data.group({ key: { Airport : 1 }, cond: { Temperature : { $gt : 30 } }, reduce: function( curr, result ) { result.total++; }, initial: { total : 0 } }); SELECT Airport, COUNT(*) as total FROM data WHERE Temperature > 30 GROUP BY Airport;
Adatmodellezés
Adatmodellezés flexibilis séma -> dokumentum szerkezeteket nem írjuk le kulcs koncepciók: az alkalmazásnak mire van szüksége adatbázis motor teljesítmény karakterisztikája adatelérési minták alkalmazás adathasználata (queries, updates) dokumentum struktúra: az alkalmazás hogyan reprezentálja az adatok közti kapcsolatokat adatok közti kapcsolatok reprezentálásának 2 fajtája: referenciák (references) beágyazott dokumentumok (embedded documents)
Embedded data a kapcsolatok egyetlen egy dokumentumban tárolhatóak denormalizált adatmodell: egyetlen egy adatbázis műveletként lehetővé teszi az összefüggő adatok lekérdezését és manipulációját lehetővé teszi, hogy az összetartozó információ darabkák ugyanazon adatbázis rekordban legyenek tárolva a dokumentumok írása (módosítása) egyetlen egy atomi művelet dokumentumok növekedése: ha a lemezen tárolt dokumentum módosításkor a számára lefoglalt tárterületet túllépi, akkor a háttértáron a MongoDB új helyet foglal a számára, s az előző pozícióját felszabadítja adathasználat és teljesítmény: gyakori adatbeszúrás (insert) esetén ajánlott a capped collection a beágyazás olvasás esetén jobb teljesítményt nyújt
Adatmodellezés beágyazással denormalizált adatmodell
References a normalizált adatmodellek referenciák segítségével írják le a dokumentumok közötti kapcsolatokat akkor használatos, ha: a beágyazás adat-duplikációt eredményezne, így nem szolgál az olvasás művelet előnyére komplex sok-sok kapcsolat reprezentálása hatalmas hierarchikus adathalmazok elkerülése érdekében nagyobb flexibilitást nyújtanak a beágyazásokhoz képest hátránya, hogy a lekérdezések és manipulációk több adatbázis műveletet igényelnek
Adatmodellezés referenciával normalizált adatmodell
One-to-One relationships Beágyazással: { } _id: "joe", name: "Joe Bookreader", address: { street: "123 Fake Street, city: "Faketon", state: "MA", zip: "12345 }
One-to-Many relationships I. Beágyazással: { } _id: "joe", name: "Joe Bookreader", addresses: [ { street: "123 Fake Street", city: "Faketon", state: "MA", zip: "12345 }, { street: "1 Some Other Street", city: "Boston", state: "MA", zip: "12345 } ]
One-to-Many relationships II. Referenciával: { name: "O'Reilly Media", founded: 1980, location: "CA", books: [12346789, 234567890,...] } { { _id: 123456789, title: "MongoDB: The Definitive Guide", author: [ "Kristina Chodorow", "Mike Dirolf" ] } _id: 234567890, title: "50 Tips and Tricks for MongoDB Developer", author: "Kristina Chodorow }
Many-to-Many relationships Kapcsoló collection-nel: felhasznalok collection egy dokumentuma: { _id : ObjectId( A ), nev : Eleonóra, taj : AAABBB111, } autok collection egy dokumentuma: { _id : ObjectId( 123 ), tipus : M6, gyarto : BMW, szin : fehér } felhasznalok autok kapcsoló collection egy dokumentuma: { _id : ObjectId( 4af9f23d8ead0e1d32000000 ), _id felhasznalo : ObjectId( A ), _id auto : ObjectId( 123 ) }
Indexelés
Indexelés lekérdezések hatékony végrehajtása indexelés nélkül: collection scan (a collection összes dokumentumának átfésülése) az indexek B-fa struktúrát használnak a collection adathalmazának kis porcióját tartalmazzák valamely mezőnek vagy mezőknek az értékét tárolja, a mező értéke alapján rendezett módon covered query: ha a kritéria és a projekció csakis az indexelt mező(ke)t tartalmazza, akkor az eredmény az index-ből kerül ki, nem lesz keresés (find)
Indexelés működése
Indexek típusai _id single field (embedded field, embedded document) compound index (multiple fields) multikey index (arrays) geospatial index (geo koordináták) text index Indexek tulajdonságai: unique (duplikált értékek nem fordulhatnak elő) sparse (csak azon doc-ok indexelése, melyek rendelkeznek az indexelt mezővel) TTL (doc-ok automatikus törlése a collection a megadott idő letelte után)
Indexek típusai Multikey index
Indexek típusai Compound index
Index létrehozása db.<collection>.createindex( <attributes>, <options> ) <attributes>: JSON, melyben az attribútum-rendezés kulcs-értékek vannak felsorolva egyszerre akár több attribútum is megadható ertékként az 1 (ASC) vagy a -1 (DESC) adható options JSON: {sparse : true} : csak azon dokumentumokat indexeli, amelyek rendelkeznek az <attributes>-ban megadott attribútumokkal {expireafterseconds : <secs>} : a megadott másodperc letelte után automatikusan törlődnek a dokumentumok a collection-ből {unique : true} : az <attributes>-ban megadott kulcsok értékei csakis egyediek lehetnek (alapértelmezetten false az értéke)
Index törlése db.<collection>.dropindex( <attributes> ) <attributes>: JSON, melyben az indexelt attribútumok vannak felsorolva a sorrendbe rendezésük típusával együtt
Indexek létrehozása Példák: db.cars.createindex( { gyarto : 1 } ); db.users.createindex( { name.first : 1 } ); db.users.createindex( { taj : 1, szuletesi_datum : -1 } ); db.users.createindex( { email : 1 }, { unique : true } );
Aggregation Framework
Aggregation Framework aggregációk: olyan műveletek, amelyek az adatokon valamilyen folyamatot hajtanak végre, majd visszaadja a számított eredményt. Aggregation Pipeline: a dokumentumok több szakaszú csővezetéken mennek keresztül, amelyben aggregált eredménnyé transzformálódnak alapvető szakaszai: filters: lekérdezésekként működnek document transformations: módosítják a kimeneti dokumentumok formáját a gazdag adat aggregáció natív műveletekkel hajtódik végre Map-Reduce is a része az Aggregation Framework-nek
Működése
Aggregation Pipeline Map-Reduce alternatívaként szolgál az aggregációs feladatokat hivatott megoldani abban az esetben, ha a mapreduce számára túl komplexek lennének szakaszokból épül fel -> minden egyes szakasz transzformálja a rajta átmenő dokumentumokat a szakaszok mindig csak az aktuális dokumentumhoz férnek hozzá optimalizálási szakasszal is rendelkezik, mely megkísérli átalakítani a pipeline-t a jobb teljesítmény érdekében eredményül egy szimpla dokumentumot ad, mely hibaleírást és az eredményt tartalmazza (16MB méret korlát!!)
Aggregation Pipeline használata db.<collection>.aggregate( [ { <stage1> }, { <stage2> },... ] ) szakaszok: $project: projekcióként szolgál (1 vagy -1 érték) $match: a find()-nál megszokott kritéria, szűrést valósít meg $redact: különleges állatfajzat, említésre méltó csak jelen esetben $limit, $skip: darabszám limitálása, kihagyása $unwind: tömbökbe beágyazott dokumentumok külön dokumentumokként való megjelenítése $group: csoportosítást valósít meg $sort: újrarendezi a dokumentum streamet adott kulcs alapján $out: ezzel a névvel egy új collection-t hoz létre, s ebbe helyezi az eredményt
Hasznos információk dokumentáció: http://docs.mongodb.org/manual GUI Mongohoz: www.robomongo.org Node.JS alapon webes GUI MongoDB-hez: www.github.com/andzdroid/mongo-express cheatsheet: www.mongodb.com/datasheets e-learning: http://www.tutorialspoint.com/mongodb/index.htm