Sequelize.js usunąć zapytanie?

Czy istnieje sposób na napisanie zapytania delete / deleteAll, takiego jak findAll?

Na przykład chcę zrobić coś takiego (zakładając, że MyModel jest modelem Sequelize ...):

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

Dla każdego, kto używa Sequelize w wersji 3 i nowszych, użyj:

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

Sequelize Documentation - Sequelize Tutorial

Szukałem głęboko w kodzie, krok po kroku do następujących plików:

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

Co znalazłem:

Nie ma metody deleteAll, istnieje metoda destru (), którą można wywołać w rekordzie, na przykład:

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

Nie wiem, czy pytanie jest nadal aktualne, ale w dokumentacji Sequelize znalazłem następujące informacje.

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

Mam nadzieję, że to pomoże!

Ten przykład pokazuje, jak obiecać zamiast oddzwonić.

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

Sprawdź ten link, aby uzyskać więcej informacji http://docs.sequelizejs.com/en/latest/api/model/#destroyoptions-promiseinteger

W nowej wersji możesz spróbować czegoś takiego

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

Oto przykład ES6 używający 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;
        }

    }

Zwróć uwagę, że używam !!operatora Bang Bang na wyniku oczekiwania, który zmieni wynik na wartość logiczną.

Jakiś czas temu napisałem coś takiego dla Sailsów, na wypadek gdyby to zaoszczędziło trochę czasu:

Przykładowe użycie:

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

Źródło:

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

od: orm.js .

Mam nadzieję, że to pomoże!

1. najlepszym sposobem na usunięcie rekordu jest znalezienie go w pierwszej kolejności (jeśli istnieje w bazie danych w tym samym czasie, gdy chcesz go usunąć)
2. obserwuj ten kod

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

Usuń wszystko, bez warunków:

Model.destroy({
    truncate: true,
})