meteor
Collezioni Mongo

Osservazioni

Creazione di record in un database precedente

Puoi impostare il formato Mongo normale definendo le tue raccolte con il campo idGeneration.

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

Inserimento di dati in un documento

Molti principianti in Mongo sono in difficoltà con le nozioni di base, come ad esempio l'inserimento di un array, data, booleano, variabile di sessione e così via in un record di documento. Questo esempio fornisce alcune indicazioni sugli input di dati di base.

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

Ottenere il _id del documento creato più di recente

Puoi ottenerlo in modo sincrono:

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

O in modo asincrono:

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

Dati degli orari

L'utilizzo di MongoDB per i dati delle serie temporali è un documento molto valido e un caso d'uso consolidato, con white paper ufficiali e presentazioni. Leggi e guarda la documentazione ufficiale di MongoDB prima di provare a inventare i tuoi schemi per i dati delle serie temporali.

MongoDB per i dati delle serie temporali

In generale, ti consigliamo di creare "bucket" per i tuoi dati di timeseries:

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

E quindi incrementare quei bucket come feed di dati nell'applicazione. Questo incremento può essere inserito in un metodo Meteor, un osservatore di raccolta, un endpoint dell'API REST e varie altre posizioni.

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

Per un esempio di Meteor più completo, vedere gli esempi dalla traccia Clinical Meteor:

Pipeline di analisi in tempo reale
Meteora clinica - Grafici - Dailystats

Filtro con Regexes

Semplice schema per filtrare le sottoscrizioni sul server, usando espressioni regolari, variabili di sessione reattive e autores deps.

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

E l'HTML che viene utilizzato sul client:

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

Questo modello di per sé è abbastanza semplice, ma le regex potrebbero non esserlo. Se non hai familiarità con le espressioni regolari, ecco alcuni utili tutorial e link:

Esercitazione di espressioni regolari
Foglio dell'espressione regolare
Espressioni regolari in Javascript

Collezioni geospaziali - Apprendimento di più

Le raccolte geospaziali generalmente implicano l'archiviazione di GeoJSON nel database Mongo, lo streaming di tali dati al client, l'accesso alla window.navigator.geolocation del window.navigator.geolocation , il caricamento di un'API di mappa, la conversione di GeoJSON in LatLng e il tracciamento sulla mappa. Preferibilmente tutto in tempo reale. Ecco un elenco di risorse per iniziare:

• mongodb memorizza in modo ottimale i suoi dati in geoJSON
• geojson.org
• window.navigator.geolocation
• Geolocalizzazione HTML
• Selettore API di Maps
• google.maps.LatLng
• Google map.data.loadGeoJson
• meteora-Cordova-geolocalizzazione-sfondo
• PhoneGap-Googlemaps-plugin
• LatLng
• maps.documentation
• google.maps.LatLng
• Indici 2sfera
• creare un indice 2space
• interrogare un indice 2dsphere
• indici e query geospaziali

Controllo delle query di raccolta

L'esempio seguente registrerà tutte le query della raccolta sulla console del server in tempo reale.

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

Osservatori e funzioni del lavoratore

Se il loop di eventi del nodo agisce come una catena di biciclette, l'osservatore della raccolta sul lato server è come un deragliatore. È un meccanismo di ingranaggi che si accosterà alla raccolta dei dati quando i dati arriveranno. Può essere molto performante, poiché tutte le biciclette da corsa hanno deragliatori. Ma è anche una fonte per rompere l'intero sistema. È una funzione reattiva ad alta velocità, che può far saltare in aria te. Essere avvertito

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

Notare che il limite di 20 è la dimensione del deragliatore .... quanti denti ha; o, più precisamente, quanti oggetti sono nel cursore mentre cammina sopra la collezione. Fai attenzione all'utilizzo della parola chiave 'var' in questo tipo di funzione. Scrivi meno oggetti possibile nella memoria e concentrati sul riutilizzo degli oggetti all'interno del metodo aggiunto. Quando l'opslog è attivo, e questa cosa sta andando a tutta velocità, è un candidato ideale per mostrare brutte perdite di memoria se sta scrivendo gli oggetti sull'heap della memoria più velocemente di quanto il garbage collector di Node sia in grado di pulire le cose.

La soluzione di cui sopra non scalerà orizzontalmente bene, perché ogni istanza di Meteor cercherà di aggiornare lo stesso record. Quindi, è necessaria una sorta di rilevamento dell'ambiente per farlo scalare orizzontalmente.

Vedi il percolatestudios:synced-cron package per un eccellente esempio di sincronizzazione dei service worker su più macchine in un cluster.
meteora-sincronizzati-cron