Question

这有点抽象但我有这样的方法：

private int[] ReturnLogicalGroupingAForOrderedElements(List<int> elements) {
    //sql query or linq query
    //returns an int[] in case there are more than one matching set.
}

假设传递的List包含以下元素：3,6和9.我需要找到完全相同的列表，元素按相同的顺序，从数据源中共享相同的逻辑分组（无论它是什么）。

我有一个包含以下列的数据表（所有这些都是int值）：

LogicalGroupingA, LogicalGroupingB, Element, ElementOrder

我需要找到并确定所有上述元素（3,6,9）存在于多行中，共享相同的逻辑分组。例如：

7,1,3,1
7,1,6,2
7,1,9,3

如果找到所有这些，那么我想从LogicalGroupingA返回值7。但考虑到这一点，可能会有一组不同的行（共享相同的逻辑分组）：

4,1,3,1
4,1,6,2
4,1,9,3
4,1,5,4

如果完整的元素系列正是要求的话，查询应该只返回所需的值（这里前三个元素等于查询的列表但是因为这里有第四个元素它不相等）。假设数据表行是混合的。 LogicalGroupingA可以包含许多LogicalGroupingB，它们也可以包含许多元素。

最初我有一个非常简单的数据表设置，其中colum包含一个像“3,6,9”的字符串，我必须在我的逻辑中解析。创建这个新的数值数据表的目的是使其尽可能快（理论上）。如果可以对此进行改进，我可以使用替代数据表结构，但主要是我要求帮助为上表创建所需的查询（sql或linq）。

编辑：可能有点糟糕的时间发布问题，因为我将在接下来的两天从我的开发机器中离开但是请确保我会给出正确的分数和安排。投票（和评论）一旦我回来并测试了建议。谢谢你的耐心等待。

Answer 1

public class Grouping
{
   public int LGA{get;set;}
   public int LGB{get;set;}
   public int El {get;set;}
   public int ElO {get;set;}
}

void Main()
{
    var dbValues = new List<Grouping>
        {
            new Grouping { LGA =7, LGB = 1, El=6, ElO=2 },
            new Grouping { LGA =7, LGB = 1, El=3, ElO=1 },
            new Grouping { LGA =4, LGB = 1, El=3, ElO=1 },
            new Grouping { LGA =4, LGB = 1, El=6, ElO=2 },
            new Grouping { LGA =4, LGB = 1, El=7, ElO=3 },
        };
    var dbGroups = dbValues.Select(dbData => new {Group = dbData.LGA, Element = dbData.El, ElO = dbData.ElO})
            .OrderBy(item => item.ElO)
            .GroupBy(item => item.Group);
    var elements = new List<int>{3, 6};

    foreach(var dbGroup in dbGroups)
    {
        if (dbGroup.Select(el => el.Element).SequenceEqual(elements))
        {
            Console.WriteLine(dbGroup.First().Group);
        }
    }
}

Answer 2

更新：过滤具有超过指定元素的组

假设4列是唯一的

SELECT
    LogicalGroupingA
FROM
(
    -- get all Groupings that have the specified order
    SELECT
      LogicalGroupingA, LogicalGroupingB
    FROM
      table
    WHERE
      (element = :listelement1 AND ElementOrder = 1) OR
      (element = :listelement2 AND ElementOrder = 2) OR
      ...
    GROUP BY
      LogicalGroupingA, LogicalGroupingB
    HAVING
      COUNT(*) = :listcount
) as candidates
WHERE
    -- filter all Groupings that have more than the specified elements
    Count(SELECT COUNT(*) FROM table WHERE LogicalGroupingA = candidates.LogicalGroupingA AND LogicalGroupingB = candidates.LogicalGroupingB) = :listcount

作为LINQ，不知道每个Linqprovider是否理解它

public class Row
{
   public int GroupA { get; set; }
   public int GroupB { get; set; }
   public int Element { get; set; }
   public int ElementOrder { get; set; }
}

private IEnumerable<int> ReturnLogicalGroupingAForOrderedElements(IList<int> elements)
{
    Expression parameter = Expression.Parameter(typeof(Row), "x");
    Expression propElement = Expression.Property(parameter, "Element");
    Expression propElementOrder = Expression.Property(parameter, "ElementOrder");
    Expression where;
    for (int i = 0; i < elements.Count; i++)
    {
        var restriction = Expression.AndAlso(
            Expression.Equal(propElement, elements[i]),
            Expression.Equal(propElementOrder, i + 1));

        if (where == null)
            where = restriction;
        else
            where = Expression.Or(where, restriction);
    }

    var groupsWithSameOrder = Rows.Where(where)
        .GroupBy(r => new { r.GroupA, r.GroupB })
        .Where(g => g.Count() == elements.Count)
        .Select(g => g.Key);

    return groupsWithSameOrder.Except(Rows
            .Where(r => groupsWithSameOrder.Contains(new { r.GroupA, r.GroupB }))
            .GroupBy(r => new { r.GroupA, r.GroupB })
            .Where(g => g.Count() != elements.Count)
            .Select(g => g.Key))
        .Select(key => key.GroupA);
}

形成SQL / LINQ查询 - 跨不同行的有序元素共享逻辑分组

2 个答案: