Class: Collection

Collection

new Collection(){Collection}

Create a new Collection instance (INTERNAL TYPE, do not instantiate directly)

Properties:
Name Type Description
collectionName string

Get the collection name.

namespace string

Get the full collection namespace.

writeConcern object

The current write concern values.

readConcern object

The current read concern values.

hint object

Get current index hint for collection.

Returns:
Collection instance.

Methods

aggregate(pipeline, options, callback){null|AggregationCursor}

Execute an aggregation framework pipeline against the collection, needs MongoDB >= 2.2

Name Type Default Description
pipeline object

Array containing all the aggregation framework commands for the execution.

options object null optional

Optional settings.

Name Type Default Description
readPreference ReadPreference | string null optional

The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).

cursor object null optional

Return the query as cursor, on 2.6 > it returns as a real cursor on pre 2.6 it returns as an emulated cursor.

Name Type Default Description
batchSize number null optional

The batchSize for the cursor

explain boolean false optional

Explain returns the aggregation execution plan (requires mongodb 2.6 >).

allowDiskUse boolean false optional

allowDiskUse lets the server know if it can use disk to store temporary results for the aggregation (requires mongodb 2.6 >).

maxTimeMS number null optional

maxTimeMS specifies a cumulative time limit in milliseconds for processing operations on the cursor. MongoDB interrupts the operation at the earliest following interrupt point.

bypassDocumentValidation boolean false optional

Allow driver to bypass schema validation in MongoDB 3.2 or higher.

raw boolean false optional

Return document results as raw BSON buffers.

promoteLongs boolean true optional

Promotes Long values to number if they fit inside the 53 bits resolution.

promoteValues boolean true optional

Promotes BSON values to native types where possible, set to false to only receive wrapper types.

promoteBuffers boolean false optional

Promotes Binary BSON values to native Node Buffers.

collation object null optional

Specify collation (MongoDB 3.4 or higher) settings for update operation (see 3.4 documentation for available fields).

callback Collection~resultCallback

The command result callback

Examples
// Correctly call the aggregation framework using a pipeline in an Array.

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
  // Some docs for insertion
  var docs = [{
      title : "this is my title", author : "bob", posted : new Date() ,
      pageViews : 5, tags : [ "fun" , "good" , "fun" ], other : { foo : 5 },
      comments : [
        { author :"joe", text : "this is cool" }, { author :"sam", text : "this is bad" }
      ]}];

  // Create a collection
  var collection = db.collection('aggregationExample1');
  // Insert the docs
  collection.insertMany(docs, {w: 1}, function(err, result) {

    // Execute aggregate, notice the pipeline is expressed as an Array
    collection.aggregate([
        { $project : {
          author : 1,
          tags : 1
        }},
        { $unwind : "$tags" },
        { $group : {
          _id : {tags : "$tags"},
          authors : { $addToSet : "$author" }
        }}
      ], function(err, result) {
        test.equal(null, err);
        test.equal('good', result[0]._id.tags);
        test.deepEqual(['bob'], result[0].authors);
        test.equal('fun', result[1]._id.tags);
        test.deepEqual(['bob'], result[1].authors);

        db.close();
    });
  });
});
// Correctly call the aggregation using a cursor

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
  // Some docs for insertion
  var docs = [{
      title : "this is my title", author : "bob", posted : new Date() ,
      pageViews : 5, tags : [ "fun" , "good" , "fun" ], other : { foo : 5 },
      comments : [
        { author :"joe", text : "this is cool" }, { author :"sam", text : "this is bad" }
      ]}];

  // Create a collection
  var collection = db.collection('aggregationExample2');
  // Insert the docs
  collection.insertMany(docs, {w: 1}, function(err, result) {

    // Execute aggregate, notice the pipeline is expressed as an Array
    var cursor = collection.aggregate([
        { $project : {
          author : 1,
          tags : 1
        }},
        { $unwind : "$tags" },
        { $group : {
          _id : {tags : "$tags"},
          authors : { $addToSet : "$author" }
        }}
      ], { cursor: { batchSize: 1 } });

    // Get all the aggregation results
    cursor.toArray(function(err, docs) {
      test.equal(null, err);
      test.equal(2, docs.length);
      db.close();
    });
  });
});
// Correctly call the aggregation using a read stream

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
  // Some docs for insertion
  var docs = [{
      title : "this is my title", author : "bob", posted : new Date() ,
      pageViews : 5, tags : [ "fun" , "good" , "fun" ], other : { foo : 5 },
      comments : [
        { author :"joe", text : "this is cool" }, { author :"sam", text : "this is bad" }
      ]}];

  // Create a collection
  var collection = db.collection('aggregationExample3');
  // Insert the docs
  collection.insertMany(docs, {w: 1}, function(err, result) {

    // Execute aggregate, notice the pipeline is expressed as an Array
    var cursor = collection.aggregate([
        { $project : {
          author : 1,
          tags : 1
        }},
        { $unwind : "$tags" },
        { $group : {
          _id : {tags : "$tags"},
          authors : { $addToSet : "$author" }
        }}
      ], { cursor: { batchSize: 1 } });

    var count = 0;
    // Get all the aggregation results
    cursor.on('data', function(doc) {
      count = count + 1;
    });

    cursor.once('end', function() {
      test.equal(2, count);
      db.close();
    });
  });
});
// Call toArray on an aggregation cursor using a Promise

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
  // Some docs for insertion
  var docs = [{
      title : "this is my title", author : "bob", posted : new Date() ,
      pageViews : 5, tags : [ "fun" , "good" , "fun" ], other : { foo : 5 },
      comments : [
        { author :"joe", text : "this is cool" }, { author :"sam", text : "this is bad" }
      ]}];

  // Create a collection
  var collection = db.collection('aggregationExample2_with_promise');
  // Insert the docs
  collection.insertMany(docs, {w: 1}).then(function(result) {
    // Execute aggregate, notice the pipeline is expressed as an Array
    var cursor = collection.aggregate([
        { $project : {
          author : 1,
          tags : 1
        }},
        { $unwind : "$tags" },
        { $group : {
          _id : {tags : "$tags"},
          authors : { $addToSet : "$author" }
        }}
      ], { cursor: { batchSize: 1 } });
    // Get all the aggregation results
    cursor.toArray().then(function(docs) {
      test.equal(2, docs.length);
      db.close();
    }).catch(function(err) {
      console.log(err.stack);
    });
  });
});
// Call toArray on an aggregation cursor using ES6 generators and the co module

var MongoClient = require('mongodb').MongoClient,
  co = require('co');
  test = require('assert');

co(function*() {
  var db = yield MongoClient.connect('mongodb://localhost:27017/test');

  // Some docs for insertion
  var docs = [{
      title : "this is my title", author : "bob", posted : new Date() ,
      pageViews : 5, tags : [ "fun" , "good" , "fun" ], other : { foo : 5 },
      comments : [
        { author :"joe", text : "this is cool" }, { author :"sam", text : "this is bad" }
      ]}];

  // Create a collection
  var collection = db.collection('aggregationExample2_with_generatorsGenerator');

  // Insert the docs
  yield collection.insertMany(docs, {w: 1});

  // Execute aggregate, notice the pipeline is expressed as an Array
  var cursor = collection.aggregate([
      { $project : {
        author : 1,
        tags : 1
      }},
      { $unwind : "$tags" },
      { $group : {
        _id : {tags : "$tags"},
        authors : { $addToSet : "$author" }
      }}
    ], { cursor: { batchSize: 1 } });

  // Get all the aggregation results
  var docs = yield cursor.toArray();
  test.equal(2, docs.length);
  db.close();
});

bulkWrite(operations, options, callback){Promise}

Perform a bulkWrite operation without a fluent API

Legal operation types are

{ insertOne: { document: { a: 1 } } }

{ updateOne: { filter: {a:2}, update: {$set: {a:2}}, upsert:true } }

{ updateMany: { filter: {a:2}, update: {$set: {a:2}}, upsert:true } }

{ deleteOne: { filter: {c:1} } }

{ deleteMany: { filter: {c:1} } }

{ replaceOne: { filter: {c:3}, replacement: {c:4}, upsert:true}}

If documents passed in do not contain the _id field,
one will be added to each of the documents missing it by the driver, mutating the document. This behavior
can be overridden by setting the forceServerObjectId flag.

Name Type Default Description
operations Array.<object>

Bulk operations to perform.

options object null optional

Optional settings.

Name Type Default Description
w number | string null optional

The write concern.

wtimeout number null optional

The write concern timeout.

j boolean false optional

Specify a journal write concern.

serializeFunctions boolean false optional

Serialize functions on any object.

ordered boolean true optional

Execute write operation in ordered or unordered fashion.

bypassDocumentValidation boolean false optional

Allow driver to bypass schema validation in MongoDB 3.2 or higher.

callback Collection~bulkWriteOpCallback optional

The command result callback

Returns:
Promise if no callback passed
Examples
// Example of a simple bulkWrite operation

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
  // Get the collection
  var col = db.collection('bulk_write');
  col.bulkWrite([
      { insertOne: { document: { a: 1 } } }
    , { updateOne: { filter: {a:2}, update: {$set: {a:2}}, upsert:true } }
    , { updateMany: { filter: {a:2}, update: {$set: {a:2}}, upsert:true } }
    , { deleteOne: { filter: {c:1} } }
    , { deleteMany: { filter: {c:1} } }
    , { replaceOne: { filter: {c:3}, replacement: {c:4}, upsert:true}}]
  , {ordered:true, w:1}, function(err, r) {
    test.equal(null, err);
    test.equal(1, r.nInserted);
    test.equal(2, r.nUpserted);
    test.equal(0, r.nRemoved);

    // Crud fields
    test.equal(1, r.insertedCount);
    test.equal(1, Object.keys(r.insertedIds).length);
    test.equal(1, r.matchedCount);
    test.ok(r.modifiedCount == 0 || r.modifiedCount == 1);
    test.equal(0, r.deletedCount);
    test.equal(2, r.upsertedCount);
    test.equal(2, Object.keys(r.upsertedIds).length);

    // Ordered bulk operation
    db.close();
  });
});
// Example of a simple bulkWrite operation using a Promise.

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
  // Get the collection
  var col = db.collection('bulk_write_with_promise');
  col.bulkWrite([
      { insertOne: { document: { a: 1 } } }
    , { updateOne: { filter: {a:2}, update: {$set: {a:2}}, upsert:true } }
    , { updateMany: { filter: {a:2}, update: {$set: {a:2}}, upsert:true } }
    , { deleteOne: { filter: {c:1} } }
    , { deleteMany: { filter: {c:1} } }
    , { replaceOne: { filter: {c:3}, replacement: {c:4}, upsert:true}}]
  , {ordered:true, w:1}).then(function(r) {
    // console.log(JSON.stringify(r, null, 2))
    test.equal(1, r.nInserted);
    test.equal(2, r.nUpserted);
    test.equal(0, r.nRemoved);
    // Crud fields
    test.equal(1, r.insertedCount);
    test.equal(1, Object.keys(r.insertedIds).length);
    test.equal(1, r.matchedCount);
    test.ok(r.modifiedCount == 0 || r.modifiedCount == 1);
    test.equal(0, r.deletedCount);
    test.equal(2, r.upsertedCount);
    test.equal(2, Object.keys(r.upsertedIds).length);

    // Ordered bulk operation
    db.close();
  });
});
// Example of a simple bulkWrite operation using a Generator and the co module.

var MongoClient = require('mongodb').MongoClient,
  co = require('co');
  test = require('assert');

co(function*() {
  var db = yield MongoClient.connect('mongodb://localhost:27017/test');
  // Get the collection
  var col = db.collection('bulk_write_with_generators');
  var r = yield col.bulkWrite([
      { insertOne: { document: { a: 1 } } }
    , { updateOne: { filter: {a:2}, update: {$set: {a:2}}, upsert:true } }
    , { updateMany: { filter: {a:2}, update: {$set: {a:2}}, upsert:true } }
    , { deleteOne: { filter: {c:1} } }
    , { deleteMany: { filter: {c:1} } }
    , { replaceOne: { filter: {c:3}, replacement: {c:4}, upsert:true}}]
  , {ordered:true, w:1});
  test.equal(1, r.nInserted);
  test.equal(2, r.nUpserted);
  test.equal(0, r.nRemoved);

  // Crud fields
  test.equal(1, r.insertedCount);
  test.equal(1, Object.keys(r.insertedIds).length);
  test.equal(1, r.matchedCount);
  test.ok(r.modifiedCount == 0 || r.modifiedCount == 1);
  test.equal(0, r.deletedCount);
  test.equal(2, r.upsertedCount);
  test.equal(2, Object.keys(r.upsertedIds).length);

  // Ordered bulk operation
  db.close();
});

count(query, options, callback){Promise}

Count number of matching documents in the db to a query.

Name Type Default Description
query object

The query for the count.

options object null optional

Optional settings.

Name Type Default Description
limit boolean null optional

The limit of documents to count.

skip boolean null optional

The number of documents to skip for the count.

hint string null optional

An index name hint for the query.

readPreference ReadPreference | string null optional

The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).

maxTimeMS number null optional

Number of miliseconds to wait before aborting the query.

callback Collection~countCallback optional

The command result callback

Returns:
Promise if no callback passed
Examples
// Example of running simple count commands against a collection.

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
  // Crete the collection for the distinct example
  var collection = db.collection('countExample1');
  // Insert documents to perform distinct against
  collection.insertMany([{a:1}, {a:2}
    , {a:3}, {a:4, b:1}], {w: 1}, function(err, ids) {

    // Perform a total count command
    collection.count(function(err, count) {
      test.equal(null, err);
      test.equal(4, count);

      // Perform a partial account where b=1
      collection.count({b:1}, function(err, count) {
        test.equal(null, err);
        test.equal(1, count);

        db.close();
      });
    });
  });
});
// Example of running simple count commands against a collection using a Promise.

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
  // Crete the collection for the distinct example
  var collection = db.collection('countExample1_with_promise');
  // Insert documents to perform distinct against
  collection.insertMany([{a:1}, {a:2}
    , {a:3}, {a:4, b:1}], {w: 1}).then(function(ids) {
    // Perform a total count command
    collection.count().then(function(count) {
      test.equal(4, count);

      // Perform a partial account where b=1
      collection.count({b:1}).then(function(count) {
        test.equal(1, count);

        db.close();
      });
    });
  });
});
// Example of running simple count commands against a collection using a Generator and the co module.

var MongoClient = require('mongodb').MongoClient,
  co = require('co');
  test = require('assert');

co(function*() {
  var db = yield MongoClient.connect('mongodb://localhost:27017/test');
  // Crete the collection for the distinct example
  var collection = db.collection('countExample1_with_generators');
  // Insert documents to perform distinct against
  var result = yield collection.insertMany([{a:1}, {a:2}
    , {a:3}, {a:4, b:1}], {w: 1});
  // Perform a total count command
  var count = yield collection.count();
  test.equal(4, count);

  // Perform a partial account where b=1
  var count = yield collection.count({b:1});
  test.equal(1, count);

  // Close database
  db.close();
});

createIndex(fieldOrSpec, options, callback){Promise}

Creates an index on the db and collection collection.

Name Type Default Description
fieldOrSpec string | object

Defines the index.

options object null optional

Optional settings.

Name Type Default Description
w number | string null optional

The write concern.

wtimeout number null optional

The write concern timeout.

j boolean false optional

Specify a journal write concern.

unique boolean false optional

Creates an unique index.

sparse boolean false optional

Creates a sparse index.

background boolean false optional

Creates the index in the background, yielding whenever possible.

dropDups boolean false optional

A unique index cannot be created on a key that has pre-existing duplicate values. If you would like to create the index anyway, keeping the first document the database indexes and deleting all subsequent documents that have duplicate value

min number null optional

For geospatial indexes set the lower bound for the co-ordinates.

max number null optional

For geospatial indexes set the high bound for the co-ordinates.

v number null optional

Specify the format version of the indexes.

expireAfterSeconds number null optional

Allows you to expire data on indexes applied to a data (MongoDB 2.2 or higher)

name string null optional

Override the autogenerated index name (useful if the resulting name is larger than 128 bytes)

partialFilterExpression object null optional

Creates a partial index based on the given filter object (MongoDB 3.2 or higher)

collation object null optional

Specify collation (MongoDB 3.4 or higher) settings for update operation (see 3.4 documentation for available fields).

callback Collection~resultCallback optional

The command result callback

Returns:
Promise if no callback passed
Examples
// A more complex createIndex using a compound unique index in the background and dropping duplicated documents

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
  // Create a collection we want to drop later
  var collection = db.collection('createIndexExample1');
  // Insert a bunch of documents for the index
  collection.insertMany([{a:1, b:1}
    , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1}, function(err, result) {
    test.equal(null, err);

    // Create an index on the a field
    collection.createIndex({a:1, b:1}
      , {unique:true, background:true, w:1}, function(err, indexName) {

      // Show that duplicate records got dropped
      collection.find({}).toArray(function(err, items) {
        test.equal(null, err);
        test.equal(4, items.length);

        // Perform a query, with explain to show we hit the query
        collection.find({a:2}).explain(function(err, explanation) {
          test.equal(null, err);
          test.ok(explanation != null);

          db.close();
        });
      })
    });
  });
});
// A simple createIndex using a simple single field index

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {

  // Create a collection we want to drop later
  var collection = db.collection('createIndexExample2');
  // Insert a bunch of documents for the index
  collection.insertMany([{a:1}, {a:2}, {a:3}, {a:4}], {w:1}, function(err, result) {
    test.equal(null, err);

    // Create an index on the a field
    collection.createIndex('a', {w:1}, function(err, indexName) {
      test.equal("a_1", indexName);

      // Perform a query, with explain to show we hit the query
      collection.find({a:2}).explain(function(err, explanation) {
        test.equal(null, err);
        test.ok(explanation != null);

        db.close();
      });
    });
  });
});
// A more complex createIndex using a compound unique index in the background

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {

  // Create a collection we want to drop later
  var collection = db.collection('createIndexExample3');
  // Insert a bunch of documents for the index
  collection.insertMany([{a:1, b:1}
    , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1}, function(err, result) {
    test.equal(null, err);

    var options = {unique:true, background:true, w:1};
    // Create an index on the a field
    collection.createIndex({a:1, b:1}
      , options, function(err, indexName) {

      test.ok(!options.readPreference);
      // Show that duplicate records got dropped
      collection.find({}).toArray(function(err, items) {
        test.equal(null, err);
        test.equal(4, items.length);

        // Perform a query, with explain to show we hit the query
        collection.find({a:2}).explain(function(err, explanation) {
          test.equal(null, err);
          test.ok(explanation != null);

          db.close();
        });
      })
    });
  });
});
// A more complex createIndex using a Promise and a compound unique index in the background and dropping duplicated documents

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
  // Create a collection we want to drop later
  var collection = db.collection('createIndexExample1_with_promise');
  // Insert a bunch of documents for the index
  collection.insertMany([{a:1, b:1}
    , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1}).then(function(result) {

    // Create an index on the a field
    collection.createIndex({a:1, b:1}
      , {unique:true, background:true, w:1}).then(function(indexName) {

      // Show that duplicate records got dropped
      collection.find({}).toArray().then(function(items) {
        test.equal(4, items.length);

        // Perform a query, with explain to show we hit the query
        collection.find({a:2}).explain().then(function(explanation) {
          test.ok(explanation != null);

          db.close();
        });
      })
    });
  });
});
// A more complex createIndex using a Generator and the co module and a compound unique index in the background and dropping duplicated documents

var MongoClient = require('mongodb').MongoClient,
  co = require('co');
  test = require('assert');

co(function*() {
  var db = yield MongoClient.connect('mongodb://localhost:27017/test');
  // Create a collection we want to drop later
  var collection = db.collection('createIndexExample1_with_generators');
  // Insert a bunch of documents for the index
  yield collection.insertMany([{a:1, b:1}
    , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1});

  // Create an index on the a field
  yield collection.createIndex({a:1, b:1}
    , {unique:true, background:true, w:1});

  // Show that duplicate records got dropped
  var items = yield collection.find({}).toArray();
  test.equal(4, items.length);

  // Perform a query, with explain to show we hit the query
  var explanation = yield collection.find({a:2}).explain()
  test.ok(explanation != null);

  db.close();
});

createIndexes(indexSpecs, callback){Promise}

Creates multiple indexes in the collection, this method is only supported for
MongoDB 2.6 or higher. Earlier version of MongoDB will throw a command not supported
error. Index specifications are defined at http://docs.mongodb.org/manual/reference/command/createIndexes/.

Name Type Description
indexSpecs array

An array of index specifications to be created

callback Collection~resultCallback optional

The command result callback

Returns:
Promise if no callback passed

deleteMany(filter, options, callback){Promise}

Delete multiple documents on MongoDB

Name Type Default Description
filter object

The Filter used to select the documents to remove

options object null optional

Optional settings.

Name Type Default Description
w number | string null optional

The write concern.

wtimeout number null optional

The write concern timeout.

j boolean false optional

Specify a journal write concern.

callback Collection~deleteWriteOpCallback optional

The command result callback

Returns:
Promise if no callback passed

deleteOne(filter, options, callback){Promise}

Delete a document on MongoDB

Name Type Default Description
filter object

The Filter used to select the document to remove

options object null optional

Optional settings.

Name Type Default Description
w number | string null optional

The write concern.

wtimeout number null optional

The write concern timeout.

j boolean false optional

Specify a journal write concern.

callback Collection~deleteWriteOpCallback optional

The command result callback

Returns:
Promise if no callback passed

distinct(key, query, options, callback){Promise}

The distinct command returns returns a list of distinct values for the given key across a collection.

Name Type Default Description
key string

Field of the document to find distinct values for.

query object

The query for filtering the set of documents to which we apply the distinct filter.

options object null optional

Optional settings.

Name Type Default Description
readPreference ReadPreference | string null optional

The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).

maxTimeMS number null optional

Number of miliseconds to wait before aborting the query.

callback Collection~resultCallback optional

The command result callback

Returns:
Promise if no callback passed
Examples
// Example of running the distinct command against a collection

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
  // Crete the collection for the distinct example
  var collection = db.collection('distinctExample1');

  // Insert documents to perform distinct against
  collection.insertMany([{a:0, b:{c:'a'}}, {a:1, b:{c:'b'}}, {a:1, b:{c:'c'}},
    {a:2, b:{c:'a'}}, {a:3}, {a:3}], {w:1}, function(err, ids) {

    // Perform a distinct query against the a field
    collection.distinct('a', function(err, docs) {
      test.deepEqual([0, 1, 2, 3], docs.sort());

      // Perform a distinct query against the sub-field b.c
      collection.distinct('b.c', function(err, docs) {
        test.deepEqual(['a', 'b', 'c'], docs.sort());

        db.close();
      });
    });
  });
});
// Example of running the distinct command against a collection with a filter query

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {

  // Crete the collection for the distinct example
  var collection = db.collection('distinctExample2');

  // Insert documents to perform distinct against
  collection.insertMany([{a:0, b:{c:'a'}}, {a:1, b:{c:'b'}}, {a:1, b:{c:'c'}},
    {a:2, b:{c:'a'}}, {a:3}, {a:3}, {a:5, c:1}], {w:1}, function(err, ids) {

    // Perform a distinct query with a filter against the documents
    collection.distinct('a', {c:1}, function(err, docs) {
      test.deepEqual([5], docs.sort());

      db.close();
    });
  })
});
// Example of running the distinct command using a Promise against a collection

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
  // Crete the collection for the distinct example
  var collection = db.collection('distinctExample1_with_promise');

  // Insert documents to perform distinct against
  collection.insertMany([{a:0, b:{c:'a'}}, {a:1, b:{c:'b'}}, {a:1, b:{c:'c'}},
    {a:2, b:{c:'a'}}, {a:3}, {a:3}], {w:1}).then(function(ids) {

    // Perform a distinct query against the a field
    collection.distinct('a').then(function(docs) {
      test.deepEqual([0, 1, 2, 3], docs.sort());

      // Perform a distinct query against the sub-field b.c
      collection.distinct('b.c').then(function(docs) {
        test.deepEqual(['a', 'b', 'c'], docs.sort());

        db.close();
      });
    });
  });
});
// Example of running the distinct command using a Generator and the co module against a collection

