如何在CosmosDB中不依赖ID实现更优的Upsert及文档查询？

我有一个客户端应用，会创建TestModel模型并做本地存储，同时将映射后的TestDto发送至Web API。

模型定义：

class TestModel // 本地存储模型
{
   Guid OwnerId;
   Guid LocalId;
   string Name;
}

class TestDto // 远程存储模型
{
   Guid Id;
   Guid OwnerId;
   Guid LocalId;
   string Name;
}

服务端场景 #

当把映射后的TestDto发送至Web API时需要执行更新操作，但客户端模型不知道数据库中存储的TestDto的Id，因此我使用OwnerId和LocalId来定位待更新的文档。当前实现代码如下：

public async Task<TestDto?> UpdateAsync(TestDto testDto)
{
    IOrderedQueryable<TestDto> queryable = _container.GetItemLinqQueryable<TestDto>();

    // 构造LINQ查询
    var matches = queryable.Where(p => p.LocalId == testDto.LocalId && p.OwnerId == testDto.OwnerId);

    using FeedIterator<TestDto> linqFeed = matches.ToFeedIterator();

    List<TestDto> results = new List<TestDto>();
    while (linqFeed.HasMoreResults)
    {
        var response = await linqFeed.ReadNextAsync();
        results.AddRange((IEnumerable<TestDto>)response);
    }

    var result = results.SingleOrDefault();

    if (result != null && results.Count == 1)
    {
        testDto.Id = result.Id; // 更新需设置Id
        await _container.UpsertItemAsync<TestDto>(testDto, new PartitionKey(testDto.OwnerId.ToString()));
    }

    return result;
}

请问是否有更优的方式来筛选、定位待更新的文档？替代当前使用FeedIterator和SingleOrDefault的实现方式，同时实现不依赖Id的CosmosDB Upsert操作？

方案1：简化LINQ查询，直接获取单个匹配项 #

通过Take(1)限制查询仅返回第一个结果，避免遍历全部Feed数据，大幅简化代码逻辑：

public async Task<TestDto?> UpdateAsync(TestDto testDto)
{
    var queryable = _container.GetItemLinqQueryable<TestDto>()
        .Where(p => p.LocalId == testDto.LocalId && p.OwnerId == testDto.OwnerId)
        .Take(1); // 仅取第一个匹配文档

    using var feedIterator = queryable.ToFeedIterator();
    var response = await feedIterator.ReadNextAsync();
    var existingItem = response.FirstOrDefault();

    if (existingItem != null)
    {
        testDto.Id = existingItem.Id;
        await _container.UpsertItemAsync(testDto, new PartitionKey(testDto.OwnerId.ToString()));
        return existingItem;
    }

    return null;
}

方案2：复合唯一键+存储过程实现原子Upsert #

如果OwnerId和LocalId的组合是全局唯一的，可通过以下方式实现无Id的原子Upsert：

1. 配置复合唯一键约束：在Cosmos DB容器的索引策略中添加唯一键规则，确保OwnerId+LocalId的组合不重复：

   "uniqueKeyPolicy": {
       "uniqueKeys": [
           {
               "paths": ["/OwnerId", "/LocalId"]
           }
       ]
   }
   

2. 创建存储过程：用JavaScript编写存储过程，在Cosmos DB端完成"查询+Upsert"的原子操作：

   function upsertByOwnerAndLocalId(newItem) {
       var collection = getContext().getCollection();
       var query = "SELECT * FROM c WHERE c.OwnerId = @ownerId AND c.LocalId = @localId";
       var parameters = [
           { name: "@ownerId", value: newItem.OwnerId },
           { name: "@localId", value: newItem.LocalId }
       ];
   
       // 执行查询定位文档
       var isAccepted = collection.queryDocuments(
           collection.getSelfLink(),
           { query: query, parameters: parameters },
           function (err, documents) {
               if (err) throw err;
   
               if (documents.length > 0) {
                   // 找到已有文档，更新Id后执行Upsert
                   newItem.id = documents[0].id;
                   collection.upsertDocument(collection.getSelfLink(), newItem, function (err, doc) {
                       if (err) throw err;
                       getContext().getResponse().setBody(doc);
                   });
               } else {
                   // 无匹配文档，直接插入（Cosmos自动生成Id）
                   collection.upsertDocument(collection.getSelfLink(), newItem, function (err, doc) {
                       if (err) throw err;
                       getContext().getResponse().setBody(doc);
                   });
               }
           }
       );
   
       if (!isAccepted) throw new Error("查询请求未被处理");
   }
   

3. C#调用存储过程：

   public async Task<TestDto?> UpdateAsync(TestDto testDto)
   {
       var partitionKey = new PartitionKey(testDto.OwnerId.ToString());
       var result = await _container.Scripts.ExecuteStoredProcedureAsync<TestDto>(
           "upsertByOwnerAndLocalId",
           partitionKey,
           testDto
       );
   
       return result.Resource;
   }
   

方案3：参数化SQL查询直接获取目标文档 #

直接构造参数化SQL查询，相比LINQ更灵活，同时避免SQL注入风险：

public async Task<TestDto?> UpdateAsync(TestDto testDto)
{
    var sqlQuery = "SELECT TOP 1 * FROM c WHERE c.OwnerId = @OwnerId AND c.LocalId = @LocalId";
    var parameters = new[]
    {
        new SqlParameter("@OwnerId", testDto.OwnerId),
        new SqlParameter("@LocalId", testDto.LocalId)
    };

    var queryDefinition = new QueryDefinition(sqlQuery).WithParameters(parameters);
    using var feedIterator = _container.GetItemQueryIterator<TestDto>(queryDefinition);

    var response = await feedIterator.ReadNextAsync();
    var existingItem = response.FirstOrDefault();

    if (existingItem != null)
    {
        testDto.Id = existingItem.Id;
        await _container.UpsertItemAsync(testDto, new PartitionKey(testDto.OwnerId.ToString()));
        return existingItem;
    }

    return null;
}

关键优化点 #

• 减少无效数据处理：通过Take(1)或SELECT TOP 1仅获取第一个匹配项，避免遍历全量Feed
• 原子性保障：存储过程方案将查询和Upsert放在同一操作中，减少网络往返，同时利用唯一键约束保证数据一致性
• 性能与安全：始终使用参数化查询，既提升查询性能，又避免SQL注入风险

内容的提问来源于stack exchange，提问作者Zoltán