Czy framework Mongodb Aggregation jest szybszy niż map/reduce?

Question

Czy struktura agregacyjna wprowadzona w mongodb 2.2, ma jakieś specjalne ulepszenia wydajności w stosunku do mapy/zmniejszenia?

Jeśli tak, dlaczego i jak i ile?

(Już mam zrobić test dla siebie, a wydajność była prawie taka sama)

Answer 1

Każda próba osobiście mam uruchomić (w tym przy użyciu własnych danych) pokazuje strukturę agregacji będącą multipliksem e szybciej niż mapa zmniejsza się i zwykle jest o rząd wielkości szybszy.

Biorąc tylko 1/10 danych, które wysłałeś (ale zamiast wyczyścić pamięć podręczną systemu operacyjnego, najpierw podgrzewając pamięć podręczną - ponieważ chcę mierzyć wydajność agregacji, a nie jak długo zajmuje strona w danych) got to:

MapReduce: 1,058ms
Aggregation Framework: 133ms

Zdejmowanie $ mecz z ram agregacji i {query:} z mapreduce (ponieważ zarówno po prostu użyć indeksu, a nie to, co chcemy do pomiaru) i zgrupowanie całego zestawu danych kluczem 2 Mam:

mapreduce: 18,803ms
Agregacja ramowa: 1,535ms

Są to w dużej mierze zgodne z moich wcześniejszych doświadczeń.

Answer 2

Moja odniesienia:

== Generation Dane ==

Generowanie 4million wiersze (z pytona) łatwo z około 350 bajtami. Każdy dokument posiada następujące klawisze:

• key1, Klawisz2 (dwa losowe kolumny do testowania indeksowanie, jeden z liczności 2000, a jeden z liczności 20)
• longdata: długi ciąg, aby zwiększyć rozmiar każdego udokumentować
• wartość: prosty numer (const 10) do testowania agregacji

 
db = Connection('127.0.0.1').test # mongo connection 
random.seed(1) 
for _ in range(2): 
    key1s = [hexlify(os.urandom(10)).decode('ascii') for _ in range(10)] 
    key2s = [hexlify(os.urandom(10)).decode('ascii') for _ in range(1000)] 
    baddata = 'some long date ' + '*' * 300 
    for i in range(2000): 
     data_list = [{ 
       'key1': random.choice(key1s), 
       'key2': random.choice(key2s), 
       'baddata': baddata, 
       'value': 10, 
       } for _ in range(1000)] 
     for data in data_list: 
      db.testtable.save(data) 

Całkowita wielkość wynosiła około 6 GB danych w Mongo. (I 2GB w PostgreSQL)

== Testy ==

Zrobiłem kilka testów, ale wystarczy do wyników porównujących:

UWAGA: Serwer zostanie ponownie uruchomiony, a OS cache jest czyszczony po każde zapytanie, aby zignorować efekt buforowania.

zapytania: kruszywa wszystkie wiersze z key1=somevalue (około 200K wiersze) i sumują value dla każdego key2

• mapę/zmniejszenia 10,6 s
• aggreate 9,7 s
• grupę 10,3 s

zapytania:

mapa/zmniejszenie:

db.testtable.mapReduce(function(){emit(this.key2, this.value);}, function(key, values){var i =0; values.forEach(function(v){i+=v;}); return i; } , {out:{inline: 1}, query: {key1: '663969462d2ec0a5fc34'} })

łączna:

db.testtable.aggregate({ $match: {key1: '663969462d2ec0a5fc34'}}, {$group: {_id: '$key2', pop: {$sum: '$value'}} })

grupa:

db.testtable.group({key: {key2:1}, cond: {key1: '663969462d2ec0a5fc34'}, reduce: function(obj,prev) { prev.csum += obj.value; }, initial: { csum: 0 } })