Sequelize能否将多个查询合并为单次数据库请求？

首先明确：Sequelize 默认不会自动将多个查询合并为单次数据库请求，你代码中的每一次 bulkCreate 调用都会发起独立的数据库请求——即便在事务中，事务仅保证操作的原子性（要么全成功要么全失败），但不会合并请求。

如果你想实现类似拼接 SQL 字符串的效果，将多个操作合并为单次请求，可以通过以下方式实现：

1. 手动拼接多语句 SQL（针对不同表的操作） #

利用 Sequelize 的 query() 方法，手动构造包含多个 INSERT 语句的 SQL 脚本（用分号分隔），一次性发送给数据库。注意：

• 你的数据库需要支持多语句执行（比如 MySQL 需要在连接配置中开启 multipleStatements: true）；
• 必须使用参数绑定来避免 SQL 注入，不能直接拼接变量。

针对你的代码场景，示例如下：

const transaction = await db.transaction();

try {
  // 构造多语句SQL片段与参数映射
  const sqlParts = [];
  const replacements = {};
  let paramSeq = 1;

  // 处理Resource批量插入
  if (resourcesTable.length) {
    const cols = Object.keys(resourcesTable[0]);
    const valueGroups = resourcesTable.map(row => 
      cols.map(() => `:res_${paramSeq++}`)
    );
    sqlParts.push(`INSERT INTO resources (${cols.join(', ')}) VALUES ${valueGroups.map(g => `(${g.join(', ')})`).join(', ')}`);
    // 绑定参数
    resourcesTable.forEach((row, idx) => {
      cols.forEach((col, colIdx) => {
        replacements[`res_${idx * cols.length + colIdx + 1}`] = row[col];
      });
    });
  }

  // 处理Contact与Location批量插入
  if (contactsTable?.length) {
    const contactCols = Object.keys(contactsTable[0]);
    const contactValues = contactsTable.map(row => 
      contactCols.map(() => `:con_${paramSeq++}`)
    );
    sqlParts.push(`INSERT INTO contacts (${contactCols.join(', ')}) VALUES ${contactValues.map(g => `(${g.join(', ')})`).join(', ')}`);
    contactsTable.forEach((row, idx) => {
      contactCols.forEach((col, colIdx) => {
        replacements[`con_${idx * contactCols.length + colIdx + 1}`] = row[col];
      });
    });

    if (locationsTable?.length) {
      const locCols = Object.keys(locationsTable[0]);
      const locValues = locationsTable.map(row => 
        locCols.map(() => `:loc_${paramSeq++}`)
      );
      sqlParts.push(`INSERT INTO locations (${locCols.join(', ')}) VALUES ${locValues.map(g => `(${g.join(', ')})`).join(', ')}`);
      locationsTable.forEach((row, idx) => {
        locCols.forEach((col, colIdx) => {
          replacements[`loc_${idx * locCols.length + colIdx + 1}`] = row[col];
        });
      });
    }
  }

  // 处理Resource_Tag批量插入
  if (resourceTagTable?.length) {
    const tagCols = Object.keys(resourceTagTable[0]);
    const tagValues = resourceTagTable.map(row => 
      tagCols.map(() => `:tag_${paramSeq++}`)
    );
    sqlParts.push(`INSERT INTO resource_tags (${tagCols.join(', ')}) VALUES ${tagValues.map(g => `(${g.join(', ')})`).join(', ')}`);
    resourceTagTable.forEach((row, idx) => {
      tagCols.forEach((col, colIdx) => {
        replacements[`tag_${idx * tagCols.length + colIdx + 1}`] = row[col];
      });
    });
  }

  // 执行合并后的SQL
  await db.query(sqlParts.join('; '), {
    replacements,
    transaction,
    type: db.QueryTypes.INSERT
  });

  await transaction.commit();
} catch (err) {
  logger.error(err);
  await transaction.rollback();
  throw new HttpError(500, "Database Error");
}

2. 注意事项 #

• 数据库兼容性：并非所有数据库都支持多语句执行（比如 PostgreSQL 默认不允许，需要特殊配置），请确认你的数据库支持该特性。
• SQL注入风险：必须严格使用参数绑定，绝不能直接将用户输入或动态数据拼接进SQL字符串。
• 调试复杂度：手动拼接SQL会失去ORM的便捷性，出错时定位问题难度更高，建议仅在对性能有明确要求时使用。

补充：并行执行多个请求（非合并） #

如果你只是想减少总耗时，而非必须合并为单次请求，可以用Promise.all让多个bulkCreate并行执行（依然是独立请求，但总耗时更短）：

const transaction = await db.transaction();

try {
  const taskList = [];
  taskList.push(Resource.bulkCreate(resourcesTable, { transaction }));
  
  if (contactsTable?.length) {
    taskList.push(Contact.bulkCreate(contactsTable, { transaction }));
    if (locationsTable?.length) {
      taskList.push(Location.bulkCreate(locationsTable, { transaction }));
    }
  }
  
  if (resourceTagTable?.length) {
    taskList.push(Resource_Tag.bulkCreate(resourceTagTable, { transaction }));
  }

  await Promise.all(taskList);
  await transaction.commit();
} catch (err) {
  logger.error(err);
  await transaction.rollback();
  throw new HttpError(500, "Database Error");
}

内容的提问来源于stack exchange，提问作者WCSin