javascript - read - node js mongodb tutorial

¿Cuál es la forma correcta de realizar una consulta MongoDB sincrónica en Node.js?

Question

Estoy usando el controlador Node.JS para MongoDB, y me gustaría realizar una consulta sincrónica, como esta:

function getAThing()
{
    var db = new mongo.Db("mydatabase", server, {});

    db.open(function(err, db)
    {
        db.authenticate("myuser", "mypassword", function(err, success)
        {
            if (success)
            {
                db.collection("Things", function(err, collection)
                {
                    collection.findOne({ name : "bob"}, function(err, thing)
                    {                           
                        return thing;
                    });
                });
            }
        });
    });
}

El problema es que db.open es una llamada ascrona (no bloquea), por lo que getAThing devuelve "indefinido" y quiero que devuelva los resultados de la consulta. Estoy seguro de que podría tener algún tipo de mecanismo de bloqueo, pero me gustaría saber la forma correcta de hacer algo como esto.

Answer 1

Ahora que Mongo Sync está disponible, esta es la forma correcta de realizar una consulta MongoDB sincrónica en Node.js.

Estoy usando esto para lo mismo. Simplemente puede escribir el método de sincronización como se muestra a continuación:

var Server = require("mongo-sync").Server;
var server = new Server(''127.0.0.1'');
var result = server.db("testdb").getCollection("testCollection").find().toArray();
console.log(result);

Nota: depende de la node-fiber del node-fiber y algunos problemas están ahí en Windows 8.

Feliz codificación :)

Answer 2

No hay forma de hacer esto sin sincronizar sin algún tipo de truco terrible. La forma correcta es hacer que getAThing acepte una función de devolución de llamada como parámetro y luego llamar a esa función una vez thing esté disponible.

function getAThing(callback)
{
    var db = new mongo.Db("mydatabase", server, {});

    db.open(function(err, db)
    {
        db.authenticate("myuser", "mypassword", function(err, success)
        {
            if (success)
            {
                db.collection("Things", function(err, collection)
                {
                    collection.findOne({ name : "bob"}, function(err, thing)
                    {       
                        db.close();                    
                        callback(err, thing);
                    });
                });
            }
        });
    });
}

Nodo 7.6+ Actualización

async/await ahora proporciona una forma de codificación en un estilo síncrono cuando se usan API asíncronas que devuelven promesas (como el controlador MongoDB nativo).

Usando este enfoque, el método anterior se puede escribir como:

async function getAThing() {
    let db = await mongodb.MongoClient.connect(''mongodb://server/mydatabase'');
    if (await db.authenticate("myuser", "mypassword")) {
        let thing = await db.collection("Things").findOne({ name: "bob" });
        await db.close();
        return thing;
    }
}

A continuación, puede llamar desde otra función async como let thing = await getAThing(); .

Sin embargo, vale la pena señalar que MongoClient proporciona un grupo de conexiones, por lo que no debería abrirlo y cerrarlo con este método. En su lugar, llame a MongoClient.connect durante el inicio de su aplicación y luego simplifique su método para:

async function getAThing() {
    return db.collection("Things").findOne({ name: "bob" });
}

Tenga en cuenta que no llamamos a await dentro del método, sino que findOne directamente la promesa que devuelve findOne .

Answer 3

Si bien no es estrictamente sincrónico, un patrón que he adoptado reiteradamente y que considero que es muy útil es usar co y promisify rendimiento de las funciones asincrónicas. Para mongo, podrías reescribir lo anterior:

var query = co( function* () {

    var db = new mongo.Db("mydatabase", server, {});
    db = promisify.object( db );
    db = yield db.open();

    yield db.authenticate("myuser", "mypassword");

    var collection = yield db.collection("Things");
    return yield collection.findOne( { name : "bob"} );

});

query.then( result => {

} ).catch( err => {

} );

Esto significa:

1. Puede escribir código "sincrónico" con cualquier biblioteca asíncrona
2. Los errores se lanzan desde las devoluciones de llamada, lo que significa que no necesita la verificación de éxito
3. Puede pasar el resultado como una promesa a cualquier otra pieza de código