Sequelize.js supprimer la requête?

Existe-t-il un moyen d'écrire une requête delete / deleteAll comme findAll?

Par exemple, je veux faire quelque chose comme ça (en supposant que MyModel est un modèle Sequelize ...):

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

Pour toute personne utilisant Sequelize version 3 et supérieure, utilisez:

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

Documentation Sequelize - Tutoriel Sequelize

J'ai cherché profondément dans le code, étape par étape dans les fichiers suivants:

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

Ce que j'ai trouvé:

Il n'y a pas de méthode deleteAll, il y a une méthode destroy () que vous pouvez appeler sur un enregistrement, par exemple:

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

Je ne sais pas si la question est toujours pertinente mais j'ai trouvé ce qui suit sur la documentation de 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

J'espère que ça aide!

Cet exemple montre comment vous des promesses au lieu d'un rappel.

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

Consultez ce lien pour plus d'informations http://docs.sequelizejs.com/en/latest/api/model/#destroyoptions-promiseinteger

Dans la nouvelle version, vous pouvez essayer quelque chose comme ça

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

Voici un exemple ES6 utilisant 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;
        }

    }

Veuillez noter que j'utilise l' !!opérateur Bang Bang sur le résultat de l'attente qui changera le résultat en booléen.

J'ai écrit quelque chose comme ça pour Sails il y a quelque temps, au cas où cela vous ferait gagner du temps:

Exemple d'utilisation:

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

La source:

/**
 * 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();
}

de: orm.js .

J'espère que cela pourra aider!

1. la meilleure façon de supprimer un enregistrement est de le trouver en premier (s'il existe dans la base de données au même moment où vous souhaitez le supprimer)
2. regarde ce code

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

Supprimer tout, pas de conditions:

Model.destroy({
    truncate: true,
})