Sequelize.js supprimer la requête?

Question

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

Answer 1

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

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

Documentation Sequelize - Tutoriel Sequelize

Answer 2

J'ai fouillé 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 / connecteurs / 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
    }
  })
})

Answer 3

Je ne sais pas si la question est toujours d'actualité mais j'ai trouvé ce qui suit dans 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 cela aide!

Answer 4

Cet exemple montre comment vous faire 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

Answer 5

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

Answer 6

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

< gagnantSource :

/**
 * 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 aide!

Answer 7

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 le !! Bang Bang Operator sur le résultat de l'attente qui changera le résultat en booléen.

Answer 8

1. la meilleure façon de supprimer un enregistrement est de le trouver d'abord (s'il existe dans la base de données au même moment où vous souhaitez le supprimer)
2. regardez 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));