针对你10亿条记录的场景，逐条循环绝对是灾难级的效率——不管是数据库资源占用还是处理速度都扛不住。下面从SQL端批量处理和**.NET/C#程序端优化**两个方向给出实操方案，核心思路都是避免单条操作，用「批量+分段」的方式降低资源消耗：

一、SQL端批量处理方案（推荐优先尝试，减少数据传输） #

如果你的数据库支持字符串拆分和聚合函数（比如SQL Server 2016+、PostgreSQL 12+），直接在数据库端处理是最优解——不需要把10亿条数据拉到程序里，省掉大量网络和内存开销。

1. 核心逻辑：拆分键值对 → 过滤目标键 → 重新拼接 #

以SQL Server为例，假设表名为YourTable，要删除的目标键是'age'：

-- 分段更新，避免一次性锁全表（每次处理10万条，可根据数据库性能调整）
DECLARE @BatchSize INT = 100000;
DECLARE @RowCount INT = 1;

WHILE @RowCount > 0
BEGIN
    -- 拆分键值对并关联对应关系
    WITH SplitData AS (
        SELECT 
            Id, -- 假设表有主键Id用于分段和关联
            kv.KeyIndex,
            kv.KeyName,
            kv.Value
        FROM YourTable
        CROSS APPLY (
            SELECT 
                ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) AS KeyIndex,
                value AS KeyName
            FROM STRING_SPLIT(dbKeys, ';')
        ) k
        CROSS APPLY (
            SELECT value AS Value
            FROM STRING_SPLIT(dbValues, ';')
            WHERE ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) = k.KeyIndex
        ) v
        -- 只筛选包含目标键的记录，减少处理量
        WHERE dbKeys LIKE '%;age;%' OR dbKeys LIKE 'age;%' OR dbKeys LIKE '%;age'
        ORDER BY Id
        OFFSET 0 ROWS FETCH NEXT @BatchSize ROWS ONLY
    ),
    -- 重新拼接过滤后的键值对
    AggregatedData AS (
        SELECT 
            Id,
            STRING_AGG(KeyName, ';') WITHIN GROUP (ORDER BY KeyIndex) AS NewDbKeys,
            STRING_AGG(Value, ';') WITHIN GROUP (ORDER BY KeyIndex) AS NewDbValues
        FROM SplitData
        WHERE KeyName <> 'age' -- 排除目标键
        GROUP BY Id
    )
    -- 批量更新原表
    UPDATE t
    SET t.dbKeys = ad.NewDbKeys,
        t.dbValues = ad.NewDbValues
    FROM YourTable t
    JOIN AggregatedData ad ON t.Id = ad.Id;

    SET @RowCount = @@ROWCOUNT;
    PRINT '本次处理' + CAST(@RowCount AS VARCHAR) + '条记录';
END

关键注意事项： #

• 分段处理：用OFFSET/FETCH分批操作，避免全表锁导致数据库服务卡顿，甚至影响业务。
• 索引优化：如果需要频繁筛选包含特定键的记录，给dbKeys加全文索引或者包含主键的非聚集索引，能大幅加快过滤速度。
• 空值处理：如果过滤后键值对为空，可以在更新后追加一步清理：

  DELETE FROM YourTable WHERE dbKeys IS NULL OR dbKeys = '';
  

二、.NET/C#程序端优化方案（适合数据库版本较低的场景） #

如果你的数据库不支持STRING_SPLIT、STRING_AGG这类高级函数，就需要用程序批量读取、处理、写入——核心是流式处理+批量更新，绝对不能把全量数据加载到内存。

1. 核心思路：分批读取 → 内存过滤键值对 → 批量更新 #

using System.Data.SqlClient;
using System.Text;

public class KeyValueBatchProcessor
{
    private const string DbConnectionString = "你的数据库连接字符串";
    private const int BatchSize = 100000; // 每次处理10万条，可根据内存调整
    private const string TargetKey = "age";