var MongoClient = require('mongodb').MongoClient,
  co = require('co');
  test = require('assert');

co(function*() {
  var db = yield MongoClient.connect('mongodb://localhost:27017/test');
  // Crete the collection for the distinct example
  var collection = db.collection('distinctExample1_with_generators');

  // Insert documents to perform distinct against
  yield collection.insertMany([{a:0, b:{c:'a'}}, {a:1, b:{c:'b'}}, {a:1, b:{c:'c'}},
    {a:2, b:{c:'a'}}, {a:3}, {a:3}], {w:1});

  // Perform a distinct query against the a field
  var docs = yield collection.distinct('a');
  test.deepEqual([0, 1, 2, 3], docs.sort());

  // Perform a distinct query against the sub-field b.c
  var docs = yield collection.distinct('b.c');
  test.deepEqual(['a', 'b', 'c'], docs.sort());

  db.close();
});

drop(options, callback){Promise}

Drop the collection from the database, removing it permanently. New accesses will create a new collection.

Name Type Default Description
options object null optional

Optional settings.

callback Collection~resultCallback optional

The results callback

Returns:
Promise if no callback passed
Examples
// Example of a simple collection drop.

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {

  // Create a collection we want to drop later
  var collection = db.collection('test_other_drop');

  // Drop the collection
  collection.drop(function(err, reply) {

    // Ensure we don't have the collection in the set of names
    db.listCollections().toArray(function(err, replies) {

      var found = false;
      // For each collection in the list of collection names in this db look for the
      // dropped collection
      replies.forEach(function(document) {
        if(document.name == "test_other_drop") {
          found = true;
          return;
        }
      });

      // Ensure the collection is not found
      test.equal(false, found);

      // Let's close the db
      db.close();
    });
  });
});
// Example of Collection.prototype.drop using a Promise

var MongoClient = require('mongodb').MongoClient,
  test = require('assert');
MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {

  // Create a collection we want to drop later
  db.createCollection('test_other_drop_with_promise').then(function(collection) {
    // Drop the collection
    collection.drop().then(function(reply) {

      // Ensure we don't have the collection in the set of names
      db.listCollections().toArray().then(function(replies) {

        var found = false;
        // For each collection in the list of collection names in this db look for the
        // dropped collection
        replies.forEach(function(document) {
          if(document.name == "test_other_drop_with_promise") {
            found = true;
            return;
          }
        });

        // Ensure the collection is not found
        test.equal(false, found);

        // Let's close the db
        db.close();
      });
    });
  });
});
// Example of Collection.prototype.drop using a Generator and the co module

var MongoClient = require('mongodb').MongoClient,
  co = require('co');
  test = require('assert');

co(function*() {
  var db = yield MongoClient.connect('mongodb://localhost:27017/test');

  // Create a collection we want to drop later
  var collection = yield db.createCollection('test_other_drop_with_generators');

  // Drop the collection
  yield collection.drop();

  // Ensure we don't have the collection in the set of names
  var replies = yield db.listCollections().toArray();

  // Did we find the collection
  var found = false;
  // For each collection in the list of collection names in this db look for the
  // dropped collection
  replies.forEach(function(document) {
    if(document.name == "test_other_drop_with_generators") {
      found = true;
      return;
    }
  });

  // Ensure the collection is not found
  test.equal(false, found);

  // Let's close the db
  db.close();
});

dropAllIndexes(callback){Promise}

Drops all indexes from this collection.

Name Type Description
callback Collection~resultCallback

The command result callback

