【问题标题】:Convert SQL Sub Query to In to Linq Lambda将 SQL 子查询转换为 In 到 Linq Lambda
【发布时间】:2011-04-03 07:02:27
【问题描述】:

如何将以下 SQL 语句转换为 Lambda 表达式或 Linq 查询?

以下查询获取每个问题的最新答案。或者换一种说法,让每个问题都有最新的答案。

这也将由实体框架执行。

SELECT Answers.*
FROM Answers
Where AnswerID IN
(
    SELECT Max(AnswerID) AnswerID
    FROM Answers
    GROUP BY QuestionID
)

这是另一种使用内连接查看上一个查询的方法

SELECT answers.* 
FROM answers 
INNER JOIN  
(
     SELECT Max(answerID) answerID --,  QuestionSiteID
     FROM answers
     GROUP BY QuestionID 
) t ON
     answers.answerID = t.answerID  

我了解到 LINQ Contains 方法对于访问 SQL 的查询来说是次优的。
LINQ to Sql and .Contains() trap.

【问题讨论】:

    标签: c# sql linq entity-framework linq-to-entities


    【解决方案1】:

    我认为您可以使用以下方法来做到这一点:

     var subQuery = from a in answers
                    group a by a.QuestionID into grouping
                    select new
                    {
                        QuestionID = grouping.Key,
                        MaxAnswerID = grouping.Max(x => x.AnswerID)
                    };
    
     var query = from a in answers
                 from s in subQuery
                 where a.AnswerID == s.MaxAnswerID
                 select a;
    

    这会在生成的 SQL 中产生一个 CROSS JOIN


    另外,您可以在查询的第二部分使用join:

     var query = from a in answers
                 join s in subQuery on a.AnswerID equals s.MaxAnswerID
                 select a;
    

    这会导致 SQL 中出现 INNER JOIN


    注意附带情况 - 上述答案合理假设 AnswerID 是 Answers 的主键 - 如果您碰巧有一个以 (AnswerID, QuestionID) 为键的表设计,那么您将需要通过 AnswerID 和 QuestionID 加入,例如:

     var subQuery = from a in answers
                    group a by a.QuestionID into grouping
                    select new
                    {
                        QuestionID = grouping.Key,
                        MaxAnswerID = grouping.Max(x => x.AnswerID)
                    };
    
     var query = from a in answers
                 from s in subQuery
                 where a.AnswerID == s.MaxAnswerID
                 && a.QuestionID == s.QuestionID
                 select a;
    

    有关此替代表格设计的更多讨论,请参阅评论线索...

    【讨论】:

    • 斯图尔特感谢您的回答。当我在 LinqPad 中运行 LINQ Query 时,它返回了我预期的结果。我还注意到只执行了一个查询。这看起来很棒。我也提供了一个答案,我们俩都创建了相同的查询执行计划。为您创建的 sql 包括交叉连接,而我的 sql 是内部连接,但正如我所说的 SQL 查询执行计划是相同的。干得好
    • 是的 - 我喜欢你可以将 Linq 查询链接在一起的方式,它最后只生成一个 SQL 查询(你也可以从 C# 函数返回子查询)。随意将答案标记为已接受,而不是提供您自己的答案;)
    • 另外,虽然您已经掌握了查询执行计划 - 使用/不使用 join 有什么影响?
    • 刚刚在 LinqPad 中运行了第二个查询,它就可以工作了。对于那些可能想知道的人,它创建了一个 Inner Join SQL 查询。我还没有在 EF 中测试过这些,但我很有信心它们会起作用。
    • @Stuart:根据您的评论“使用/不使用连接”,我注意到您的第一个 linq 查询创建了一个 SQL 交叉连接,而您的第二个 linq 查询创建了一个 SQL 内连接。两个查询都创建了相同的 SQL 执行计划
    【解决方案2】:

    您可以使用let 语句来选择每个 QuestionID 组的第一个答案:

    from answer in Answers
    group answer by answer.QuestionID into question
    let firstAnswer = question.OrderByDescending(q => q.AnswerID).First()
    select firstAnswer
    

    编辑:Linq2Sql 将上述查询转换为 N+1 数据库调用。这个查询被翻译成一个 SQL 查询:

    from a in Answers
    group a by a.QuestionID into grouping
    join a2 in Answers on 
        new {AnswerID = grouping.Max(x => x.AnswerID), QuestionID = grouping.Key} 
        equals new {a2.AnswerID, a2.QuestionID}
    select a2
    

    让我想知道 Linq2Sql 应该比 SQL 更简单。

    【讨论】:

    • 应该是OrderByDescending?
    • 这个答案+1 - 我喜欢它的外观!有兴趣知道 - 它被翻译成的 SQL 是什么 - 它是一个带有子查询的查询吗?
    • 感谢您的回答。我运行了 LinqPad 语句,它检索到了我预期的结果。我还注意到系统中的每个问题都创建了一个 sql 语句。如果我有 100 个问题,那么将运行 100 个查询。
    • @Bar:尝试用Take(1)替换First()
    • @Bar,小伙子:或者把 in Answers 改成 in Answers.ToList()
    【解决方案3】:

    尝试使用这个查询:

    var query = from c in context.Childs
                group c by c.ParentEntityId into pc
                select pc.OrderByDescending(pcc => pcc.Id).Take(1);
    

    我刚刚检查了探查器中的查询,它产生了单个 SQL 查询(丑陋的):

    SELECT 
    [Project3].[ParentEntityId] AS [ParentEntityId], 
    [Project3].[C1] AS [C1], 
    [Project3].[Id] AS [Id], 
    [Project3].[Name] AS [Name], 
    [Project3].[ParentEntityId1] AS [ParentEntityId1]
    FROM ( SELECT 
        [Distinct1].[ParentEntityId] AS [ParentEntityId], 
        [Limit1].[Id] AS [Id], 
        [Limit1].[Name] AS [Name], 
        [Limit1].[ParentEntityId] AS [ParentEntityId1], 
        CASE WHEN ([Limit1].[Id] IS NULL) THEN CAST(NULL AS int) ELSE 1 END AS [C1]
        FROM   (SELECT DISTINCT 
            [Extent1].[ParentEntityId] AS [ParentEntityId]
            FROM [dbo].[ChildEntities] AS [Extent1] ) AS [Distinct1]
        OUTER APPLY  (SELECT TOP (1) [Project2].[Id] AS [Id], [Project2].[Name] AS [Name], [Project2].[ParentEntityId] AS [ParentEntityId]
            FROM ( SELECT 
                [Extent2].[Id] AS [Id], 
                [Extent2].[Name] AS [Name], 
                [Extent2].[ParentEntityId] AS [ParentEntityId]
                FROM [dbo].[ChildEntities] AS [Extent2]
                WHERE ([Distinct1].[ParentEntityId] = [Extent2].[ParentEntityId]) OR (([Distinct1].[ParentEntityId] IS NULL) AND ([Extent2].[ParentEntityId] IS NULL))
            )  AS [Project2]
            ORDER BY [Project2].[Id] DESC ) AS [Limit1]
    )  AS [Project3]
    ORDER BY [Project3].[ParentEntityId] ASC, [Project3].[C1] ASC
    

    【讨论】:

    • 同样会导致 N+1 个查询...奇怪
    • 对我来说,这个 LINQ 提供了多个查询,例如 SELECT TOP (1) [t0].[AnswerID], [t0].[QuestionID] FROM [Answers] AS [t0] WHERE ((@x1 IS NULL) AND ([t0].[QuestionID] IS NULL)) OR ((@x1 IS NOT NULL) AND ([t0].[QuestionID] IS NOT NULL) AND (@x1 = [t0].[QuestionID])) ORDER BY [t0].[AnswerID] DESC
    • 有趣。我正在针对 SQL Server 2008 使用实体框架。您的配置是什么?我可以想象将使用 Linq-to-Sql 运行多个查询,但我在 Linq-to-entities 中没有看到这一点。
    • 现在我看到您在回答中提到了 Linq-to-Sql。这两个是不同的野兽。 Linq-to-sql 以某种方式优化查询,并在运行单个或多个查询时自行决定。使用默认 SQL 提供程序的 Linq-to-entities 始终创建单个查询。
    • 我在 SQL2008R2 上使用 LinqPad,这样可以解释差异。 outer apply 和 top 1 的效率也很低,但看起来 EF 至少避免了往返!
    猜你喜欢
    • 2018-09-23
    • 2021-05-30
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    相关资源
    最近更新 更多