meteor
Mongo-Sammlungen

Bemerkungen

Datensätze in einer älteren Datenbank erstellen

Sie können das normale Mongo-Format standardmäßig verwenden, indem Sie Ihre Sammlungen mit dem Feld idGeneration definieren.

MyCollection = new Meteor.Collection('mycollection', {idGeneration : 'MONGO'});

Daten in ein Dokument einfügen

Viele Anfänger von Mongo haben Schwierigkeiten mit den Grundlagen, wie z. B. das Einfügen eines Arrays, eines Datums, eines Boolean, einer Sitzungsvariablen usw. in einen Dokumentensatz. Dieses Beispiel enthält einige Hinweise zu grundlegenden Dateneingaben.

Todos.insert({
  text: "foo",                        // String
  listId: Session.get('list_id'),     // String
  value: parseInt(2),                 // Number
  done: false,                        // Boolean
  createdAt: new Date(),              // Dimestamp
  timestamp: (new Date()).getTime(),  // Time
  tags: []                            // Array
});

Abrufen der _id des zuletzt erstellten Dokuments

Sie können es entweder synchron bekommen:

var docId = Todos.insert({text: 'foo'});
console.log(docId);

Oder asynchron:

Todos.insert({text: 'foo'}, function(error, docId){
  console.log(docId);
});

Zeitreihendaten

Die Verwendung von MongoDB für Zeitreihendaten ist ein sehr gut dokumentiertes und etabliertes Anwendungsbeispiel mit offiziellen Whitepapers und Präsentationen. Lesen und sehen Sie sich die offizielle Dokumentation von MongoDB an, bevor Sie versuchen, Ihre eigenen Schemata für Zeitreihendaten zu erfinden.

MongoDB für Zeitreihendaten

Im Allgemeinen sollten Sie "Buckets" für Ihre Zeitreihendaten erstellen:

DailyStats.insert({
   "date" : moment().format("MM-DD-YYYY"),
   "dateIncrement" : moment().format("YYYYMMDD"),
   "dailyTotal" : 0,
   'bucketA': 0,
   'bucketB': 0,
   'bucketC': 0
   });

Erhöhen Sie dann diese Buckets, während Daten in Ihre Anwendung eingespeist werden. Dieses Inkrement kann in eine Meteor-Methode, einen Sammlungsbeobachter, einen REST-API-Endpunkt und verschiedene andere Stellen eingefügt werden.

DailyStats.update({_id: doc._id}, {$inc: {bucketA: 1} });

Ein vollständigeres Meteor-Beispiel finden Sie in den Beispielen des klinischen Meteor-Tracks:

Echtzeit-Analytics-Pipeline
Klinischer Meteor - Schaubilder - Dailystats

Filtern mit Regexes

Einfaches Muster zum Filtern von Abonnements auf dem Server unter Verwendung von regulären Ausdrücken, reaktiven Sitzungsvariablen und automatischen Ausfällen.

// create our collection
WordList =  new Meteor.Collection("wordlist");

// and a default session variable to hold the value we're searching for
Session.setDefault('dictionary_search', '');

Meteor.isClient(function(){
    // we create a reactive context that will rerun items when a Session variable gets updated 
    Deps.autorun(function(){
        // and create a subscription that will get re-subscribe to when Session variable gets updated
        Meteor.subscribe('wordlist', Session.get('dictionary_search'));
    });

    Template.dictionaryIndexTemplate.events({
        'keyup #dictionarySearchInput': function(evt,tmpl){
            // we set the Session variable with the value of our input when it changes
            Session.set('dictionary_search', $('#dictionarySearchInput').val());
        },
        'click #dictionarySearchInput':function(){
            // and clear the session variable when we enter the input
            Session.set('dictionary_search', '');
        },
    });
});
Meteor.isServer(function(){
    Meteor.publish('wordlist', function (word_search) {
        // this query gets rerun whenever the client subscribes to this publication
        return WordList.find({
            // and here we do our regex search
            Word: { $regex: word_search, $options: 'i' }
        },{limit: 100});
    });
});

Und der HTML-Code, der auf dem Client verwendet wird:

<input id="dictionarySearchInput" type="text" placeholder="Filter..." value="hello"></input>

Dieses Muster selbst ist ziemlich geradlinig, aber die Regexen mögen nicht sein. Wenn Sie sich mit Regex nicht auskennen, finden Sie hier einige nützliche Tutorials und Links:

Tutorial für reguläre Ausdrücke
Regulärer Ausdruck Spickzettel
Reguläre Ausdrücke in Javascript

Geospatial Collections - Weitere Informationen

Geospatial-Sammlungen umfassen im Allgemeinen das Speichern von GeoJSON in der Mongo-Datenbank, das Streaming dieser Daten an den Client, den Zugriff auf die window.navigator.geolocation des Browsers, das Laden einer Karten-API, das Konvertieren von GeoJSON in LatLngs und das Plotten auf der Karte. Am liebsten alles in Echtzeit. Hier finden Sie eine Liste mit Ressourcen, um Ihnen den Einstieg zu erleichtern:

• mongodb speichert seine Daten optimal in geoJSON
• geojson.org
• window.navigator.geolocation
• HTML-Geolocation
• Karten-API-Auswahl
• google.maps.LatLng
• Google map.data.loadGeoJson
• Meteor-Cordova-Geolocation-Hintergrund
• phonegap-googlemaps-plugin
• LatLng
• Karten.Dokumentation
• google.maps.LatLng
• 2dsphere indexes
• Erstellen Sie einen 2dsphere-Index
• Abfrage eines 2dsphere-Index
• Geodaten und Abfragen

Überwachungssammlungsabfragen

Im folgenden Beispiel werden alle Ihre Sammlungsabfragen in Echtzeit an der Server-Konsole protokolliert.

Meteor.startup(     
  function () {     
    var wrappedFind = Meteor.Collection.prototype.find;     

    // console.log('[startup] wrapping Collection.find')        

    Meteor.Collection.prototype.find = function () {        
      // console.log(this._name + '.find', JSON.stringify(arguments))       
      return wrappedFind.apply(this, arguments);        
    }       
  },        

  function () {     
    var wrappedUpdate = Meteor.Collection.prototype.update;     

    // console.log('[startup] wrapping Collection.find')        

    Meteor.Collection.prototype.update = function () {      
      console.log(this._name + '.update', JSON.stringify(arguments))        
      return wrappedUpdate.apply(this, arguments);      
    }       
  }     
);      

Beobachter & Arbeiterfunktionen

Wenn die Node-Ereignisschleife wie eine Fahrradkette wirkt, ist der serverseitige Sammlungsbeobachter wie ein Umwerfer. Es handelt sich um einen Getriebemechanismus, der bei der Datenerfassung auf die Datenerfassung angewendet wird. Er kann sehr leistungsfähig sein, da alle Rennräder über Schaltwerke verfügen. Aber es ist auch eine Quelle, um das gesamte System zu durchbrechen. Es ist eine reaktionsschnelle Hochgeschwindigkeitsfunktion, die Sie sprengen kann. Sei gewarnt.

Meteor.startup(function(){
  console.log('starting worker....');

  var dataCursor = Posts.find({viewsCount: {$exists: true}},{limit:20});

  var handle = dataCursor.observeChanges({
    added: function (id, record) {
      if(record.viewsCount > 10){
         // run some statistics
         calculateStatistics();

         // or update a value
         Posts.update({_id: id}, {$set:{
           popular: true
         }});

      }
    },
    removed: function () {
      console.log("Lost one.");
    }
  });
});

Die Grenze von 20 ist die Größe des Umwerfers. Wie viele Zähne hat er? oder genauer gesagt, wie viele Elemente sich im Cursor befinden, wenn er über die Sammlung läuft. Seien Sie vorsichtig mit dem Schlüsselwort 'var' in dieser Art von Funktion. Schreiben Sie so wenige Objekte wie möglich in den Speicher und konzentrieren Sie sich auf die Wiederverwendung von Objekten innerhalb der hinzugefügten Methode. Wenn das opslog eingeschaltet ist und dieses Ding auf Hochtouren läuft, ist dies ein hervorragender Kandidat für das Freilegen von unangenehmen Speicherverlusten, wenn Objekte schneller auf den Speicherheap geschrieben werden, als der Node-Garbage Collector die Dinge aufräumen kann.

Die obige Lösung lässt sich nicht horizontal gut skalieren, da jede Meteor-Instanz versucht, denselben Datensatz zu aktualisieren. Daher ist eine Art Umgebungserkennung erforderlich, damit diese horizontal skaliert werden kann.

In dem Paket percolatestudios:synced-cron ein hervorragendes Beispiel für die Synchronisierung von Service-Mitarbeitern auf mehreren Computern in einem Cluster.
Meteorensynchron-Cron