Question

我正在使用MySQL的sequelize。例如，如果我这样做：

models.People.update({OwnerId: peopleInfo.newuser},
        {where: {id: peopleInfo.scenario.id}})
        .then(function (result) {
            response(result).code(200);

        }).catch(function (err) {
        request.server.log(['error'], err.stack);
       ).code(200);
    });

如果人员模型已成功更新，我无法获取信息。变量结果只是一个包含一个元素的数组，0 = 1

我如何确定记录是否已更新。

Answer 1

以下是我认为您正在寻找的内容。

db.connections.update({
  user: data.username,
  chatroomID: data.chatroomID
}, {
  where: { socketID: socket.id },
  returning: true,
  plain: true
})
.then(function (result) {
  console.log(result);   
  // result = [x] or [x, y]
  // [x] if you're not using Postgres
  // [x, y] if you are using Postgres
});

来自Sequelize docs： promise返回一个包含一个或两个元素的数组。第一个元素x始终是受影响的行数，而第二个元素y是实际受影响的行（仅在options.returning设置为true的postgres中受支持。）

假设您使用的是Postgres，则可以使用result[1].dataValues访问更新的对象。

您必须设置returning: true选项以告知Sequelize返回对象。而plain: true只是返回对象本身，而不是其他可能没用的混乱元数据。

Answer 2

sequelize的更新功能返回一些受影响的行（结果数组的第一个参数）。

您应该调用find来获取更新的行

sort +uniq(@x)

Answer 3

最后我明白了。返回true不会在mysql中工作，我们必须使用findByPk，以希望此代码有所帮助。

       return new Promise(function(resolve, reject) {
User.update({
        subject: params.firstName, body: params.lastName, status: params.status
    },{
        returning:true,
        where: {id:id }                             
    }).then(function(){
        let response = User.findById(params.userId);                      
        resolve(response);
    });

}）;

Answer 4

您可以使用async-await做同样的事情，特别是避免嵌套的Promises 您只需要创建一个异步函数：）

const asyncFunction = async function(req, res) {
    try {
        //update 
        const updatePeople = await models.People.update({OwnerId: peopleInfo.newuser},
                                    {where: {id: peopleInfo.scenario.id}})
        if (!updatePeople) throw ('Error while Updating');
        // fetch updated data
        const returnUpdatedPerson =  await models.People.findById(peopleInfo.scenario.id)
        if(!returnUpdatedPerson) throw ('Error while Fetching Data');
        res(user).code(200);
    } catch (error) {
        res.send(error)
    }
}

Answer 5

您可以找到该项目并更新其属性，然后保存。 save（）导致对数据库的UPDATE查询

        const job = await Job.findOne({where: {id, ownerId: req.user.id}});
        if (!job) {
            throw Error(`Job not updated. id: ${id}`);
        }

        job.name = input.name;
        job.payload = input.payload;
        await job.save();

在Postgres上：

Executing (default): UPDATE "jobs" SET "payload"=$1,"updatedAt"=$2 WHERE "id" = $3

Answer 6

还有另一种方法-使用findByPk静态方法和一起更新非静态方法。例如：

let person = await models.People.findByPk(peopleInfo.scenario.id);
if (!person) {
  // Here you can handle the case when a person is not found
  // For example, I return a "Not Found" message and a 404 status code
}
person = await person.update({ OwnerId: peopleInfo.newuser });
response(person).code(200);

请注意，此代码必须在异步函数中。

Answer 7

您可以先获取要更新的模型，然后在其上调用 set() 和 save()。返回此对象将为您提供更新的模型。

虽然这可能不是最短的方法，但我更喜欢它，因为您可以单独处理未找到和更新错误。

const instance = await Model.findOne({
  where: {
    'id': objectId
  }
});

if (instance && instance.dataValues) {
  instance.set('name', objectName);
  return await instance.save(); // promise rejection (primary key violation…) might be thrown here
} else {
  throw new Error(`No Model was found for the id ${objectId}`);
}

Answer 8

简单的片段即可更新并获取更新的结果

models.People.findOne({
    where: {id: peopleInfo.scenario.id}
})
.then((people) => {
    if(people == null) console.log("invalid people");
    people.fieldOne = currentValue;
    people.fieldtwo = currentValue;
    return people.save()
})

Answer 9

如果您使用的是postgres并更新一行。

  try {
    const result = await MODELNAME.update(req.body, {
      where: { id: req.params.id },
      returning: true
    });
    if (!result) HANDLEERROR()
    const data = result[1][0].get();

    res.status(200).json({ success: true, data });
  } catch (error) {
    HANDLEERROR()
  }

Sequelize - 更新记录，并返回结果

9 个答案: