tajti ákos c és java blogja

a nosql mozgalomról szóló bejegyzésben írtam pár változatról: melyik miben tér el a hagyományos relációs adatbázisoktól és miért jobb, mint azok. már akkor is említettem, hogy a dokumentum-orientált adatbázisok gyorsan a kedvenceimmé váltak. nem csak az ragadott meg bennük, hogy rendkívül rugalmasak, de a map/reduce lekérdezéseket is nagyon izgalmasnak találom. közülük a mongodb-ről fogok írni ebben a postban. nem tudok mindenre kitérni, mivel abból egy hatalmas post születne, viszont amit lényegesnek találok, arról szót ejtek. az online dokumentáció szerencsére rengeteg példát és más segítséget ad.

a dokumentum-orientált adatbázisok dokumentumokkal dolgoznak. egy dokumentum nagyjából egy relációs adatbázisbeli sornak felel meg. a legfontosabb különbség az, hogy az egy "táblához" tartozó dokumentumok eltérő szerkezetűek lehetnek. igazából a szerkezetet előre le sem kell írnunk. csak dokumentumokat készítünk, amiket elhelyezünk az adatbázisban. az egyikben akár teljesen eltérő mezők is szerepelhetnek, mint a másikban. nincsenek szabályok. ez az igazi rugalmasság.

a mongodbnél a dokumentumok BSON formátumban élnek, ami nagyon hasonló a JSON-hoz, csak pár dologgal tud többet (ráadásul binárisan tárolódik).

természetesen kell valami, ami a logikailag egy helyre tartozó dokumentumokat összefogja. hagyományos adatbázisokban ez a tábla, a mongodb viszont collection-nek nevezi ezt a szerkezetet. ezeken a kollekciókon hajthatjuk végre a szokásos műveleteket: dokumentum hozzáadása, törlése, keresése; dokumentumok leválogatása, csoportosítás, map/reduce stb. hogy teljes legyen a kép, a kollekciók adatbázisokba vannak szervezve. a mongodb telepítése után rögtön kapunk is belőlük kettőt: a local és az admin nevűeket.

a java drivert innen tudjátok letölteni. bár javascriptben sok esetben egyszerűbben megírható a kód, azért így sem vészesen bonyolult a helyzet. ráadásul sokszor a javascript kódot el lehet tárolni magában a dbben, vagy ha ez jobban tetszik, ott van még a rhino, mint megoldás. most pedig jöjjön a kód!

ahhoz, hogy bármit is tudjunk kezdeni a mongodbvel csatlakoznunk kell hozzá. ehhez nem kell más, csak egy Mongo objektum:

  Mongo mongo = new Mongo("localhost", 27017);

ahogy szokás, létre kell hoznunk egy kollekciót is, ahová a dokumentumokat pakolhatjuk:

  
  DB db = mongo.getDB("local"); 
  db.createCollection("test", null);

a fenti két sor létrehozza a test kollekciót a local adatbázisban.

a dokumentumokat  a BSONObject interfész reprezentálja. ez, ahogy a BSON formátumból adódik, egy Map-szerű megoldás: egy dokumentum kulcs-érték párokból áll. a BSONObjectnek számos implementációja létezik, például a BasicDBObject. ehhez, ahogy egy Map-nél megszokhattuk, a put() metódussal pakolhatunk kulcs-érték párokat. Az egyszerűség kedvéért a példákban a Person osztályt fogom használni, ami kiterjeszti a BasicDbObject-et (és példányosításkor megfelelően fel is tölti magát minden objektum).

egy dokumentumot elmenteni az insert metódussal tudunk:

  collection.insert(new Person("béla", 26, "Budapest"));

ezzel a neki megfelelő dokumentum bekerül a kollekcióba. a beszúrás tehát nagyon egyszerű. a lekérdezések ennél már sokkal érdekesebbek. az első lehetőség a find() metódus. paraméter nélkül meghívva a kollekció összes dokumentumát visszakapjuk. ha kicsit szűkíteni szeretnénk a kört, akkor adhatunk meg feltételt, amit egy DBObject objektummal írhatunk le map szerűen. ha például az összes olyan dokumentumot szeretnénk látni, amben szerepel age mező és az értéke kisebb, mint 41, akkor a feltétel így néz ki:

  BasicDBObject query = new BasicDBObject("age", new BasicDBObject("$lt", 41));

már ebből a példából is látszik, hogy van néhány beépített operátor, amit a mongodb lekérdezésekben használhatunk. hogy mik ezek, arról a dokumentáció részletesen mesél.

egy másik, sokkal érdekes lehetőség a dokumentumok felhasználására a map/reduce. ennél a módszernél a lekérdezést két függvénnyel végezzük. az első a map függvény. ez a kollekció minden dokumentumára meghívódik és ezek közül valamennyit (például egy feltétel alapján) leképez kulcs-érték párokra. az érték itt bármi lehet, akár a teljes objektum is. a leképezés a mongodb esetében úgy történik, hogy az emit() függvénnyel előálíltjuk a párt.

a második a reduce függvény. ez akár hiányozhat is, ekkor egy szokványos lekérdezésről van szó. a redukáló függvényt működését úgy a legegyszerűbb elképzelni, hogy annyiszor hívódik meg, ahány különböző kulcsot előállítottunk az emit() függvénnyel. az azonos kulcsokhoz tartozó értékek összegyűlnek egy tömbbe és ez lesz a reduce függvény paramétere. persze ennél a valóságban bonyolultabb lehet a helyzet, hiszen egyáltalán nem biztos, hogy a tömb egyben adódik át a reduce függvénynek. az is megeshet, hogy darabokban, több hívás alatt kerül feldolgozásra.

erre az egészre, amit fent leírtam, van egy egyszerű példám. tegyük fel, hogy össze akarjuk adni az adatbázisban szereplő 23 évnél fiatalabb és 23 évnél idősebb személyek korát. ehhez először szükségünk van egy olyan map függvényre, ami valahogyan szétválasztja a két csoportot. egy megoldás az alábbi:

function() {
 if (this.age <= 23){
   emit(1, this.age); 
 } else {
   emit(2, this.age);
 } 
}

tehát egyes kulccsal szerepelnek az eredményben a fiatalabbak, kettessel az idősebbek. a reduce függvénynek ezután ezzel kell dolgoznia. a megoldás az alábbi:

function(key, values) { 
	var sum = 0;
	for (var i = 0; i < values.length; i++){ 
		sum += values[i]; 
	}
	return sum; 
} 

a függvénynek két paramétere van. az első a kulcs, a második a hozzá tartozó értékek tömbje. innen már egyszerű, hogy mi történik pontosan.

mongodb-ben a kollekció mapReduce() metódusával tudunk ilyesmit csinálni. a szépséghiba az egészben az, hogy a függvényeket javascriptben kell megírnunk (ahogy azt már fönt említettem).

a mongodb-ről sokkal többet lehetne még írni, én ezeket találtam a legérdekesebbnek. érdemes a dokumentációban elmélyedni kicsit, illetve a különböző nosql adatbázisoknak utánanézni sem fölösleges. most ugyanis nagyon úgy látszik (legalábbis én úgy látom), hogy a rugalmas, nagy terhelésnek kitett alkalmazásoknál ez az egyetlen járható út hosszútávon.