Sequelize.js delete query?

99

Existe uma maneira de escrever uma consulta delete / deleteAll como findAll?

Por exemplo, eu quero fazer algo assim (assumindo que MyModel é um modelo Sequelize ...):

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

Respostas:

236

Para qualquer pessoa que use o Sequelize versão 3 e superior, use:

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

Sequelize Documentation - Sequelize Tutorial

ncksllvn
fonte
É uma pergunta muito antiga, então na época eu acho que o Sequelize não tinha um método de destruição surpreendentemente
ncksllvn
3
Justo; Porém, como este é o primeiro resultado de pesquisa no Google e as pessoas também são desencorajadas a fazer perguntas que já foram feitas, parece que a resposta aceita deve ser atualizada ... mas isso provavelmente é mais um problema de todo o site.
Rojuinex
1
Estou me perguntando se a documentação do sequelize não dá, esse exemplo de codificação muito fácil ... Qualquer um pode entender isso. Obrigado ncksllvn. Você economiza meu tempo ...
weeraa
Como você lida se o id é um id inválido?
Rod
21

Pesquisei profundamente no código, passo a passo, nos seguintes arquivos:

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

O que eu encontrei:

Não há um método deleteAll, há um método destroy () que você pode chamar em um registro, por exemplo:

Project.find(123).on('success', function(project) {
  project.destroy().on('success', function(u) {
    if (u && u.deletedAt) {
      // successfully deleted the project
    }
  })
})
alessioalex
fonte
Sim, eu sabia sobre o método de destruição, mas infelizmente é apenas para um registro. Acho que terei que escrever meu próprio método deleteAll. Obrigado!
Lakenen
Muito estranho que isso não exista. Talvez você possa escrevê-lo sozinho e enviar uma solicitação de pull para sequenciar. Tenho certeza que outras pessoas realmente poderiam usá-lo.
alessioalex
1
Sinta-se à vontade para enviar uma solicitação pull ou abrir um problema no repositório github :)
sdepold
3
destroy () não está na documentação do sequelizejs.com, no caso de alguém mais estar aqui procurando por isso como eu
mikermcneil
2
Todos os seus links estão retornando 404s para mim. Eu sou o único?
OrwellHindenberg
16

Não sei se a questão ainda é relevante, mas eu encontrei o seguinte na documentação do 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

Espero que ajude!

Cgiacomi
fonte
2
Para referência, isso é definido em lib / model.js , e você não precisa usar uma string. Você pode usar qualquer tipo de whereobjeto (por exemplo {someId: 123}).
Domi de
10

Este exemplo mostra como fazer promessas em vez de 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); 
});

Verifique este link para obter mais informações http://docs.sequelizejs.com/en/latest/api/model/#destroyoptions-promiseinteger

Hisham Haniffa
fonte
1
não deve rowDeleted ser 1 ao verificar a exclusão bem-sucedida de uma linha?
saraf
1
Isso não funciona mais assim. Return é o ID da linha afetado / não a contagem de linhas afetadas.
Tony Butler,
Você não deveria usar catch para detectar o erro em vez de callback?
Ahmed Ghrib
7

Na nova versão, você pode tentar algo assim

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

Aqui está um ES6 usando um exemplo 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;
        }

    }

Observe que estou usando o !!Bang Bang Operator no resultado do await, que mudará o resultado para um booleano.

li x
fonte
2

Escrevi algo assim para o Sails há algum tempo, caso você economize algum tempo:

Exemplo de uso:

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

Fonte:

/**
 * 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 .

Espero que ajude!

mikermcneil
fonte
0
  1. a melhor maneira de deletar um registro é encontrá-lo primeiro (se existir no banco de dados ao mesmo tempo que você deseja deletar)
  2. observe este código
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));
bahri noredine
fonte
0

Excluir tudo, sem condições:

Model.destroy({
    truncate: true,
})
S ..
fonte