Sequelize.js delete query?

Question

Is there a way to write a delete/deleteAll query like findAll?

For example I want to do something like this (assuming MyModel is a Sequelize model...):

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

score 334 · Accepted Answer · edited Jan 24 '23 at 02:21

334

For anyone using Sequelize version 3 and above, use:

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

Sequelize Documentation - Sequelize Tutorial

edited Jan 24 '23 at 02:21

Alvin

920
3
9

answered Nov 11 '15 at 21:52

ncksllvn

5,699
2
21
28

It's a pretty old question so at the time I guess Sequelize didn't have a destroy method surprisingly – ncksllvn Jun 16 '16 at 18:39
3

Fair enough; though because this is the first search result on Google, and people are also discouraged from asking questions that have already been asked it seems like the accepted answer should get updated... but that's probably more of a site wide issue. – Rojuinex Jun 19 '16 at 20:14
1

I'm wondering sequelize documentation doesn't give, this much pretty easy coding sample... Any one can understand this. Thank you ncksllvn. You save my time... – weeraa Mar 05 '18 at 17:29
How do you handle if the id is an invalid id? – Rod Aug 25 '18 at 18:24

score 24 · Answer 2 · answered Dec 06 '11 at 16:17

24

I've searched deep into the code, step by step into the following files:

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

What I found:

There isn't a deleteAll method, there's a destroy() method you can call on a record, for example:

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

answered Dec 06 '11 at 16:17

alessioalex

62,577
16
155
122

Yeah, I knew about the destroy method, but unfortunately it's only for one record. I guess I'll have to write my own deleteAll method. Thanks! – lakenen Dec 06 '11 at 16:32
Really weird that this doesn't exist. Maybe you can write it yourself and submit a pull request to sequelize. I'm sure other people could really use it. – alessioalex Dec 06 '11 at 16:35
1

Feel free to submit a pull request or to open an issue in the github repository :) – sdepold Dec 07 '11 at 06:10
4

destroy() isn't in the documentation on sequelizejs.com, in case anyone else was here looking for that like I was – mikermcneil Feb 26 '12 at 05:59
I've got an "TypeError: Cannot call method 'hasOwnProperty' of null " error when trying to delete using the destroy() method. Does anyone know what could it be? – Thiago Miranda de Oliveira Mar 15 '12 at 14:31
2

Your links are all returning 404s for me. Am I the only one? – OrwellHindenberg Jun 23 '16 at 18:44
@OrwellHindenberg No it's happening to me too. – Antonio Pavicevac-Ortiz Dec 07 '17 at 13:44
Those links referred to an old version of Sequelize, they are probably of no use if you're using a current version – golimar Sep 11 '20 at 15:20

Hisham Haniffa · Answer 3 · 2016-05-14T03:53:34.403

20

This example shows how to you promises instead of callback.

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

Check this link out for more info http://docs.sequelizejs.com/en/latest/api/model/#destroyoptions-promiseinteger

edited May 14 '16 at 03:53

answered Dec 31 '15 at 14:20

Hisham Haniffa

449
5
7

1

shouldn't rowDeleted be 1 when checking for successful deletion of one row? – saraf May 10 '16 at 11:17
2

This no longer works like that. Return is the row ID affected / not the count of rows affected. – Tony Butler Apr 11 '18 at 21:35
Shouldn't you use catch to catch the error instead of callback? – AG_HIHI Feb 05 '20 at 14:16

score 18 · Answer 4 · answered Jan 30 '14 at 09:29

18

Don't know if the question is still relevant but I have found the following on Sequelize's documentation.

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

Hope it helps!

answered Jan 30 '14 at 09:29

cgiacomi

4,629
6
27
33

2

