meteor
Colecciones Mongo

Observaciones

Creación de registros en una base de datos heredada

Puede predeterminar el formato Mongo normal definiendo sus colecciones con el campo idGeneration.

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

Insertar datos en un documento

Muchos principiantes en Mongo luchan con lo básico, como la forma de insertar una matriz, fecha, booleano, variable de sesión, etc. en un registro de documento. Este ejemplo proporciona una guía sobre las entradas de datos básicos.

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

Obtención del _id del documento creado más recientemente.

Puedes conseguirlo sincrónicamente:

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

O asíncronamente:

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

Datos de series de tiempo

El uso de MongoDB para datos de series de tiempo es un documento muy bueno y un caso de uso establecido, con informes oficiales y presentaciones. Lea y vea la documentación oficial de MongoDB antes de intentar inventar sus propios esquemas para obtener datos de series de tiempo.

MongoDB para datos de series de tiempo

En general, querrá crear "grupos" para los datos de su serie temporal:

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

Y luego incremente esos depósitos como fuentes de datos en su aplicación. Este incremento se puede colocar en un Método Meteor, un observador de la colección, un punto final de REST API y varios otros lugares.

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

Para un ejemplo más completo de Meteor, vea los ejemplos de la pista de Meteorología clínica:

Análisis en tiempo real Pipeline
Meteorito Clínico - Gráficos - Dailystats

Filtrado con Regexes

Patrón simple para filtrar las suscripciones en el servidor, usando expresiones regulares, variables de sesión reactivas y ejecuciones automáticas 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});
    });
});

Y el HTML que se usa en el cliente:

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

Este patrón en sí es bastante sencillo, pero las expresiones regulares pueden no serlo. Si no está familiarizado con las expresiones regulares, aquí hay algunos tutoriales y enlaces útiles:

Tutorial de Expresión Regular
Hoja de trucos de expresiones regulares
Expresiones regulares en Javascript

Colecciones geoespaciales - Aprendiendo más

Las colecciones geoespaciales generalmente implican el almacenamiento de GeoJSON en la base de datos de Mongo, la transmisión de esos datos al cliente, el acceso a window.navigator.geolocation del navegador, la carga de una API de mapas, la conversión de GeoJSON a LatLngs y el trazado en el mapa. Preferiblemente todo en tiempo real. Aquí hay una lista de recursos para comenzar:

• mongodb almacena óptimamente sus datos en geoJSON
• geojson.org
• window.navigator.geolocation
• Geolocalización de HTML
• Selector API de mapas
• google.maps.LatLng
• Google map.data.loadGeoJson
• meteoro-cordova-geolocalización-fondo
• phonegap-googlemaps-plugin
• LatLng
• maps.documentation
• google.maps.LatLng
• Índices 2dsphere
• crear un índice 2dsphere
• Consulta un índice de 2dsphere
• Índices y consultas geoespaciales.

Auditoría de consultas de cobro

El siguiente ejemplo registrará todas sus consultas de colección en la consola del servidor en tiempo real.

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

Observadores y funciones de los trabajadores

Si el bucle de eventos del nodo actúa como una cadena de bicicletas, el observador de la recopilación del lado del servidor es como un desviador. Es un mecanismo de engranaje que se sentará en la recopilación de datos a medida que los reciban. Puede ser muy eficaz, ya que todas las bicicletas de carrera tienen desviadores. Pero también es una fuente para romper todo el sistema. Es una función reactiva de alta velocidad, que puede explotar en ti. Ser advertido

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

Tenga en cuenta que el límite de 20 es el tamaño del desviador ... cuántos dientes tiene; o, más específicamente, cuántos elementos están en el cursor mientras camina sobre la colección. Tenga cuidado al usar la palabra clave 'var' en este tipo de función. Escriba la menor cantidad posible de objetos en la memoria y céntrese en la reutilización de objetos dentro del método agregado. Cuando se enciende el opslog, y esto va a toda velocidad, es un candidato ideal para exponer fugas de memoria desagradables si está escribiendo objetos en el montón de memoria más rápido de lo que el recolector de basura Node puede limpiar las cosas.

La solución anterior no se escalará horizontalmente bien, porque cada instancia de Meteor intentará actualizar el mismo registro. Por lo tanto, es necesario algún tipo de detección del entorno para que esto se escale horizontalmente.

Consulte el paquete percolatestudios:synced-cron para ver un excelente ejemplo de la sincronización de trabajadores de servicio en varias máquinas en un clúster.
cron sincronizado de meteoros