如何有效地替换克隆对象中 id 字段的值？

Question

假设我在一个表中有两条记录：

[
    {
        id: 1,
        name: 'Michael',
        associations: [
            {
                from: 1,
                to: 2
            }
        ]
    },
    {
        id: 2,
        name: 'John',
        associations: [
            {
                from: 2,
                to: 1
            }
        ]
    },
]

如果我克隆这两个对象，我需要得到以下结果：

[
    {
        id: 1,
        name: 'Michael',
        associations: [
            {
                from: 1,
                to: 2
            }
        ]
    },
    {
        id: 2,
        name: 'John',
        associations: [
            {
                from: 2,
                to: 1
            }
        ]
    },
    {
        id: 3,
        name: 'Michael',
        associations: [
            {
                from: 3,
                to: 4
            }
        ]
    },
    {
        id: 4,
        name: 'John',
        associations: [
            {
                from: 4,
                to: 3
            }
        ]
    },
]

我怎样才能有效地做到这一点？

我目前正在做的是循环浏览所有记录并为每个记录运行INSERT。对于每个元素，我跟踪它的oldId 和newId，然后，我查询具有这些newIds 之一的所有记录。然后，我替换了这些值。显然，这对于两条记录来说很好，但如果我有数千条记录需要克隆，每条记录都包含数千个关联，这会对性能造成很大影响。

这里是代码。函数cloneElements是发起者。

const updateElementAssociationsById = async ({ id, associations }) => {
    return dbQuery(id, associations); // UPDATE ... SET associations WHERE id
}

const handleUpdateAssociations = async ({ data }) => {
    const promises = [];
    const records = await dbQuery(data.map(({ newId }) => newId)) ; // SELECT * FROM ... WHERE id in ANY 

    records.forEach(({ id, ...record }) => {
        const associations = [];

        record.associations.forEach((association) => {
            const sourceElement = data.find(({ oldId }) => oldId === association.from);
            const targetElement = data.find(({ oldId }) => oldId === association.to)

            association.from = sourceElement.newId;
            association.to = targetElement.newId;

            associations.push(association);
        });

        promises.push(updateElementAssociationsById({ id, associations }))
    });

    await Promise.all(promises);
}

const createElement = async ({ element, data }) => {
    const newElement = await dbQuery(element); // INSERT INTO ... RETURNING *;

    data.push({
        oldId: element.id,
        newId: newElement.id,
    });   
}

const cloneElements = async (records) => {
    const promises = [];
    const data = [];

    records.forEach((element) => {
        promises.push(createElement({ element, records, data }));
    });

    await Promise.all(promises);

    await handleUpdateAssociations({ data });
}

Answer 1

假设您一生中复制的次数不足以达到 int 约束。

给定 int 约束的最大可用 id 数为 +2147483627 ，大约为 2.1B 条记录。

如果我们不重复使用 id，我们可以跳过查询数据库中的新 id，因为新 id 只是前一个的偏移量。

async function cloneElements(records) {
  // get highest unique ID
  // assuming the records are ordered by id, you can just get the last element of the array.
  const highestID = records[records.length-1].id;

  // offset everything.
  const newRecords = records.map(record => ({
    id: record.id + highestID,
    ...record, // "name" key
    associations: record.associations.map(asso => ({
      from: asso.from + highestID,
      to: asso.to + highestID,
    }))
  }));
  
  await Promise.all(
    newRecords.map(newRecord => dbQuery(newRecord))
  );
}

---

有一种更优化的方法来获取偏移量，特别是如果您打算只克隆部分保存的记录，请参阅：https://www.postgresql.org/message-id/DF9C8135-DC67-11D7-B235-000A959C9730@starlett.lv

---

编辑：感觉很奇怪，你的数据库设计有 id 范围。 我认为您也可以纯粹解决“克隆实体列表” 使用 SQL（Insert into ... select from 有增量）。还有，你 实际上不需要在JS中设置ID，如果你在创建它们 顺序正确，生成的id应该是正确的。

Answer 2

对于克隆，你只需要像下面这样，

let arrayFormat = [
    {
        id: 1,
        name: 'Michael',
        associations: [
            {
                from: 1,
                to: 2
            }
        ]
    },
    {
        id: 2,
        name: 'John',
        associations: [
            {
                from: 2,
                to: 1
            }
        ]
    },
];

let arrayLen = arrayFormat.length
arrayFormat.map((arr, index) => {
  if(index === arrayLen) {
   return false
  } 
  arrayFormat.push(arr)
})

console.log(JSON.stringify(arrayFormat))