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

Question

这可能有点抽象，但我有一个类似这样的方法：

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

假设传递的列表包含以下元素:3、6和9。我需要从datatable源中找到完全相同的列表、顺序相同的元素、共享相同的逻辑组(无论它是什么)。

我有一个包含以下列的数据表(所有列都是整数值)：

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，这些can也可以包含许多元素。

最初，我有一个非常简单的datatable设置，其中一个列包含一个类似于"3,6,9“的字符串，我必须在我的逻辑中解析它。创建这个新的数字数据表的目的是(在理论上)使它尽可能快。如果可以改进的话，我愿意使用另一种datatable结构，但我主要是请求帮助为上面的表形成所需的查询(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);
}