Como atualizar um registro usando sequelize for node?

Estou criando uma API RESTful com NodeJS, express, express-resource e Sequelize que é usada para gerenciar conjuntos de dados armazenados em um banco de dados MySQL.

Estou tentando descobrir como atualizar corretamente um registro usando Sequelize.

Eu crio um modelo:

module.exports = function (sequelize, DataTypes) {
  return sequelize.define('Locale', {
    id: {
      type: DataTypes.INTEGER,
      autoIncrement: true,
      primaryKey: true
    },
    locale: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true,
      validate: {
        len: 2
      }
    },
    visible: {
      type: DataTypes.BOOLEAN,
      defaultValue: 1
    }
  })
}

Então, em meu controlador de recursos, defino uma ação de atualização.

Aqui eu quero ser capaz de atualizar o registro onde o id corresponde a uma req.paramsvariável.

Primeiro eu construo um modelo e depois uso o updateAttributesmétodo para atualizar o registro.

const Sequelize = require('sequelize')
const { dbconfig } = require('../config.js')

// Initialize database connection
const sequelize = new Sequelize(dbconfig.database, dbconfig.username, dbconfig.password)

// Locale model
const Locales = sequelize.import(__dirname + './models/Locale')

// Create schema if necessary
Locales.sync()


/**
 * PUT /locale/:id
 */

exports.update = function (req, res) {
  if (req.body.name) {
    const loc = Locales.build()

    loc.updateAttributes({
      locale: req.body.name
    })
      .on('success', id => {
        res.json({
          success: true
        }, 200)
      })
      .on('failure', error => {
        throw new Error(error)
      })
  }
  else
    throw new Error('Data not provided')
}

Agora, isso não produz realmente uma consulta de atualização como eu esperava.

Em vez disso, uma consulta de inserção é executada:

INSERT INTO `Locales`(`id`, `locale`, `createdAt`, `updatedAt`, `visible`)
VALUES ('1', 'us', '2011-11-16 05:26:09', '2011-11-16 05:26:15', 1)

Portanto, minha pergunta é: Qual é a maneira adequada de atualizar um registro usando Sequelize ORM?

Não usei o Sequelize , mas depois de ler sua documentação, é óbvio que você está instanciando um novo objeto , é por isso que o Sequelize insere um novo registro no banco de dados.

Primeiro você precisa pesquisar esse registro, buscá-lo e só depois alterar suas propriedades e atualizá- lo, por exemplo:

Project.find({ where: { title: 'aProject' } })
  .on('success', function (project) {
    // Check if record exists in db
    if (project) {
      project.update({
        title: 'a very different title now'
      })
      .success(function () {})
    }
  })

Desde a versão 2.0.0, você precisa envolver sua cláusula where em uma wherepropriedade:

Project.update(
  { title: 'a very different title now' },
  { where: { _id: 1 } }
)
  .success(result =>
    handleResult(result)
  )
  .error(err =>
    handleError(err)
  )

Atualização 09/03/2016

A última versão, na verdade, não usar successe errormais, mas em vez disso usa thenpromessas -Capaz.

Portanto, o código superior terá a seguinte aparência:

Project.update(
  { title: 'a very different title now' },
  { where: { _id: 1 } }
)
  .then(result =>
    handleResult(result)
  )
  .catch(err =>
    handleError(err)
  )

Usando async / await

try {
  const result = await Project.update(
    { title: 'a very different title now' },
    { where: { _id: 1 } }
  )
  handleResult(result)
} catch (err) {
  handleError(err)
}

http://docs.sequelizejs.com/en/latest/api/model/#updatevalues-options-promisearrayaffectedcount-affectedrows

Desde sequelize v1.7.0 agora você pode chamar um método update () no modelo. Muito mais limpo

Por exemplo:

Project.update(

  // Set Attribute values 
        { title:'a very different title now' },

  // Where clause / criteria 
         { _id : 1 }     

 ).success(function() { 

     console.log("Project with id =1 updated successfully!");

 }).error(function(err) { 

     console.log("Project update failed !");
     //handle error here

 });

E para quem procura uma resposta em dezembro de 2018, esta é a sintaxe correta usando promessas:

Project.update(
    // Values to update
    {
        title:  'a very different title now'
    },
    { // Clause
        where: 
        {
            id: 1
        }
    }
).then(count => {
    console.log('Rows updated ' + count);
});

Resposta de janeiro de 2020
A coisa a entender é que há um método de atualização para o Modelo e um método de atualização separado para uma Instância (registro). Model.update()atualiza TODOS os registros correspondentes e retorna uma matriz, consulte a documentação do Sequelize . Instance.update()atualiza o registro e retorna um objeto de instância.

Portanto, para atualizar um único registro por pergunta, o código seria mais ou menos assim:

SequlizeModel.findOne({where: {id: 'some-id'}})
.then(record => {
  
  if (!record) {
    throw new Error('No record found')
  }

  console.log(`retrieved record ${JSON.stringify(record,null,2)}`) 

  let values = {
    registered : true,
    email: '[email protected]',
    name: 'Joe Blogs'
  }
  
  record.update(values).then( updatedRecord => {
    console.log(`updated record ${JSON.stringify(updatedRecord,null,2)}`)
    // login into your DB and confirm update
  })

})
.catch((error) => {
  // do seomthing with the error
  throw new Error(error)
})

