meteor
Mongo samlingar

Anmärkningar

Skapa poster i en äldre databas

Du kan som standard använda det normala Mongo-formatet genom att definiera dina samlingar med fältet idGeneration.

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

Infoga data i ett dokument

Många nybörjare till Mongo kämpar med grunderna, till exempel hur man sätter in en matris, datum, booleska, sessionvariabel och så vidare i en dokumentrekord. Det här exemplet ger viss vägledning om grundläggande dataingångar.

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
});

Skaffa _iden för det senast skapade dokumentet

Du kan få det antingen synkront:

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

Eller asynkront:

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

Tidssedeldata

Att använda MongoDB för tidsseriedata är ett mycket väl dokument och etablerat användningsfall med officiella whitepapers och presentations. Läs och se den officiella dokumentationen från MongoDB innan du försöker uppfinna dina egna scheman för tidsseriedata.

MongoDB för tidsseriedata

I allmänhet vill du skapa "hinkar" för dina tidsinformation:

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

Och öka sedan skoporna som dataflöden i din applikation. Detta steg kan läggas i en Meteor-metod, en samlingsobservatör, en REST API-slutpunkt och olika andra platser.

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

För ett mer komplett Meteor-exempel, se exemplen från Clinical Meteor-spåret:

Realtidsanalyspipeline
Clinical Meteor - Grafer - Dailystats

Filtrera med Regexes

Enkelt mönster för att filtrera prenumerationer på servern, använda regexer, reaktiva sessionvariabler och deponera autoruns.

// 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});
    });
});

Och HTML-koden som används på klienten:

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

Detta mönster i sig är ganska rakt fram, men regexen kanske inte. Om du inte känner till regexer, här är några användbara tutorials och länkar:

Regelbunden expressionshandledning
Regular Expression Cheat Sheet
Regelbundna uttryck i Javascript

Geospatiala samlingar - Lär dig mer

Geospatiala samlingar handlar vanligtvis om att lagra GeoJSON i Mongo-databasen, strömma den informationen till klienten, öppna webbläsarens window.navigator.geolocation , ladda upp ett Map API, konvertera GeoJSON till LatLngs och plotta på kartan. Helst allt i realtid. Här är en lista över resurser för att komma igång:

• mongodb lagrar sina data optimalt i geoJSON
• geojson.org
• window.navigator.geolocation
• HTML geolocation
• Kartor API-väljare
• google.maps.LatLng
• Google map.data.loadGeoJson
• meteor-cordova-geolocation-bakgrund
• PhoneGap-googlemaps-plugin
• LatLng
• maps.documentation
• google.maps.LatLng
• 2dsphere-index
• skapa ett 2dsphere-index
• fråga ett 2dsphere-index
• geospatiala index och frågor

Revisionssamlingsfrågor

Följande exempel loggar alla dina samlingfrågor till serverkonsolen i realtid.

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);      
    }       
  }     
);      

Observatörer & arbetarfunktioner

Om Node-händelsslingan fungerar som en cykelkedja är observatören på insamlingen på serversidan som en derailleur. Det är en växelmekanism som kommer att sitta på datainsamlingen när data kommer in. Det kan vara mycket performant, eftersom alla racecyklar har derailleorer. Men det är också en källa för att bryta hela systemet. Det är en reaktiv funktion med hög hastighet som kan spränga dig. Varnas.

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.");
    }
  });
});

Observera att gränsen på 20 är storleken på derailleuren .... hur många tänder den har; eller närmare bestämt hur många objekt som finns i markören när det går över samlingen. Var försiktig med att använda nyckelordet "var" i den här typen av funktion. Skriv så få objekt till minnet som möjligt och fokusera på återanvändning av objekt i den tillagda metoden. När opslog är på, och den här saken går i full fart, är det en främsta kandidat för att avslöja otäcka minnesläckor om det skrivs ner föremål på minneshögen snabbare än Node-sopsamlaren kan rensa saker.

Ovanstående lösning skalas inte horisontellt bra, eftersom varje Meteor-instans kommer att försöka uppdatera samma post. Så det krävs någon form av miljödetektering för att detta ska skalas horisontellt.

Se paketet percolatestudios:synced-cron för ett utmärkt exempel på att synkronisera servicearbetare över flera maskiner i ett kluster.
meteor-synkroniserad-cron