web-dev-qa-db-de.com

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 machen (vorausgesetzt, MyModel ist ein Sequelize-Modell ...):

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

Verwenden Sie für alle, die Sequelize Version 3 oder höher verwenden:

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

Sequelize Documentation - Sequelize Tutorial

180
ncksllvn

Ich habe tief in den 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#L14

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. Beispiel:

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

Ich weiß nicht, ob die Frage immer 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-

Ich hoffe es hilft!

15
cgiacomi

Dieses Beispiel zeigt, wie Sie Versprechungen anstelle eines Rückrufs machen.

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

Überprüfen Sie diesen Link für weitere Informationen http://docs.sequelizejs.com/en/latest/api/model/#destroyoptions-promiseinteger

8
Hisham Haniffa

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

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 von await verwende, wodurch das Ergebnis in einen Booleschen Wert umgewandelt wird.

2
li x

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

Verwendungsbeispiel:

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

2
mikermcneil

spätestens @ 2019 asynchron und warten

const id = 12;

const result = await User.destroy({ where: { id });

use result 
0
Frank HN
  1. der beste Weg, einen Datensatz zu löschen, besteht darin, ihn zuerst zu finden (falls er in der Datenbank zum gleichen Zeitpunkt vorhanden ist, zu dem Sie ihn löschen möchten).
  2. schau dir diesen Code an
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));
0
bahri noredine