Deprecated
  • use dropIndexes
    Returns:
    Promise if no [callback] passed
    Examples
    // Example of a how to drop all the indexes on a collection using dropAllIndexes
    
    var MongoClient = require('mongodb').MongoClient,
      test = require('assert');
    MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
      db.createCollection('dropExample1', function(err, r) {
        test.equal(null, err);
    
        // Drop the collection
        db.collection('dropExample1').dropAllIndexes(function(err, reply) {
          test.equal(null, err);
    
          // Let's close the db
          db.close();
        });
      });
    });
    // Example of a how to drop all the indexes on a collection using dropAllIndexes with a Promise
    
    var MongoClient = require('mongodb').MongoClient,
      test = require('assert');
    MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
      db.createCollection('dropExample1_with_promise').then(function(r) {
        // Drop the collection
        db.collection('dropExample1_with_promise').dropAllIndexes().then(function(reply) {
          // Let's close the db
          db.close();
        });
      });
    });
    // Example of a how to drop all the indexes on a collection using dropAllIndexes with a Generator and the co module
    
    var MongoClient = require('mongodb').MongoClient,
      co = require('co');
      test = require('assert');
    
    co(function*() {
      var db = yield MongoClient.connect('mongodb://localhost:27017/test');
      yield db.createCollection('dropExample1_with_generators');
      // Drop the collection
      yield db.collection('dropExample1_with_generators').dropAllIndexes();
      // Let's close the db
      db.close();
    });

    dropIndex(indexName, options, callback){Promise}

    Drops an index from this collection.

    Name Type Default Description
    indexName string

    Name of the index to drop.

    options object null optional

    Optional settings.

    Name Type Default Description
    w number | string null optional

    The write concern.

    wtimeout number null optional

    The write concern timeout.

    j boolean false optional

    Specify a journal write concern.

    callback Collection~resultCallback optional

    The command result callback

    Returns:
    Promise if no callback passed
    Examples
    // An examples showing the creation and dropping of an index
    
    var MongoClient = require('mongodb').MongoClient,
      test = require('assert');
    MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
      var collection = db.collection('dropIndexExample1');
      // Insert a bunch of documents for the index
      collection.insertMany([{a:1, b:1}
        , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1}, function(err, result) {
        test.equal(null, err);
    
        // Create an index on the a field
        collection.ensureIndex({a:1, b:1}
          , {unique:true, background:true, w:1}, function(err, indexName) {
    
          // Drop the index
          collection.dropIndex("a_1_b_1", function(err, result) {
            test.equal(null, err);
    
            // Verify that the index is gone
            collection.indexInformation(function(err, indexInformation) {
              test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
              test.equal(null, indexInformation.a_1_b_1);
    
              db.close();
            });
          });
        });
      });
    });
    // An examples showing the creation and dropping of an index using a Promise
    
    var MongoClient = require('mongodb').MongoClient,
      test = require('assert');
    MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
      var collection = db.collection('dropIndexExample1_with_promise');
      // Insert a bunch of documents for the index
      collection.insertMany([{a:1, b:1}
        , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1}).then(function(result) {
    
        // Create an index on the a field
        collection.ensureIndex({a:1, b:1}
          , {unique:true, background:true, w:1}).then(function(indexName) {
    
          // Drop the index
          collection.dropIndex("a_1_b_1").then(function(result) {
    
            // Verify that the index is gone
            collection.indexInformation().then(function(indexInformation) {
              test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
              test.equal(null, indexInformation.a_1_b_1);
    
              db.close();
            });
          });
        });
      });
    });
    // An examples showing the creation and dropping of an index using a Generator and the co module
    
    var MongoClient = require('mongodb').MongoClient,
      co = require('co');
      test = require('assert');
    
    co(function*() {
      var db = yield MongoClient.connect('mongodb://localhost:27017/test');
      var collection = db.collection('dropIndexExample1_with_generators');
      // Insert a bunch of documents for the index
      yield collection.insertMany([{a:1, b:1}
        , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1});
    
      // Create an index on the a field
      yield collection.ensureIndex({a:1, b:1}
        , {unique:true, background:true, w:1});
    
      // Drop the index
      yield collection.dropIndex("a_1_b_1");
    
      // Verify that the index is gone
      var indexInformation = yield collection.indexInformation()
      test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
      test.equal(null, indexInformation.a_1_b_1);
    
      // Close db
      db.close();
    });

    dropIndexes(callback){Promise}

    Drops all indexes from this collection.

    Name Type Description
    callback Collection~resultCallback optional

    The command result callback

    Returns:
    Promise if no callback passed
    Examples
    // An examples showing the creation and dropping of an index
    
    var MongoClient = require('mongodb').MongoClient,
      test = require('assert');
    MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
    
      // Create a collection we want to drop later
      var collection = db.collection('shouldCorrectlyCreateAndDropAllIndex');
      // Insert a bunch of documents for the index
      collection.insertMany([{a:1, b:1}
        , {a:2, b:2}, {a:3, b:3}, {a:4, b:4, c:4}], {w:1}, function(err, result) {
        test.equal(null, err);
    
        // Create an index on the a field
        collection.ensureIndex({a:1, b:1}
          , {unique:true, background:true, w:1}, function(err, indexName) {
    
          // Create an additional index
          collection.ensureIndex({c:1}
            , {unique:true, background:true, w:1}, function(err, indexName) {
    
            // Drop the index
            collection.dropAllIndexes(function(err, result) {
              test.equal(null, err);
    
              // Verify that the index is gone
              collection.indexInformation(function(err, indexInformation) {
                test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
                test.equal(null, indexInformation.a_1_b_1);
                test.equal(null, indexInformation.c_1);
    
                db.close();
              });
            });
          });
        });
      });
    });
    // An examples showing the creation and dropping of an index using Promises.
    
    var MongoClient = require('mongodb').MongoClient,
      test = require('assert');
    MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
    
      // Create a collection we want to drop later
      var collection = db.collection('shouldCorrectlyCreateAndDropAllIndex_with_promise');
      // Insert a bunch of documents for the index
      collection.insertMany([{a:1, b:1}
        , {a:2, b:2}, {a:3, b:3}, {a:4, b:4, c:4}], {w:1}).then(function(result) {
    
        // Create an index on the a field
        collection.ensureIndex({a:1, b:1}
          , {unique:true, background:true, w:1}).then(function(indexName) {
    
          // Create an additional index
          collection.ensureIndex({c:1}
            , {unique:true, background:true, sparse:true, w:1}).then(function(indexName) {
    
            // Drop the index
            collection.dropAllIndexes().then(function(result) {
    
              // Verify that the index is gone
              collection.indexInformation().then(function(indexInformation) {
                test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
                test.equal(null, indexInformation.a_1_b_1);
                test.equal(null, indexInformation.c_1);
    
                db.close();
              });
            });
          });
        });
      });
    });
    // An examples showing the creation and dropping of an index using Generators.
    
    var MongoClient = require('mongodb').MongoClient,
      co = require('co');
      test = require('assert');
    
    co(function*() {
      var db = yield MongoClient.connect('mongodb://localhost:27017/test');
    
      // Create a collection we want to drop later
      var collection = db.collection('shouldCorrectlyCreateAndDropAllIndex_with_generators');
      // Insert a bunch of documents for the index
      yield collection.insertMany([{a:1, b:1}
        , {a:2, b:2}, {a:3, b:3}, {a:4, b:4, c:4}], {w:1});
    
      // Create an index on the a field
      yield collection.ensureIndex({a:1, b:1}
        , {unique:true, background:true, w:1});
    
      // Create an additional index
      yield collection.ensureIndex({c:1}
        , {unique:true, background:true, sparse:true, w:1});
    
      // Drop the index
      yield collection.dropAllIndexes();
    
      // Verify that the index is gone
      var indexInformation = yield collection.indexInformation();
      test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
      test.equal(null, indexInformation.a_1_b_1);
      test.equal(null, indexInformation.c_1);
    
      db.close();
    });

    ensureIndex(fieldOrSpec, options, callback){Promise}

    Ensures that an index exists, if it does not it creates it

    Name Type Default Description
    fieldOrSpec string | object

    Defines the index.

    options object null optional

    Optional settings.

    Name Type Default Description
    w number | string null optional

    The write concern.

    wtimeout number null optional

    The write concern timeout.

    j boolean false optional

    Specify a journal write concern.

    unique boolean false optional

    Creates an unique index.

    sparse boolean false optional

    Creates a sparse index.

    background boolean false optional

    Creates the index in the background, yielding whenever possible.

    dropDups boolean false optional

    A unique index cannot be created on a key that has pre-existing duplicate values. If you would like to create the index anyway, keeping the first document the database indexes and deleting all subsequent documents that have duplicate value

    min number null optional

    For geospatial indexes set the lower bound for the co-ordinates.

    max number null optional

    For geospatial indexes set the high bound for the co-ordinates.

    v number null optional

    Specify the format version of the indexes.

    expireAfterSeconds number null optional

    Allows you to expire data on indexes applied to a data (MongoDB 2.2 or higher)

    name number null optional

    Override the autogenerated index name (useful if the resulting name is larger than 128 bytes)

    collation object null optional

    Specify collation (MongoDB 3.4 or higher) settings for update operation (see 3.4 documentation for available fields).

    callback Collection~resultCallback optional

    The command result callback

    Deprecated
    • use createIndexes instead
      Returns:
      Promise if no callback passed
      Examples
      // A more complex ensureIndex using a compound unique index in the background and dropping duplicated documents.
      
      var MongoClient = require('mongodb').MongoClient,
        test = require('assert');
      MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
        var collection = db.collection('ensureIndexExample1');
        // Insert a bunch of documents for the index
        collection.insertMany([{a:1, b:1}
          , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1}, function(err, result) {
          test.equal(null, err);
      
          // Create an index on the a field
          db.ensureIndex('ensureIndexExample1', {a:1, b:1}
            , {unique:true, background:true, w:1}, function(err, indexName) {
      
            // Show that duplicate records got dropped
            collection.find({}).toArray(function(err, items) {
              test.equal(null, err);
              test.equal(4, items.length);
      
              // Perform a query, with explain to show we hit the query
              collection.find({a:2}).explain(function(err, explanation) {
                test.equal(null, err);
                test.ok(explanation != null);
      
                db.close();
              });
            })
          });
        });
      });
      // A more complex ensureIndex using a compound unique index in the background.
      
      var MongoClient = require('mongodb').MongoClient,
        test = require('assert');
      MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
        var collection = db.collection('ensureIndexExample2');
        // Insert a bunch of documents for the index
        collection.insertMany([{a:1, b:1}
          , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1}, function(err, result) {
          test.equal(null, err);
      
          // Create an index on the a field
          collection.ensureIndex({a:1, b:1}
            , {unique:true, background:true, w:1}, function(err, indexName) {
            test.equal(null, err);
      
            // Show that duplicate records got dropped
            collection.find({}).toArray(function(err, items) {
              test.equal(null, err);
              test.equal(4, items.length);
      
              // Perform a query, with explain to show we hit the query
              collection.find({a:2}).explain(function(err, explanation) {
                test.equal(null, err);
                test.ok(explanation != null);
      
                db.close();
              });
            })
          });
        });
      });
      // A more complex ensureIndex using a compound unique index in the background and dropping duplicated documents using a Promise.
      
      var MongoClient = require('mongodb').MongoClient,
        test = require('assert');
      MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
        var collection = db.collection('ensureIndexExample1_with_promise');
        // Insert a bunch of documents for the index
        collection.insertMany([{a:1, b:1}
          , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1}).then(function(result) {
      
          // Create an index on the a field
          db.ensureIndex('ensureIndexExample1_with_promise', {a:1, b:1}
            , {unique:true, background:true, w:1}).then(function(indexName) {
      
            // Show that duplicate records got dropped
            collection.find({}).toArray().then(function(items) {
              test.equal(4, items.length);
      
              // Perform a query, with explain to show we hit the query
              collection.find({a:2}).explain().then(function(explanation) {
                test.ok(explanation != null);
      
                db.close();
              });
            })
          });
        });
      });
      // A more complex ensureIndex using a compound unique index in the background using a Promise.
      
      var MongoClient = require('mongodb').MongoClient,
        test = require('assert');
      MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
        var collection = db.collection('ensureIndexExample2_with_promise');
        // Insert a bunch of documents for the index
        collection.insertMany([{a:1, b:1}
          , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1}).then(function(result) {
      
          // Create an index on the a field
          collection.ensureIndex({a:1, b:1}
            , {unique:true, background:true, w:1}).then(function(indexName) {
      
            // Show that duplicate records got dropped
            collection.find({}).toArray().then(function(items) {
              test.equal(4, items.length);
      
              // Perform a query, with explain to show we hit the query
              collection.find({a:2}).explain().then(function(explanation) {
                test.ok(explanation != null);
      
                db.close();
              });
            })
          });
        });
      });
      // A more complex ensureIndex using a compound unique index in the background and dropping duplicated documents using a Generator and the co module.
      
      var MongoClient = require('mongodb').MongoClient,
        co = require('co');
        test = require('assert');
      
      co(function*() {
        var db = yield MongoClient.connect('mongodb://localhost:27017/test');
        var collection = db.collection('ensureIndexExample1_with_generators');
        // Insert a bunch of documents for the index
        yield collection.insertMany([{a:1, b:1}
          , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1});
      
        // Create an index on the a field
        yield db.ensureIndex('ensureIndexExample1_with_generators', {a:1, b:1}
          , {unique:true, background:true, w:1});
      
        // Show that duplicate records got dropped
        var items = yield collection.find({}).toArray();
        test.equal(4, items.length);
      
        // Perform a query, with explain to show we hit the query
        var explanation = yield collection.find({a:2}).explain();
        test.ok(explanation != null);
      
        db.close();
      });
      // A more complex ensureIndex using a compound unique index in the background using a Generator and the co module.
      
      var MongoClient = require('mongodb').MongoClient,
        co = require('co');
        test = require('assert');
      
      co(function*() {
        var db = yield MongoClient.connect('mongodb://localhost:27017/test');
        var collection = db.collection('ensureIndexExample2_with_generators');
        // Insert a bunch of documents for the index
        yield collection.insertMany([{a:1, b:1}
          , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1});
      
        // Create an index on the a field
        yield collection.ensureIndex({a:1, b:1}
          , {unique:true, background:true, w:1});
      
        // Show that duplicate records got dropped
        var items = yield collection.find({}).toArray();
        test.equal(4, items.length);
      
        // Perform a query, with explain to show we hit the query
        var explanation = yield collection.find({a:2}).explain();
        test.ok(explanation != null);
      
        // Close db
        db.close();
      });

      Creates a cursor for a query that can be used to iterate over results from MongoDB

      Name Type Description
      query object

      The cursor query object.

      Throws:
      Examples
      // A simple query using the find method on the collection.
      
      var MongoClient = require('mongodb').MongoClient,
        test = require('assert');
      MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
      
        // Create a collection we want to drop later
        var collection = db.collection('simple_query');
      
        // Insert a bunch of documents for the testing
        collection.insertMany([{a:1}, {a:2}, {a:3}], {w:1}, function(err, result) {
          test.equal(null, err);
      
          // Perform a simple find and return all the documents
          collection.find().toArray(function(err, docs) {
            test.equal(null, err);
            test.equal(3, docs.length);
      
            db.close();
          });
        });
      });
      // A simple query showing the explain for a query
      
      var MongoClient = require('mongodb').MongoClient,
        test = require('assert');
      MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
      
        // Create a collection we want to drop later
        var collection = db.collection('simple_explain_query');
        // Insert a bunch of documents for the testing
        collection.insertMany([{a:1}, {a:2}, {a:3}], {w:1}, function(err, result) {
          test.equal(null, err);
      
          // Perform a simple find and return all the documents
          collection.find({}).explain(function(err, explain) {
            test.equal(null, err);
            test.ok(explain != null);
      
            db.close();
          });
        });
      });
      // A simple query showing skip and limit
      
      var MongoClient = require('mongodb').MongoClient,
        test = require('assert');
      MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
      
        // Create a collection we want to drop later
        var collection = db.collection('simple_limit_skip_query');
        // Insert a bunch of documents for the testing
        collection.insertMany([{a:1, b:1}, {a:2, b:2}, {a:3, b:3}], {w:1}, function(err, result) {
          test.equal(null, err);
      
          // Perform a simple find and return all the documents
          collection.find({})
            .skip(1).limit(1).project({b:1}).toArray(function(err, docs) {
              test.equal(null, err);
              test.equal(1, docs.length);
              test.equal(null, docs[0].a);
              test.equal(2, docs[0].b);
      
              db.close();
          });
        });
      });
      // A simple query using the find method and toArray method with a Promise.
      
      var MongoClient = require('mongodb').MongoClient,
        test = require('assert');
      MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
      
        // Create a collection we want to drop later
        var collection = db.collection('simple_query_with_promise');
      
        // Insert a bunch of documents for the testing
        collection.insertMany([{a:1}, {a:2}, {a:3}], {w:1}).then(function(result) {
      
          // Perform a simple find and return all the documents
          collection.find().toArray().then(function(docs) {
            test.equal(3, docs.length);
      
            db.close();
          });
        });
      });
      // A simple query showing the explain for a query using a Promise.
      
      var MongoClient = require('mongodb').MongoClient,
        test = require('assert');
      MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
      
        // Create a collection we want to drop later
        var collection = db.collection('simple_explain_query_with_promise');
        // Insert a bunch of documents for the testing
        collection.insertMany([{a:1}, {a:2}, {a:3}], {w:1}).then(function(result) {
      
          // Perform a simple find and return all the documents
          collection.find({}).explain().then(function(docs) {
            test.ok(docs != null);
      
            db.close();
          });
        });
      });
      // A simple query showing skip and limit using a Promise.
      
      var MongoClient = require('mongodb').MongoClient,
        test = require('assert');
      MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
      
        // Create a collection we want to drop later
        var collection = db.collection('simple_limit_skip_query_with_promise');
        // Insert a bunch of documents for the testing
        collection.insertMany([{a:1, b:1}, {a:2, b:2}, {a:3, b:3}], {w:1}).then(function(result) {
      
          // Perform a simple find and return all the documents
          collection.find({})
            .skip(1).limit(1).project({b:1}).toArray().then(function(docs) {
              test.equal(1, docs.length);
              test.equal(null, docs[0].a);
              test.equal(2, docs[0].b);
      
              db.close();
          });
        });
      });
      // A simple query using the find method and toArray method with a Generator and the co module.
      
      var MongoClient = require('mongodb').MongoClient,
        co = require('co');
        test = require('assert');
      
      co(function*() {
        var db = yield MongoClient.connect('mongodb://localhost:27017/test');
      
        // Create a collection we want to drop later
        var collection = db.collection('simple_query_with_generators');
      
        // Insert a bunch of documents for the testing
        yield collection.insertMany([{a:1}, {a:2}, {a:3}], {w:1});
      
        // Perform a simple find and return all the documents
        var docs = yield collection.find().toArray();
        test.equal(3, docs.length);
      
        // Close the db
        db.close();
      });
      // A simple query showing the explain for a query using a Generator and the co module.
      
      var MongoClient = require('mongodb').MongoClient,
        co = require('co');
        test = require('assert');
      
      co(function*() {
        var db = yield MongoClient.connect('mongodb://localhost:27017/test');
      
        // Create a collection we want to drop later
        var collection = db.collection('simple_explain_query_with_generators');
        // Insert a bunch of documents for the testing
        yield collection.insertMany([{a:1}, {a:2}, {a:3}], {w:1});
      
        // Perform a simple find and return all the documents
        var explain = yield collection.find({}).explain();
        test.ok(explain != null);
      
        db.close();
      });
      // A simple query showing skip and limit using a Generator and the co module.
      
      var MongoClient = require('mongodb').MongoClient,
        co = require('co');
        test = require('assert');
      
      co(function*() {
        var db = yield MongoClient.connect('mongodb://localhost:27017/test');
      
        // Create a collection we want to drop later
        var collection = db.collection('simple_limit_skip_query_with_generators');
        // Insert a bunch of documents for the testing
        yield collection.insertMany([{a:1, b:1}, {a:2, b:2}, {a:3, b:3}], {w:1});
      
        // Perform a simple find and return all the documents
        var docs = yield collection.find({})
        .skip(1).limit(1).project({b:1}).toArray();
          test.equal(1, docs.length);
          test.equal(null, docs[0].a);
          test.equal(2, docs[0].b);
      
          // Close db
          db.close();
      });

      findAndModify(query, sort, doc, options, callback){Promise}

      Find and update a document.

      Name Type Default Description
      query object

      Query object to locate the object to modify.

      sort array

      If multiple docs match, choose the first one in the specified sort order as the object to manipulate.

      doc object

      The fields/vals to be updated.

      options object null optional

      Optional settings.

      Name Type Default Description
      w number | string null optional

      The write concern.

      wtimeout number null optional

      The write concern timeout.

      j boolean false optional

      Specify a journal write concern.

      remove boolean false optional

      Set to true to remove the object before returning.

      upsert boolean false optional

      Perform an upsert operation.

      new boolean false optional

      Set to true if you want to return the modified object rather than the original. Ignored for remove.

      fields object null optional

      Object containing the field projection for the result returned from the operation.

      callback Collection~findAndModifyCallback optional

      The command result callback

      Deprecated
      • use findOneAndUpdate, findOneAndReplace or findOneAndDelete instead
        Returns:
        Promise if no callback passed
        Examples
        // A whole set of different ways to use the findAndModify command.
        // The first findAndModify command modifies a document and returns the modified document back.
        The second findAndModify command removes the document.
        The second findAndModify command upserts a document and returns the new document. var MongoClient = require('mongodb').MongoClient, test = require('assert'); MongoClient.connect('mongodb://localhost:27017/test', function(err, db) { // Create a collection we want to drop later var collection = db.collection('simple_find_and_modify_operations_'); // Insert some test documentations collection.insertMany([{a:1}, {b:1}, {c:1}], {w:1}, function(err, result) { test.equal(null, err); // Simple findAndModify command returning the new document collection.findAndModify({a:1}, [['a', 1]], {$set:{b1:1}}, {new:true}, function(err, doc) { test.equal(null, err); test.equal(1, doc.value.a); test.equal(1, doc.value.b1); // Simple findAndModify command returning the new document and // removing it at the same time collection.findAndModify({b:1}, [['b', 1]], {$set:{b:2}}, {remove:true}, function(err, doc) { // Verify that the document is gone collection.findOne({b:1}, function(err, item) { test.equal(null, err); test.equal(null, item); // Simple findAndModify command performing an upsert and returning the new document // executing the command safely collection.findAndModify({d:1}, [['b', 1]], {d:1, f:1}, {new:true, upsert:true, w:1}, function(err, doc) { test.equal(null, err); test.equal(1, doc.value.d); test.equal(1, doc.value.f); db.close(); }) }); }); }); }); });
        // A whole set of different ways to use the findAndModify command with a Promise..
        // The first findAndModify command modifies a document and returns the modified document back.
        The second findAndModify command removes the document.
        The second findAndModify command upserts a document and returns the new document. var MongoClient = require('mongodb').MongoClient, test = require('assert'); MongoClient.connect('mongodb://localhost:27017/test', function(err, db) { // Create a collection we want to drop later var collection = db.collection('simple_find_and_modify_operations_with_promise'); // Insert some test documentations collection.insertMany([{a:1}, {b:1}, {c:1}], {w:1}).then(function(result) { // Simple findAndModify command returning the new document collection.findAndModify({a:1}, [['a', 1]], {$set:{b1:1}}, {new:true}).then(function(doc) { test.equal(1, doc.value.a); test.equal(1, doc.value.b1); // Simple findAndModify command returning the new document and // removing it at the same time collection.findAndModify({b:1}, [['b', 1]], {$set:{b:2}}, {remove:true}).then(function(doc) { // Verify that the document is gone collection.findOne({b:1}).then(function(item) { test.equal(null, item); // Simple findAndModify command performing an upsert and returning the new document // executing the command safely collection.findAndModify({d:1}, [['b', 1]], {d:1, f:1}, {new:true, upsert:true, w:1}).then(function(doc) { test.equal(1, doc.value.d); test.equal(1, doc.value.f); db.close(); }) }); }); }); }); });
        // A whole set of different ways to use the findAndModify command with a Generator and the co module..
        // The first findAndModify command modifies a document and returns the modified document back.
        The second findAndModify command removes the document.
        The second findAndModify command upserts a document and returns the new document. var MongoClient = require('mongodb').MongoClient, co = require('co'); test = require('assert'); co(function*() { var db = yield MongoClient.connect('mongodb://localhost:27017/test'); // Create a collection we want to drop later var collection = db.collection('simple_find_and_modify_operations_with_generators'); // Insert some test documentations yield collection.insertMany([{a:1}, {b:1}, {c:1}], {w:1}); // Simple findAndModify command returning the new document var doc = yield collection.findAndModify({a:1}, [['a', 1]], {$set:{b1:1}}, {new:true}); test.equal(1, doc.value.a); test.equal(1, doc.value.b1); // Simple findAndModify command returning the new document and // removing it at the same time var doc = yield collection.findAndModify({b:1}, [['b', 1]], {$set:{b:2}}, {remove:true}); // Verify that the document is gone var item = yield collection.findOne({b:1}); test.equal(null, item); // Simple findAndModify command performing an upsert and returning the new document // executing the command safely var doc = yield collection.findAndModify({d:1}, [['b', 1]], {d:1, f:1}, {new:true, upsert:true, w:1}); test.equal(1, doc.value.d); test.equal(1, doc.value.f); // Close the db db.close(); });

        findAndRemove(query, sort, options, callback){Promise}

        Find and remove a document.

        Name Type Default Description
        query object

        Query object to locate the object to modify.

        sort array

        If multiple docs match, choose the first one in the specified sort order as the object to manipulate.

        options object null optional

        Optional settings.

        Name Type Default Description
        w number | string null optional

        The write concern.

        wtimeout number null optional

        The write concern timeout.

        j boolean false optional

        Specify a journal write concern.

        callback Collection~resultCallback optional

        The command result callback

        Deprecated
        • use findOneAndDelete instead
          Returns:
          Promise if no callback passed
          Examples
          // An example of using findAndRemove
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
          
            // Create a collection we want to drop later
            var collection = db.collection('simple_find_and_modify_operations_2');
            // Insert some test documentations
            collection.insertMany([{a:1}, {b:1, d:1}, {c:1}], {w:1}, function(err, result) {
              test.equal(null, err);
          
              // Simple findAndModify command returning the old document and
              // removing it at the same time
              collection.findAndRemove({b:1}, [['b', 1]], function(err, doc) {
                test.equal(null, err);
                test.equal(1, doc.value.b);
                test.equal(1, doc.value.d);
          
                // Verify that the document is gone
                collection.findOne({b:1}, function(err, item) {
                  test.equal(null, err);
                  test.equal(null, item);
          
                  db.close();
                });
              });
            });
          });
          // An example of using findAndRemove using a Promise.
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
          
            // Create a collection we want to drop later
            var collection = db.collection('simple_find_and_modify_operations_2_with_promise');
            // Insert some test documentations
            collection.insertMany([{a:1}, {b:1, d:1}, {c:1}], {w:1}).then(function(result) {
          
              // Simple findAndModify command returning the old document and
              // removing it at the same time
              collection.findAndRemove({b:1}, [['b', 1]]).then(function(doc) {
                test.equal(1, doc.value.b);
                test.equal(1, doc.value.d);
          
                // Verify that the document is gone
                collection.findOne({b:1}).then(function(item) {
                  test.equal(null, item);
          
                  db.close();
                });
              });
            });
          });
          // An example of using findAndRemove using a Generator and the co module.
          
          var MongoClient = require('mongodb').MongoClient,
            co = require('co');
            test = require('assert');
          
          co(function*() {
            var db = yield MongoClient.connect('mongodb://localhost:27017/test');
          
            // Create a collection we want to drop later
            var collection = db.collection('simple_find_and_modify_operations_2_with_generators');
            // Insert some test documentations
            yield collection.insertMany([{a:1}, {b:1, d:1}, {c:1}], {w:1});
          
            // Simple findAndModify command returning the old document and
            // removing it at the same time
            var doc = yield collection.findAndRemove({b:1}, [['b', 1]]);
            test.equal(1, doc.value.b);
            test.equal(1, doc.value.d);
          
            // Verify that the document is gone
            var item = yield collection.findOne({b:1});
            test.equal(null, item);
          
            // Db close
            db.close();
          });

          findOne(query, options, callback){Promise}

          Fetches the first document that matches the query

          Name Type Default Description
          query object

          Query for find Operation

          options object null optional

          Optional settings.

          Name Type Default Description
          limit number 0 optional

          Sets the limit of documents returned in the query.

          sort array | object null optional

          Set to sort the documents coming back from the query. Array of indexes, [['a', 1]] etc.

          fields object null optional

          The fields to return in the query. Object of fields to include or exclude (not both), {'a':1}

          skip number 0 optional

          Set to skip N documents ahead in your query (useful for pagination).

          hint Object null optional

          Tell the query to use specific indexes in the query. Object of indexes to use, {'_id':1}

          explain boolean false optional

          Explain the query instead of returning the data.

          snapshot boolean false optional

          Snapshot query.

          timeout boolean false optional

          Specify if the cursor can timeout.

          tailable boolean false optional

          Specify if the cursor is tailable.

          batchSize number 0 optional

          Set the batchSize for the getMoreCommand when iterating over the query results.

          returnKey boolean false optional

          Only return the index key.

          maxScan number null optional

          Limit the number of items to scan.

          min number null optional

          Set index bounds.

          max number null optional

          Set index bounds.

          showDiskLoc boolean false optional

          Show disk location of results.

          comment string null optional

          You can put a $comment field on a query to make looking in the profiler logs simpler.

          raw boolean false optional

          Return document results as raw BSON buffers.

          promoteLongs boolean true optional

          Promotes Long values to number if they fit inside the 53 bits resolution.

          promoteValues boolean true optional

          Promotes BSON values to native types where possible, set to false to only receive wrapper types.

          promoteBuffers boolean false optional

          Promotes Binary BSON values to native Node Buffers.

          readPreference ReadPreference | string null optional

          The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).

          partial boolean false optional

          Specify if the cursor should return partial results when querying against a sharded system

          maxTimeMS number null optional

          Number of miliseconds to wait before aborting the query.

          collation object null optional

          Specify collation (MongoDB 3.4 or higher) settings for update operation (see 3.4 documentation for available fields).

          callback Collection~resultCallback optional

          The command result callback

          Returns:
          Promise if no callback passed
          Examples
          // A simple query using findOne
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
          
            // Create a collection we want to drop later
            var collection = db.collection('simple_limit_skip_find_one_query');
            // Insert a bunch of documents for the testing
            collection.insertMany([{a:1, b:1}, {a:2, b:2}, {a:3, b:3}], {w:1}, function(err, result) {
              test.equal(null, err);
          
              // Perform a simple find and return all the documents
              collection.findOne({a:2}, {fields:{b:1}}, function(err, doc) {
                test.equal(null, err);
                test.equal(null, doc.a);
                test.equal(2, doc.b);
          
                db.close();
              });
            });
          });
          // A simple query using findOne with a Promise.
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
          
            // Create a collection we want to drop later
            var collection = db.collection('simple_limit_skip_find_one_query_with_promise');
            // Insert a bunch of documents for the testing
            collection.insertMany([{a:1, b:1}, {a:2, b:2}, {a:3, b:3}], {w:1}).then(function(result) {
          
              // Perform a simple find and return all the documents
              collection.findOne({a:2}, {fields:{b:1}}).then(function(doc) {
                test.equal(null, doc.a);
                test.equal(2, doc.b);
          
                db.close();
              });
            });
          });
          // A simple query using findOne with a Generator and the co module.
          
          var MongoClient = require('mongodb').MongoClient,
            co = require('co');
            test = require('assert');
          
          co(function*() {
            var db = yield MongoClient.connect('mongodb://localhost:27017/test');
          
            // Create a collection we want to drop later
            var collection = db.collection('simple_limit_skip_find_one_query_with_generators');
          
            // Insert a bunch of documents for the testing
            yield collection.insertMany([{a:1, b:1}, {a:2, b:2}, {a:3, b:3}], {w:1});
          
            // Perform a simple find and return all the documents
            var doc = yield collection.findOne({a:2}, {fields:{b:1}});
            test.equal(null, doc.a);
            test.equal(2, doc.b);
          
            // Db close
            db.close();
          });

          findOneAndDelete(filter, options, callback){Promise}

          Find a document and delete it in one atomic operation, requires a write lock for the duration of the operation.

          Name Type Default Description
          filter object

          Document selection filter.

          options object null optional

          Optional settings.

          Name Type Default Description
          projection object null optional

          Limits the fields to return for all matching documents.

          sort object null optional

          Determines which document the operation modifies if the query selects multiple documents.

          maxTimeMS number null optional

          The maximum amount of time to allow the query to run.

          callback Collection~findAndModifyCallback optional

          The collection result callback

          Returns:
          Promise if no callback passed
          Examples
          // Example of a simple findOneAndDelete operation
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            // Get the collection
            var col = db.collection('find_one_and_delete');
            col.insertMany([{a:1, b:1}], {w:1}, function(err, r) {
              test.equal(null, err);
              test.equal(1, r.result.n);
          
              col.findOneAndDelete({a:1}
                , { projection: {b:1}, sort: {a:1} }
                , function(err, r) {
                  test.equal(null, err);
                  test.equal(1, r.lastErrorObject.n);
                  test.equal(1, r.value.b);
          
                  db.close();
              });
            });
          });
          // Example of a simple findOneAndDelete operation using a Promise.
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            // Get the collection
            var col = db.collection('find_one_and_delete_with_promise');
            col.insertMany([{a:1, b:1}], {w:1}).then(function(r) {
              test.equal(1, r.result.n);
          
              col.findOneAndDelete({a:1}
                , { projection: {b:1}, sort: {a:1} }
                ).then(function(r) {
                  test.equal(1, r.lastErrorObject.n);
                  test.equal(1, r.value.b);
          
                  db.close();
              });
            });
          });
          // Example of a simple findOneAndDelete operation using a Generator and the co module.
          
          var MongoClient = require('mongodb').MongoClient,
            co = require('co');
            test = require('assert');
          
          co(function*() {
            var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            // Get the collection
            var col = db.collection('find_one_and_delete_with_generators');
            var r = yield col.insertMany([{a:1, b:1}], {w:1});
            test.equal(1, r.result.n);
          
            var r = yield col.findOneAndDelete({a:1}
              , { projection: {b:1}, sort: {a:1} }
              );
            test.equal(1, r.lastErrorObject.n);
            test.equal(1, r.value.b);
          
            db.close();
          });

          findOneAndReplace(filter, replacement, options, callback){Promise}

          Find a document and replace it in one atomic operation, requires a write lock for the duration of the operation.

          Name Type Default Description
          filter object

          Document selection filter.

          replacement object

          Document replacing the matching document.

          options object null optional

          Optional settings.

          Name Type Default Description
          projection object null optional

          Limits the fields to return for all matching documents.

          sort object null optional

          Determines which document the operation modifies if the query selects multiple documents.

          maxTimeMS number null optional

          The maximum amount of time to allow the query to run.

          upsert boolean false optional

          Upsert the document if it does not exist.

          returnOriginal boolean true optional

          When false, returns the updated document rather than the original. The default is true.

          callback Collection~findAndModifyCallback optional

          The collection result callback

          Returns:
          Promise if no callback passed
          Examples
          // Example of a simple findOneAndReplace operation
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            // Get the collection
            var col = db.collection('find_one_and_replace');
            col.insertMany([{a:1, b:1}], {w:1}, function(err, r) {
              test.equal(null, err);
              test.equal(1, r.result.n);
          
              col.findOneAndReplace({a:1}
                , {c:1, b:1}
                , {
                      projection: {b:1, c:1}
                    , sort: {a:1}
                    , returnOriginal: false
                    , upsert: true
                  }
                , function(err, r) {
                  test.equal(null, err);
                  test.equal(1, r.lastErrorObject.n);
                  test.equal(1, r.value.b);
                  test.equal(1, r.value.c);
          
                  db.close();
              });
            });
          });
          // Example of a simple findOneAndReplace operation using a Promise.
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            // Get the collection
            var col = db.collection('find_one_and_replace_with_promise');
            col.insertMany([{a:1, b:1}], {w:1}).then(function(r) {
              test.equal(1, r.result.n);
          
              col.findOneAndReplace({a:1}
                , {c:1, b:1}
                , {
                      projection: {b:1, c:1}
                    , sort: {a:1}
                    , returnOriginal: false
                    , upsert: true
                  }
                ).then(function(r) {
                  test.equal(1, r.lastErrorObject.n);
                  test.equal(1, r.value.b);
                  test.equal(1, r.value.c);
          
                  db.close();
              });
            });
          });
          // Example of a simple findOneAndReplace operation using a Generator and the co module.
          
          var MongoClient = require('mongodb').MongoClient,
            co = require('co');
            test = require('assert');
          
          co(function*() {
            var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            // Get the collection
            var col = db.collection('find_one_and_replace_with_generators');
            var r = yield col.insertMany([{a:1, b:1}], {w:1});
            test.equal(1, r.result.n);
          
            var r = yield col.findOneAndReplace({a:1}
              , {c:1, b:1}
              , {
                    projection: {b:1, c:1}
                  , sort: {a:1}
                  , returnOriginal: false
                  , upsert: true
                }
              );
            test.equal(1, r.lastErrorObject.n);
            test.equal(1, r.value.b);
            test.equal(1, r.value.c);
          
            db.close();
          });

          findOneAndUpdate(filter, update, options, callback){Promise}

          Find a document and update it in one atomic operation, requires a write lock for the duration of the operation.

          Name Type Default Description
          filter object

          Document selection filter.

          update object

          Update operations to be performed on the document

          options object null optional

          Optional settings.

          Name Type Default Description
          projection object null optional

          Limits the fields to return for all matching documents.

          sort object null optional

          Determines which document the operation modifies if the query selects multiple documents.

          maxTimeMS number null optional

          The maximum amount of time to allow the query to run.

          upsert boolean false optional

          Upsert the document if it does not exist.

          returnOriginal boolean true optional

          When false, returns the updated document rather than the original. The default is true.

          callback Collection~findAndModifyCallback optional

          The collection result callback

          Returns:
          Promise if no callback passed
          Examples
          // Example of a simple findOneAndUpdate operation
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            // Get the collection
            var col = db.collection('find_one_and_update');
            col.insertMany([{a:1, b:1}], {w:1}, function(err, r) {
              test.equal(null, err);
              test.equal(1, r.result.n);
          
              col.findOneAndUpdate({a:1}
                , {$set: {d:1}}
                , {
                      projection: {b:1, d:1}
                    , sort: {a:1}
                    , returnOriginal: false
                    , upsert: true
                  }
                , function(err, r) {
                  test.equal(null, err);
                  test.equal(1, r.lastErrorObject.n);
                  test.equal(1, r.value.b);
                  test.equal(1, r.value.d);
          
                  db.close();
              });
            });
          });
          // Example of a simple findOneAndUpdate operation using a Promise.
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            // Get the collection
            var col = db.collection('find_one_and_update_with_promise');
            col.insertMany([{a:1, b:1}], {w:1}).then(function(r) {
              test.equal(1, r.result.n);
          
              col.findOneAndUpdate({a:1}
                , {$set: {d:1}}
                , {
                      projection: {b:1, d:1}
                    , sort: {a:1}
                    , returnOriginal: false
                    , upsert: true
                  }
                ).then(function(r) {
                  test.equal(1, r.lastErrorObject.n);
                  test.equal(1, r.value.b);
                  test.equal(1, r.value.d);
          
                  db.close();
              });
            });
          });
          // Example of a simple findOneAndUpdate operation using a Generator and the co module.
          
          var MongoClient = require('mongodb').MongoClient,
            co = require('co');
            test = require('assert');
          
          co(function*() {
            var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            // Get the collection
            var col = db.collection('find_one_and_update_with_generators');
            var r = yield col.insertMany([{a:1, b:1}], {w:1});
            test.equal(1, r.result.n);
          
            var r = yield col.findOneAndUpdate({a:1}
              , {$set: {d:1}}
              , {
                    projection: {b:1, d:1}
                  , sort: {a:1}
                  , returnOriginal: false
                  , upsert: true
                }
              );
            test.equal(1, r.lastErrorObject.n);
            test.equal(1, r.value.b);
            test.equal(1, r.value.d);
          
            db.close();
          });

          geoHaystackSearch(x, y, options, callback){Promise}

          Execute a geo search using a geo haystack index on a collection.

          Name Type Default Description
          x number

          Point to search on the x axis, ensure the indexes are ordered in the same order.

          y number

          Point to search on the y axis, ensure the indexes are ordered in the same order.

          options object null optional

          Optional settings.

          Name Type Default Description
          readPreference ReadPreference | string null optional

          The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).

          maxDistance number null optional

          Include results up to maxDistance from the point.

          search object null optional

          Filter the results by a query.

          limit number false optional

          Max number of results to return.

          callback Collection~resultCallback optional

          The command result callback

          Returns:
          Promise if no callback passed
          Examples
          // Example of a simple geoHaystackSearch query across some documents
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
          
            // Fetch the collection
            var collection = db.collection("simple_geo_haystack_command");
          
            // Add a location based index
            collection.ensureIndex({loc: "geoHaystack", type: 1}, {bucketSize: 1}, function(err, result) {
          
              // Save a new location tagged document
              collection.insertMany([{a:1, loc:[50, 30]}, {a:1, loc:[30, 50]}], {w:1}, function(err, result) {
          
                // Use geoNear command to find document
                collection.geoHaystackSearch(50, 50, {search:{a:1}, limit:1, maxDistance:100}, function(err, docs) {
                  test.equal(1, docs.results.length);
                  db.close();
                });
              });
            });
          });
          // Example of a simple geoHaystackSearch query across some documents using a Promise.
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
          
            // Fetch the collection
            var collection = db.collection("simple_geo_haystack_command_with_promise");
          
            // Add a location based index
            collection.ensureIndex({loc: "geoHaystack", type: 1}, {bucketSize: 1}).then(function(result) {
          
              // Save a new location tagged document
              collection.insertMany([{a:1, loc:[50, 30]}, {a:1, loc:[30, 50]}], {w:1}).then(function(result) {
          
                // Use geoNear command to find document
                collection.geoHaystackSearch(50, 50, {search:{a:1}, limit:1, maxDistance:100}).then(function(docs) {
                  test.equal(1, docs.results.length);
                  db.close();
                });
              });
            });
          });
          // Example of a simple geoHaystackSearch query across some documents using a Generator and the co module.
          
          var MongoClient = require('mongodb').MongoClient,
            co = require('co');
            test = require('assert');
          
          co(function*() {
            var db = yield MongoClient.connect('mongodb://localhost:27017/test');
          
            // Fetch the collection
            var collection = db.collection("simple_geo_haystack_command_with_generators");
          
            // Add a location based index
            yield collection.ensureIndex({loc: "geoHaystack", type: 1}, {bucketSize: 1});
          
            // Save a new location tagged document
            yield collection.insertMany([{a:1, loc:[50, 30]}, {a:1, loc:[30, 50]}], {w:1});
          
            // Use geoNear command to find document
            var docs = yield collection.geoHaystackSearch(50, 50, {search:{a:1}, limit:1, maxDistance:100});
            test.equal(1, docs.results.length);
            db.close();
          });

          geoNear(x, y, options, callback){Promise}

          Execute the geoNear command to search for items in the collection

          Name Type Default Description
          x number

          Point to search on the x axis, ensure the indexes are ordered in the same order.

          y number

          Point to search on the y axis, ensure the indexes are ordered in the same order.

          options object null optional

          Optional settings.

          Name Type Default Description
          readPreference ReadPreference | string null optional

          The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).

          num number null optional

          Max number of results to return.

          minDistance number null optional

          Include results starting at minDistance from a point (2.6 or higher)

          maxDistance number null optional

          Include results up to maxDistance from the point.

          distanceMultiplier number null optional

          Include a value to multiply the distances with allowing for range conversions.

          query object null optional

          Filter the results by a query.

          spherical boolean false optional

          Perform query using a spherical model.

          uniqueDocs boolean false optional

          The closest location in a document to the center of the search region will always be returned MongoDB > 2.X.

          includeLocs boolean false optional

          Include the location data fields in the top level of the results MongoDB > 2.X.

          callback Collection~resultCallback optional

          The command result callback

          Returns:
          Promise if no callback passed
          Examples
          // Example of a simple geoNear query across some documents
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
          
            // Fetch the collection
            var collection = db.collection("simple_geo_near_command");
          
            // Add a location based index
            collection.ensureIndex({loc:"2d"}, function(err, result) {
          
              // Save a new location tagged document
              collection.insertMany([{a:1, loc:[50, 30]}, {a:1, loc:[30, 50]}], {w:1}, function(err, result) {
          
                // Use geoNear command to find document
                collection.geoNear(50, 50, {query:{a:1}, num:1}, function(err, docs) {
                  test.equal(1, docs.results.length);
          
                  db.close();
                });
              });
            });
          });
          // Example of a simple geoNear query across some documents using a Promise.
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
          
            // Fetch the collection
            var collection = db.collection("simple_geo_near_command_with_promise");
          
            // Add a location based index
            collection.ensureIndex({loc:"2d"}).then(function(result) {
          
              // Save a new location tagged document
              collection.insertMany([{a:1, loc:[50, 30]}, {a:1, loc:[30, 50]}], {w:1}).then(function(result) {
          
                // Use geoNear command to find document
                collection.geoNear(50, 50, {query:{a:1}, num:1}).then(function(docs) {
                  test.equal(1, docs.results.length);
          
                  db.close();
                });
              });
            });
          });
          // Example of a simple geoNear query across some documents using a Generator and the co module.
          
          var MongoClient = require('mongodb').MongoClient,
            co = require('co');
            test = require('assert');
          
          co(function*() {
            var db = yield MongoClient.connect('mongodb://localhost:27017/test');
          
            // Fetch the collection
            var collection = db.collection("simple_geo_near_command_with_generators");
          
            // Add a location based index
            yield collection.ensureIndex({loc:"2d"});
          
            // Save a new location tagged document
            yield collection.insertMany([{a:1, loc:[50, 30]}, {a:1, loc:[30, 50]}], {w:1});
          
            // Use geoNear command to find document
            var docs = yield collection.geoNear(50, 50, {query:{a:1}, num:1});
            test.equal(1, docs.results.length);
          
            // Close db
            db.close();
          });

          group(keys, condition, initial, reduce, finalize, command, options, callback){Promise}

          Run a group command across a collection

          Name Type Default Description
          keys object | array | function | code

          An object, array or function expressing the keys to group by.

          condition object

          An optional condition that must be true for a row to be considered.

          initial object

          Initial value of the aggregation counter object.

          reduce function | Code

          The reduce function aggregates (reduces) the objects iterated

          finalize function | Code

          An optional function to be run on each item in the result set just before the item is returned.

          command boolean

          Specify if you wish to run using the internal group command or using eval, default is true.

          options object null optional

          Optional settings.

          Name Type Default Description
          readPreference ReadPreference | string null optional

          The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).

          callback Collection~resultCallback optional

          The command result callback

          Returns:
          Promise if no callback passed
          Examples
          // A whole lot of different ways to execute the group command
          
          var MongoClient = require('mongodb').MongoClient,
            Code = require('mongodb').Code,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
          
            // Create a test collection
            var collection = db.collection('test_group');
          
            // Perform a simple group by on an empty collection
            collection.group([], {}, {"count":0}, "function (obj, prev) { prev.count++; }", function(err, results) {
              test.deepEqual([], results);
          
              // Trigger some inserts on the collection
              collection.insertMany([{'a':2}, {'b':5}, {'a':1}], {w:1}, function(err, ids) {
          
                // Perform a group count
                collection.group([], {}, {"count":0}, "function (obj, prev) { prev.count++; }", function(err, results) {
                  test.equal(3, results[0].count);
          
                  // Perform a group count using the eval method
                  collection.group([], {}, {"count":0}, "function (obj, prev) { prev.count++; }", false, function(err, results) {
                    test.equal(3, results[0].count);
          
                    // Group with a conditional
                    collection.group([], {'a':{'$gt':1}}, {"count":0}, "function (obj, prev) { prev.count++; }", function(err, results) {
                      // Results
                      test.equal(1, results[0].count);
          
                      // Group with a conditional using the EVAL method
                      collection.group([], {'a':{'$gt':1}}, {"count":0}, "function (obj, prev) { prev.count++; }" , false, function(err, results) {
                        // Results
                        test.equal(1, results[0].count);
          
                        // Insert some more test data
                        collection.insertMany([{'a':2}, {'b':3}], {w:1}, function(err, ids) {
          
                          // Do a Group by field a
                          collection.group(['a'], {}, {"count":0}, "function (obj, prev) { prev.count++; }", function(err, results) {
                            // Results
                            test.equal(2, results[0].a);
                            test.equal(2, results[0].count);
                            test.equal(null, results[1].a);
                            test.equal(2, results[1].count);
                            test.equal(1, results[2].a);
                            test.equal(1, results[2].count);
          
                            // Do a Group by field a
                            collection.group({'a':true}, {}, {"count":0}, function (obj, prev) { prev.count++; }, true, function(err, results) {
                              // Results
                              test.equal(2, results[0].a);
                              test.equal(2, results[0].count);
                              test.equal(null, results[1].a);
                              test.equal(2, results[1].count);
                              test.equal(1, results[2].a);
                              test.equal(1, results[2].count);
          
                              // Correctly handle illegal function
                              collection.group([], {}, {}, "5 ++ 5", function(err, results) {
                                test.ok(err.message != null);
          
                                // Use a function to select the keys used to group by
                                var keyf = function(doc) { return {a: doc.a}; };
                                collection.group(keyf, {a: {$gt: 0}}, {"count": 0, "value": 0}, function(obj, prev) { prev.count++; prev.value += obj.a; }, true, function(err, results) {
                                  // Results
                                  results.sort(function(a, b) { return b.count - a.count; });
                                  test.equal(2, results[0].count);
                                  test.equal(2, results[0].a);
                                  test.equal(4, results[0].value);
                                  test.equal(1, results[1].count);
                                  test.equal(1, results[1].a);
                                  test.equal(1, results[1].value);
          
                                  // Use a Code object to select the keys used to group by
                                  var keyf = new Code(function(doc) { return {a: doc.a}; });
                                  collection.group(keyf, {a: {$gt: 0}}, {"count": 0, "value": 0}, function(obj, prev) { prev.count++; prev.value += obj.a; }, true, function(err, results) {
                                    // Results
                                    results.sort(function(a, b) { return b.count - a.count; });
                                    test.equal(2, results[0].count);
                                    test.equal(2, results[0].a);
                                    test.equal(4, results[0].value);
                                    test.equal(1, results[1].count);
                                    test.equal(1, results[1].a);
                                    test.equal(1, results[1].value);
          
                                    // Correctly handle illegal function when using the EVAL method
                                    collection.group([], {}, {}, "5 ++ 5", false, function(err, results) {
                                      test.ok(err.message != null);
          
                                      db.close();
                                    });
                                  });
                                });
                              });
                            });
                          });
                        });
                      });
                    });
                  });
                });
              });
            });
          });
          // A whole lot of different ways to execute the group command using a Promise.
          
          var MongoClient = require('mongodb').MongoClient,
            Code = require('mongodb').Code,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
          
            // Create a test collection
            var collection = db.collection('test_group_with_promise');
          
            // Perform a simple group by on an empty collection
            collection.group([], {}, {"count":0}, "function (obj, prev) { prev.count++; }").then(function(results) {
              test.deepEqual([], results);
          
              // Trigger some inserts on the collection
              collection.insertMany([{'a':2}, {'b':5}, {'a':1}], {w:1}).then(function(ids) {
          
                // Perform a group count
                collection.group([], {}, {"count":0}, "function (obj, prev) { prev.count++; }").then(function(results) {
                  test.equal(3, results[0].count);
          
                  // Perform a group count using the eval method
                  collection.group([], {}, {"count":0}, "function (obj, prev) { prev.count++; }", false).then(function(results) {
                    test.equal(3, results[0].count);
          
                    // Group with a conditional
                    collection.group([], {'a':{'$gt':1}}, {"count":0}, "function (obj, prev) { prev.count++; }").then(function(results) {
                      // Results
                      test.equal(1, results[0].count);
          
                      // Group with a conditional using the EVAL method
                      collection.group([], {'a':{'$gt':1}}, {"count":0}, "function (obj, prev) { prev.count++; }" , false).then(function(results) {
                        // Results
                        test.equal(1, results[0].count);
                        // Insert some more test data
                        collection.insertMany([{'a':2}, {'b':3}], {w:1}).then(function(ids) {
          
                          // Do a Group by field a
                          collection.group(['a'], {}, {"count":0}, "function (obj, prev) { prev.count++; }").then(function(results) {
                            // Results
                            test.equal(2, results[0].a);
                            test.equal(2, results[0].count);
                            test.equal(null, results[1].a);
                            test.equal(2, results[1].count);
                            test.equal(1, results[2].a);
                            test.equal(1, results[2].count);
          
                            // Do a Group by field a
                            collection.group({'a':true}, {}, {"count":0}, function (obj, prev) { prev.count++; }, true).then(function(results) {
                              // Results
                              test.equal(2, results[0].a);
                              test.equal(2, results[0].count);
                              test.equal(null, results[1].a);
                              test.equal(2, results[1].count);
                              test.equal(1, results[2].a);
                              test.equal(1, results[2].count);
          
                              // Correctly handle illegal function
                              collection.group([], {}, {}, "5 ++ 5").then(function(err, results) {
                              }).catch(function(err) {
                                test.ok(err.message != null);
          
                                // Use a function to select the keys used to group by
                                var keyf = function(doc) { return {a: doc.a}; };
                                collection.group(keyf, {a: {$gt: 0}}, {"count": 0, "value": 0}, function(obj, prev) { prev.count++; prev.value += obj.a; }, true).then(function(results) {
                                  // Results
                                  results.sort(function(a, b) { return b.count - a.count; });
                                  test.equal(2, results[0].count);
                                  test.equal(2, results[0].a);
                                  test.equal(4, results[0].value);
                                  test.equal(1, results[1].count);
                                  test.equal(1, results[1].a);
                                  test.equal(1, results[1].value);
          
                                  // Use a Code object to select the keys used to group by
                                  var keyf = new Code(function(doc) { return {a: doc.a}; });
                                  collection.group(keyf, {a: {$gt: 0}}, {"count": 0, "value": 0}, function(obj, prev) { prev.count++; prev.value += obj.a; }, true).then(function(results) {
                                    // Results
                                    results.sort(function(a, b) { return b.count - a.count; });
                                    test.equal(2, results[0].count);
                                    test.equal(2, results[0].a);
                                    test.equal(4, results[0].value);
                                    test.equal(1, results[1].count);
                                    test.equal(1, results[1].a);
                                    test.equal(1, results[1].value);
          
                                    // Correctly handle illegal function when using the EVAL method
                                    collection.group([], {}, {}, "5 ++ 5", false).then(function(results) {
                                    }).catch(function(err) {
                                      test.ok(err.message != null);
          
                                      db.close();
                                    });
                                  });
                                });
                              });
                            });
                          });
                        });
                      });
                    });
                  });
                });
              });
            });
          });
          // A whole lot of different ways to execute the group command using a Generator and the co module.
          
          var MongoClient = require('mongodb').MongoClient,
            Code = require('mongodb').Code;
            co = require('co');
            test = require('assert');
          
          co(function*() {
            var db = yield MongoClient.connect('mongodb://localhost:27017/test');
          
            // Create a test collection
            var collection = db.collection('test_group_with_generators');
          
            // Perform a simple group by on an empty collection
            var results = yield collection.group([], {}, {"count":0}, "function (obj, prev) { prev.count++; }");
            test.deepEqual([], results);
          
            // Trigger some inserts on the collection
            yield collection.insertMany([{'a':2}, {'b':5}, {'a':1}], {w:1});
          
            // Perform a group count
            var results = yield collection.group([], {}, {"count":0}, "function (obj, prev) { prev.count++; }");
            test.equal(3, results[0].count);
          
            // Perform a group count using the eval method
            var results = yield collection.group([], {}, {"count":0}, "function (obj, prev) { prev.count++; }", false);
            test.equal(3, results[0].count);
          
            // Group with a conditional
            var results = yield collection.group([], {'a':{'$gt':1}}, {"count":0}, "function (obj, prev) { prev.count++; }");
            // Results
            test.equal(1, results[0].count);
          
            // Group with a conditional using the EVAL method
            var results = yield collection.group([], {'a':{'$gt':1}}, {"count":0}, "function (obj, prev) { prev.count++; }" , false);
            // Results
            test.equal(1, results[0].count);
          
            // Insert some more test data
            yield collection.insertMany([{'a':2}, {'b':3}], {w:1});
          
            // Do a Group by field a
            var results = yield collection.group(['a'], {}, {"count":0}, "function (obj, prev) { prev.count++; }");
            // Results
            test.equal(2, results[0].a);
            test.equal(2, results[0].count);
            test.equal(null, results[1].a);
            test.equal(2, results[1].count);
            test.equal(1, results[2].a);
            test.equal(1, results[2].count);
          
            // Do a Group by field a
            var results = yield collection.group({'a':true}, {}, {"count":0}, function (obj, prev) { prev.count++; }, true);
            // Results
            test.equal(2, results[0].a);
            test.equal(2, results[0].count);
            test.equal(null, results[1].a);
            test.equal(2, results[1].count);
            test.equal(1, results[2].a);
            test.equal(1, results[2].count);
          
            try {
              // Correctly handle illegal function
              var results = yield collection.group([], {}, {}, "5 ++ 5")
            } catch(err) {
              test.ok(err.message != null);
          
              // Use a function to select the keys used to group by
              var keyf = function(doc) { return {a: doc.a}; };
              var results = yield collection.group(keyf, {a: {$gt: 0}}, {"count": 0, "value": 0}, function(obj, prev) { prev.count++; prev.value += obj.a; }, true);
              // Results
              results.sort(function(a, b) { return b.count - a.count; });
              test.equal(2, results[0].count);
              test.equal(2, results[0].a);
              test.equal(4, results[0].value);
              test.equal(1, results[1].count);
              test.equal(1, results[1].a);
              test.equal(1, results[1].value);
          
              // Use a Code object to select the keys used to group by
              var keyf = new Code(function(doc) { return {a: doc.a}; });
              var results = yield collection.group(keyf, {a: {$gt: 0}}, {"count": 0, "value": 0}, function(obj, prev) { prev.count++; prev.value += obj.a; }, true);
              // Results
              results.sort(function(a, b) { return b.count - a.count; });
              test.equal(2, results[0].count);
              test.equal(2, results[0].a);
              test.equal(4, results[0].value);
              test.equal(1, results[1].count);
              test.equal(1, results[1].a);
              test.equal(1, results[1].value);
          
              try {
                yield collection.group([], {}, {}, "5 ++ 5", false);
              } catch(err) {
                test.ok(err.message != null);
          
                db.close();
              }
            };
          });

          indexes(callback){Promise}

          Retrieve all the indexes on the collection.

          Name Type Description
          callback Collection~resultCallback optional

          The command result callback

          Returns:
          Promise if no callback passed
          Examples
          // Example of retrieving a collections indexes
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            // Crete the collection for the distinct example
            var collection = db.collection('simple_key_based_distinct');
            // Create a geo 2d index
            collection.ensureIndex({loc:"2d"}, {w:1}, function(err, result) {
              test.equal(null, err);
          
              // Create a simple single field index
              collection.ensureIndex({a:1}, {w:1}, function(err, result) {
                test.equal(null, err);
          
                setTimeout(function() {
                  // List all of the indexes on the collection
                  collection.indexes(function(err, indexes) {
                    test.equal(3, indexes.length);
          
                    db.close();
                  });
                }, 1000);
              });
            });
          });
          // Example of retrieving a collections indexes using a Promise.
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            // Crete the collection for the distinct example
            var collection = db.collection('simple_key_based_distinct_with_promise');
          
            // Create a geo 2d index
            collection.ensureIndex({loc:"2d"}, {w:1}).then(function(result) {
          
              // Create a simple single field index
              collection.ensureIndex({a:1}, {w:1}).then(function(result) {
          
                setTimeout(function() {
                  // List all of the indexes on the collection
                  collection.indexes().then(function(indexes) {
                    test.equal(3, indexes.length);
          
                    db.close();
                  });
                }, 1000);
              });
            });
          });
          // Example of retrieving a collections indexes using a Generator and the co module.
          
          var MongoClient = require('mongodb').MongoClient,
            co = require('co');
            test = require('assert');
          
          co(function*() {
            var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            // Crete the collection for the distinct example
            var collection = db.collection('simple_key_based_distinct_with_generators');
          
            // Create a geo 2d index
            yield collection.ensureIndex({loc:"2d"}, {w:1});
          
            // Create a simple single field index
            yield collection.ensureIndex({a:1}, {w:1});
          
            setTimeout(function() {
              co(function*() {
                // List all of the indexes on the collection
                var indexes = yield collection.indexes()
                test.equal(3, indexes.length);
          
                db.close();
              });
            }, 1000);
          });

          indexExists(indexes, callback){Promise}

          Checks if one or more indexes exist on the collection, fails on first non-existing index

          Name Type Description
          indexes string | array

          One or more index names to check.

          callback Collection~resultCallback optional

          The command result callback

          Returns:
          Promise if no callback passed
          Examples
          // An example showing the use of the indexExists function for a single index name and a list of index names.
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            // Create a test collection that we are getting the options back from
            var collection = db.collection('test_collection_index_exists', {w:1});
            test.equal(null, err);
            // Create an index on the collection
            collection.createIndex('a', {w:1}, function(err, indexName) {
              // Let's test to check if a single index exists
              collection.indexExists("a_1", function(err, result) {
                test.equal(true, result);
          
                // Let's test to check if multiple indexes are available
                collection.indexExists(["a_1", "_id_"], function(err, result) {
                  test.equal(true, result);
          
                  // Check if a non existing index exists
                  collection.indexExists("c_1", function(err, result) {
                    test.equal(false, result);
          
                    db.close();
                  });
                });
              });
            });
          });
          // An example showing the use of the indexExists function using a Promise for a single index name and a list of index names.
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            // Create a test collection that we are getting the options back from
            var collection = db.collection('test_collection_index_exists_with_promise', {w:1});
            // Create an index on the collection
            collection.createIndex('a', {w:1}).then(function(indexName) {
              // Let's test to check if a single index exists
              collection.indexExists("a_1").then(function(result) {
                test.equal(true, result);
          
                // Let's test to check if multiple indexes are available
                collection.indexExists(["a_1", "_id_"]).then(function(result) {
                  test.equal(true, result);
          
                  // Check if a non existing index exists
                  collection.indexExists("c_1").then(function(result) {
                    test.equal(false, result);
          
                    db.close();
                  });
                });
              });
            });
          });
          // An example showing the use of the indexExists function using a Generator and the co module for a single index name and a list of index names.
          
          var MongoClient = require('mongodb').MongoClient,
            co = require('co');
            test = require('assert');
          
          co(function*() {
            var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            // Create a test collection that we are getting the options back from
            var collection = db.collection('test_collection_index_exists_with_generators', {w:1});
            // Create an index on the collection
            yield collection.createIndex('a', {w:1});
          
            // Let's test to check if a single index exists
            var result = yield collection.indexExists("a_1");
            test.equal(true, result);
          
            // Let's test to check if multiple indexes are available
            var result = yield collection.indexExists(["a_1", "_id_"]);
            test.equal(true, result);
          
            // Check if a non existing index exists
            var result = yield collection.indexExists("c_1");
            test.equal(false, result);
          
            db.close();
          });

          indexInformation(options, callback){Promise}

          Retrieves this collections index info.

          Name Type Default Description
          options object null optional

          Optional settings.

          Name Type Default Description
          full boolean false optional

          Returns the full raw index information.

          callback Collection~resultCallback optional

          The command result callback

          Returns:
          Promise if no callback passed
          Examples
          // An example showing the information returned by indexInformation
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
          
            // Create a collection we want to drop later
            var collection = db.collection('more_index_information_test_2');
            // Insert a bunch of documents for the index
            collection.insertMany([{a:1, b:1}
              , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1}, function(err, result) {
              test.equal(null, err);
          
              // Create an index on the a field
              collection.ensureIndex({a:1, b:1}
                , {unique:true, background:true, w:1}, function(err, indexName) {
                test.equal(null, err);
                // Fetch basic indexInformation for collection
                db.indexInformation('more_index_information_test_2', function(err, indexInformation) {
                  test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
                  test.deepEqual([ [ 'a', 1 ], [ 'b', 1 ] ], indexInformation.a_1_b_1);
          
                  // Fetch full index information
                  collection.indexInformation({full:true}, function(err, indexInformation) {
                    test.deepEqual({ _id: 1 }, indexInformation[0].key);
                    test.deepEqual({ a: 1, b: 1 }, indexInformation[1].key);
          
                    db.close();
                  });
                });
              });
            });
          });
          // An examples showing the information returned by indexInformation
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
          
            // Create a collection we want to drop later
            var collection = db.collection('more_index_information_test_3');
            // Insert a bunch of documents for the index
            collection.insertMany([{a:1, b:1}
              , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1}, function(err, result) {
              test.equal(null, err);
          
              // Create an index on the a field
              collection.ensureIndex({a:1, b:1}
                , {unique:true, background:true, w:1}, function(err, indexName) {
                test.equal(null, err);
          
                // Fetch basic indexInformation for collection
                collection.indexInformation(function(err, indexInformation) {
                  test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
                  test.deepEqual([ [ 'a', 1 ], [ 'b', 1 ] ], indexInformation.a_1_b_1);
          
                  // Fetch full index information
                  collection.indexInformation({full:true}, function(err, indexInformation) {
                    test.deepEqual({ _id: 1 }, indexInformation[0].key);
                    test.deepEqual({ a: 1, b: 1 }, indexInformation[1].key);
          
                    db.close();
                  });
                });
              });
            });
          });
          // An example showing the information returned by indexInformation using a Promise.
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
          
            // Create a collection we want to drop later
            var collection = db.collection('more_index_information_test_2_with_promise');
            // Insert a bunch of documents for the index
            collection.insertMany([{a:1, b:1}
              , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1}).then(function(result) {
          
              // Create an index on the a field
              collection.ensureIndex({a:1, b:1}
                , {unique:true, background:true, w:1}).then(function(indexName) {
                // Fetch basic indexInformation for collection
                db.indexInformation('more_index_information_test_2_with_promise').then(function(indexInformation) {
                  test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
                  test.deepEqual([ [ 'a', 1 ], [ 'b', 1 ] ], indexInformation.a_1_b_1);
          
                  // Fetch full index information
                  collection.indexInformation({full:true}).then(function(indexInformation) {
                    test.deepEqual({ _id: 1 }, indexInformation[0].key);
                    test.deepEqual({ a: 1, b: 1 }, indexInformation[1].key);
          
                    db.close();
                  });
                }).catch(function(err) {
                  console.dir(err)
                });
              });
            }).catch(function(err) {
              console.dir(err)
            });
          });
          // An examples showing the information returned by indexInformation using a Promise.
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
          
            // Create a collection we want to drop later
            var collection = db.collection('more_index_information_test_3_with_promise');
            // Insert a bunch of documents for the index
            collection.insertMany([{a:1, b:1}
              , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1}).then(function(result) {
          
              // Create an index on the a field
              collection.ensureIndex({a:1, b:1}
                , {unique:true, background:true, w:1}).then(function(indexName) {
          
                // Fetch basic indexInformation for collection
                collection.indexInformation().then(function(indexInformation) {
                  test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
                  test.deepEqual([ [ 'a', 1 ], [ 'b', 1 ] ], indexInformation.a_1_b_1);
          
                  // Fetch full index information
                  collection.indexInformation({full:true}).then(function(indexInformation) {
                    test.deepEqual({ _id: 1 }, indexInformation[0].key);
                    test.deepEqual({ a: 1, b: 1 }, indexInformation[1].key);
          
                    db.close();
                  });
                });
              });
            });
          });
          // An example showing the information returned by indexInformation using a Generator and the co module.
          
          var MongoClient = require('mongodb').MongoClient,
            co = require('co');
            test = require('assert');
          
          co(function*() {
            var db = yield MongoClient.connect('mongodb://localhost:27017/test');
          
            // Create a collection we want to drop later
            var collection = db.collection('more_index_information_test_2_with_generators');
            // Insert a bunch of documents for the index
            yield collection.insertMany([{a:1, b:1}
              , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1});
          
            // Create an index on the a field
            yield collection.ensureIndex({a:1, b:1}
              , {unique:true, background:true, w:1});
          
            // Fetch basic indexInformation for collection
            var indexInformation = yield db.indexInformation('more_index_information_test_2_with_generators');
            test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
            test.deepEqual([ [ 'a', 1 ], [ 'b', 1 ] ], indexInformation.a_1_b_1);
          
            // Fetch full index information
            var indexInformation = yield collection.indexInformation({full:true});
            test.deepEqual({ _id: 1 }, indexInformation[0].key);
            test.deepEqual({ a: 1, b: 1 }, indexInformation[1].key);
          
            // Close db
            db.close();
          });
          // An examples showing the information returned by indexInformation using a Generator and the co module.
          
          var MongoClient = require('mongodb').MongoClient,
            co = require('co');
            test = require('assert');
          
          co(function*() {
            var db = yield MongoClient.connect('mongodb://localhost:27017/test');
          
            // Create a collection we want to drop later
            var collection = db.collection('more_index_information_test_3_with_generators');
            // Insert a bunch of documents for the index
            yield collection.insertMany([{a:1, b:1}
              , {a:2, b:2}, {a:3, b:3}, {a:4, b:4}], {w:1});
          
            // Create an index on the a field
            yield collection.ensureIndex({a:1, b:1}
              , {unique:true, background:true, w:1});
          
            // Fetch basic indexInformation for collection
            var indexInformation = yield collection.indexInformation();
            test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
            test.deepEqual([ [ 'a', 1 ], [ 'b', 1 ] ], indexInformation.a_1_b_1);
          
            // Fetch full index information
            var indexInformation = yield collection.indexInformation({full:true});
            test.deepEqual({ _id: 1 }, indexInformation[0].key);
            test.deepEqual({ a: 1, b: 1 }, indexInformation[1].key);
          
            db.close();
          });

          initializeOrderedBulkOp(options, callback){null}

          Initiate an In order bulk write operation, operations will be serially executed in the order they are added, creating a new operation for each switch in types.

          Name Type Default Description
          options object null optional

          Optional settings.

          Name Type Default Description
          w number | string null optional

          The write concern.

          wtimeout number null optional

          The write concern timeout.

          j boolean false optional

          Specify a journal write concern.

          callback OrderedBulkOperation

          The command result callback

          Examples
          // Example of a simple ordered insert/update/upsert/remove ordered collection
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            // Get the collection
            var col = db.collection('batch_write_ordered_ops_0');
            // Initialize the Ordered Batch
            var batch = col.initializeOrderedBulkOp();
            // Add some operations to be executed in order
            batch.insert({a:1});
            batch.find({a:1}).updateOne({$set: {b:1}});
            batch.find({a:2}).upsert().updateOne({$set: {b:2}});
            batch.insert({a:3});
            batch.find({a:3}).remove({a:3});
          
            // Execute the operations
            batch.execute(function(err, result) {
              // Check state of result
              test.equal(2, result.nInserted);
              test.equal(1, result.nUpserted);
              test.equal(1, result.nMatched);
              test.ok(1 == result.nModified || result.nModified == null);
              test.equal(1, result.nRemoved);
          
              var upserts = result.getUpsertedIds();
              test.equal(1, upserts.length);
              test.equal(2, upserts[0].index);
              test.ok(upserts[0]._id != null);
          
              var upsert = result.getUpsertedIdAt(0);
              test.equal(2, upsert.index);
              test.ok(upsert._id != null);
          
              // Finish up test
              db.close();
            });
          });
          // Example of a simple ordered insert/update/upsert/remove ordered collection using a Promise.
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            // Get the collection
            var col = db.collection('batch_write_ordered_ops_0_with_promise');
            // Initialize the Ordered Batch
            var batch = col.initializeOrderedBulkOp();
            // Add some operations to be executed in order
            batch.insert({a:1});
            batch.find({a:1}).updateOne({$set: {b:1}});
            batch.find({a:2}).upsert().updateOne({$set: {b:2}});
            batch.insert({a:3});
            batch.find({a:3}).remove({a:3});
          
            // Execute the operations
            batch.execute().then(function(result) {
              // Check state of result
              test.equal(2, result.nInserted);
              test.equal(1, result.nUpserted);
              test.equal(1, result.nMatched);
              test.ok(1 == result.nModified || result.nModified == 0 || result.nModified == null);
              test.equal(1, result.nRemoved);
          
              var upserts = result.getUpsertedIds();
              test.equal(1, upserts.length);
              test.equal(2, upserts[0].index);
              test.ok(upserts[0]._id != null);
          
              var upsert = result.getUpsertedIdAt(0);
              test.equal(2, upsert.index);
              test.ok(upsert._id != null);
          
              // Finish up test
              db.close();
            });
          });
          // Example of a simple ordered insert/update/upsert/remove ordered collection using a Generator and the co module.
          
          var MongoClient = require('mongodb').MongoClient,
            co = require('co');
            test = require('assert');
          
          co(function*() {
            var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            // Get the collection
            var col = db.collection('batch_write_ordered_ops_0_with_generators');
            // Initialize the Ordered Batch
            var batch = col.initializeOrderedBulkOp();
            // Add some operations to be executed in order
            batch.insert({a:1});
            batch.find({a:1}).updateOne({$set: {b:1}});
            batch.find({a:2}).upsert().updateOne({$set: {b:2}});
            batch.insert({a:3});
            batch.find({a:3}).remove({a:3});
          
            // Execute the operations
            var result = yield batch.execute();
            // Check state of result
            test.equal(2, result.nInserted);
            test.equal(1, result.nUpserted);
            test.equal(1, result.nMatched);
            test.ok(1 == result.nModified || result.nModified == null);
            test.equal(1, result.nRemoved);
          
            var upserts = result.getUpsertedIds();
            test.equal(1, upserts.length);
            test.equal(2, upserts[0].index);
            test.ok(upserts[0]._id != null);
          
            var upsert = result.getUpsertedIdAt(0);
            test.equal(2, upsert.index);
            test.ok(upsert._id != null);
          
            // Finish up test
            db.close();
          });

          initializeUnorderedBulkOp(options){UnorderedBulkOperation}

          Initiate a Out of order batch write operation. All operations will be buffered into insert/update/remove commands executed out of order.

          Name Type Default Description
          options object null optional

          Optional settings.

          Name Type Default Description
          w number | string null optional

          The write concern.

          wtimeout number null optional

          The write concern timeout.

          j boolean false optional

          Specify a journal write concern.

          Examples
          // Example of a simple ordered insert/update/upsert/remove ordered collection
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            // Get the collection
            var col = db.collection('batch_write_unordered_ops_legacy_0');
            // Initialize the unordered Batch
            var batch = col.initializeUnorderedBulkOp();
          
            // Add some operations to be executed in order
            batch.insert({a:1});
            batch.find({a:1}).updateOne({$set: {b:1}});
            batch.find({a:2}).upsert().updateOne({$set: {b:2}});
            batch.insert({a:3});
            batch.find({a:3}).remove({a:3});
          
            // Execute the operations
            batch.execute(function(err, result) {
              // Check state of result
              test.equal(2, result.nInserted);
              test.equal(1, result.nUpserted);
              test.equal(1, result.nMatched);
              test.ok(1 == result.nModified || result.nModified == null);
              test.equal(1, result.nRemoved);
          
              var upserts = result.getUpsertedIds();
              test.equal(1, upserts.length);
              test.equal(2, upserts[0].index);
              test.ok(upserts[0]._id != null);
          
              var upsert = result.getUpsertedIdAt(0);
              test.equal(2, upsert.index);
              test.ok(upsert._id != null);
          
              // Finish up test
              db.close();
            });
          });
          // Example of a simple ordered insert/update/upsert/remove ordered collection using a Promise.
          
          var MongoClient = require('mongodb').MongoClient,
            test = require('assert');
          MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            // Get the collection
            var col = db.collection('batch_write_unordered_ops_legacy_0_with_promise');
            // Initialize the unordered Batch
            var batch = col.initializeUnorderedBulkOp();
          
            // Add some operations to be executed in order
            batch.insert({a:1});
            batch.find({a:1}).updateOne({$set: {b:1}});
            batch.find({a:2}).upsert().updateOne({$set: {b:2}});
            batch.insert({a:3});
            batch.find({a:3}).remove({a:3});
          
            // Execute the operations
            batch.execute().then(function(result) {
              // Check state of result
              test.equal(2, result.nInserted);
              test.equal(1, result.nUpserted);
              test.equal(1, result.nMatched);
              test.ok(1 == result.nModified || result.nModified == 0 || result.nModified == null);
              test.equal(1, result.nRemoved);
          
              var upserts = result.getUpsertedIds();
              test.equal(1, upserts.length);
              test.equal(2, upserts[0].index);
              test.ok(upserts[0]._id != null);
          
              var upsert = result.getUpsertedIdAt(0);
              test.equal(2, upsert.index);
              test.ok(upsert._id != null);
          
              // Finish up test
              db.close();
            });
          });
          // Example of a simple ordered insert/update/upsert/remove ordered collection using a Generator and the co module.
          
          var MongoClient = require('mongodb').MongoClient,
            co = require('co');
            test = require('assert');
          
          co(function*() {
            var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            // Get the collection
            var col = db.collection('batch_write_unordered_ops_legacy_0_with_generators');
            // Initialize the unordered Batch
            var batch = col.initializeUnorderedBulkOp({useLegacyOps: true});
          
            // Add some operations to be executed in order
            batch.insert({a:1});
            batch.find({a:1}).updateOne({$set: {b:1}});
            batch.find({a:2}).upsert().updateOne({$set: {b:2}});
            batch.insert({a:3});
            batch.find({a:3}).remove({a:3});
          
            // Execute the operations
            var result = yield batch.execute();
            // Check state of result
            test.equal(2, result.nInserted);
            test.equal(1, result.nUpserted);
            test.equal(1, result.nMatched);
            test.ok(1 == result.nModified || result.nModified == null);
            test.equal(1, result.nRemoved);
          
            var upserts = result.getUpsertedIds();
            test.equal(1, upserts.length);
            test.equal(2, upserts[0].index);
            test.ok(upserts[0]._id != null);
          
            var upsert = result.getUpsertedIdAt(0);
            test.equal(2, upsert.index);
            test.ok(upsert._id != null);
          
            // Finish up test
            db.close();
          });

          insert(docs, options, callback){Promise}

          Inserts a single document or a an array of documents into MongoDB. If documents passed in do not contain the _id field,
          one will be added to each of the documents missing it by the driver, mutating the document. This behavior
          can be overridden by setting the forceServerObjectId flag.

          Name Type Default Description
          docs object | Array.<object>

          Documents to insert.

          options object null optional

          Optional settings.

          Name Type Default Description
          w number | string null optional

          The write concern.

          wtimeout number null optional

          The write concern timeout.

          j boolean false optional

          Specify a journal write concern.

          serializeFunctions boolean false optional

          Serialize functions on any object.

          forceServerObjectId boolean false optional

          Force server to assign _id values instead of driver.

          bypassDocumentValidation boolean false optional

          Allow driver to bypass schema validation in MongoDB 3.2 or higher.

          callback Collection~insertWriteOpCallback optional

          The command result callback

          Deprecated
          • Use insertOne, insertMany or bulkWrite
            Returns:
            Promise if no callback passed
            Examples
            // A simple document insert example, not using safe mode to ensure document persistance on MongoDB
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              var collection = db.collection("simple_document_insert_collection_no_safe");
              // Insert a single document
              collection.insertOne({hello:'world_no_safe'});
            
              // Wait for a second before finishing up, to ensure we have written the item to disk
              setTimeout(function() {
            
                // Fetch the document
                collection.findOne({hello:'world_no_safe'}, function(err, item) {
                  test.equal(null, err);
                  test.equal('world_no_safe', item.hello);
                  db.close();
                })
              }, 100);
            });
            // A batch document insert example, using safe mode to ensure document persistance on MongoDB
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              // Fetch a collection to insert document into
              var collection = db.collection("batch_document_insert_collection_safe");
              // Insert a single document
              collection.insertMany([{hello:'world_safe1'}
                , {hello:'world_safe2'}], {w:1}, function(err, result) {
                test.equal(null, err);
            
                // Fetch the document
                collection.findOne({hello:'world_safe2'}, function(err, item) {
                  test.equal(null, err);
                  test.equal('world_safe2', item.hello);
                  db.close();
                })
              });
            });
            // Example of inserting a document containing functions
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              // Fetch a collection to insert document into
              var collection = db.collection("simple_document_insert_with_function_safe");
            
              var o = {w:1};
              o.serializeFunctions = true;
              // Insert a single document
              collection.insertOne({hello:'world'
                , func:function() {}}, o, function(err, result) {
                test.equal(null, err);
            
                // Fetch the document
                collection.findOne({hello:'world'}, function(err, item) {
                  test.equal(null, err);
                  test.ok("function() {}", item.code);
                  db.close();
                })
              });
            });
            // Example of using keepGoing to allow batch insert to complete even when there are illegal documents in the batch
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a collection
              var collection = db.collection('keepGoingExample');
            
              // Add an unique index to title to force errors in the batch insert
              collection.ensureIndex({title:1}, {unique:true}, function(err, indexName) {
            
                // Insert some intial data into the collection
                collection.insertMany([{name:"Jim"}
                  , {name:"Sarah", title:"Princess"}], {w:1}, function(err, result) {
            
                  // Force keep going flag, ignoring unique index issue
                  collection.insert([{name:"Jim"}
                    , {name:"Sarah", title:"Princess"}
                    , {name:'Gump', title:"Gump"}], {w:1, keepGoing:true}, function(err, result) {
            
                    // Count the number of documents left (should not include the duplicates)
                    collection.count(function(err, count) {
                      test.equal(3, count);
                      db.close();
                    })
                  });
                });
              });
            });
            // A simple document insert using a Promise example, not using safe mode to ensure document persistance on MongoDB
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              var collection = db.collection("simple_document_insert_collection_no_safe_with_promise");
              // Insert a single document
              collection.insertOne({hello:'world_no_safe'});
            
              // Wait for a second before finishing up, to ensure we have written the item to disk
              setTimeout(function() {
            
                // Fetch the document
                collection.findOne({hello:'world_no_safe'}).then(function(item) {
                  test.equal('world_no_safe', item.hello);
                  db.close();
                })
              }, 100);
            });
            // A batch document insert using a Promise example, using safe mode to ensure document persistance on MongoDB
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              // Fetch a collection to insert document into
              var collection = db.collection("batch_document_insert_collection_safe_with_promise");
              // Insert a single document
              collection.insertMany([{hello:'world_safe1'}
                , {hello:'world_safe2'}], {w:1}).then(function(result) {
            
                // Fetch the document
                collection.findOne({hello:'world_safe2'}).then(function(item) {
                  test.equal('world_safe2', item.hello);
                  db.close();
                })
              });
            });
            // Example of inserting a document containing functions using a Promise.
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              // Fetch a collection to insert document into
              var collection = db.collection("simple_document_insert_with_function_safe_with_promise");
            
              var o = {w:1};
              o.serializeFunctions = true;
              // Insert a single document
              collection.insertOne({hello:'world'
                , func:function() {}}, o).then(function(result) {
            
                // Fetch the document
                collection.findOne({hello:'world'}).then(function(item) {
                  test.ok("function() {}", item.code);
                  db.close();
                })
              });
            });
            // Example of using keepGoing to allow batch insert using a Promise to complete even when there are illegal documents in the batch
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a collection
              var collection = db.collection('keepGoingExample_with_promise');
              collection.drop(function() {
                // Add an unique index to title to force errors in the batch insert
                collection.ensureIndex({title:1}, {unique:true}).then(function(indexName) {
            
                  // Insert some intial data into the collection
                  collection.insertMany([{name:"Jim"}
                    , {name:"Sarah", title:"Princess"}], {w:1}).then(function(result) {
            
                    // Force keep going flag, ignoring unique index issue
                    collection.insert([{name:"Jim"}
                      , {name:"Sarah", title:"Princess"}
                      , {name:'Gump', title:"Gump"}], {w:1, keepGoing:true}).then(function(result) {
                      }).catch(function(err) {
                      // Count the number of documents left (should not include the duplicates)
                      collection.count().then(function(count) {
                        test.equal(3, count);
                      })
                    });
                  });
                });
              });
            });
            // A simple document insert using a Generator and the co module example, not using safe mode to ensure document persistance on MongoDB
            
            var MongoClient = require('mongodb').MongoClient,
              co = require('co');
              test = require('assert');
            
            co(function*() {
              var db = yield MongoClient.connect('mongodb://localhost:27017/test');
              var collection = db.collection("simple_document_insert_collection_no_safe_with_generators");
              // Insert a single document
              collection.insertOne({hello:'world_no_safe'});
            
              // Wait for a second before finishing up, to ensure we have written the item to disk
              setTimeout(function() {
                co(function*() {
                  // Fetch the document
                  var item = yield collection.findOne({hello:'world_no_safe'});
                  test.equal('world_no_safe', item.hello);
                  db.close();
                })
              }, 100);
            });
            // A batch document insert using a Generator and the co module example, using safe mode to ensure document persistance on MongoDB
            
            var MongoClient = require('mongodb').MongoClient,
              co = require('co');
              test = require('assert');
            
            co(function*() {
              var db = yield MongoClient.connect('mongodb://localhost:27017/test');
              // Fetch a collection to insert document into
              var collection = db.collection("batch_document_insert_collection_safe_with_generators");
            
              // Insert a single document
              yield collection.insertMany([{hello:'world_safe1'}
                , {hello:'world_safe2'}], {w:1});
            
              // Fetch the document
              var item = yield collection.findOne({hello:'world_safe2'});
              test.equal('world_safe2', item.hello);
              db.close();
            });
            // Example of inserting a document containing functions using a Generator and the co module.
            
            var MongoClient = require('mongodb').MongoClient,
              co = require('co');
              test = require('assert');
            
            co(function*() {
              var db = yield MongoClient.connect('mongodb://localhost:27017/test');
              // Fetch a collection to insert document into
              var collection = db.collection("simple_document_insert_with_function_safe_with_generators");
            
              // Get the option
              var o = {w:1};
              o.serializeFunctions = true;
            
              // Insert a single document
              yield collection.insertOne({hello:'world', func:function() {}}, o);
            
              // Fetch the document
              var item = yield collection.findOne({hello:'world'});
              test.ok("function() {}", item.code);
              db.close();
            });
            // Example of using keepGoing to allow batch insert using a Generator and the co module to complete even when there are illegal documents in the batch
            
            var MongoClient = require('mongodb').MongoClient,
              co = require('co');
              test = require('assert');
            
            co(function*() {
              var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            
              // Create a collection
              var collection = db.collection('keepGoingExample_with_generators');
            
              // Add an unique index to title to force errors in the batch insert
              yield collection.ensureIndex({title:1}, {unique:true});
            
              // Insert some intial data into the collection
              yield collection.insertMany([{name:"Jim"}
                , {name:"Sarah", title:"Princess"}], {w:1});
            
              try {
                // Force keep going flag, ignoring unique index issue
                yield collection.insert([{name:"Jim"}
                  , {name:"Sarah", title:"Princess"}
                  , {name:'Gump', title:"Gump"}], {w:1, keepGoing:true});
              } catch(err) {}
              // Count the number of documents left (should not include the duplicates)
              var count = yield collection.count();
              test.equal(3, count);
            }).catch(function(err) {
              console.log(err.stack)
            });

            insertMany(docs, options, callback){Promise}

            Inserts an array of documents into MongoDB. If documents passed in do not contain the _id field,
            one will be added to each of the documents missing it by the driver, mutating the document. This behavior
            can be overridden by setting the forceServerObjectId flag.

            Name Type Default Description
            docs Array.<object>

            Documents to insert.

            options object null optional

            Optional settings.

            Name Type Default Description
            w number | string null optional

            The write concern.

            wtimeout number null optional

            The write concern timeout.

            j boolean false optional

            Specify a journal write concern.

            serializeFunctions boolean false optional

            Serialize functions on any object.

            forceServerObjectId boolean false optional

            Force server to assign _id values instead of driver.

            bypassDocumentValidation boolean false optional

            Allow driver to bypass schema validation in MongoDB 3.2 or higher.

            ordered boolean true optional

            If true, when an insert fails, don't execute the remaining writes. If false, continue with remaining inserts when one fails.

            callback Collection~insertWriteOpCallback optional

            The command result callback

            Returns:
            Promise if no callback passed
            Examples
            // Example of a simple insertMany operation
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              // Get the collection
              var col = db.collection('insert_many');
              col.insertMany([{a:1}, {a:2}], function(err, r) {
                test.equal(null, err);
                test.equal(2, r.insertedCount);
                // Finish up test
                db.close();
              });
            });
            // Example of a simple insertMany operation using a Promise.
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              // Get the collection
              var col = db.collection('insert_many_with_promise');
              col.insertMany([{a:1}, {a:2}]).then(function(r) {
                test.equal(2, r.insertedCount);
                // Finish up test
                db.close();
              });
            });
            // Example of a simple insertMany operation using a Generator and the co module.
            
            var MongoClient = require('mongodb').MongoClient,
              co = require('co');
              test = require('assert');
            
            co(function*() {
              var db = yield MongoClient.connect('mongodb://localhost:27017/test');
              // Get the collection
              var col = db.collection('insert_many_with_generators');
              var r = yield col.insertMany([{a:1}, {a:2}]);
              test.equal(2, r.insertedCount);
              // Finish up test
              db.close();
            });

            insertOne(doc, options, callback){Promise}

            Inserts a single document into MongoDB. If documents passed in do not contain the _id field,
            one will be added to each of the documents missing it by the driver, mutating the document. This behavior
            can be overridden by setting the forceServerObjectId flag.

            Name Type Default Description
            doc object

            Document to insert.

            options object null optional

            Optional settings.

            Name Type Default Description
            w number | string null optional

            The write concern.

            wtimeout number null optional

            The write concern timeout.

            j boolean false optional

            Specify a journal write concern.

            serializeFunctions boolean false optional

            Serialize functions on any object.

            forceServerObjectId boolean false optional

            Force server to assign _id values instead of driver.

            bypassDocumentValidation boolean false optional

            Allow driver to bypass schema validation in MongoDB 3.2 or higher.

            callback Collection~insertOneWriteOpCallback optional

            The command result callback

            Returns:
            Promise if no callback passed
            Examples
            // Example of a simple insertOne operation
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              // Get the collection
              var col = db.collection('insert_one');
              col.insertOne({a:1}, function(err, r) {
                test.equal(null, err);
                test.equal(1, r.insertedCount);
                // Finish up test
                db.close();
              });
            });
            // Example of a simple insertOne operation using a Promise.
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              // Get the collection
              var col = db.collection('insert_one_with_promise');
              col.insertOne({a:1}).then(function(r) {
                test.equal(1, r.insertedCount);
                // Finish up test
                db.close();
              });
            });
            // Example of a simple insertOne operation using a Generator and the co module.
            
            var MongoClient = require('mongodb').MongoClient,
              co = require('co');
              test = require('assert');
            
            co(function*() {
              var db = yield MongoClient.connect('mongodb://localhost:27017/test');
              // Get the collection
              var col = db.collection('insert_one_with_generators');
              var r = yield col.insertOne({a:1});
              test.equal(1, r.insertedCount);
              // Finish up test
              db.close();
            });

            isCapped(callback){Promise}

            Returns if the collection is a capped collection

            Name Type Description
            callback Collection~resultCallback optional

            The results callback

            Returns:
            Promise if no callback passed
            Examples
            // An example showing how to establish if it's a capped collection
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a test collection that we are getting the options back from
              db.createCollection('test_collection_is_capped', {'capped':true, 'size':1024}, function(err, collection) {
                test.equal('test_collection_is_capped', collection.collectionName);
            
                // Let's fetch the collection options
                collection.isCapped(function(err, capped) {
                  test.equal(true, capped);
            
                  db.close();
                });
              });
            });
            // An example showing how to establish if it's a capped collection using a Promise.
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a test collection that we are getting the options back from
              db.createCollection('test_collection_is_capped_with_promise', {'capped':true, 'size':1024}).then(function(collection) {
                test.equal('test_collection_is_capped_with_promise', collection.collectionName);
            
                // Let's fetch the collection options
                collection.isCapped().then(function(capped) {
                  test.equal(true, capped);
            
                  db.close();
                });
              });
            });
            // An example showing how to establish if it's a capped collection using a Generator and the co module.
            
            var MongoClient = require('mongodb').MongoClient,
              co = require('co');
              test = require('assert');
            
            co(function*() {
              var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            
              // Create a test collection that we are getting the options back from
              var collection = yield db.createCollection('test_collection_is_capped_with_generators', {'capped':true, 'size':1024});
              test.equal('test_collection_is_capped_with_generators', collection.collectionName);
            
              // Let's fetch the collection options
              var capped = yield collection.isCapped();
              test.equal(true, capped);
            
              db.close();
            });

            listIndexes(options){CommandCursor}

            Get the list of all indexes information for the collection.

            Name Type Default Description
            options object null optional

            Optional settings.

            Name Type Default Description
            batchSize number null optional

            The batchSize for the returned command cursor or if pre 2.8 the systems batch collection

            readPreference ReadPreference | string null optional

            The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).

            mapReduce(map, reduce, options, callback){Promise}

            Run Map Reduce across a collection. Be aware that the inline option for out will return an array of results not a collection.

            Name Type Default Description
            map function | string

            The mapping function.

            reduce function | string

            The reduce function.

            options object null optional

            Optional settings.

            Name Type Default Description
            readPreference ReadPreference | string null optional

            The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).

            out object null optional

            Sets the output target for the map reduce job. {inline:1} | {replace:'collectionName'} | {merge:'collectionName'} | {reduce:'collectionName'}

            query object null optional

            Query filter object.

            sort object null optional

            Sorts the input objects using this key. Useful for optimization, like sorting by the emit key for fewer reduces.

            limit number null optional

            Number of objects to return from collection.

            keeptemp boolean false optional

            Keep temporary data.

            finalize function | string null optional

            Finalize function.

            scope object null optional

            Can pass in variables that can be access from map/reduce/finalize.

            jsMode boolean false optional

            It is possible to make the execution stay in JS. Provided in MongoDB > 2.0.X.

            verbose boolean false optional

            Provide statistics on job execution time.

            bypassDocumentValidation boolean false optional

            Allow driver to bypass schema validation in MongoDB 3.2 or higher.

            callback Collection~resultCallback optional

            The command result callback

            Throws:
            Returns:
            Promise if no callback passed
            Examples
            // A simple map reduce example
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a test collection
              var collection = db.collection('test_map_reduce_functions');
            
              // Insert some documents to perform map reduce over
              collection.insertMany([{'user_id':1}, {'user_id':2}], {w:1}, function(err, r) {
            
                // Map function
                var map = function() { emit(this.user_id, 1); };
                // Reduce function
                var reduce = function(k,vals) { return 1; };
            
                // Perform the map reduce
                collection.mapReduce(map, reduce, {out: {replace : 'tempCollection'}}, function(err, collection) {
                  test.equal(null, err);
            
                  // Mapreduce returns the temporary collection with the results
                  collection.findOne({'_id':1}, function(err, result) {
                    test.equal(1, result.value);
            
                    collection.findOne({'_id':2}, function(err, result) {
                      test.equal(1, result.value);
            
                      db.close();
                    });
                  });
                });
              });
            });
            // A simple map reduce example using the inline output type on MongoDB > 1.7.6 returning the statistics
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a test collection
              var collection = db.collection('test_map_reduce_functions_inline');
            
              // Insert some test documents
              collection.insertMany([{'user_id':1}, {'user_id':2}], {w:1}, function(err, r) {
            
                // Map function
                var map = function() { emit(this.user_id, 1); };
                // Reduce function
                var reduce = function(k,vals) { return 1; };
            
                // Execute map reduce and return results inline
                collection.mapReduce(map, reduce, {out : {inline: 1}, verbose:true}, function(err, results, stats) {
                  test.equal(2, results.length);
                  test.ok(stats != null);
            
                  collection.mapReduce(map, reduce, {out : {replace: 'mapreduce_integration_test'}, verbose:true}, function(err, results, stats) {
                    test.ok(stats != null);
                    db.close();
                  });
                });
              });
            });
            // Mapreduce different test with a provided scope containing a javascript function.
            
            var MongoClient = require('mongodb').MongoClient,
              Code = require('mongodb').Code,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a test collection
              var collection = db.collection('test_map_reduce_functions_scope');
            
              // Insert some test documents
              collection.insertMany([{'user_id':1, 'timestamp':new Date()}
                , {'user_id':2, 'timestamp':new Date()}], {w:1}, function(err, r) {
            
                // Map function
                var map = function(){
                    emit(fn(this.timestamp.getYear()), 1);
                }
            
                // Reduce function
                var reduce = function(k, v){
                    count = 0;
                    for(i = 0; i < v.length; i++) {
                        count += v[i];
                    }
                    return count;
                }
            
                // Javascript function available in the map reduce scope
                var t = function(val){ return val+1; }
            
                // Execute the map reduce with the custom scope
                var o = {};
                o.scope =  { fn: new Code(t.toString()) }
                o.out = { replace: 'replacethiscollection' }
            
                collection.mapReduce(map, reduce, o, function(err, outCollection) {
                  test.equal(null, err);
            
                  // Find all entries in the map-reduce collection
                  outCollection.find().toArray(function(err, results) {
                    test.equal(null, err);
                    test.equal(2, results[0].value)
            
                    // mapReduce with scope containing plain function
                    var o = {};
                    o.scope =  { fn: t }
                    o.out = { replace: 'replacethiscollection' }
            
                    collection.mapReduce(map, reduce, o, function(err, outCollection) {
                      test.equal(null, err);
            
                      // Find all entries in the map-reduce collection
                      outCollection.find().toArray(function(err, results) {
                        test.equal(2, results[0].value)
            
                        db.close();
                      });
                    });
                  });
                });
              });
            });
            // Mapreduce different test with a provided scope containing javascript objects with functions.
            
            var MongoClient = require('mongodb').MongoClient,
              Code = require('mongodb').Code,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a test collection
              var collection = db.collection('test_map_reduce_functions_scope_objects');
            
              // Insert some test documents
              collection.insertMany([{'user_id':1, 'timestamp':new Date()}
                , {'user_id':2, 'timestamp':new Date()}], {w:1}, function(err, r) {
            
                // Map function
                var map = function(){
                  emit(obj.fn(this.timestamp.getYear()), 1);
                }
            
                // Reduce function
                var reduce = function(k, v){
                  count = 0;
                  for(i = 0; i < v.length; i++) {
                    count += v[i];
                  }
                  return count;
                }
            
                // Javascript function available in the map reduce scope
                var t = function(val){ return val+1; }
            
                // Execute the map reduce with the custom scope containing objects
                var o = {};
                o.scope =  { obj: {fn: new Code(t.toString())} }
                o.out = { replace: 'replacethiscollection' }
            
                collection.mapReduce(map, reduce, o, function(err, outCollection) {
                  test.equal(null, err);
            
                  // Find all entries in the map-reduce collection
                  outCollection.find().toArray(function(err, results) {
                    test.equal(null, err);
                    test.equal(2, results[0].value)
            
                    // mapReduce with scope containing plain function
                    var o = {};
                    o.scope =  { obj: {fn: t} }
                    o.out = { replace: 'replacethiscollection' }
            
                    collection.mapReduce(map, reduce, o, function(err, outCollection) {
                      test.equal(null, err);
            
                      // Find all entries in the map-reduce collection
                      outCollection.find().toArray(function(err, results) {
                        test.equal(2, results[0].value)
                        db.close();
                      });
                    });
                  });
                });
              });
            });
            // A simple map reduce example using a Promise.
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a test collection
              var collection = db.collection('test_map_reduce_functions_with_promise');
            
              // Insert some documents to perform map reduce over
              collection.insertMany([{'user_id':1}, {'user_id':2}], {w:1}).then(function(r) {
            
                // Map function
                var map = function() { emit(this.user_id, 1); };
                // Reduce function
                var reduce = function(k,vals) { return 1; };
            
                // Perform the map reduce
                collection.mapReduce(map, reduce, {out: {replace : 'tempCollection'}}).then(function(collection) {
            
                  // Mapreduce returns the temporary collection with the results
                  collection.findOne({'_id':1}).then(function(result) {
                    test.equal(1, result.value);
            
                    collection.findOne({'_id':2}).then(function(result) {
                      test.equal(1, result.value);
            
                      db.close();
                    });
                  });
                });
              });
            });
            // A simple map reduce example using the inline output type on MongoDB > 1.7.6 returning the statistics using a Promise.
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a test collection
              var collection = db.collection('test_map_reduce_functions_inline_with_promise');
            
              // Insert some test documents
              collection.insertMany([{'user_id':1}, {'user_id':2}], {w:1}).then(function(r) {
            
                // Map function
                var map = function() { emit(this.user_id, 1); };
                // Reduce function
                var reduce = function(k,vals) { return 1; };
            
                // Execute map reduce and return results inline
                collection.mapReduce(map, reduce, {out : {inline: 1}, verbose:true}).then(function(result) {
                  test.equal(2, result.results.length);
                  test.ok(result.stats != null);
            
                  collection.mapReduce(map, reduce, {out : {replace: 'mapreduce_integration_test'}, verbose:true}).then(function(result) {
                    test.ok(result.stats != null);
                    db.close();
                  });
                });
              });
            });
            // Mapreduce using a provided scope containing a javascript function executed using a Promise.
            
            var MongoClient = require('mongodb').MongoClient,
              Code = require('mongodb').Code,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a test collection
              var collection = db.collection('test_map_reduce_functions_scope_with_promise');
            
              // Insert some test documents
              collection.insertMany([{'user_id':1, 'timestamp':new Date()}
                , {'user_id':2, 'timestamp':new Date()}], {w:1}).then(function(r) {
            
                // Map function
                var map = function(){
                    emit(fn(this.timestamp.getYear()), 1);
                }
            
                // Reduce function
                var reduce = function(k, v){
                    count = 0;
                    for(i = 0; i < v.length; i++) {
                        count += v[i];
                    }
                    return count;
                }
            
                // Javascript function available in the map reduce scope
                var t = function(val){ return val+1; }
            
                // Execute the map reduce with the custom scope
                var o = {};
                o.scope =  { fn: new Code(t.toString()) }
                o.out = { replace: 'replacethiscollection' }
            
                collection.mapReduce(map, reduce, o).then(function(outCollection) {
            
                  // Find all entries in the map-reduce collection
                  outCollection.find().toArray().then(function(results) {
                    test.equal(2, results[0].value)
            
                    // mapReduce with scope containing plain function
                    var o = {};
                    o.scope =  { fn: t }
                    o.out = { replace: 'replacethiscollection' }
            
                    collection.mapReduce(map, reduce, o).then(function(outCollection) {
                      // Find all entries in the map-reduce collection
                      outCollection.find().toArray().then(function(results) {
                        test.equal(2, results[0].value)
            
                        db.close();
                      });
                    });
                  });
                });
              });
            });
            // Mapreduce using a scope containing javascript objects with functions using a Promise.
            
            var MongoClient = require('mongodb').MongoClient,
              Code = require('mongodb').Code,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a test collection
              var collection = db.collection('test_map_reduce_functions_scope_objects_with_promise');
            
              // Insert some test documents
              collection.insertMany([{'user_id':1, 'timestamp':new Date()}
                , {'user_id':2, 'timestamp':new Date()}], {w:1}).then(function(r) {
            
                // Map function
                var map = function(){
                  emit(obj.fn(this.timestamp.getYear()), 1);
                }
            
                // Reduce function
                var reduce = function(k, v){
                  count = 0;
                  for(i = 0; i < v.length; i++) {
                    count += v[i];
                  }
                  return count;
                }
            
                // Javascript function available in the map reduce scope
                var t = function(val){ return val+1; }
            
                // Execute the map reduce with the custom scope containing objects
                var o = {};
                o.scope =  { obj: {fn: new Code(t.toString())} }
                o.out = { replace: 'replacethiscollection' }
            
                collection.mapReduce(map, reduce, o).then(function(outCollection) {
            
                  // Find all entries in the map-reduce collection
                  outCollection.find().toArray().then(function(results) {
                    test.equal(2, results[0].value)
            
                    // mapReduce with scope containing plain function
                    var o = {};
                    o.scope =  { obj: {fn: t} }
                    o.out = { replace: 'replacethiscollection' }
            
                    collection.mapReduce(map, reduce, o).then(function(outCollection) {
                      // Find all entries in the map-reduce collection
                      outCollection.find().toArray().then(function(results) {
                        test.equal(2, results[0].value)
                        db.close();
                      });
                    });
                  });
                });
              });
            });
            // A simple map reduce example using a Generator and the co module.
            
            var MongoClient = require('mongodb').MongoClient,
              co = require('co');
              test = require('assert');
            
            co(function*() {
              var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            
              // Create a test collection
              var collection = db.collection('test_map_reduce_functions_with_generators');
            
              // Insert some documents to perform map reduce over
              yield collection.insertMany([{'user_id':1}, {'user_id':2}], {w:1});
            
              // Map function
              var map = function() { emit(this.user_id, 1); };
              // Reduce function
              var reduce = function(k,vals) { return 1; };
            
              // Perform the map reduce
              var collection = yield collection.mapReduce(map, reduce, {out: {replace : 'tempCollection'}});
            
              // Mapreduce returns the temporary collection with the results
              var result = yield collection.findOne({'_id':1});
              test.equal(1, result.value);
              var result = yield collection.findOne({'_id':2});
              test.equal(1, result.value);
            
              // Db close
              db.close();
            });
            // A simple map reduce example using the inline output type on MongoDB > 1.7.6 returning the statistics using a Generator and the co module.
            
            var MongoClient = require('mongodb').MongoClient,
              co = require('co');
              test = require('assert');
            
            co(function*() {
              var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            
              // Create a test collection
              var collection = db.collection('test_map_reduce_functions_inline_with_generators');
            
              // Insert some test documents
              yield collection.insertMany([{'user_id':1}, {'user_id':2}], {w:1});
            
              // Map function
              var map = function() { emit(this.user_id, 1); };
              // Reduce function
              var reduce = function(k,vals) { return 1; };
            
              // Execute map reduce and return results inline
              var result = yield collection.mapReduce(map, reduce, {out : {inline: 1}, verbose:true});
              test.equal(2, result.results.length);
              test.ok(result.stats != null);
            
              var result = yield collection.mapReduce(map, reduce, {out : {replace: 'mapreduce_integration_test'}, verbose:true});
              test.ok(result.stats != null);
              db.close();
            });
            // Mapreduce using a provided scope containing a javascript function executed using a Generator and the co module.
            
            var MongoClient = require('mongodb').MongoClient,
              co = require('co');
              test = require('assert');
            
            co(function*() {
              var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            
              // Create a test collection
              var collection = db.collection('test_map_reduce_functions_scope_with_generators');
            
              // Insert some test documents
              yield collection.insertMany([{'user_id':1, 'timestamp':new Date()}
                , {'user_id':2, 'timestamp':new Date()}], {w:1});
            
              // Map function
              var map = function(){
                  emit(fn(this.timestamp.getYear()), 1);
              }
            
              // Reduce function
              var reduce = function(k, v){
                  count = 0;
                  for(i = 0; i < v.length; i++) {
                      count += v[i];
                  }
                  return count;
              }
            
              // Javascript function available in the map reduce scope
              var t = function(val){ return val+1; }
            
              // Execute the map reduce with the custom scope
              var o = {};
              o.scope =  { fn: new Code(t.toString()) }
              o.out = { replace: 'replacethiscollection' }
            
              // Execute with output collection
              var outCollection = yield collection.mapReduce(map, reduce, o);
              // Find all entries in the map-reduce collection
              var results = yield outCollection.find().toArray()
              test.equal(2, results[0].value);
            
              // mapReduce with scope containing plain function
              var o = {};
              o.scope =  { fn: t }
              o.out = { replace: 'replacethiscollection' }
            
              // Execute with outCollection
              var outCollection = yield collection.mapReduce(map, reduce, o);
              // Find all entries in the map-reduce collection
              var results = yield outCollection.find().toArray();
              test.equal(2, results[0].value)
            
              db.close();
            });
            // Mapreduce using a scope containing javascript objects with functions using a Generator and the co module.
            
            var MongoClient = require('mongodb').MongoClient,
              co = require('co');
              test = require('assert');
            
            co(function*() {
              var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            
              // Create a test collection
              var collection = db.collection('test_map_reduce_functions_scope_objects_with_generators');
            
              // Insert some test documents
              yield collection.insertMany([{'user_id':1, 'timestamp':new Date()}
                , {'user_id':2, 'timestamp':new Date()}], {w:1});
            
              // Map function
              var map = function(){
                emit(obj.fn(this.timestamp.getYear()), 1);
              }
            
              // Reduce function
              var reduce = function(k, v){
                count = 0;
                for(i = 0; i < v.length; i++) {
                  count += v[i];
                }
                return count;
              }
            
              // Javascript function available in the map reduce scope
              var t = function(val){ return val+1; }
            
              // Execute the map reduce with the custom scope containing objects
              var o = {};
              o.scope =  { obj: {fn: new Code(t.toString())} }
              o.out = { replace: 'replacethiscollection' }
            
              // Execute returning outCollection
              var outCollection = yield collection.mapReduce(map, reduce, o);
            
              // Find all entries in the map-reduce collection
              var results = yield outCollection.find().toArray();
              test.equal(2, results[0].value)
            
              // mapReduce with scope containing plain function
              var o = {};
              o.scope =  { obj: {fn: t} }
              o.out = { replace: 'replacethiscollection' }
            
              // Execute returning outCollection
              var outCollection = yield collection.mapReduce(map, reduce, o);
              // Find all entries in the map-reduce collection
              var results = yield outCollection.find().toArray();
              test.equal(2, results[0].value)
              db.close();
            });

            options(callback){Promise}

            Returns the options of the collection.

            Name Type Description
            callback Collection~resultCallback optional

            The results callback

            Returns:
            Promise if no callback passed
            Examples
            // An example returning the options for a collection.
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a test collection that we are getting the options back from
              db.createCollection('test_collection_options', {'capped':true, 'size':1024}, function(err, collection) {
                test.equal('test_collection_options', collection.collectionName);
            
                // Let's fetch the collection options
                collection.options(function(err, options) {
                  test.equal(true, options.capped);
                  test.ok(options.size >= 1024);
            
                  db.close();
                });
              });
            });
            // An example returning the options for a collection using a Promise.
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a test collection that we are getting the options back from
              db.createCollection('test_collection_options_with_promise', {'capped':true, 'size':1024}).then(function(collection) {
                test.equal('test_collection_options_with_promise', collection.collectionName);
            
                // Let's fetch the collection options
                collection.options().then(function(options) {
                  test.equal(true, options.capped);
                  test.ok(options.size >= 1024);
            
                  db.close();
                });
              });
            });
            // An example returning the options for a collection using a Generator and the co module.
            
            var MongoClient = require('mongodb').MongoClient,
              co = require('co');
              test = require('assert');
            
            co(function*() {
              var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            
              // Create a test collection that we are getting the options back from
              var collection = yield db.createCollection('test_collection_options_with_generators', {'capped':true, 'size':1024});
              test.equal('test_collection_options_with_generators', collection.collectionName);
            
              // Let's fetch the collection options
              var options = yield collection.options();
              test.equal(true, options.capped);
              test.ok(options.size >= 1024);
            
              db.close();
            });

            parallelCollectionScan(options, callback){Promise}

            Return N number of parallel cursors for a collection allowing parallel reading of entire collection. There are
            no ordering guarantees for returned results.

            Name Type Default Description
            options object null optional

            Optional settings.

            Name Type Default Description
            readPreference ReadPreference | string null optional

            The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).

            batchSize number null optional

            Set the batchSize for the getMoreCommand when iterating over the query results.

            numCursors number 1 optional

            The maximum number of parallel command cursors to return (the number of returned cursors will be in the range 1:numCursors)

            raw boolean false optional

            Return all BSON documents as Raw Buffer documents.

            callback Collection~parallelCollectionScanCallback optional

            The command result callback

            Returns:
            Promise if no callback passed
            Examples
            // A parallelCollectionScan example
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              var docs = [];
            
              // Insert some documents
              for(var i = 0; i < 1000; i++) {
                docs.push({a:i});
              }
            
              // Get the collection
              var collection = db.collection('parallelCollectionScan');
              // Insert 1000 documents in a batch
              collection.insertMany(docs, function(err, result) {
                var results = [];
                var numCursors = 3;
            
                // Execute parallelCollectionScan command
                collection.parallelCollectionScan({numCursors:numCursors}, function(err, cursors) {
                  test.equal(null, err);
                  test.ok(cursors != null);
                  test.ok(cursors.length > 0);
                  var left = cursors.length;
            
                  for(var i = 0; i < cursors.length; i++) {
                    cursors[i].toArray(function(err, items) {
                      test.equal(err, null);
            
                      // Add docs to results array
                      results = results.concat(items);
                      left = left - 1;
            
                      // No more cursors let's ensure we got all results
                      if(left == 0) {
                        test.equal(docs.length, results.length);
            
                        db.close();
                      }
                    });
                  }
                });
              });
            });
            // A parallelCollectionScan example using a Promise.
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              var docs = [];
            
              // Insert some documents
              for(var i = 0; i < 1000; i++) {
                docs.push({a:i});
              }
            
              // Get the collection
              var collection = db.collection('parallelCollectionScan_with_promise');
              // Insert 1000 documents in a batch
              collection.insertMany(docs).then(function(result) {
                var results = [];
                var numCursors = 3;
            
                // Execute parallelCollectionScan command
                collection.parallelCollectionScan({numCursors:numCursors}).then(function(cursors) {
                  test.ok(cursors != null);
                  test.ok(cursors.length > 0);
                  var left = cursors.length;
            
                  for(var i = 0; i < cursors.length; i++) {
                    cursors[i].toArray().then(function(items) {
                      // Add docs to results array
                      results = results.concat(items);
                      left = left - 1;
            
                      // No more cursors let's ensure we got all results
                      if(left == 0) {
                        test.equal(docs.length, results.length);
            
                        db.close();
                      }
                    });
                  }
                });
              });
            });
            // A parallelCollectionScan example using a Generator and the co module.
            
            var MongoClient = require('mongodb').MongoClient,
              co = require('co');
              test = require('assert');
            
            co(function*() {
              var db = yield MongoClient.connect('mongodb://localhost:27017/test');
              var docs = [];
            
              // Insert some documents
              for(var i = 0; i < 1000; i++) {
                docs.push({a:i});
              }
            
              // Get the collection
              var collection = db.collection('parallelCollectionScan_with_generators');
              // Insert 1000 documents in a batch
              yield collection.insertMany(docs);
              var results = [];
              var numCursors = 3;
            
              // Execute parallelCollectionScan command
              var cursors = yield collection.parallelCollectionScan({numCursors:numCursors});
              test.ok(cursors != null);
              test.ok(cursors.length >= 0);
            
              for(var i = 0; i < cursors.length; i++) {
                var items = yield cursors[i].toArray();
                // Add docs to results array
                results = results.concat(items);
              }
            
              test.equal(docs.length, results.length);
              db.close();
            });

            reIndex(callback){Promise}

            Reindex all indexes on the collection
            Warning: reIndex is a blocking operation (indexes are rebuilt in the foreground) and will be slow for large collections.

            Name Type Description
            callback Collection~resultCallback optional

            The command result callback

            Returns:
            Promise if no callback passed
            Examples
            // An example showing how to force a reindex of a collection.
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a collection we want to drop later
              var collection = db.collection('shouldCorrectlyForceReindexOnCollection');
              // Insert a bunch of documents for the index
              collection.insertMany([{a:1, b:1}
                , {a:2, b:2}, {a:3, b:3}, {a:4, b:4, c:4}], {w:1}, function(err, result) {
                test.equal(null, err);
            
                // Create an index on the a field
                collection.ensureIndex({a:1, b:1}
                  , {unique:true, background:true, w:1}, function(err, indexName) {
            
                  // Force a reindex of the collection
                  collection.reIndex(function(err, result) {
                    test.equal(null, err);
                    test.equal(true, result);
            
                    // Verify that the index is gone
                    collection.indexInformation(function(err, indexInformation) {
                      test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
                      test.deepEqual([ [ 'a', 1 ], [ 'b', 1 ] ], indexInformation.a_1_b_1);
            
                      db.close();
                    });
                  });
                });
              });
            });
            // An example showing how to force a reindex of a collection using a Promise.
            
            var MongoClient = require('mongodb').MongoClient,
              test = require('assert');
            MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
            
              // Create a collection we want to drop later
              var collection = db.collection('shouldCorrectlyForceReindexOnCollection_with_promise');
              // Insert a bunch of documents for the index
              collection.insertMany([{a:1, b:1}
                , {a:2, b:2}, {a:3, b:3}, {a:4, b:4, c:4}], {w:1}).then(function(result) {
            
                // Create an index on the a field
                collection.ensureIndex({a:1, b:1}
                  , {unique:true, background:true, w:1}).then(function(indexName) {
            
                  // Force a reindex of the collection
                  collection.reIndex().then(function(result) {
                    test.equal(true, result);
            
                    // Verify that the index is gone
                    collection.indexInformation().then(function(indexInformation) {
                      test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
                      test.deepEqual([ [ 'a', 1 ], [ 'b', 1 ] ], indexInformation.a_1_b_1);
            
                      db.close();
                    });
                  });
                });
              });
            });
            // An example showing how to force a reindex of a collection using a Generator and the co module.
            
            var MongoClient = require('mongodb').MongoClient,
              co = require('co');
              test = require('assert');
            
            co(function*() {
              var db = yield MongoClient.connect('mongodb://localhost:27017/test');
            
              // Create a collection we want to drop later
              var collection = db.collection('shouldCorrectlyForceReindexOnCollection_with_generators');
              // Insert a bunch of documents for the index
              yield collection.insertMany([{a:1, b:1}
                , {a:2, b:2}, {a:3, b:3}, {a:4, b:4, c:4}], {w:1});
            
              // Create an index on the a field
              yield collection.ensureIndex({a:1, b:1}
                , {unique:true, background:true, w:1});
            
              // Force a reindex of the collection
              var result = yield collection.reIndex();
              test.equal(true, result);
            
              // Verify that the index is gone
              var indexInformation = yield collection.indexInformation();
              test.deepEqual([ [ '_id', 1 ] ], indexInformation._id_);
              test.deepEqual([ [ 'a', 1 ], [ 'b', 1 ] ], indexInformation.a_1_b_1);
            
              db.close();
            });

            remove(selector, options, callback){Promise}

            Remove documents.

            Name Type Default Description
            selector object

            The selector for the update operation.

            options object null optional

            Optional settings.

            Name Type Default Description
            w number | string null optional

            The write concern.

            wtimeout number null optional

            The write concern timeout.

            j boolean false optional

            Specify a journal write concern.

            single boolean false optional

            Removes the first document found.

            callback Collection~writeOpCallback optional

            The command result callback

            Deprecated
            • use deleteOne, deleteMany or bulkWrite
              Returns:
              Promise if no callback passed
              Examples
              // An example removing all documents in a collection not using safe mode
              
              var MongoClient = require('mongodb').MongoClient,
                test = require('assert');
              MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              
                // Fetch a collection to insert document into
                var collection = db.collection("remove_all_documents_no_safe");
                // Insert a bunch of documents
                collection.insertMany([{a:1}, {b:2}], {w:1}, function(err, result) {
                  test.equal(null, err);
              
                  // Remove all the document
                  collection.removeMany();
              
                  // Fetch all results
                  collection.find().toArray(function(err, items) {
                    test.equal(null, err);
                    test.equal(0, items.length);
                    db.close();
                  });
                })
              });
              // An example removing a subset of documents using safe mode to ensure removal of documents
              
              var MongoClient = require('mongodb').MongoClient,
                test = require('assert');
              MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                test.equal(null, err);
              
                // Fetch a collection to insert document into
                var collection = db.collection("remove_subset_of_documents_safe");
                // Insert a bunch of documents
                collection.insertMany([{a:1}, {b:2}], {w:1}, function(err, result) {
                  test.equal(null, err);
              
                  // Remove all the document
                  collection.removeOne({a:1}, {w:1}, function(err, r) {
                    test.equal(null, err);
                    test.equal(1, r.result.n);
                    db.close();
                  });
                });
              });
              // An example removing all documents in a collection not using safe mode using a Promise.
              
              var MongoClient = require('mongodb').MongoClient,
                test = require('assert');
              MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              
                // Fetch a collection to insert document into
                var collection = db.collection("remove_all_documents_no_safe_with_promise");
                // Insert a bunch of documents
                collection.insertMany([{a:1}, {b:2}], {w:1}).then(function(result) {
                  // Remove all the document
                  collection.removeMany();
              
                  // Fetch all results
                  collection.find().toArray().then(function(items) {
                    test.equal(0, items.length);
                    db.close();
                  });
                })
              });
              // An example removing a subset of documents using safe mode to ensure removal of documents using a Promise.
              
              var MongoClient = require('mongodb').MongoClient,
                test = require('assert');
              MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
              
                // Fetch a collection to insert document into
                var collection = db.collection("remove_subset_of_documents_safe_with_promise");
                // Insert a bunch of documents
                collection.insertMany([{a:1}, {b:2}], {w:1}).then(function(result) {
                  // Remove all the document
                  collection.removeOne({a:1}, {w:1}).then(function(r) {
                    test.equal(1, r.result.n);
                    db.close();
                  });
                });
              });
              // An example removing all documents in a collection not using safe mode using a Generator and the co module.
              
              var MongoClient = require('mongodb').MongoClient,
                co = require('co');
                test = require('assert');
              
              co(function*() {
                var db = yield MongoClient.connect('mongodb://localhost:27017/test');
              
                // Fetch a collection to insert document into
                var collection = db.collection("remove_all_documents_no_safe_with_generators");
              
                // Insert a bunch of documents
                yield collection.insertMany([{a:1}, {b:2}], {w:1});
              
                // Remove all the document
                collection.removeMany();
              
                // Fetch all results
                var items = yield collection.find().toArray();
                test.equal(0, items.length);
                db.close();
              });
              // An example removing a subset of documents using safe mode to ensure removal of documents using a Generator and the co module.
              
              var MongoClient = require('mongodb').MongoClient,
                co = require('co');
                test = require('assert');
              
              co(function*() {
                var db = yield MongoClient.connect('mongodb://localhost:27017/test');
              
                // Fetch a collection to insert document into
                var collection = db.collection("remove_subset_of_documents_safe_with_generators");
                // Insert a bunch of documents
                yield collection.insertMany([{a:1}, {b:2}], {w:1});
                // Remove all the document
                var r = yield collection.removeOne({a:1}, {w:1});
                test.equal(1, r.result.n);
                db.close();
              });

              rename(newName, options, callback){Promise}

              Rename the collection.

              Name Type Default Description
              newName string

              New name of of the collection.

              options object null optional

              Optional settings.

              Name Type Default Description
              dropTarget boolean false optional

              Drop the target name collection if it previously exists.

              callback Collection~collectionResultCallback optional

              The results callback

              Returns:
              Promise if no callback passed
              Examples
              // An example of illegal and legal renaming of a collection
              
              var MongoClient = require('mongodb').MongoClient,
                test = require('assert');
              MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                // Open a couple of collections
                db.createCollection('test_rename_collection', function(err, collection1) {
                  db.createCollection('test_rename_collection2', function(err, collection2) {
                    // Attemp to rename a collection to a number
                    try {
                      collection1.rename(5, function(err, collection) {});
                    } catch(err) {
                      test.ok(err instanceof Error);
                      test.equal("collection name must be a String", err.message);
                    }
              
                    // Attemp to rename a collection to an empty string
                    try {
                      collection1.rename("", function(err, collection) {});
                    } catch(err) {
                      test.ok(err instanceof Error);
                      test.equal("collection names cannot be empty", err.message);
                    }
              
                    // Attemp to rename a collection to an illegal name including the character $
                    try {
                      collection1.rename("te$t", function(err, collection) {});
                    } catch(err) {
                      test.ok(err instanceof Error);
                      test.equal("collection names must not contain '$'", err.message);
                    }
              
                    // Attemp to rename a collection to an illegal name starting with the character .
                    try {
                      collection1.rename(".test", function(err, collection) {});
                    } catch(err) {
                      test.ok(err instanceof Error);
                      test.equal("collection names must not start or end with '.'", err.message);
                    }
              
                    // Attemp to rename a collection to an illegal name ending with the character .
                    try {
                      collection1.rename("test.", function(err, collection) {});
                    } catch(err) {
                      test.ok(err instanceof Error);
                      test.equal("collection names must not start or end with '.'", err.message);
                    }
              
                    // Attemp to rename a collection to an illegal name with an empty middle name
                    try {
                      collection1.rename("tes..t", function(err, collection) {});
                    } catch(err) {
                      test.equal("collection names cannot be empty", err.message);
                    }
              
                    // Insert a couple of documents
                    collection1.insertMany([{'x':1}, {'x':2}], {w:1}, function(err, docs) {
              
                      // Attemp to rename the first collection to the second one, this will fail
                      collection1.rename('test_rename_collection2', function(err, collection) {
                        test.ok(err instanceof Error);
                        test.ok(err.message.length > 0);
              
                        // Attemp to rename the first collection to a name that does not exist
                        // this will be succesful
                        collection1.rename('test_rename_collection3', function(err, collection2) {
                          test.equal("test_rename_collection3", collection2.collectionName);
              
                          // Ensure that the collection is pointing to the new one
                          collection2.count(function(err, count) {
                            test.equal(2, count);
                            db.close();
                          });
                        });
                      });
                    });
              
                  });
                });
              });
              // An example of illegal and legal renaming of a collection using a Promise.
              
              var MongoClient = require('mongodb').MongoClient,
                test = require('assert');
              MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                // Open a couple of collections
                db.createCollection('test_rename_collection_with_promise').then(function(collection1) {
                  db.createCollection('test_rename_collection2_with_promise').then(function(collection2) {
                    // Attemp to rename a collection to a number
                    try {
                      collection1.rename(5, function(err, collection) {});
                    } catch(err) {
                      test.ok(err instanceof Error);
                      test.equal("collection name must be a String", err.message);
                    }
              
                    // Attemp to rename a collection to an empty string
                    try {
                      collection1.rename("", function(err, collection) {});
                    } catch(err) {
                      test.ok(err instanceof Error);
                      test.equal("collection names cannot be empty", err.message);
                    }
              
                    // Attemp to rename a collection to an illegal name including the character $
                    try {
                      collection1.rename("te$t", function(err, collection) {});
                    } catch(err) {
                      test.ok(err instanceof Error);
                      test.equal("collection names must not contain '$'", err.message);
                    }
              
                    // Attemp to rename a collection to an illegal name starting with the character .
                    try {
                      collection1.rename(".test", function(err, collection) {});
                    } catch(err) {
                      test.ok(err instanceof Error);
                      test.equal("collection names must not start or end with '.'", err.message);
                    }
              
                    // Attemp to rename a collection to an illegal name ending with the character .
                    try {
                      collection1.rename("test.", function(err, collection) {});
                    } catch(err) {
                      test.ok(err instanceof Error);
                      test.equal("collection names must not start or end with '.'", err.message);
                    }
              
                    // Attemp to rename a collection to an illegal name with an empty middle name
                    try {
                      collection1.rename("tes..t", function(err, collection) {});
                    } catch(err) {
                      test.equal("collection names cannot be empty", err.message);
                    }
              
                    // Insert a couple of documents
                    collection1.insertMany([{'x':1}, {'x':2}], {w:1}).then(function(docs) {
              
                      // Attemp to rename the first collection to the second one, this will fail
                      collection1.rename('test_rename_collection2_with_promise').then(function(err, collection) {
                      }).catch(function(err) {
                        test.ok(err instanceof Error);
                        test.ok(err.message.length > 0);
              
                        // Attemp to rename the first collection to a name that does not exist
                        // this will be succesful
                        collection1.rename('test_rename_collection3_with_promise').then(function(collection2) {
                          test.equal("test_rename_collection3_with_promise", collection2.collectionName);
              
                          // Ensure that the collection is pointing to the new one
                          collection2.count().then(function(count) {
                            test.equal(2, count);
                            db.close();
                          });
                        });
                      });
                    });
              
                  });
                });
              });
              // An example of illegal and legal renaming of a collection using a Generator and the co module.
              
              var MongoClient = require('mongodb').MongoClient,
                co = require('co');
                test = require('assert');
              
              co(function*() {
                var db = yield MongoClient.connect('mongodb://localhost:27017/test');
                // Open a couple of collections
                var collection1 = yield db.createCollection('test_rename_collection_with_generators');
                var collection2 = yield db.createCollection('test_rename_collection2_with_generators');
                // Attemp to rename a collection to a number
                try {
                  collection1.rename(5, function(err, collection) {});
                } catch(err) {
                  test.ok(err instanceof Error);
                  test.equal("collection name must be a String", err.message);
                }
              
                // Attemp to rename a collection to an empty string
                try {
                  collection1.rename("", function(err, collection) {});
                } catch(err) {
                  test.ok(err instanceof Error);
                  test.equal("collection names cannot be empty", err.message);
                }
              
                // Attemp to rename a collection to an illegal name including the character $
                try {
                  collection1.rename("te$t", function(err, collection) {});
                } catch(err) {
                  test.ok(err instanceof Error);
                  test.equal("collection names must not contain '$'", err.message);
                }
              
                // Attemp to rename a collection to an illegal name starting with the character .
                try {
                  collection1.rename(".test", function(err, collection) {});
                } catch(err) {
                  test.ok(err instanceof Error);
                  test.equal("collection names must not start or end with '.'", err.message);
                }
              
                // Attemp to rename a collection to an illegal name ending with the character .
                try {
                  collection1.rename("test.", function(err, collection) {});
                } catch(err) {
                  test.ok(err instanceof Error);
                  test.equal("collection names must not start or end with '.'", err.message);
                }
              
                // Attemp to rename a collection to an illegal name with an empty middle name
                try {
                  collection1.rename("tes..t", function(err, collection) {});
                } catch(err) {
                  test.equal("collection names cannot be empty", err.message);
                }
              
                // Insert a couple of documents
                yield collection1.insertMany([{'x':1}, {'x':2}], {w:1});
              
                try {
                  // Attemp to rename the first collection to the second one, this will fail
                  yield collection1.rename('test_rename_collection2_with_generators');
                } catch(err) {
                  test.ok(err instanceof Error);
                  test.ok(err.message.length > 0);
              
                  // Attemp to rename the first collection to a name that does not exist
                  // this will be succesful
                  var collection2 = yield collection1.rename('test_rename_collection3_with_generators');
                  test.equal("test_rename_collection3_with_generators", collection2.collectionName);
              
                  // Ensure that the collection is pointing to the new one
                  var count = yield collection2.count();
                  test.equal(2, count);
                  db.close();
                }
              });

              replaceOne(filter, doc, options, callback){Promise}

              Replace a document on MongoDB

              Name Type Default Description
              filter object

              The Filter used to select the document to update

              doc object

              The Document that replaces the matching document

              options object null optional

              Optional settings.

              Name Type Default Description
              upsert boolean false optional

              Update operation is an upsert.

              w number | string null optional

              The write concern.

              wtimeout number null optional

              The write concern timeout.

              j boolean false optional

              Specify a journal write concern.

              bypassDocumentValidation boolean false optional

              Allow driver to bypass schema validation in MongoDB 3.2 or higher.

              callback Collection~updateWriteOpCallback optional

              The command result callback

              Returns:
              Promise if no callback passed

              save(doc, options, callback){Promise}

              Save a document. Simple full document replacement function. Not recommended for efficiency, use atomic
              operators and update instead for more efficient operations.

              Name Type Default Description
              doc object

              Document to save

              options object null optional

              Optional settings.

              Name Type Default Description
              w number | string null optional

              The write concern.

              wtimeout number null optional

              The write concern timeout.

              j boolean false optional

              Specify a journal write concern.

              callback Collection~writeOpCallback optional

              The command result callback

              Deprecated
              • use insertOne, insertMany, updateOne or updateMany
                Returns:
                Promise if no callback passed
                Examples
                // Example of a simple document save with safe set to false
                
                var MongoClient = require('mongodb').MongoClient,
                  test = require('assert');
                MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                
                  // Fetch the collection
                  var collection = db.collection("save_a_simple_document");
                  // Save a document with no safe option
                  collection.save({hello:'world'});
                
                  // Wait for a second
                  setTimeout(function() {
                
                    // Find the saved document
                    collection.findOne({hello:'world'}, function(err, item) {
                      test.equal(null, err);
                      test.equal('world', item.hello);
                      db.close();
                    });
                  }, 2000);
                });
                // Example of a simple document save and then resave with safe set to true
                
                var MongoClient = require('mongodb').MongoClient,
                  test = require('assert');
                MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                
                  // Fetch the collection
                  var collection = db.collection("save_a_simple_document_modify_it_and_resave_it");
                
                  // Save a document with no safe option
                  collection.save({hello:'world'}, {w:1}, function(err, result) {
                
                    // Find the saved document
                    collection.findOne({hello:'world'}, function(err, item) {
                      test.equal(null, err);
                      test.equal('world', item.hello);
                
                      // Update the document
                      item['hello2'] = 'world2';
                
                      // Save the item with the additional field
                      collection.save(item, {w:1}, function(err, result) {
                
                        // Find the changed document
                        collection.findOne({hello:'world'}, function(err, item) {
                          test.equal(null, err);
                          test.equal('world', item.hello);
                          test.equal('world2', item.hello2);
                
                          db.close();
                        });
                      });
                    });
                  });
                });
                // Example of a simple document save with safe set to false using a Promise.
                
                var MongoClient = require('mongodb').MongoClient,
                  test = require('assert');
                MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                
                  // Fetch the collection
                  var collection = db.collection("save_a_simple_document_with_promise");
                  // Save a document with no safe option
                  collection.save({hello:'world'});
                
                  // Wait for a second
                  setTimeout(function() {
                
                    // Find the saved document
                    collection.findOne({hello:'world'}).then(function(item) {
                      test.equal('world', item.hello);
                      db.close();
                    });
                  }, 2000);
                });
                // Example of a simple document save and then resave with safe set to true using a Promise.
                
                var MongoClient = require('mongodb').MongoClient,
                  test = require('assert');
                MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                
                  // Fetch the collection
                  var collection = db.collection("save_a_simple_document_modify_it_and_resave_it_with_promise");
                
                  // Save a document with no safe option
                  collection.save({hello:'world'}, {w:1}).then(function(result) {
                
                    // Find the saved document
                    collection.findOne({hello:'world'}).then(function(item) {
                      test.equal('world', item.hello);
                
                      // Update the document
                      item['hello2'] = 'world2';
                
                      // Save the item with the additional field
                      collection.save(item, {w:1}).then(function(result) {
                
                        // Find the changed document
                        collection.findOne({hello:'world'}).then(function(item) {
                          test.equal('world', item.hello);
                          test.equal('world2', item.hello2);
                
                          db.close();
                        });
                      });
                    });
                  });
                });
                // Example of a simple document save with safe set to false using a Generator and the co module.
                
                var MongoClient = require('mongodb').MongoClient,
                  co = require('co');
                  test = require('assert');
                
                co(function*() {
                  var db = yield MongoClient.connect('mongodb://localhost:27017/test');
                
                  // Fetch the collection
                  var collection = db.collection("save_a_simple_document_with_generators");
                  // Save a document with no safe option
                  collection.save({hello:'world'});
                
                  // Wait for a second
                  setTimeout(function() {
                    co(function*() {
                      // Find the saved document
                      var item = yield collection.findOne({hello:'world'});
                      test.equal('world', item.hello);
                      db.close();
                    });
                  }, 2000);
                });
                // Example of a simple document save and then resave with safe set to true using a Generator and the co module.
                
                var MongoClient = require('mongodb').MongoClient,
                  co = require('co');
                  test = require('assert');
                
                co(function*() {
                  var db = yield MongoClient.connect('mongodb://localhost:27017/test');
                
                  // Fetch the collection
                  var collection = db.collection("save_a_simple_document_modify_it_and_resave_it_with_generators");
                
                  // Save a document with no safe option
                  yield collection.save({hello:'world'}, {w:1});
                
                  // Find the saved document
                  var item = yield collection.findOne({hello:'world'})
                  test.equal('world', item.hello);
                
                  // Update the document
                  item['hello2'] = 'world2';
                
                  // Save the item with the additional field
                  yield collection.save(item, {w:1});
                
                  // Find the changed document
                  var item = yield collection.findOne({hello:'world'});
                  test.equal('world', item.hello);
                  test.equal('world2', item.hello2);
                
                  db.close();
                });

                stats(options, callback){Promise}

                Get all the collection statistics.

                Name Type Default Description
                options object null optional

                Optional settings.

                Name Type Default Description
                scale number null optional

                Divide the returned sizes by scale value.

                callback Collection~resultCallback optional

                The collection result callback

                Returns:
                Promise if no callback passed
                Examples
                // Example of retrieving a collections stats
                
                var MongoClient = require('mongodb').MongoClient,
                  test = require('assert');
                MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                
                  // Crete the collection for the distinct example
                  var collection = db.collection('collection_stats_test');
                
                  // Insert some documents
                  collection.insertMany([{a:1}, {hello:'world'}], {w:1}, function(err, result) {
                
                    // Retrieve the statistics for the collection
                    collection.stats(function(err, stats) {
                      test.equal(2, stats.count);
                
                      db.close();
                    });
                  });
                });
                // Example of retrieving a collections stats using a Promise.
                
                var MongoClient = require('mongodb').MongoClient,
                  test = require('assert');
                MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                
                  // Crete the collection for the distinct example
                  var collection = db.collection('collection_stats_test_with_promise');
                
                  // Insert some documents
                  collection.insertMany([{a:1}, {hello:'world'}], {w:1}).then(function(result) {
                
                    // Retrieve the statistics for the collection
                    collection.stats().then(function(stats) {
                      test.equal(2, stats.count);
                
                      db.close();
                    });
                  });
                });
                // Example of retrieving a collections stats using a Generator and the co module.
                
                var MongoClient = require('mongodb').MongoClient,
                  co = require('co');
                  test = require('assert');
                
                co(function*() {
                  var db = yield MongoClient.connect('mongodb://localhost:27017/test');
                
                  // Crete the collection for the distinct example
                  var collection = db.collection('collection_stats_test_with_generators');
                
                  // Insert some documents
                  yield collection.insertMany([{a:1}, {hello:'world'}], {w:1});
                
                  // Retrieve the statistics for the collection
                  var stats = yield collection.stats();
                  test.equal(2, stats.count);
                
                  db.close();
                });

                update(selector, document, options, callback){Promise}

                Updates documents.

                Name Type Default Description
                selector object

                The selector for the update operation.

                document object

                The update document.

                options object null optional

                Optional settings.

                Name Type Default Description
                w number | string null optional

                The write concern.

                wtimeout number null optional

                The write concern timeout.

                j boolean false optional

                Specify a journal write concern.

                upsert boolean false optional

                Update operation is an upsert.

                multi boolean false optional

                Update one/all documents with operation.

                bypassDocumentValidation boolean false optional

                Allow driver to bypass schema validation in MongoDB 3.2 or higher.

                collation object null optional

                Specify collation (MongoDB 3.4 or higher) settings for update operation (see 3.4 documentation for available fields).

                callback Collection~writeOpCallback optional

                The command result callback

                Deprecated
                • use updateOne, updateMany or bulkWrite
                  Throws:
                  Returns:
                  Promise if no callback passed
                  Examples
                  // Example of a simple document update with safe set to false on an existing document using a Promise.
                  
                  var MongoClient = require('mongodb').MongoClient,
                    test = require('assert');
                  MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                  
                    // Get a collection
                    var collection = db.collection('update_a_simple_document_with_promise');
                  
                    // Insert a document, then update it
                    collection.insertOne({a:1}, {w:1}).then(function(doc) {
                  
                      // Update the document with an atomic operator
                      collection.updateOne({a:1}, {$set:{b:2}});
                  
                      // Wait for a second then fetch the document
                      setTimeout(function() {
                  
                        // Fetch the document that we modified
                        collection.findOne({a:1}).then(function(item) {
                          test.equal(1, item.a);
                          test.equal(2, item.b);
                          db.close();
                        });
                      }, 1000);
                    });
                  });
                  // Example of a simple document update using upsert (the document will be inserted if it does not exist) using a Promise.
                  
                  var MongoClient = require('mongodb').MongoClient,
                    test = require('assert');
                  MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                  
                    // Get a collection
                    var collection = db.collection('update_a_simple_document_upsert_with_promise');
                    // Update the document using an upsert operation, ensuring creation if it does not exist
                    collection.updateOne({a:1}, {b:2, a:1}, {upsert:true, w: 1}).then(function(result) {
                      test.equal(1, result.result.n);
                  
                      // Fetch the document that we modified and check if it got inserted correctly
                      collection.findOne({a:1}).then(function(item) {
                        test.equal(1, item.a);
                        test.equal(2, item.b);
                        db.close();
                      });
                    });
                  });
                  // Example of an update across multiple documents using the multi option and using a Promise.
                  
                  var MongoClient = require('mongodb').MongoClient,
                    test = require('assert');
                  MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                  
                    // Get a collection
                    var collection = db.collection('update_a_simple_document_multi_with_promise');
                  
                    // Insert a couple of documentations
                    collection.insertMany([{a:1, b:1}, {a:1, b:2}], {w:1}).then(function(result) {
                  
                      var o = {w:1};
                      o.multi = true
                      // Update multiple documents using the multi option
                      collection.updateMany({a:1}, {$set:{b:0}}, o).then(function(r) {
                        test.equal(2, r.result.n);
                  
                        // Fetch all the documents and verify that we have changed the b value
                        collection.find().toArray().then(function(items) {
                          test.equal(1, items[0].a);
                          test.equal(0, items[0].b);
                          test.equal(1, items[1].a);
                          test.equal(0, items[1].b);
                  
                          db.close();
                        });
                      })
                    });
                  });
                  // Example of a simple document update with safe set to false on an existing document using a Generator and the co module.
                  
                  var MongoClient = require('mongodb').MongoClient,
                    co = require('co');
                    test = require('assert');
                  
                  co(function*() {
                    var db = yield MongoClient.connect('mongodb://localhost:27017/test');
                  
                    // Get a collection
                    var collection = db.collection('update_a_simple_document_with_generators');
                  
                    // Insert a document, then update it
                    yield collection.insertOne({a:1}, {w:1});
                  
                    // Update the document with an atomic operator
                    collection.updateOne({a:1}, {$set:{b:2}});
                  
                    // Wait for a second then fetch the document
                    setTimeout(function() {
                      co(function*() {
                        // Fetch the document that we modified
                        var item = yield collection.findOne({a:1});
                        test.equal(1, item.a);
                        test.equal(2, item.b);
                  
                        db.close();
                      });
                    }, 1000);
                  });
                  // Example of a simple document update using upsert (the document will be inserted if it does not exist) using a Generator and the co module.
                  
                  var MongoClient = require('mongodb').MongoClient,
                    co = require('co');
                    test = require('assert');
                  
                  co(function*() {
                    var db = yield MongoClient.connect('mongodb://localhost:27017/test');
                  
                    // Get a collection
                    var collection = db.collection('update_a_simple_document_upsert_with_generators');
                    // Update the document using an upsert operation, ensuring creation if it does not exist
                    var result = yield collection.updateOne({a:1}, {b:2, a:1}, {upsert:true, w: 1});
                    test.equal(1, result.result.n);
                  
                    // Fetch the document that we modified and check if it got inserted correctly
                    var item = yield collection.findOne({a:1});
                    test.equal(1, item.a);
                    test.equal(2, item.b);
                    db.close();
                  });
                  // Example of an update across multiple documents using the multi option and using a Generator and the co module.
                  
                  var MongoClient = require('mongodb').MongoClient,
                    co = require('co');
                    test = require('assert');
                  
                  co(function*() {
                    var db = yield MongoClient.connect('mongodb://localhost:27017/test');
                  
                    // Get a collection
                    var collection = db.collection('update_a_simple_document_multi_with_generators');
                  
                    // Insert a couple of documentations
                    yield collection.insertMany([{a:1, b:1}, {a:1, b:2}], {w:1});
                  
                    var o = {w:1};
                    o.multi = true
                  
                    // Update multiple documents using the multi option
                    var r = yield collection.updateMany({a:1}, {$set:{b:0}}, o);
                    test.equal(2, r.result.n);
                  
                    // Fetch all the documents and verify that we have changed the b value
                    var items = yield collection.find().toArray();
                    test.equal(1, items[0].a);
                    test.equal(0, items[0].b);
                    test.equal(1, items[1].a);
                    test.equal(0, items[1].b);
                  
                    db.close();
                  });

                  updateMany(filter, update, options, callback){Promise}

                  Update multiple documents on MongoDB

                  Name Type Default Description
                  filter object

                  The Filter used to select the document to update

                  update object

                  The update operations to be applied to the document

                  options object null optional

                  Optional settings.

                  Name Type Default Description
                  upsert boolean false optional

                  Update operation is an upsert.

                  w number | string null optional

                  The write concern.

                  wtimeout number null optional

                  The write concern timeout.

                  j boolean false optional

                  Specify a journal write concern.

                  callback Collection~updateWriteOpCallback optional

                  The command result callback

                  Returns:
                  Promise if no callback passed
                  Examples
                  // Example of an update across multiple documents using the multi option.
                  
                  var MongoClient = require('mongodb').MongoClient,
                    test = require('assert');
                  MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                  
                    // Get a collection
                    var collection = db.collection('update_a_simple_document_multi');
                  
                    // Insert a couple of documentations
                    collection.insertMany([{a:1, b:1}, {a:1, b:2}], {w:1}, function(err, result) {
                  
                      var o = {w:1};
                      o.multi = true
                      // Update multiple documents using the multi option
                      collection.updateMany({a:1}, {$set:{b:0}}, o, function(err, r) {
                        test.equal(null, err);
                        test.equal(2, r.result.n);
                  
                        // Fetch all the documents and verify that we have changed the b value
                        collection.find().toArray(function(err, items) {
                          test.equal(null, err);
                          test.equal(1, items[0].a);
                          test.equal(0, items[0].b);
                          test.equal(1, items[1].a);
                          test.equal(0, items[1].b);
                  
                          db.close();
                        });
                      })
                    });
                  });
                  // Example of a simple updateMany operation
                  
                  var MongoClient = require('mongodb').MongoClient,
                    test = require('assert');
                  MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                    // Get the collection
                    var col = db.collection('update_many');
                    col.insertMany([{a:1}, {a:1}], function(err, r) {
                      test.equal(null, err);
                      test.equal(2, r.insertedCount);
                  
                      // Update all documents
                      col.updateMany({a:1}, {$set: {b: 1}}, function(err, r) {
                        test.equal(null, err);
                        test.equal(2, r.matchedCount);
                        test.equal(2, r.modifiedCount);
                  
                        // Finish up test
                        db.close();
                      });
                    });
                  });
                  // Example of a simple updateMany operation using a Promise.
                  
                  var MongoClient = require('mongodb').MongoClient,
                    test = require('assert');
                  MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                    // Get the collection
                    var col = db.collection('update_many_with_promise');
                    col.insertMany([{a:1}, {a:1}]).then(function(r) {
                      test.equal(2, r.insertedCount);
                  
                      // Update all documents
                      col.updateMany({a:1}, {$set: {b: 1}}).then(function(r) {
                        if(r.n) {
                          test.equal(2, r.n);
                        } else {
                          test.equal(2, r.matchedCount);
                          test.equal(2, r.modifiedCount);
                        }
                  
                        // Finish up test
                        db.close();
                      });
                    });
                  });
                  // Example of a simple updateMany operation using a Generator and the co module.
                  
                  var MongoClient = require('mongodb').MongoClient,
                    co = require('co');
                    test = require('assert');
                  
                  co(function*() {
                    var db = yield MongoClient.connect('mongodb://localhost:27017/test');
                    // Get the collection
                    var col = db.collection('update_many_with_generators');
                    var r = yield col.insertMany([{a:1}, {a:1}]);
                    test.equal(2, r.insertedCount);
                  
                    // Update all documents
                    var r = yield col.updateMany({a:1}, {$set: {b: 1}});
                    test.equal(2, r.matchedCount);
                    test.equal(2, r.modifiedCount);
                  
                    // Finish up test
                    db.close();
                  });

                  updateOne(filter, update, options, callback){Promise}

                  Update a single document on MongoDB

                  Name Type Default Description
                  filter object

                  The Filter used to select the document to update

                  update object

                  The update operations to be applied to the document

                  options object null optional

                  Optional settings.

                  Name Type Default Description
                  upsert boolean false optional

                  Update operation is an upsert.

                  w number | string null optional

                  The write concern.

                  wtimeout number null optional

                  The write concern timeout.

                  j boolean false optional

                  Specify a journal write concern.

                  bypassDocumentValidation boolean false optional

                  Allow driver to bypass schema validation in MongoDB 3.2 or higher.

                  callback Collection~updateWriteOpCallback optional

                  The command result callback

                  Returns:
                  Promise if no callback passed
                  Examples
                  // Example of a simple document update with safe set to false on an existing document
                  
                  var MongoClient = require('mongodb').MongoClient,
                    test = require('assert');
                  MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                  
                    // Get a collection
                    var collection = db.collection('update_a_simple_document');
                  
                    // Insert a document, then update it
                    collection.insertOne({a:1}, {w:1}, function(err, doc) {
                  
                      // Update the document with an atomic operator
                      collection.updateOne({a:1}, {$set:{b:2}});
                  
                      // Wait for a second then fetch the document
                      setTimeout(function() {
                  
                        // Fetch the document that we modified
                        collection.findOne({a:1}, function(err, item) {
                          test.equal(null, err);
                          test.equal(1, item.a);
                          test.equal(2, item.b);
                          db.close();
                        });
                      }, 1000);
                    });
                  });
                  // Example of a simple document update using upsert (the document will be inserted if it does not exist)
                  
                  var MongoClient = require('mongodb').MongoClient,
                    test = require('assert');
                  MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                  
                    // Get a collection
                    var collection = db.collection('update_a_simple_document_upsert');
                    // Update the document using an upsert operation, ensuring creation if it does not exist
                    collection.updateOne({a:1}, {b:2, a:1}, {upsert:true, w: 1}, function(err, result) {
                      test.equal(null, err);
                      test.equal(1, result.result.n);
                  
                      // Fetch the document that we modified and check if it got inserted correctly
                      collection.findOne({a:1}, function(err, item) {
                        test.equal(null, err);
                        test.equal(1, item.a);
                        test.equal(2, item.b);
                        db.close();
                      });
                    });
                  });
                  // Example of a simple updateOne operation
                  
                  var MongoClient = require('mongodb').MongoClient,
                    test = require('assert');
                  MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                    // Get the collection
                    var col = db.collection('update_one');
                    col.updateOne({a:1}
                      , {$set: {a:2}}
                      , {upsert:true}, function(err, r) {
                      test.equal(null, err);
                      test.equal(0, r.matchedCount);
                      test.equal(1, r.upsertedCount);
                      // Finish up test
                      db.close();
                    });
                  });
                  // Example of a simple updateOne operation using a Promise.
                  
                  var MongoClient = require('mongodb').MongoClient,
                    test = require('assert');
                  MongoClient.connect('mongodb://localhost:27017/test', function(err, db) {
                    // Get the collection
                    var col = db.collection('update_one_with_promise');
                    col.updateOne({a:1}
                      , {$set: {a:2}}
                      , {upsert:true}).then(function(r) {
                      test.equal(0, r.matchedCount);
                      test.equal(1, r.upsertedCount);
                      // Finish up test
                      db.close();
                    });
                  });
                  // Example of a simple updateOne operation using a Generator and the co module.
                  
                  var MongoClient = require('mongodb').MongoClient,
                    co = require('co');
                    test = require('assert');
                  
                  co(function*() {
                    var db = yield MongoClient.connect('mongodb://localhost:27017/test');
                    // Get the collection
                    var col = db.collection('update_one_with_generators');
                    var r = yield col.updateOne({a:1}
                      , {$set: {a:2}}
                      , {upsert:true});
                    test.equal(0, r.matchedCount);
                    test.equal(1, r.upsertedCount);
                    // Finish up test
                    db.close();
                  });

                  Type Definitions

                  bulkWriteOpCallback(error, result)

                  The callback format for inserts

                  Name Type Description
                  error MongoError

                  An error instance representing the error during the execution.

                  result Collection~BulkWriteOpResult

                  The result object if the command was executed successfully.

                  BulkWriteOpResultObject

                  Properties:
                  Name Type Description
                  insertedCount number

                  Number of documents inserted.

                  matchedCount number

                  Number of documents matched for update.

                  modifiedCount number

                  Number of documents modified.

                  deletedCount number

                  Number of documents deleted.

                  upsertedCount number

                  Number of documents upserted.

                  insertedIds object

                  Inserted document generated Id's, hash key is the index of the originating operation

                  upsertedIds object

                  Upserted document generated Id's, hash key is the index of the originating operation

                  result object

                  The command result object.

                  collectionResultCallback(error, collection)

                  The callback format for the collection method, must be used if strict is specified

                  Name Type Description
                  error MongoError

                  An error instance representing the error during the execution.

                  collection Collection

                  The collection instance.

                  countCallback(error, result)

                  The callback format for results

                  Name Type Description
                  error MongoError

                  An error instance representing the error during the execution.

                  result number

                  The count of documents that matched the query.

                  deleteWriteOpCallback(error, result)

                  The callback format for inserts

                  Name Type Description
                  error MongoError

                  An error instance representing the error during the execution.

                  result Collection~deleteWriteOpResult

                  The result object if the command was executed successfully.

                  deleteWriteOpResultObject

                  Properties:
                  Name Type Description
                  result Object

                  The raw result returned from MongoDB, field will vary depending on server version.

                  Properties
                  Name Type Description
                  ok Number

                  Is 1 if the command executed correctly.

                  n Number

                  The total count of documents deleted.

                  connection Object

                  The connection object used for the operation.

                  deletedCount Number

                  The number of documents deleted.

                  findAndModifyCallback(error, result)

                  The callback format for inserts

                  Name Type Description
                  error MongoError

                  An error instance representing the error during the execution.

                  result Collection~findAndModifyWriteOpResult

                  The result object if the command was executed successfully.

                  findAndModifyWriteOpResultObject

                  Properties:
                  Name Type Description
                  value object

                  Document returned from findAndModify command.

                  lastErrorObject object

                  The raw lastErrorObject returned from the command.

                  ok Number

                  Is 1 if the command executed correctly.

                  insertOneWriteOpCallback(error, result)

                  The callback format for inserts

                  Name Type Description
                  error MongoError

                  An error instance representing the error during the execution.

                  result Collection~insertOneWriteOpResult

                  The result object if the command was executed successfully.

                  insertOneWriteOpResultObject

                  Properties:
                  Name Type Description
                  insertedCount Number

                  The total amount of documents inserted.

                  ops Array.<object>

                  All the documents inserted using insertOne/insertMany/replaceOne. Documents contain the _id field if forceServerObjectId == false for insertOne/insertMany

                  insertedId ObjectId

                  The driver generated ObjectId for the insert operation.

                  connection object

                  The connection object used for the operation.

                  result object

                  The raw command result object returned from MongoDB (content might vary by server version).

                  Properties
                  Name Type Description
                  ok Number

                  Is 1 if the command executed correctly.

                  n Number

                  The total count of documents inserted.

                  insertWriteOpCallback(error, result)

                  The callback format for inserts

                  Name Type Description
                  error MongoError

                  An error instance representing the error during the execution.

                  result Collection~insertWriteOpResult

                  The result object if the command was executed successfully.

                  insertWriteOpResultObject

                  Properties:
                  Name Type Description
                  insertedCount Number

                  The total amount of documents inserted.

                  ops Array.<object>

                  All the documents inserted using insertOne/insertMany/replaceOne. Documents contain the _id field if forceServerObjectId == false for insertOne/insertMany

                  insertedIds Array.<ObjectId>

                  All the generated _id's for the inserted documents.

                  connection object

                  The connection object used for the operation.

                  result object

                  The raw command result object returned from MongoDB (content might vary by server version).

                  Properties
                  Name Type Description
                  ok Number

                  Is 1 if the command executed correctly.

                  n Number

                  The total count of documents inserted.

                  parallelCollectionScanCallback(error, cursors)

                  The callback format for results

                  Name Type Description
                  error MongoError

                  An error instance representing the error during the execution.

                  cursors Array.<Cursor>

                  A list of cursors returned allowing for parallel reading of collection.

                  resultCallback(error, result)

                  The callback format for results

                  Name Type Description
                  error MongoError

                  An error instance representing the error during the execution.

                  result object

                  The result object if the command was executed successfully.

                  updateWriteOpCallback(error, result)

                  The callback format for inserts

                  Name Type Description
                  error MongoError

                  An error instance representing the error during the execution.

                  result Collection~updateWriteOpResult

                  The result object if the command was executed successfully.

                  updateWriteOpResultObject

                  Properties:
                  Name Type Description
                  result Object

                  The raw result returned from MongoDB, field will vary depending on server version.

                  Properties
                  Name Type Description
                  ok Number

                  Is 1 if the command executed correctly.

                  n Number

                  The total count of documents scanned.

                  nModified Number

                  The total count of documents modified.

                  connection Object

                  The connection object used for the operation.

                  matchedCount Number

                  The number of documents that matched the filter.

                  modifiedCount Number

                  The number of documents that were modified.

                  upsertedCount Number

                  The number of documents upserted.

                  upsertedId Object

                  The upserted id.

                  Properties
                  Name Type Description
                  _id ObjectId

                  The upserted _id returned from the server.

                  writeOpCallback(error, result)

                  The callback format for inserts

                  Name Type Description
                  error MongoError

                  An error instance representing the error during the execution.

                  result Collection~WriteOpResult

                  The result object if the command was executed successfully.

                  WriteOpResultObject

                  Properties:
                  Name Type Description
                  ops Array.<object>

                  All the documents inserted using insertOne/insertMany/replaceOne. Documents contain the _id field if forceServerObjectId == false for insertOne/insertMany

                  connection object

                  The connection object used for the operation.

                  result object

                  The command result object.

                  comments powered by Disqus