Come eliminare un database con Mongoose?

Sto preparando uno script per la creazione di database in Node.js e Mongoose. Come posso verificare se il database esiste già e, in tal caso, rilasciarlo (eliminarlo) utilizzando Mongoose?

Non riuscivo a trovare un modo per farlo cadere con Mongoose.

Non esiste un metodo per eliminare una raccolta da mangusta, il meglio che puoi fare è rimuovere il contenuto di uno:

Model.remove({}, function(err) { 
   console.log('collection removed') 
});

Ma c'è un modo per accedere al driver javascript nativo di mongodb, che può essere utilizzato per questo

mongoose.connection.collections['collectionName'].drop( function(err) {
    console.log('collection dropped');
});

avvertimento

Fai un backup prima di provarlo nel caso qualcosa vada storto!

Mongoose creerà un database se non ne esiste già uno sulla connessione, quindi una volta stabilita la connessione, puoi semplicemente interrogarlo per vedere se c'è qualcosa al suo interno.

Puoi rilasciare qualsiasi database a cui sei connesso:

var mongoose = require('mongoose');
/* Connect to the DB */
mongoose.connect('mongodb://localhost/mydatabase',function(){
    /* Drop the DB */
    mongoose.connection.db.dropDatabase();
});

Se modifichi la soluzione di @ hellslam in questo modo, funzionerà

Uso questa tecnica per eliminare il database dopo i miei test di integrazione

//CoffeeScript
mongoose = require "mongoose"
conn = mongoose.connect("mongodb://localhost/mydb")

conn.connection.db.dropDatabase()

//JavaScript
var conn, mongoose;
mongoose = require("mongoose");
conn = mongoose.connect("mongodb://localhost/mydb");

conn.connection.db.dropDatabase();

HTH almeno ha fatto per me, quindi ho deciso di condividere =)

Ho provato le risposte di @ hellslam e @ silverfighter. Ho trovato una condizione di gara che ha frenato i miei test. Nel mio caso sto eseguendo test mocha e nella funzione before del test voglio cancellare l'intero DB. Ecco cosa funziona per me.

var con = mongoose.connect('mongodb://localhost/mydatabase');
mongoose.connection.on('open', function(){
    con.connection.db.dropDatabase(function(err, result){
        done();
    });
});

Puoi leggere di più https://github.com/Automattic/mongoose/issues/1469

Una risposta aggiornata, per 4.6.0+, se preferisci le promesse ( vedi documenti ):

mongoose.connect('mongodb://localhost/mydb', { useMongoClient: true })
.then((connection) => {
   connection.db.dropDatabase();
   // alternatively:
   // mongoose.connection.db.dropDatabase();
});

Ho testato questo codice nel mio codice, usando mongoose 4.13.6. Inoltre, nota l'uso useMongoClientdell'opzione ( vedi documenti ). I documenti indicano:

La logica di connessione predefinita di Mongoose è deprecata a partire dalla 4.11.0. Si prega di aderire alla nuova logica di connessione utilizzando l'opzione useMongoClient, ma assicurarsi di testare prima le connessioni se si aggiorna una base di codice esistente!

La difficoltà che ho avuto con le altre soluzioni è che si basano sul riavvio dell'applicazione se si desidera ripristinare il funzionamento degli indici.

Per le mie esigenze (ovvero poter eseguire uno unit test delle bombe su tutte le raccolte, quindi ricrearle insieme ai loro indici), ho finito per implementare questa soluzione:

Questo si basa sulle librerie underscore.js e async.js per assemblare gli indici in parallelo, potrebbe essere risolto se sei contrario a quella libreria, ma lo lascio come esercizio per lo sviluppatore.

mongoose.connection.db.executeDbCommand( {dropDatabase:1}, function(err, result) {
  var mongoPath = mongoose.connections[0].host + ':' + mongoose.connections[0].port + '/' + mongoose.connections[0].name
  //Kill the current connection, then re-establish it
  mongoose.connection.close()
  mongoose.connect('mongodb://' + mongoPath, function(err){
    var asyncFunctions = []

    //Loop through all the known schemas, and execute an ensureIndex to make sure we're clean
    _.each(mongoose.connections[0].base.modelSchemas, function(schema, key) {
      asyncFunctions.push(function(cb){
        mongoose.model(key, schema).ensureIndexes(function(){
          return cb()
        })
      })
    })

    async.parallel(asyncFunctions, function(err) {
      console.log('Done dumping all collections and recreating indexes')
    })
  })
})

Per svuotare una particolare raccolta in un database:

model.remove(function(err, p){
    if(err){ 
        throw err;
    } else{
        console.log('No Of Documents deleted:' + p);
    }
});

Nota:

1. Scegli un modello che fa riferimento a uno schema particolare (schema di raccolta che desideri eliminare).
2. Questa operazione non eliminerà il nome della raccolta dal database.
3. Questo elimina tutti i documenti in una raccolta.

Questo funziona per me a partire da Mongoose v4.7.0:

mongoose.connection.dropDatabase();

Il modo migliore per inserire il database in Mongoose dipende dalla versione di Mongoose che stai utilizzando. Se stai utilizzando una versione di Mongoose 4.6.4 o successiva, è probabile che questo metodo aggiunto in quella versione funzionerà bene per te:

mongoose.connection.dropDatabase();

Nelle versioni precedenti questo metodo non esisteva. Invece, dovevi usare una chiamata MongoDB diretta:

mongoose.connection.db.dropDatabase();

Tuttavia, se questo è stato eseguito subito dopo la creazione della connessione al database, potrebbe non riuscire silenziosamente. Ciò è correlato alla connessione effettivamente asincrona e non ancora configurata quando viene eseguito il comando. Questo normalmente non è un problema per altre chiamate Mongoose come.find() , che si accodano fino a quando la connessione non è aperta e quindi vengono eseguite.

Se guardi il codice sorgente di dropDatabase() collegamento che è stato aggiunto, puoi vedere che è stato progettato per risolvere esattamente questo problema. Verifica se la connessione è aperta e pronta. In tal caso, attiva immediatamente il comando. In caso contrario, registra il comando da eseguire quando la connessione al database è stata aperta.

Alcuni dei suggerimenti precedenti consigliano di inserire sempre il dropDatabasecomando nel opengestore. Ma ciò funziona solo nel caso in cui la connessione non sia ancora aperta.

Connection.prototype.dropDatabase = function(callback) {
  var Promise = PromiseProvider.get();
  var _this = this;
  var promise = new Promise.ES6(function(resolve, reject) {
    if (_this.readyState !== STATES.connected) {
      _this.on('open', function() {
        _this.db.dropDatabase(function(error) {
          if (error) {
            reject(error);
          } else {
            resolve();
          }
        });
      });
    } else {
      _this.db.dropDatabase(function(error) {
        if (error) {
          reject(error);
        } else {
          resolve();
        }
      });
    }
  });
  if (callback) {
    promise.then(function() { callback(); }, callback);
  }
  return promise;
};

Ecco una versione semplice della logica precedente che può essere utilizzata con le versioni precedenti di Mongoose:

// This shim is backported from Mongoose 4.6.4 to reliably drop a database
// http://stackoverflow.com/a/42860208/254318
// The first arg should be "mongoose.connection"
function dropDatabase (connection, callback) {
    // readyState 1 === 'connected'
    if (connection.readyState !== 1) {
      connection.on('open', function() {
        connection.db.dropDatabase(callback);
      });
    } else {
      connection.db.dropDatabase(callback);
    }
}  

Mangusta 4.6.0+:

mongoose.connect('mongodb://localhost/mydb')
mongoose.connection.once('connected', () => {
    mongoose.connection.db.dropDatabase();
});

Passare una richiamata per connettersi non funzionerà più:

TypeError: Impossibile leggere la proprietà "commandsTakeWriteConcern" di null

beforeEach((done) => {
      mongoose.connection.dropCollection('products',(error ,result) => {
      if (error) {
        console.log('Products Collection is not dropped')
      } else {
        console.log(result)
      }
    done()
    })
  })

Poiché il metodo remove è sconsigliato nella libreria mongoose, possiamo usare la funzione deleteMany senza che vengano passati parametri.

Model.deleteMany();

Questo cancellerà tutto il contenuto di questo particolare modello e la tua collezione sarà vuota.

Per rilasciare tutti i documenti in una raccolta:

await mongoose.connection.db.dropDatabase();

Questa risposta è basata sul file mongoose index.d.ts:

dropDatabase(): Promise<any>;

Per rilasciare tutti i documenti in una raccolta:

myMongooseModel.collection.drop();

come si è visto nei test