如何基于order属性处理文档增删排并最小化数据库变更？

通用核心思路 #

放弃维护连续整数的order字段，改用间隙值分配策略，利用数字的相对大小实现排序，彻底避免批量更新后续文档的操作：

• 初始分配：初始化文档时，给每个文档分配间隔较大的order值（如0, 100, 200...），预留足够插入空间。
• 插入操作：
  • 追加到末尾：取当前最大order值加固定间隙（如100）作为新文档的order。
  • 插入到中间：计算前后文档order的中间值，直接赋值给新文档；若间隙不足（前后值差≤1），仅批量更新冲突位置后的部分文档扩展间隙（而非全部后续文档）。
• 删除操作：直接删除目标文档，无需修改其他任何文档的order值。
• 移动操作：将目标文档的order更新为新位置前后文档的中间值即可；间隙不足时同样执行局部间隙扩展。

Firebase/NoSQL JavaScript 具体实现 #

1. 初始化集合（批量分配间隙值） #

async function initDocuments(documents) {
  const batch = db.batch();
  documents.forEach((doc, index) => {
    const ref = db.collection('your-collection').doc();
    batch.set(ref, {
      ...doc,
      order: index * 100
    });
  });
  await batch.commit();
}

2. 插入文档到指定位置 #

// newDocData: 新文档数据；prevDocRef: 前序文档引用；nextDocRef: 后序文档引用
async function insertDocumentBetween(newDocData, prevDocRef, nextDocRef) {
  let newOrder;

  if (!prevDocRef) {
    // 插入到集合开头
    const firstDocQuery = await db.collection('your-collection').orderBy('order').limit(1).get();
    newOrder = firstDocQuery.empty ? 0 : firstDocQuery.docs[0].data().order - 100;
  } else if (!nextDocRef) {
    // 追加到集合末尾
    const lastDocQuery = await db.collection('your-collection').orderBy('order', 'desc').limit(1).get();
    newOrder = lastDocQuery.empty ? 0 : lastDocQuery.docs[0].data().order + 100;
  } else {
    // 插入到两个文档之间
    const [prevDoc, nextDoc] = await Promise.all([prevDocRef.get(), nextDocRef.get()]);
    const prevOrder = prevDoc.data().order;
    const nextOrder = nextDoc.data().order;

    if (nextOrder - prevOrder > 1) {
      newOrder = Math.floor((prevOrder + nextOrder) / 2);
    } else {
      // 间隙不足，扩展后续文档的order值
      const batch = db.batch();
      const docsToUpdate = await db.collection('your-collection')
        .where('order', '>=', nextOrder)
        .orderBy('order')
        .get();

      docsToUpdate.forEach(doc => {
        batch.update(doc.ref, { order: doc.data().order + 100 });
      });
      await batch.commit();
      newOrder = prevOrder + 50;
    }
  }

  await db.collection('your-collection').add({
    ...newDocData,
    order: newOrder
  });
}

3. 移动文档到目标位置 #

// docRef: 要移动的文档引用；targetPrevRef: 目标位置前序文档引用；targetNextRef: 目标位置后序文档引用
async function moveDocument(docRef, targetPrevRef, targetNextRef) {
  let newOrder;

  if (!targetPrevRef) {
    // 移到集合开头
    const firstDocQuery = await db.collection('your-collection').orderBy('order').limit(1).get();
    newOrder = firstDocQuery.empty ? 0 : firstDocQuery.docs[0].data().order - 100;
  } else if (!targetNextRef) {
    // 移到集合末尾
    const lastDocQuery = await db.collection('your-collection').orderBy('order', 'desc').limit(1).get();
    newOrder = lastDocQuery.empty ? 0 : lastDocQuery.docs[0].data().order + 100;
  } else {
    const [prevDoc, nextDoc] = await Promise.all([targetPrevRef.get(), targetNextRef.get()]);
    const prevOrder = prevDoc.data().order;
    const nextOrder = nextDoc.data().order;

    if (nextOrder - prevOrder > 1) {
      newOrder = Math.floor((prevOrder + nextOrder) / 2);
    } else {
      // 间隙不足，扩展后续文档的order值（跳过自身）
      const batch = db.batch();
      const docsToUpdate = await db.collection('your-collection')
        .where('order', '>=', nextOrder)
        .orderBy('order')
        .get();

      docsToUpdate.forEach(doc => {
        if (doc.ref.path !== docRef.path) {
          batch.update(doc.ref, { order: doc.data().order + 100 });
        }
      });
      await batch.commit();
      newOrder = prevOrder + 50;
    }
  }

  await docRef.update({ order: newOrder });
}

4. 删除文档 #

async function deleteDocument(docRef) {
  await docRef.delete();
  // 无需更新其他文档的order值，排序逻辑不受影响
}

关键注意事项 #

• 初始间隙大小（如100）可根据业务插入频率调整：插入越频繁，间隙设得越大，能大幅减少需要扩展间隙的场景。
• 扩展间隙时仅需更新冲突位置后的部分文档，而非全部后续文档，进一步降低写入开销。
• 依赖数据库的orderBy功能时，仅需保证order值的相对大小正确，无需连续，完全满足自定义排序需求。

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