具有左联接的LINQ和sql查询并选择max子查询

Question

I have a database table named Engine (EngineId, Make, Model, SerialNumber, etc.) and a table named Test (TestId, EngineId, TestDate, Value1, Value2, etc.). I want to select each engine record plus the latest test results (if any, might be none).

I am using ASP.NET Core 1.1 and Entity Framework and I have Engine and Test model entities.

I am trying to convert the following SQL to a LINQ query expression:

SELECT e.*, t.Value1, t.Value2
FROM Engine e
LEFT JOIN Test t on e.EngineID = t.EngineID
AND t.TestDate= (SELECT MAX(TestDate) FROM Test t2)

I can get started with the left join but I don't see how to do the subquery:

var engines = from e in _context.Engine
              join t in _context.Test on e.EngineId equals t.EngineId into td
              from c in td.DefaultIfEmpty()
              select new EngineVM
              {
                  EngineId = e.EngineId,
                  Unit = e.Unit,
                  Make = e.Make,
                  Model = e.Model,
                  SerialNumber = e.SerialNumber
              };

Here is my view model:

public class EngineVM
{
    public long EngineId { get; set; }
    public string Make { get; set; }
    public string Model { get; set; }
    public string SerialNumber { get; set; }
    public decimal? LastTestValue1 { get; set; }
    public decimal? LastTestValue2 { get; set; }
}

Update

Here was the solution:

var lastTestQuery = _context.Test
        .FromSql(@"
            SELECT t.* FROM Test t
            WHERE t.TestDate = (SELECT MAX(t2.TestDate) FROM Test t2
            WHERE t2.EngineId = t.EngineId)"
        );

// Query to get engine records to display along with last test data
var engines = (from e in _context.Engine
               orderby e.SerialNumber
               join t in lastTestQuery on e.EngineId equals t.EngineId into lastEngineTest
               from t in lastEngineTest.DefaultIfEmpty()  // forces left join
               let lastTest = (from x in lastEngineTest select x).FirstOrDefault()
               select new EngineVM
               {
                   EngineId = e.EngineId,
                   Unit = e.Unit,
                   Make = e.Make,
                   Model = e.Model,
                   SerialNumber = e.SerialNumber,
                   Status = CalculateEngineStatus(e.EngineId,
                                                  e.PermittedNox,
                                                  lastTest.Nox)
               }).OrderByDescending(x => x.Status);

Answer 1

