Sequelize.js elimina la query?

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

Ad esempio, voglio fare qualcosa del genere (supponendo che MyModel sia un modello Sequelize ...):

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

Per chiunque utilizzi Sequelize versione 3 e successive, utilizzare:

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

Sequelize Documentation - Sequelize Tutorial

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 esiste un metodo deleteAll, esiste un metodo destroy () che puoi 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
    }
  })
})

Non so se la domanda è ancora pertinente, ma ho trovato quanto segue nella 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

Spero che sia d'aiuto!

Questo esempio mostra come promette invece di richiamare.

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); 
});

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

Nella nuova versione, puoi 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);
        });

Ecco un ES6 che utilizza l'esempio Await / Async:

    async deleteProduct(id) {

        if (!id) {
            return {msg: 'No Id specified..', payload: 1};
        }

        try {
            return !!await products.destroy({
                where: {
                    id: id
                }
            });
        } catch (e) {
            return false;
        }

    }

Si prega di notare che sto usando l' !!operatore Bang Bang sul risultato dell'attesa che cambierà il risultato in un booleano.

Qualche tempo fa ho scritto qualcosa del genere per Sails, nel caso ti facesse risparmiare un po 'di tempo:

Utilizzo di esempio:

// 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 aiuti!

1. il modo migliore per eliminare un record è trovarlo prima (se esiste nel database nello stesso momento in cui lo vuoi eliminare)
2. guarda questo codice

const StudentSequelize = require("../models/studientSequelize");
const StudentWork = StudentSequelize.Student;

const id = req.params.id;
    StudentWork.findByPk(id) // here i fetch result by ID sequelize V. 5
    .then( resultToDelete=>{
        resultToDelete.destroy(id); // when i find the result i deleted it by destroy function
    })
    .then( resultAfterDestroy=>{
        console.log("Deleted :",resultAfterDestroy);
    })
    .catch(err=> console.log(err));

Elimina tutto, nessuna condizione:

Model.destroy({
    truncate: true,
})