Question

我有一个来自旧应用程序的查询，我试图将其转换为Entity Framework Core应用程序。我正在处理的关系是一对多的简单关系，其中一个Order可以具有许多OrderEvent。旧查询看起来像这样：

select Order.Id, mostRecent.*
from Order
left join OrderEvent mostRecent 
on mostRecent.Id in (select top(1) Id 
                     from OrderEvent
                     where OrderEvent.OrdId = Order.Id 
                           and OrderEvent.PostDateTime is not null
                     order by OrderEvent.PostDateTime desc)
where Order.SomeColumn = 'some value'

我正在努力弄清楚如何在LINQ中编写此查询。似乎在使用equals时不能使用join以外的任何东西，因此我首先尝试了以下方法：

var test = (from order in _context.Ord.AsNoTracking()
            join mostRecentQuery in _context.OrdEvt.AsNoTracking()
            on (from orderEvent in _context.OrdEvt.AsNoTracking()
                where orderEvent.PostDateTime != null && orderEvent.OrdId == order.Id
                orderby orderEvent.PostDateTime descending
                select orderEvent.Id).FirstOrDefault()
            equals mostRecentQuery.Id
            into mostRecentResults
            from mostRecent in mostRecentResults.DefaultIfEmpty()
            select new
            {
               OrderId = order.Id,
               OrderEvent = mostRecent
            }).ToList();

无论这个SQL吐出什么，它看起来都太慢了，我什至无法运行它连接到Sql Server。但是，使用Sqlite时我可以运行此查询，并且它会生成以下sql：

SELECT 'big list of fields....'
  FROM "Ord" AS "order"
  LEFT JOIN "OrdEvt" AS "mostRecentQuery" ON COALESCE((
      SELECT "orderEvent0"."Id"
      FROM "OrdEvt" AS "orderEvent0"
      WHERE "orderEvent0"."PostDateTime" IS NOT NULL AND ("orderEvent0"."OrdId" = "order"."Id")
      ORDER BY "orderEvent0"."PostDateTime" DESC
      LIMIT 1
  ), X'00000000000000000000000000000000') = "mostRecentQuery"."Id"

这很接近我要做什么，但是我不确定为什么要使用COALESCE函数。

是否可以用Linq查询语法表示我要转换的查询？

Answer 1

我不确定您的问题是什么，因为您忽略了为什么它无法编译。

这里有一个简单的示例，它加入了联接并为订单选择一个事件：

public class Order
{
    public int OrderId { get; set; }
    public string OrderName { get; set; }
}

public class OrderEvent
{
    public int OrderId { get; set; }
    public string EventName { get; set; }
    public DateTime Date { get; set; }
}

public static void Main(string[] args) // Here our Exe-Args are delivered to our program..
{

    List<Order> orders = new List<Order>()
    {
        new Order() { OrderId = 1, OrderName = "One" }
    };
    List<OrderEvent> orderEvents = new List<OrderEvent>()
    {
        new OrderEvent() { OrderId = 1, EventName = "EventTwo", Date = DateTime.Now.AddHours(-1) },
        new OrderEvent() { OrderId = 1, EventName = "EventOne", Date = DateTime.Now },
        new OrderEvent() { OrderId = 1, EventName = "EventThree", Date = DateTime.Now.AddHours(-2) },
        new OrderEvent() { OrderId = 2, EventName = "EventX", Date = DateTime.Now },
    };

    var tmp = orders.GroupJoin( // Join something to our orders
            orderEvents, // join all events
            o => o.OrderId, // key of our order
            e => e.OrderId, // foreign-key to order in our event
            (o, es) => // lambda-expression "selector". One order "o" and multiple events "es"
            es.OrderByDescending(e => e.Date) // We order our events
            .Select(s => new // we build a new object
            {
                OrderId = o.OrderId,
                OrderName = o.OrderName,
                RecentEvent = s.EventName
            }).First()); // we choose the object with biggest date (first after orderDesc)

    foreach (var item in tmp)
    {
        Console.WriteLine(item.OrderId + ", " + item.OrderName + ", " + item.RecentEvent);
    }

    tmp = from o in orders
               join e in orderEvents on o.OrderId equals e.OrderId into es
               select new
               {
                   OrderId = o.OrderId,
                   OrderName = o.OrderName,
                   RecentEvent = (from x in es orderby x.Date descending select x.EventName).First()
               };

    foreach (var item in tmp)
    {
        Console.WriteLine(item.OrderId + ", " + item.OrderName + ", " + item.RecentEvent);
    }
}

Linq查询使用In子句联接到子查询

1 个答案: