如何使用节点序列化更新记录？

我正在创建一个包含 NodeJS、 Express、 Express-resource 和 Sequelize 的 RESTful API，用于管理存储在 MySQL 数据库中的数据集。

我正在试图弄明白如何正确地使用 Sequelize 更新记录。

我创建了一个模型:

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

然后，在资源控制器中定义一个 update 操作。

在这里，我希望能够更新记录，其中的 id 匹配 req.params变量。

首先我建立一个模型，然后我使用 updateAttributes方法来更新记录。

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

现在，这实际上并不像我期望的那样产生一个更新查询。

相反，执行一个插入查询:

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

因此，我的问题是: 使用 SequelizeORM 更新记录的正确方法是什么？

438316 次浏览
小开
最佳答案

我没有使用过 结束，但是在阅读了它的文档之后，很明显您是 实例化一个新对象，这就是 Sequelize 向数据库中插入新记录的原因。

首先，你需要搜索那条记录，获取它，然后改变它的属性和 更新，例如:

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 () {})
}
})
小开

自从 Sequelize v1.7.0以来，您现在可以在模型上调用 update ()方法了

例如:

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


});
小开

从版本2.0.0开始，您需要将 哪里子句包装在 where属性中:

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

更新2016-03-09

最新版本实际上不再使用 success和 error，而是使用 then-able 承诺。

所以上面的代码看起来如下:

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

使用异步/等待

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

小开

我认为使用 UPDATE ... WHERE作为解释 给你和 给你是一种精益的方法

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)
})
小开

此解决方案不适用

失败 | 失败 | 错误()是不推荐的，将在2.1中删除，请 用承诺的方式代替。

所以你必须使用

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

你也可以使用 .complete()

问候

小开

Public static update (值: Object，选项: Object) : 保证

检查文件一次

  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]


})
小开

对于那些希望在2018年12月得到答案的人来说，这是使用承诺的正确语法:

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

使用异步并在现代的 javascript Es6中等待

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


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

你可以返回结果..。

小开

可以使用 Model.update ()方法。

异步/等待:

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

用. then () . 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
})
小开

嗨，更新记录很简单

  1. 通过 ID (或您想要的)查找记录
  2. 然后用 result.feild = updatedField传递 params
  3. 如果数据库序列中不存在该记录，则使用参数创建一个新记录
  4. 观察这个例子以获得更多的理解 代码 # 1测试该代码是否适用于 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)
});

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

2020年1月答案
需要理解的是，Model 有一个更新方法，Instance (记录)有一个单独的更新方法。Model.update()更新所有匹配记录并返回一个数组 请参阅 Sequelize 文档。Instance.update()更新记录并返回一个实例对象。

因此，要为每个问题更新一条记录，代码应该是这样的:

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: 'some@email.com',
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)
})

因此，使用 Model.findOne()或 Model.findByPkId()获得一个句柄一个实例(记录) ，然后使用 Instance.update()

小开

如果您在这里寻找一种方法来增加模型中的特定字段值..。

从 sequelize@5.21.3开始我就这么做了

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

参考资料: https://github.com/sequelize/sequelize/issues/7268

小开

有两种方法可以在序列化中更新记录。

首先，如果你有一个唯一标识符，那么你可以使用 where 子句或者如果你想用相同的标识符更新多个记录。

您可以创建要更新的整个对象，也可以创建特定的列

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


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

只更新特定列

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

其次，可以使用查找查询来查找它，并使用 set 和 save 函数来更新数据库。


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

在更新或创建新行时始终使用事务。这样，如果出现任何错误或者进行了多次更新，它就会回滚任何更新:


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

我已经在下面的代码中使用了 sequelize.js，node.js和 transaction，并且添加了适当的错误处理，如果它没有找到数据，它将抛出没有找到该 id 的数据的错误

editLocale: async (req, res) => {


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


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


let id = req.body.id;


let checkLocale= await sequelize.Locale.findOne({
where: {
id : req.body.id
}
});


checkLocale = checkLocale.get();
if (checkLocale ) {
let Locale= await sequelize.Locale.update(req.body, {
where: {
id: id
}
});


let result = error.OK;
result.data = Locale;


logger.info(result);
return res.status(200).send(result);
}
else {
logger.warn(error.DATA_NOT_FOUND);
return res.status(404).send(error.DATA_NOT_FOUND);
}
}).catch(function (err) {
logger.error(err);
return res.status(500).send(error.SERVER_ERROR);
});
},
小开

我是这样做的:

Model.findOne({
where: {
condtions
}
}).then( j => {
return j.update({
field you want to update
}).then( r => {
return res.status(200).json({msg: 'succesfully updated'});
}).catch(e => {
return res.status(400).json({msg: 'error ' +e});
})
}).catch( e => {
return res.status(400).json({msg: 'error ' +e});
});
小开

如果 Model.update语句对您不起作用，您可以这样尝试:

try{
await sequelize.query('update posts set param=:param where conditionparam=:conditionparam', {replacements: {param: 'parameter', conditionparam:'condition'}, type: QueryTypes.UPDATE})
}
catch(err){
console.log(err)
}
小开

我使用更新方法来更新我的记录。

  1. Model 是一个.js 文件，您的模型在其中放置
  2. Users 是型号名称
  3. 更新是建立在函数所提供的顺序。
  4. 我将名称和城市更新到用户表中，其中 id 等于1
models.users.update({req.body},
{where:{ id:1}}
)
小开 
var whereStatement = {};


whereStatement.id = req.userId;


if (whereStatement) {
User.findOne({
where: whereStatement
})
.then(user => {


if (user) {
          

var updateuserdetails = {
email: req.body.email,
mobile: req.body.mobile,
status: req.body.status,
user_type_id: req.body.user_type_id
};


user.update(
updateuserdetails
)
.then(function () {
res.status(200).send({ message: 'Success...' });
})
.catch(err => {
res.status(500).send({ message: err.message });
});
}


        

})
小开

查找和更新的序列化

使用 异步和 等待

const approveUser = asyncHandler(async (req, res) => {


var userID = parseInt(req.params.id);


const user = await User.findByPk(userID);


if (!user) throw new Error('No record found');


const result = await user.update({ isValid: !user.isValid });


if (result) {
res.status(201).json({
result,
});
} else {
res.status(400);
throw new Error('Invalid data');
}
});
小开

如果你已经定义了一个 UserModel，这样你就可以用户

let data = await UserModel.update(body, {
where: {
id:id,
},
individualHooks: true,
});

提交答案