Cómo transmitir MongoDB los Resultados de la Consulta con nodejs?

He estado buscando para un ejemplo de cómo se puede transmitir el resultado de un MongoDB consulta a un nodejs cliente. Todas las soluciones que he encontrado hasta ahora, parecen leer el resultado de la consulta a la vez y, a continuación, enviar el resultado al servidor.

Lugar, me gustaría (obviamente) como para el suministro de una devolución de llamada del método de consulta y han MongoDB llamada que cuando la siguiente parte del conjunto de resultados está disponible.

He estado buscando en la mangosta – debo probable que el uso de un controlador diferente?

Jan

5 Kommentare

  1. 28

    Streaming en la Mangosta se hizo disponible en la versión 2.4.0 que apareció tres meses después de que hayas publicado esta pregunta:

    Model.where('created').gte(twoWeeksAgo).stream().pipe(writeStream);

    Más elaborado ejemplos pueden ser encontrados en sus página de documentación.

    • Mongoose: Query.prototype.stream() is deprecated in mongoose >= 4.5.0, use Query.prototype.cursor() instead
  2. 29

    nodo-mongodb-conductor (la capa subyacente que cada mongoDB cliente utiliza en nodejs), excepto el cursor de la API que otros mencionados tiene un buen flujo de API (#458). Por desgracia yo no la encuentre documentado en otros lugares.

    Actualización: hay docs también aquí.

    Puede ser utilizado como esta:

    var stream = collection.find().stream()
    stream.on('error', function (err) {
      console.error(err)
    })
    stream.on('data', function (doc) {
      console.log(doc)
    })

    Se implementa realmente la ReadableStream de la interfaz, por lo que tiene todos los extras (pausa/reanudar etc)

  3. 10

    mongoose no es realmente «controlador», es en realidad un ORM envoltura alrededor de la MongoDB conductor (nodo-mongodb-nativo).

    A hacer lo que estás haciendo, echa un vistazo a la del conductor .find y .each método. Aquí un poco de código a partir de los ejemplos:

    //Find all records. find() returns a cursor
    collection.find(function(err, cursor) {
      sys.puts("Printing docs from Cursor Each")
      cursor.each(function(err, doc) {
        if(doc != null) sys.puts("Doc from Each " + sys.inspect(doc));
      })                    
    });

    Para transmitir los resultados, básicamente lo que hace es reemplazar ese sys.puts con tu «stream» de la función. No está seguro de cómo va a transmitir los resultados. Creo que se puede hacer response.write() + response.flush(), pero usted también puede querer a la caja socket.io.

    • Gracias – el problema de controlador me enteré ayer. La búsqueda/cursor solución que estaba esperando, pero es sorprendentemente difícil encontrar ejemplos. La mayoría de hacer una búsqueda y, a continuación, docs.foreach( … )
    • Actualización: en Realidad, yo no conseguir que esto funcione de la manera que usted describe. Lo que tenía que hacer es crear un EventEmitter para pegar la secuencia de respuesta y el flujo de datos desde el backend juntos.
    • Estás en lo correcto acerca de los ejemplos, mejor que se puede esperar es la carpeta ejemplos en el código fuente. EventEmitter también suena correcto. Si tienes un buen ejemplo, sin duda, nos puede actualizar esta respuesta con algo más detallada.
    • Ok, editado su respuesta al punto a la mía para que yo pueda aceptar la tuya
    • ¿Tienes un enlace a una prueba de concepto? Que sería útil.
    • No, era sólo un proyecto de compañía. Básicamente, he implementado el código de abajo (en mi respuesta).

  4. 3

    Aquí está la solución que he encontrado (por favor me corrija alguien si que son la forma incorrecta de hacerlo):
    (También se excusa la mala codificación – demasiado tarde para mí ahora embellecer este)

    var sys = require('sys')
    var http = require("http");
    
    var Db = require('/usr/local/src/npm/node_modules/mongodb/lib/mongodb').Db,
      Connection = require('/usr/local/src/npm/node_modules/mongodb/lib/mongodb').Connection,
      Collection = require('/usr/local/src/npm/node_modules/mongodb/lib/mongodb').Collection,
      Server = require('/usr/local/src/npm/node_modules/mongodb/lib/mongodb').Server;
    
    var db = new Db('test', new Server('localhost',Connection.DEFAULT_PORT , {}));
    
    var products;
    
    db.open(function (error, client) {
      if (error) throw error;
      products = new Collection(client, 'products');
    });
    
    function ProductReader(collection) {
            this.collection = collection;
    }
    
    ProductReader.prototype = new process.EventEmitter();
    
    ProductReader.prototype.do = function() {
            var self = this;
    
            this.collection.find(function(err, cursor) {
                    if (err) {
                            self.emit('e1');
                            return;
    
                    }
                    sys.puts("Printing docs from Cursor Each");
    
                    self.emit('start');
                    cursor.each(function(err, doc) {
                            if (!err) {
                                    self.emit('e2');
                                    self.emit('end');
                                    return;
                            }
    
                            if(doc != null) {
                                    sys.puts("doc:" + doc.name);
                                    self.emit('doc',doc);
                            } else {
                                    self.emit('end');
                            }
                    })
            });
    };
    http.createServer(function(req,res){
            pr = new ProductReader(products);
            pr.on('e1',function(){
                    sys.puts("E1");
                    res.writeHead(400,{"Content-Type": "text/plain"});
                    res.write("e1 occurred\n");
                    res.end();
            });
            pr.on('e2',function(){
                    sys.puts("E2");
                    res.write("ERROR\n");
            });
    
            pr.on('start',function(){
                    sys.puts("START");
                    res.writeHead(200,{"Content-Type": "text/plain"});
                    res.write("<products>\n");
            });
    
            pr.on('doc',function(doc){
                    sys.puts("A DOCUMENT" + doc.name);
                    res.write("<product><name>" + doc.name + "</name></product>\n");
            });
    
            pr.on('end',function(){
                    sys.puts("END");
                    res.write("</products>");
                    res.end();
            });
    
            pr.do();
    
      }).listen(8000);
  5. 0

    He estado estudiando mongodb flujos de mí mismo, aunque no tengo toda la respuesta que usted está buscando, tengo parte de ella.
    usted puede configurar un socket.io corriente

    es el uso de javascript zócalo.io y el zócalo.io-streaming disponible en NPM
    también mongodb para la base de datos porque
    el uso de un 40 años de edad de la base de datos que tiene problemas es incorrecta, el momento de modernizar
    también los 40 años de edad db de SQL y SQL no corrientes a mis conocimientos

    Así que aunque sólo se les preguntó acerca de los datos desde el servidor al cliente, también quiero conseguir el cliente al servidor en mi respuesta porque NUNCA puedo encontrar en cualquier lugar cuando busco y yo quería para la instalación de un lugar con tanto el envío y recepción de elementos a través de stream para que todos pudieran obtener el cuelgue de ella rápidamente.

    lado del cliente el envío de datos al servidor a través de streaming de

    stream = ss.createStream();
    blobstream=ss.createBlobReadStream(data);
    blobstream.pipe(stream);
    ss(socket).emit('data.stream',stream,{},function(err,successful_db_insert_id){
     //if you get back the id it went into the db and everything worked
    });

    servidor que recibe corriente desde el lado del cliente y, a continuación, responder al hecho

    ss(socket).on('data.stream.out',function(stream,o,c){
     buffer=[];
     stream.on('data',function(chunk){buffer.push(chunk);});
     stream.on('end',function(){
      buffer=Buffer.concat(buffer);
      db.insert(buffer,function(err,res){
       res=insertedId[0];
       c(null,res);
      });
     });
    });

    //Esta es la otra mitad de que la recogida de datos y en la transmisión para el cliente

    lado del cliente para solicitar y recibir los datos del flujo de servidor

    stream=ss.createStream();
    binarystring='';
    stream.on('data',function(chunk){ 
     for(var I=0;i<chunk.length;i++){
      binarystring+=String.fromCharCode(chunk[i]); 
     }
    });
    stream.on('end',function(){ data=window.btoa(binarystring); c(null,data); });
    ss(socket).emit('data.stream.get,stream,o,c);

    lado del servidor responder a la solicitud para la transmisión de datos

    ss(socket).on('data.stream.get',function(stream,o,c){
     stream.on('end',function(){
      c(null,true);
     });
     db.find().stream().pipe(stream);
    });

    El último no es el único donde yo soy una especie de simplemente tirando de ella fuera de mi culo porque aún no la he probado, pero debería funcionar. En realidad hago algo parecido pero yo escribir el archivo en el disco duro, a continuación, utilice fs.createReadStream para transmitir al cliente. Así que no se si al 100% pero por lo que he leído debe ser, voy a volver a usted una vez que la pruebo.

    P. s. alguien quiere recordarme acerca de mi manera coloquial de hablar, soy Canadiense, y me encanta decir «eh» venid a mí con tus abrazos y éxitos bros/sis’ 😀

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea