Sequelize.js elimina la query?

Question

C'è un modo per scrivere una query delete/deleteAll come findAll?

Per esempio io voglio fare qualcosa di simile (assumendo MyModel è un modello Sequelize ...):

MyModel.deleteAll({ where: ['some_field != ?', something] }) 
    .on('success', function() { /* ... */ }); 

Answer 1

per chiunque utilizzi Sequelize versione 3 e successive, l'uso:

Model.destroy({ 
    where: { 
     // criteria 
    } 
}) 

Sequelize Documentation - Sequelize Tutorial

Answer 2

Ho cercato in profondità nel codice, passo dopo passo nei seguenti file:

https://github.com/sdepold/sequelize/blob/master/test/Model/destroy.js

https://github.com/sdepold/sequelize/blob/master/lib/model.js#L140

https://github.com/sdepold/sequelize/blob/master/lib/query-interface.js#L207-217

https://github.com/sdepold/sequelize/blob/master/lib/connectors/mysql/query-generator.js

Quello che ho trovato:

Non c'è un metodo CancTutti, c'è un metodo destroy() è possibile chiamare su un record, ad esempio:

Project.find(123).on('success', function(project) { 
    project.destroy().on('success', function(u) { 
    if (u && u.deletedAt) { 
     // successfully deleted the project 
    } 
    }) 
}) 

Answer 3

ho scritto qualcosa così per vele un po 'indietro, nel caso in cui esso consente di risparmiare un po' di tempo:

Esempio di utilizzo:

// Delete the user with id=4 
User.findAndDelete(4,function(error,result){ 
    // all done 
}); 

// Delete all users with type === 'suspended' 
User.findAndDelete({ 
    type: 'suspended' 
},function(error,result){ 
    // all done 
}); 

Fonte:

/** 
* Retrieve models which match `where`, then delete them 
*/ 
function findAndDelete (where,callback) { 

    // Handle *where* argument which is specified as an integer 
    if (_.isFinite(+where)) { 
     where = { 
      id: where 
     }; 
    } 

    Model.findAll({ 
     where:where 
    }).success(function(collection) { 
     if (collection) { 
      if (_.isArray(collection)) { 
       Model.deleteAll(collection, callback); 
      } 
      else { 
       collection.destroy(). 
       success(_.unprefix(callback)). 
       error(callback); 
      } 
     } 
     else { 
      callback(null,collection); 
     } 
    }).error(callback); 
} 

/** 
* Delete all `models` using the query chainer 
*/ 
deleteAll: function (models) { 
    var chainer = new Sequelize.Utils.QueryChainer(); 
    _.each(models,function(m,index) { 
     chainer.add(m.destroy()); 
    }); 
    return chainer.run(); 
} 

da: orm.js.

Spero che questo aiuti!

Answer 4

Non so se la domanda è ancora pertinente, ma ho trovato quanto segue sulla documentazione di Sequelize.

User.destroy('`name` LIKE "J%"').success(function() { 
    // We just deleted all rows that have a name starting with "J" 
}) 

http://sequelizejs.com/blog/state-of-v1-7-0

Speranza che aiuta!

Answer 5

Questo esempio mostra come vi promette invece di callback.

Model.destroy({ 
    where: { 
     id: 123 //this will be your id that you want to delete 
    } 
}).then(function(rowDeleted){ // rowDeleted will return number of rows deleted 
    if(rowDeleted === 1){ 
    console.log('Deleted successfully'); 
    } 
}, function(err){ 
    console.log(err); 
}); 

controllare questo link per maggiori informazioni http://docs.sequelizejs.com/en/latest/api/model/#destroyoptions-promiseinteger

Answer 6

Nella nuova versione, è possibile provare qualcosa di simile

function (req,res) {  
     model.destroy({ 
      where: { 
       id: req.params.id 
      } 
     }) 
     .then(function (deletedRecord) { 
      if(deletedRecord === 1){ 
       res.status(200).json({message:"Deleted successfully"});   
      } 
      else 
      { 
       res.status(404).json({message:"record not found"}) 
      } 
     }) 
     .catch(function (error){ 
      res.status(500).json(error); 
     });