For reference, this is defined in [lib/model.js](https://github.com/sequelize/sequelize/blob/51ce2fb7f60359fc04814afe6779bb0ada41b18d/lib/model.js#L1272), and you don't have to use a string. You can use any sort of `where` object (e.g. `{someId: 123}`). – Domi Jun 16 '14 at 12:55

score 13 · Answer 5 · edited Jan 09 '18 at 22:56

In new version, you can try something like this

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

score 7 · Answer 6 · answered Apr 01 '18 at 11:23

Here's a ES6 using Await / Async example:

    async deleteProduct(id) {

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

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

    }

Please note that I'm using the !! Bang Bang Operator on the result of the await which will change the result into a Boolean.

score 2 · Answer 7 · answered Oct 12 '12 at 06:30

I wrote something like this for Sails a while back, in case it saves you some time:

Example usage:

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

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

from: orm.js.

Hope that helps!

score 2 · Answer 8 · answered Oct 16 '20 at 13:01

I have used sequelize.js, node.js and transaction in belowcode and added proper error handling if it doesn't find data it will throw error that no data found with that id

deleteMyModel: async (req, res) => {

    sequelize.sequelize.transaction(async (t1) => {

        if (!req.body.id) {
            return res.status(500).send(error.MANDATORY_FIELDS);
        }

        let feature = await sequelize.MyModel.findOne({
            where: {
                id: req.body.id
            }
        })

        if (feature) {
            let feature = await sequelize.MyModel.destroy({
                where: {
                    id: req.body.id
                }
            });

            let result = error.OK;
            result.data = MyModel;
            return res.status(200).send(result);

        } else {
            return res.status(404).send(error.DATA_NOT_FOUND);
        }
    }).catch(function (err) {
        return res.status(500).send(error.SERVER_ERROR);
    });
}

Shouldn't you add `transaction: t1` into the options of `findOne`, and `destroy` functions? — Farzan, Jun 05 '22 at 17:52

score 2 · Answer 9 · edited Nov 21 '20 at 04:42

Sequelize methods return promises, and there is no delete() method. Sequelize uses destroy() instead.

Example

Model.destroy({
  where: {
    some_field: {
      //any selection operation
      // for example [Op.lte]:new Date()
    }
  }
}).then(result => {
  //some operation
}).catch(error => {
  console.log(error)
})

Documentation for more details: https://www.codota.com/code/javascript/functions/sequelize/Model/destroy

score 1 · Answer 10 · answered Feb 05 '22 at 12:45

Simple DELETE queries Delete queries also accept the where option, just like the read queries shown above.

// Delete everyone named "Jane"
await User.destroy({
  where: {
    firstName: "Jane"
  }
});

To destroy everything the TRUNCATE SQL can be used:

// Truncate the table
await User.destroy({
  truncate: true
});

score 0 · Answer 11 · answered Aug 01 '19 at 21:16

the best way to delete a record is to find it firstly (if exist in data base in the same time you want to delete it)
watch this 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));

score 0 · Answer 12 · answered Jun 22 '20 at 12:05

0

Delete all, no conditions:

Model.destroy({
    truncate: true,
})

answered Jun 22 '20 at 12:05

S..

5,511
2
36
43

score 0 · Answer 13 · answered Apr 11 '21 at 20:29

Example Using an API method

exports.deleteSponsor = async (req, res) => {
  try {

using conditions like userid,eventid and sponsorid

    const { userId } = req.body;
    const { eventId } = req.body;
    const { sponsorId } = req.body;

checking exist or not

    if (!sponsorId)
      return res
        .status(422)
        .send({ message: "Missing Sponsor id in parameters" });
`checking in db too`

    const sponsorDetails = await Sponsor.findAll({
      where: { [Op.or]: [{ id: sponsorId }] },
    });

    if (sponsorDetails.length === 0) {
      return res.status(422).send({ message: "Sponsor id not exist" });
    } else {
      await Sponsor.destroy({

where clause as per your requirements you can change

        where: {
          id: sponsorId,
          userId: userId,
          eventId: eventId,
        }
      });
      return res
        .status(201)
        .send({ message: "Sponsor deleted successfully" });
    }
  } catch (err) {
    console.log(err);
    customGenericException(err, res);
  }
};

score 0 · Answer 14 · answered Jun 03 '21 at 04:41

0

You can use like below to delete All rows.

general_category.destroy({ truncate: true, where: {} })

answered Jun 03 '21 at 04:41

Ninja Master

126
3

Sequelize.js delete query?

14 Answers14

Example

Linked