Średnia liczba zapytań o agregację w Meteoru

Question

Ok, wciąż w mojej aplikacji z zabawkami, chcę dowiedzieć się, jaki jest średni przebieg w grupie odometrów właścicieli samochodów. Jest to dość łatwe dla klienta, ale nie skaluje się. Dobrze? Ale na serwerze nie wiem dokładnie, jak to osiągnąć.

Pytania:

1. Jak wdrożyć coś na serwerze następnie używać go na kliencie?
2. Jak wykorzystać funkcję agregacji $ avg mongo do zoptymalizowania funkcji agregacji?
3. Lub alternatywnie (2) jak zrobić mapę/zmniejszyć na serwerze i udostępnić ją klientowi?

Sugestia przez @HubertOG było wykorzystanie Meteor.call, co ma sens i zrobiłem tak:

# Client side 
Template.mileage.average_miles = -> 
    answer = null 
    Meteor.call "average_mileage", (error, result) -> 
    console.log "got average mileage result #{result}" 
    answer = result 
    console.log "but wait, answer = #{answer}" 
    answer 

# Server side 
Meteor.methods average_mileage: -> 
    console.log "server mileage called" 
    total = count = 0 
    r = Mileage.find({}).forEach (mileage) -> 
    total += mileage.mileage 
    count += 1 
    console.log "server about to return #{total/count}" 
    total/count 

To wydaje się działać dobrze, ale to nie dlatego, że tak blisko jak ja można powiedzieć, że Meteor.call jest połączeniem asynchronicznym, a answer zawsze będzie zwracanym zerem. Obsługa rzeczy na serwerze wydaje się dość powszechnym przypadkiem użycia, który musiałam przeoczyć. Co by to było?

Dzięki!

Answer 1

Od wersji Meteor 0.6.5 interfejs API kolekcji nie obsługuje zapytań o agregację, ponieważ nie ma (prostego) sposobu aktualizowania na bieżąco. Jednak nadal możesz je napisać samodzielnie i udostępnić je w postaci Meteor.publish, chociaż wynik będzie statyczny. Moim zdaniem, robienie tego w ten sposób jest jeszcze lepsze, ponieważ można łączyć wiele agregacji i korzystać z interfejsu API po stronie klienta.

Meteor.publish("someAggregation", function (args) { 
    var sub = this; 
    // This works for Meteor 0.6.5 
    var db = MongoInternals.defaultRemoteCollectionDriver().mongo.db; 

    // Your arguments to Mongo's aggregation. Make these however you want. 
    var pipeline = [ 
     { $match: doSomethingWith(args) }, 
     { $group: { 
      _id: whatWeAreGroupingWith(args), 
      count: { $sum: 1 } 
     }} 
    ]; 

    db.collection("server_collection_name").aggregate(  
     pipeline, 
     // Need to wrap the callback so it gets called in a Fiber. 
     Meteor.bindEnvironment(
      function(err, result) { 
       // Add each of the results to the subscription. 
       _.each(result, function(e) { 
        // Generate a random disposable id for aggregated documents 
        sub.added("client_collection_name", Random.id(), { 
         key: e._id.somethingOfInterest,       
         count: e.count 
        }); 
       }); 
       sub.ready(); 
      }, 
      function(error) { 
       Meteor._debug("Error doing aggregation: " + error); 
      } 
     ) 
    ); 
}); 

Powyższe jest przykładową agregacją grupowania/liczenia. Niektóre rzeczy uwaga:

• Kiedy to zrobisz, będziesz naturalnie robić agregacji na server_collection_name i pchania wyniki do innej kolekcji o nazwie client_collection_name.
• Ta subskrypcja nie będzie dostępna i prawdopodobnie zostanie zaktualizowana po zmianie argumentów, więc używamy naprawdę prostej pętli, która wypycha wszystkie wyniki.
• Wyniki agregacji nie mają identyfikatorów obiektów Mongo, więc generujemy kilka własnych.
• Oddzwonienie do agregacji musi być opakowane w Fibre. Używam tutaj Meteor.bindEnvironment, ale można również użyć Future, aby uzyskać więcej kontroli niskiego poziomu.

Jeśli zaczniesz łączyć wyniki takich publikacji, musisz dokładnie rozważyć, w jaki sposób losowo wygenerowane identyfikatory wpływają na pole scalania.Jednak prosta implementacja tego jest tylko standardową kwerendą bazy danych, z tą różnicą, że jest wygodniejsza w korzystaniu z interfejsów API Meteor po stronie klienta.

TL; DR wersja: Prawie zawsze, gdy pchają się od danych z serwerem, publish jest stosowniejsze method.

Aby uzyskać więcej informacji na temat różnych sposobów wykonywania agregacji, check out this post.

Answer 2

Możesz użyć do tego Meteor.methods.

// server 
Meteor.methods({ 
    average: function() { 
    ... 
    return something; 
    }, 

}); 

// client 

var _avg = {      /* Create an object to store value and dependency */ 
    dep: new Deps.Dependency(); 
}; 

Template.mileage.rendered = function() { 
    _avg.init = true; 
}; 

Template.mileage.averageMiles = function() { 
    _avg.dep.depend();    /* Make the function rerun when _avg.dep is touched */ 
    if(_avg.init) {     /* Fetch the value from the server if not yet done */ 
    _avg.init = false; 
    Meteor.call('average', function(error, result) { 
     _avg.val = result; 
     _avg.dep.changed();   /* Rerun the helper */ 
    }); 
    } 
    return _avg.val; 
}); 

Answer 3

Jeśli chcesz reaktywności, użyj Meteor.publish zamiast Meteor.call. Jest taki przykład w docs, gdzie publikują liczbę wiadomości w danym pomieszczeniu (tuż nad dokumentacją dla this.userId), powinieneś być w stanie zrobić coś podobnego.

Answer 4

Zrobiłem to metodą "agregatu". (Wersja 0.7.x)

if(Meteor.isServer){ 
Future = Npm.require('fibers/future'); 
Meteor.methods({ 
    'aggregate' : function(param){ 
     var fut = new Future(); 
     MongoInternals.defaultRemoteCollectionDriver().mongo._getCollection(param.collection).aggregate(param.pipe,function(err, result){ 
      fut.return(result); 
     }); 
     return fut.wait(); 
    } 
    ,'test':function(param){ 
     var _param = { 
      pipe : [ 
      { $unwind:'$data' }, 
      { $match:{ 
       'data.y':"2031", 
       'data.m':'01', 
       'data.d':'01' 
      }}, 
      { $project : { 
       '_id':0 
       ,'project_id'    : "$project_id" 
       ,'idx'      : "$data.idx" 
       ,'y'      : '$data.y' 
       ,'m'      : '$data.m' 
       ,'d'      : '$data.d' 
      }} 
     ], 
      collection:"yourCollection" 
     } 
     Meteor.call('aggregate',_param); 
    } 
}); 

}