    public async Task ProcessBatchAsync()
    {
        using var conn = new SqlConnection(DbConnectionString);
        await conn.OpenAsync();

        long lastProcessedId = 0;
        int processedCount;

        do
        {
            // 分批读取需要处理的记录（只拉取必要字段，减少数据传输）
            var selectCmd = new SqlCommand(@"
                SELECT TOP (@BatchSize) Id, dbKeys, dbValues
                FROM YourTable
                WHERE (dbKeys LIKE '%;age;%' OR dbKeys LIKE 'age;%' OR dbKeys LIKE '%;age')
                AND Id > @LastProcessedId
                ORDER BY Id", conn);
            selectCmd.Parameters.AddWithValue("@BatchSize", BatchSize);
            selectCmd.Parameters.AddWithValue("@LastProcessedId", lastProcessedId);

            using var reader = await selectCmd.ExecuteReaderAsync();
            var updateItems = new List<(long Id, string NewKeys, string NewValues)>();

            // 流式读取，逐行处理
            while (await reader.ReadAsync())
            {
                long id = reader.GetInt64(0);
                string rawKeys = reader.GetString(1);
                string rawValues = reader.GetString(2);

                var keyArray = rawKeys.Split(';', StringSplitOptions.RemoveEmptyEntries);
                var valueArray = rawValues.Split(';', StringSplitOptions.RemoveEmptyEntries);

                var newKeysBuilder = new StringBuilder();
                var newValuesBuilder = new StringBuilder();

                // 过滤目标键，同时保证键值对应
                for (int i = 0; i < keyArray.Length; i++)
                {
                    if (keyArray[i] != TargetKey)
                    {
                        if (newKeysBuilder.Length > 0) newKeysBuilder.Append(';');
                        newKeysBuilder.Append(keyArray[i]);

                        if (i < valueArray.Length) // 兼容键值数量不匹配的异常情况
                        {
                            if (newValuesBuilder.Length > 0) newValuesBuilder.Append(';');
                            newValuesBuilder.Append(valueArray[i]);
                        }
                    }
                }

                updateItems.Add((id, newKeysBuilder.ToString(), newValuesBuilder.ToString()));
                lastProcessedId = id;
            }

            reader.Close();

            // 批量更新到数据库
            if (updateItems.Count > 0)
            {
                processedCount = await BatchUpdateAsync(conn, updateItems);
                Console.WriteLine($"已处理 {processedCount} 条，累计处理至ID: {lastProcessedId}");
            }
            else
            {
                processedCount = 0;
            }

        } while (processedCount > 0);
    }

    private async Task<int> BatchUpdateAsync(SqlConnection conn, List<(long Id, string NewKeys, string NewValues)> items)
    {
        var sb = new StringBuilder();
        // 用CASE WHEN拼接批量更新语句，减少数据库交互次数
        sb.Append("UPDATE YourTable SET dbKeys = CASE Id ");
        foreach (var item in items)
        {
            sb.AppendFormat("WHEN {0} THEN '{1}' ", item.Id, item.NewKeys.Replace("'", "''"));
        }
        sb.Append("END, dbValues = CASE Id ");
        foreach (var item in items)
        {
            sb.AppendFormat("WHEN {0} THEN '{1}' ", item.Id, item.NewValues.Replace("'", "''"));
        }
        sb.Append("END WHERE Id IN (");
        sb.Append(string.Join(",", items.Select(x => x.Id)));
        sb.Append(")");

        using var updateCmd = new SqlCommand(sb.ToString(), conn);
        return await updateCmd.ExecuteNonQueryAsync();
    }
}

优化点说明： #

• 流式读取：用SqlDataReader逐行读取，避免一次性加载10万条数据到内存，降低OOM风险。
• 批量更新：用CASE WHEN拼接单条更新语句，比循环执行单条UPDATE快几个数量级。
• 异步处理：全程用async/await，提高程序吞吐量，避免线程阻塞。
• 异常兼容：处理键值数量不匹配的情况，避免程序崩溃。

三、终极优化：重构数据结构 #

上面的方案能解决当前问题，但分号分隔字符串存储键值对本身是反范式设计——10亿条数据的场景下，后续的查询、修改、统计都会非常痛苦。如果业务允许 downtime，建议重构表结构：

• 新建子表YourTable_KeyValue，字段：ParentId（关联主表主键）、KeyName、KeyValue。
• 把原表的dbKeys和dbValues拆分后批量插入子表，然后删除原表的这两个字段。
• 后续操作直接对子表进行，不仅效率提升几个数量级，还能通过索引优化各种查询需求。

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