What's remove() and save() mean in mongodb node.js when initializing one database

Question

I am newly using node.js. I am reading the code of one app. The code below is to initialize the db, to load some question into the survey system I can't understand what's remove() and save() means here. Because I can't find any explanation about these two method. It seems mongoose isn't used after being connected. Could any one explain the usage of these methods?

Well, this is my understanding of this code, not sure to be correct. My TA tell me it should be run before server.js.

/**
 *  This is a utility script for dropping the questions table, and then
 *  re-populating it with new questions.
 */

// connect to the database
var mongoose = require('mongoose');
var configDB = require('./config/database.js');
mongoose.connect(configDB.url);

// load the schema for entries in the 'questions' table
var Question = require('./app/models/questions');

// here are the questions we'll load into the database.  Field names don't
// quite match with the schema, but we'll be OK.
var questionlist = [
       /*some question*/
];

// drop all data, and if the drop succeeds, run the insertion callback
Question.remove({}, function(err) {
    // count successful inserts, and exit the process once the last insertion
    // finishes (or any insertion fails)
    var received = 0;
    for (var i = 0; i < questionlist.length; ++i) {
        var q = new Question();
        /*some detail about defining q neglected*/
        q.save(function(err, q) {
            if (err) {
                console.error(err);
                process.exit();
            }
            received++;
            if (received == questionlist.length)
                process.exit();
        });
    }
});

Answer 1

Mongoose basically maps your MongoDB queries to JavaScript objects using schema.

remove() receives a selector, and callback function. Empty selector means, that all Questions will be affected.

After that a new Question object is created. I guess that you omitted some data being set on it. After that it's being saved back into MongoDB.

You can read more about that in the official documentation: http://mongoosejs.com/docs/api.html#types-subdocument-js

Answer 2

To add some additional detail, mongoose is all based on using schemas and working with those to manipulate your data. In a mongodb database, you have collections, and each collection holds different kinds of data. When you're using mongoose, what's happening behind the scenes is every different Schema you work with maps to a mongodb collection. So when you're working with Question Schema in mongoose land, there's really some Question collection behind the scenes in the actual db that your working with. You might also have a Users Schema, which would act as an abstraction for some Users collection in the db, or maybe you could have a Products Schema, which again would map to some collection of products behind the scenes in the actual db.

As mentioned previously, when calling remove({}, callback) on the Questions Schema, you're telling mongoose to go find the Questions collection in the db and remove all entries, or documents as they're called in mongodb, that match a certain criteria. You specify that criteria in the object literal that is passed in as the first argument. So if the Questions Schema has some boolean field called correct and you wanted to delete all of the incorrect questions, you could say Question.remove({ correct: false }, callback) . Also as mentioned previously, when passing an empty object to remove , your telling mongoose to remove ALL documents in the Schema, or collection rather. If you're not familiar with callback functions, pretty much the callback function says, "hey after you finish this async operation, go ahead and do this."

The save() function that is used here is a little different than how save() is used in the official mongodb driver, which is one reason why I don't prefer mongoose. But to explain, pretty much all save is doing here is you're creating this new question, referred to by the q variable, and when you call save() on that question object, you're telling mongoose to take that object and insert it as a new document into your Questions collection behind the scenes. So save here just means insert into the db. If you were using the official mongo driver, it would be db.getCollection('collectionName').insert({/* Object representing new document to insert */}) .

And yes your TA is correct. This code will need to run before your server.js file. Whatever your server code does, I assume it's going to connect to your database.

I would encourage you to look at the mongoose API documentation . Long term though, the official mongodb driver might be your best bet.

Answer 3

remove query is use for removing all documents from collection and save is use for creating new document. As per your code it seems like every time the script run it removes all the record from Question collection and then save new records for question from question list.