Sequelize .update() 总是返回 [0]

Question

编辑：请阅读底部的编辑。

我正在使用 sequelize，试图在 mySQL 数据库中查找或创建一行，然后立即对新创建的行进行更新。我的 .update 函数始终返回 [0]，即使将已知的现有值硬编码到查询中也是如此。

const importToSqlBI = async (metadataArray, filepath) => {
  metadataArray.shift(); // remove the header row
  let release;
  ReleaseBI.findOrCreate({
    where: {
      rel_num: metadataArray[0].release
    }
  }).then(([response, created]) => {
    release = JSON.parse(JSON.stringify(response));
    let numOnly = release.rel_num.substring(1, 3);
    release.rel_num_only = numOnly;

    if(created){
      updateRelease(release);
    }
    let z = mapArray(metadataArray, release);
  }).catch(err => {
    console.log("uploads.js:", 128, err);
  });
  return "finished";
};

const updateRelease = (release) => {
  let z = ReleaseBI.update({...release}, {
    where: {
      rel_id: release.rel_id
    }
  }).then((response) => {
    return response;
  }).catch(err => {
    console.log("uploads.js:", 149, err);
  });
  return z; // this always returns [0], meaning nothing was updated
};

这是续集在控制台中吐出的代码。请注意，查询中从来没有任何值，只有问号（我的对象包含所有正确的值，并且列名使用正确的数据类型拼写正确）。

Executing (default): UPDATE `releases` SET `rel_id`=?,`rel_num`=? WHERE `rel_id` = ?

看起来它甚至没有从传递给查询的对象中获取任何东西。

我做错了什么？

编辑：如果我更改我正在更新的列（从 rel_num_only 到 rel_num），则查询通过。两者都是 SQL 中的有效列，实际上，我使用 auto-sequelize 生成了模型。所以 sequelize 无法识别它自己制作的模型中的列...？

续集模型：

module.exports = function(sequelize, DataTypes) {
  return sequelize.define('releases', {
    rel_id: {
      type: DataTypes.INTEGER(11),
      allowNull: false,
      primaryKey: true,
      autoIncrement: true
    },
    rel_num: {
      type: DataTypes.STRING(50),
      allowNull: true
    },
    rel_num_only: {
      type: DataTypes.STRING(50),
      allowNull: true
    }
  }, {
    tableName: 'releases',
    underscored: true,
    timestamps: false
  });
};

Answer 1

我最终通过创建异步函数来解决这个问题。

const importToSqlBI = async (metadataArray, filepath) => {
  metadataArray.shift(); 
  ReleaseBI.findOrCreate({
    where: {
      rel_num: metadataArray[0].release
    }
  }).then(async ([response, created]) => {
    let release = await JSON.parse(JSON.stringify(response));

    let composersArray = await metadataArray.reduce((acc, curr) => {
      let composers = [];
      curr.composer_name.split("/").forEach((composer, i) => {
        composers.push({
          composer_name: composer.trim(),
          pro: curr.pro.includes("/") ? curr.pro.split("/")[i].trim() : curr.pro,
          publisher: curr.publisher.includes("/") ? curr.publisher.split("/")[i].trim() : curr.publisher,
          composer_split: curr.composer_split.includes("/") ? curr.composer_split.split("/")[i].trim() : curr.composer_split,
          publisher_split: curr.publisher_split.includes("/") ? curr.publisher_split.split("/")[i].trim() : curr.publisher_split,
          newUploadCount: metadataArray.filter(x => x.composer_name.includes(composer)).length
        });
      });
      let everyNewComposerInAccumulator = composers.every(x => acc.find(y => x.composer_name === y.composer_name));
      let newComposers = everyNewComposerInAccumulator ?
        [] :
        composers.filter(x => acc.every(y => y.composer_name !== x.composer_name));
      return [...acc, ...newComposers];
    }, []);

    let uniquePublishers = await composersArray.reduce((acc, curr) => {
      return !acc.some(composer => composer.publisher_name.includes(curr.publisher)) ?
        [...acc, { pro: /\((\S+)\)/.exec(curr.publisher)[1], publisher_name: curr.publisher }] :
        acc;
    }, []);

    uniquePublishers = await Promise.all(uniquePublishers.map(publisher =>
      findOrCreatePublisherBI(publisher)
    ));

    const foundComposers = await Promise.all(composersArray.map(composer =>
      findOrCreateComposerBI(composer, uniquePublishers.find(p => p.publisher_name === composer.publisher))
    ));

    let keywordsArray = await composersArray.map(x => ({
      composer_name: x.composer_name,
      newUploadCount: x.newUploadCount
    })).reduce((acc, curr) => {
      let composerSubwordsArray = curr.composer_name.includes(" ") ?
        curr.composer_name.split(" ").map(x => ({ keyword: x.toLowerCase(), newUploadCount: curr.newUploadCount})) :
        [{ keyword: curr.composer_name.toLowerCase(),
          newUploadCount: curr.newUploadCount
        }];

      return [...acc, ...composerSubwordsArray,
        { keyword: curr.composer_name.toLowerCase(), newUploadCount: curr.newUploadCount },
      ];
    }, []);

    // removes keywords less than 3 in length: irrelevant keywords
    keywordsArray = keywordsArray.filter(x => x.keyword.length >= 3);

    keywordsArray = await Promise.all(keywordsArray.map(keyword => {
      if(!forbiddenKeywords.includes(keyword.keyword)){
        return findOrCreateKeywordsBI(keyword);
      }
    }).filter(x => x !== undefined));

    let sqlData = await objArrayParseBI(metadataArray, release, foundComposers, keywordsArray);

    // and insert them into our SQL database
    createCues(sqlData, metadataArray, foundComposers, filepath);

  }).catch(err => {
    console.log("uploads.ctrl.js:", 87, err);
  });
};