Sequelize.js Abfrage löschen?

Gibt es eine Möglichkeit, eine delete / deleteAll-Abfrage wie findAll zu schreiben?

Zum Beispiel möchte ich so etwas tun (vorausgesetzt, MyModel ist ein Sequelize-Modell ...):

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

Verwenden Sie für alle Benutzer von Sequelize Version 3 und höher:

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

Sequelize Documentation - Sequelize Tutorial

Ich habe tief im Code gesucht, Schritt für Schritt in die folgenden Dateien:

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

Was ich fand:

Es gibt keine deleteAll-Methode, sondern eine destroy () -Methode, die Sie für einen Datensatz aufrufen können, zum Beispiel:

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

Ich weiß nicht, ob die Frage noch relevant ist, aber ich habe Folgendes in der Dokumentation von Sequelize gefunden.

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

Ich hoffe es hilft!

Dieses Beispiel zeigt, wie Sie Versprechen statt Rückruf versprechen.

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

Weitere Informationen finden Sie unter diesem Link unter http://docs.sequelizejs.com/en/latest/api/model/#destroyoptions-promiseinteger

In der neuen Version können Sie so etwas ausprobieren

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

Hier ist ein ES6 mit Await / Async-Beispiel:

    async deleteProduct(id) {

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

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

    }

Bitte beachten Sie, dass ich den !!Bang Bang Operator für das Ergebnis des Wartens verwende, wodurch das Ergebnis in einen Booleschen Wert geändert wird.

Ich habe vor einiger Zeit so etwas für Sails geschrieben, falls es Ihnen Zeit spart:

Anwendungsbeispiel:

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

Quelle:

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

von: orm.js .

Hoffentlich hilft das!

1. Der beste Weg, einen Datensatz zu löschen, besteht darin, ihn zuerst zu finden (falls er in der Datenbank vorhanden ist, während Sie ihn löschen möchten).
2. Beobachten Sie diesen 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));

Alle löschen, keine Bedingungen:

Model.destroy({
    truncate: true,
})