I managed to generate a single query by using the FromSql mechanism in EF Core Looks like this is the way to go for subqueries :( if you want to run as much as possible via the SQL Engine

var lastTestQuery = _context.Test
    .FromSql(@"
        SELECT t.* FROM Test t
        WHERE t.TestDate = (SELECT MAX(t2.TestDate) FROM Test t2 WHERE t2.EngineId = t.EngineId)"
    );

var enginesWithLastTest = _context.Engine
    .GroupJoin(lastTestQuery, engine => engine.EngineId, test => test.EngineId, (engine, tests) => new {
        Engine = engine,
        LastTests = tests.DefaultIfEmpty()
    })
    .ToList();

foreach (var item in enginesWithLastTest)
{
    var eng = item.Engine;
    var test = item.LastTests.FirstOrDefault();
    Console.WriteLine($"{eng.EngineId} {eng.Make} {eng.Model} {eng.SerialNumber} {test?.TestValue}");
}

Looking into SQL Server Profiler, this is the generated query:

SELECT [engine].[EngineId],
        [engine].[AllowedAmount],
        [engine].[Make],
        [engine].[Model],
        [engine].[SerialNumber],
        [test].[TestId],
        [test].[EngineId],
        [test].[TestDate],
        [test].[TestValue]
FROM [Engine] AS [engine]
LEFT JOIN 
    (SELECT t.*
    FROM Test t
    WHERE t.TestDate = 
        (SELECT MAX(t2.TestDate)
        FROM Test t2
        WHERE t2.EngineId = t.EngineId) ) AS [test]
        ON [engine].[EngineId] = [test].[EngineId]
ORDER BY  [engine].[EngineId]

A pure LINQ query expressions approach (no lambdas), and without FromSQL

Featuring:

• Single SQL Query (check below... my be not the best SQL but there you are)
• Single LINQ expression (long but... there you go again)

Here's the code:

var query =
    from engine in _context.Engine
    join test in (
        from t in _context.Test
        where t.TestDate == (from t2 in _context.Test where t2.EngineId == t.EngineId select t2.TestDate).Max()
        select t
    ) on engine.EngineId equals test.EngineId into td
    from latestTest in td.DefaultIfEmpty()
    orderby engine.SerialNumber ascending
    select new EngineVM {
        EngineId = engine.EngineId,
        Make = engine.Make,
        Model = engine.Model,
        SerialNumber = engine.SerialNumber,
        LastTestValue1 = latestTest != null ? (decimal?) latestTest.TestValue : null
    };

var enginesWithLastTest = query.ToList();

foreach (var eng in enginesWithLastTest)
{
    Console.WriteLine($"{eng.EngineId} {eng.Make} {eng.Model} {eng.SerialNumber} {eng.LastTestValue1}");
}

And the generated SQL:

SELECT [engine].[EngineId], [engine].[AllowedAmount], [engine].[Make], [engine].[Model], [engine].[SerialNumber], [t1].[TestId], [t1].[EngineId], [t1].[TestDate], [t1].[TestValue]
FROM [Engine] AS [engine]
LEFT JOIN (
    SELECT [t0].[TestId], [t0].[EngineId], [t0].[TestDate], [t0].[TestValue]
    FROM [Test] AS [t0]
    WHERE [t0].[TestDate] = (
        SELECT MAX([t20].[TestDate])
        FROM [Test] AS [t20]
        WHERE [t20].[EngineId] = [t0].[EngineId]
    )
) AS [t1] ON [engine].[EngineId] = [t1].[EngineId]
ORDER BY [engine].[SerialNumber], [engine].[EngineId]

Note2: Always check the SQL execution plan when you compose a LINQ monster. You might be better off running two queries and building a dictionary

Note: I'm eager to hear feedback and improvements on this answer. I'm just starting with EF Core myself

Answer 2

LINQ Join

var listOfEnginesWithTestData = engineList.Join(testList,
                                     engine => engine.EngineID,
                                     test => test.EngineID,
                                     (engine, test) => new
                                     {
                                         Engine = engine,
                                         Test = test
                                     }).Select(x => new { x.Engine, x.Test.Value1, x.Test.Value2 }).ToList();

Explaination

This code snippet performs the following:

1. Use Join to combine the two tables on a matching EngineId .
2. Use Select to select only the values you're seeking from the combined data: Engine , Test.Value1 and Test.Value2

Sample Console App

Here is a sample Console App that uses List s. You are querying a database, and your code will look slightly different.

using System;
using System.Collections.Generic;
using System.Linq;

namespace SQLLeftJoin
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            var engineList = new List<Engine>
            {
                new Engine{ EngineID = "1"},
                new Engine{ EngineID = "2"},
                new Engine{ EngineID = "3"}
            };

            var testList = new List<Test>
            {
                new Test{TestID = "1", EngineID = "1", TestDate = DateTime.Now},
                new Test{TestID = "2", EngineID = "1", TestDate = DateTime.Now},
                new Test{TestID = "3", EngineID = "2", TestDate = DateTime.Now},
                new Test{TestID = "4", EngineID = "2", TestDate = DateTime.Now},
                new Test{TestID = "5", EngineID = "3", TestDate = DateTime.Now},
                new Test{TestID = "6", EngineID = "3", TestDate = DateTime.Now},
                new Test{TestID = "7", EngineID = "3", TestDate = DateTime.Now},
            };

            var listOfEnginesWithTestData = engineList.Join(testList,
                                             engine => engine.EngineID,
                                             test => test.EngineID,
                                             (engine, test) => new
                                             {
                                                 Engine = engine,
                                                 Test = test
                                             }).Select(x => new { x.Engine, x.Test.Value1, x.Test.Value2 }).ToList();
        }
    }

    class Engine
    {
        public string EngineID { get; set; }
    }

    class Test
    {
        public string TestID { get; set; }
        public string EngineID { get; set; }
        public DateTime TestDate { get; set; }
        public object Value1 { get; set; }
        public object Value2 { get; set; }
    }
}

Answer 3

try Code:

DateTime maxTastdate=db.Test.Max(c=>c.TestDate);
var result=( from e in db.Engine 
             join t in db.Test.where(c=>c.TestDate=maxTastdate)
             on e.EngineID  equlas t.EngineID into jj from kk in jj.DefaultIfEmpty()
             select new {
                           EngineId=e.EngineId,
                           Make=e.Make,
                           Model=e.Model,
                           SerialNumber=e.SerialNumber
                           Value1=kk.Value1,
                           Value2=kk.Value2
                        }).Tolist()