下面是我的应用程序数据库表，其中包含存储在表中的 SQL 查询:QueryStorage

Id           Query           ConnectionString       Rdbms
1            select...        Data Source           Sql Server
2            select...        Data Source           Oracle

上表中的 SQL 查询是通过网络服务更新的，我们不允许在查询之上更新，尽管我们可以在查询之上添加一些东西，如下所示:

查询存储在表中: 从源中选择 id 作为 LinkedColumn，Amount 作为 CompareColumn

从我的 c# 应用程序调整查询:从(存储的 sql 查询)中选择 Q.LinkedColumn、Q.CompareColumn 作为 Q

我正在尝试比较 2 个无序列表，如下所示:

从 QueryStorage 表 记录中为 Id = 1(Sql server) 执行的查询如下所示:

select Id as LinkedColumn,CompareColumn from Source

列表 1:

LinkedColumn     CompareColumn
1                100
2                200
3                300
4                400
5                500
6                600
7                700
8                800
9                900
10               1000

从 QueryStorage 表记录中为 Id = 2(Oracle) 执行的查询如下:

select Id as LinkedColumn,CompareColumn from Target

列表 2:

LinkedColumn       CompareColumn
10                 10
9                  20
8                  30
7                  40
6                  50
5                  60
4                  70
3                  80
2                  90
1                  5

我想在 LinkedColumn from source to target 上加入，然后在 CompareColumn 上进行比较，这应该会给我以下输出:

SrcLinkedColumn      SrcCompareColumn     TgtLinkedColumn    TgtCompareColumn
    1                       100           1                  5
    2                       200           2                  90               

逻辑:

var data = (from s in List1.AsEnumerable()
             join t in List2.AsEnumerable() on s.Field<string>("LinkedColumn") equals t.Field<string>("LinkedColumn")
             where s.Field<decimal>("CompareColumn") != t.Field<decimal>("CompareColumn")
                        select new
                        {
                            srcLinkedcol = s.Field<string>("LinkedColumn"),
                            srcCompareCol = s.Field<decimal>("CompareColumn"),
                            tgtLinkedCol = t.Field<string>("LinkedColumn"),
                            tgtCompareCol = t.Field<decimal>("CompareColumn")
                        }).ToList();

从源到目标将有数百万条记录，我想与这么大的问题进行比较 内存不足异常 我们现在面临的问题是将所有数据加载到内存中，然后执行与上面的 linq 查询比较。

我想到了以下两种解决方案:

1) 打开2个有序数据阅读器。

优点:

    - No memory exception
    - Fast as there will be 1 to 1 comparision of LinkedColumn for List1 and 
      List2 records.

缺点:

    - Order by is require on LinkedColumns and as i have no control over 
      query as because it is dumped by webservice in QueryStorage table so 
      user is explicitly require to submit query with order by on 
      LinkedColumn.
    - Wont work if order by on Linkedcolumn is not present.
    - Order by query have performance overhead so because of this user may not include order by on LinkedColumn in query.                               

2) 通过调整查询并添加 OffSet 和 FetchRowNext 逐 block 记录比较。这就是我对算法的看法:

但我仍然觉得使用第二种方法我会遇到内存异常问题，因为在某些步骤中，来自源和目标的数据不匹配，我会将它们存储在缓冲区(数据表或列表等)中以供下一个 block 比较。

任何人都可以指导我解决这个问题的好的算法或更好的方法吗？

注意:我不想使用 LinkedServer 和 SSIS。

最佳答案

您的第二个解决方案看起来像是在尝试重新发明 External merge sort .如果您的数据不适合内存，这是一种有效的方法，但当您的数据集适合内存时，这是一种过大的方法。

2400 万行，每行有两个数字(8 字节)仅约 200MB 内存。 两个数据集是 400MB。这在现代桌面硬件上算不了什么。

将两个数据集加载到内存中。在简单的数组中。对内存中的数组进行排序。 通过扫描两个已排序的数组一次来找出差异。 为此，您不需要花哨的 LINQ。

这是伪代码。我们有 Array1 和 Array2。维护两个包含每个数组的当前索引的变量:Idx1 和 Idx2。沿着数组移动索引，寻找 LinkedColumn 匹配的位置。

Idx1 = 0; Idx2 = 0;
while (true)
{
    // scan arrays until both indexes point to the same LinkedColumn
    // here we assume that both arrays are sorted by LinkedColumn
    // and that values in LinkedColumn are unique

    while (Idx1 < Array1.Length && Idx2 < Array2.Length &&
        Array1[Idx1].LinkedColumn < Array2[Idx2].LinkedColumn)
    {
        // move along Array1
        Idx1++;
    }

    while (Idx1 < Array1.Length && Idx2 < Array2.Length &&
        Array1[Idx1].LinkedColumn > Array2[Idx2].LinkedColumn)
    {
        // move along Array2
        Idx2++;
    }

    // at this point both indexes point to the same LinkedColumn
    // or one or both of the arrays are over

    if (Idx1 >= Array1.Length || Idx2 >= Array2.Length)
    {
        break;
    }

    // compare the values
    if (Array1[Idx1].CompareColumn != Array2[Idx2].CompareColumn)
    {
        // TODO: output/save/print the difference
    }

    Idx1++; Idx2++;
}

或

您可以将两个数据集转储到您选择的数据库中的两个表 T1 和 T2 中，在两个表中的 LinkedColumn 上创建唯一索引并运行此查询:

SELECT
     T1.LinkedColumn  AS SrcLinkedColumn
    ,T1.CompareColumn AS SrcCompareColumn
    ,T2.LinkedColumn  AS DstLinkedColumn
    ,T2.CompareColumn AS DstCompareColumn
FROM
    T1 INNER JOIN T2 ON T1.LinkedColumn = T2.LinkedColumn
WHERE
    T1.CompareColumn <> T2.CompareColumn
ORDER BY
    T1.LinkedColumn
;

上面的伪代码执行与 DBMS 服务器为此查询执行的相同的合并连接。

关于c# - 比较内存中的 2 个无序记录集，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/48583201/