Portanto, use Model.findOne()ou Model.findByPkId()para obter um identificador de uma única instância (registro) e, em seguida, use oInstance.update()

Acho que usar UPDATE ... WHEREcomo explicado aqui e aqui está uma abordagem enxuta

Project.update(
      { title: 'a very different title no' } /* set attributes' value */, 
      { where: { _id : 1 }} /* where criteria */
).then(function(affectedRows) {
Project.findAll().then(function(Projects) {
     console.log(Projects) 
})

Esta solução está obsoleta

fail | fail | error () está obsoleto e será removido na versão 2.1, use o estilo promessa em vez disso.

então você tem que usar

Project.update(

    // Set Attribute values 
    {
        title: 'a very different title now'
    },

    // Where clause / criteria 
    {
        _id: 1
    }

).then(function() {

    console.log("Project with id =1 updated successfully!");

}).catch(function(e) {
    console.log("Project update failed !");
})

E você pode usar .complete()bem

Saudações

Usando async e await em um javascript Es6 moderno

const title = "title goes here";
const id = 1;

    try{
    const result = await Project.update(
          { title },
          { where: { id } }
        )
    }.catch(err => console.log(err));

você pode retornar o resultado ...

atualização estática pública (valores: Objeto, opções: Objeto): Promessa>

verifique a documentação uma vez http://docs.sequelizejs.com/class/lib/model.js~Model.html#static-method-update

  Project.update(
    // Set Attribute values 
    { title:'a very different title now' },
  // Where clause / criteria 
     { _id : 1 }     
  ).then(function(result) { 

 //it returns an array as [affectedCount, affectedRows]

  })

Você pode usar o método Model.update ().

Com async / await:

try{
  const result = await Project.update(
    { title: "Updated Title" }, //what going to be updated
    { where: { id: 1 }} // where clause
  )  
} catch (error) {
  // error handling
}

Com .então (). Catch ():

Project.update(
    { title: "Updated Title" }, //what going to be updated
    { where: { id: 1 }} // where clause
)
.then(result => {
  // code with result
})
.catch(error => {
  // error handling
})

oi para atualizar o registro é muito simples

1. sequelize encontre o registro por ID (ou pelo que você quiser)
2. então você passa os parâmetros com result.feild = updatedField
3. se o registro não existir na sequência do banco de dados crie um novo registro com os parâmetros
4. veja o exemplo para entender melhor o código 1, testar esse código para todas as versões sob V4

const sequelizeModel = require("../models/sequelizeModel");
    const id = req.params.id;
            sequelizeModel.findAll(id)
            .then((result)=>{
                result.name = updatedName;
                result.lastname = updatedLastname;
                result.price = updatedPrice;
                result.tele = updatedTele;
                return result.save()
            })
            .then((result)=>{
                    console.log("the data was Updated");
                })
            .catch((err)=>{
                console.log("Error : ",err)
            });

Código para V5

const id = req.params.id;
            const name = req.body.name;
            const lastname = req.body.lastname;
            const tele = req.body.tele;
            const price = req.body.price;
    StudentWork.update(
        {
            name        : name,
            lastname    : lastname,
            tele        : tele,
            price       : price
        },
        {returning: true, where: {id: id} }
      )
            .then((result)=>{
                console.log("data was Updated");
                res.redirect('/');
            })
    .catch((err)=>{
        console.log("Error : ",err)
    });

Se você está procurando uma maneira de incrementar um valor de campo específico em um modelo ...

Isso funcionou para mim a partir de [email protected]

User.increment("field", {by: 1, where: {id: 1});

REF: https://github.com/sequelize/sequelize/issues/7268

Existem duas maneiras de atualizar o registro em sequência.

Em primeiro lugar, se você tiver um identificador exclusivo, poderá usar a cláusula where ou, se desejar, atualizar vários registros com o mesmo identificador.

Você pode criar o objeto inteiro para atualizar ou uma coluna específica

const objectToUpdate = {
title: 'Hello World',
description: 'Hello World'
}

models.Locale.update(objectToUpdate, { where: { id: 2}})

Atualize apenas uma coluna específica

models.Locale.update({ title: 'Hello World'}, { where: { id: 2}})

Em segundo lugar, você pode usar localizar uma consulta para localizá-la e usar a função definir e salvar para atualizar o banco de dados.

const objectToUpdate = {
title: 'Hello World',
description: 'Hello World'
}

models.Locale.findAll({ where: { title: 'Hello World'}}).then((result) => {
   if(result){
   // Result is array because we have used findAll. We can use findOne as well if you want one row and update that.
        result[0].set(objectToUpdate);
        result[0].save(); // This is a promise
}
})

Sempre use a transação ao atualizar ou criar uma nova linha. dessa forma, ele reverterá todas as atualizações se houver algum erro ou se você fizer várias atualizações:

models.sequelize.transaction((tx) => {
    models.Locale.update(objectToUpdate, { transaction: t, where: {id: 2}});
})