Question

我现在遇到一个问题，因为表已删除ID。

首先，我在下面的查询中，实体（表）“ RecordsProduct”具有映射到被告表的“ DefendnatId”。很好！

            records = records
                .Include(r => r.Employer)
                .Include(r => r.Contractor)
                .Include(r => r.RecordProducts)
                .ThenInclude(rp => rp.Defendant)
                .Where(r => EF.Functions.Like(r.Employer.DefendantCode, "%" + input.DefendantCode + "%")
                    || EF.Functions.Like(r.Contractor.DefendantCode, "%" + input.DefendantCode + "%")
                    || r.RecordProducts.Any(rp => EF.Functions.Like(rp.Defendant.DefendantCode, "%" + input.DefendantCode + "%") && rp.IsActive == true));

DefendantId已从表中删除，并由名为DefendantProductId的转换表中的ProductDefendant代替

ProductDefendant表：

DefendantProductId
DefendantId
ProductId

所以我不能再这样做了

rp.Defendant.DefendantCode

现在我必须这样做

rp.ProductDefendant.Defendant.DefendantCode

现在我的查询开始了！我可以做些什么来修改它以使其更快？还是更改联接的工作方式？

           records = records
                .Include(r => r.Employer)
                .Include(r => r.Contractor)
                .Include(r => r.RecordProducts)
                .ThenInclude(rp => rp.ProductDefendant.Defendant)
                .Where(r => EF.Functions.Like(r.Employer.DefendantCode, "%" + input.DefendantCode + "%")
                    || EF.Functions.Like(r.Contractor.DefendantCode, "%" + input.DefendantCode + "%")
                    || r.RecordProducts.Any(rp => EF.Functions.Like(rp.ProductDefendant.Defendant.DefendantCode, "%" + input.DefendantCode + "%")
                    && rp.IsActive == true));

这是下面生成的SQL。我认为问题出在“哪里”子句

SELECT [t].[Id], [t].[StartDate], [t].[EndDate], [t].[WitnessName], [t].[SourceCode], [t].[JobsiteName], [t].[ShipName], [t].[EmployerCode]
FROM (
    SELECT DISTINCT [r].[RecordID] AS [Id], [r].[StartDate], [r].[EndDate], [r.Witness].[FullName] AS [WitnessName], CASE
        WHEN [r].[SourceID] IS NOT NULL
        THEN [r.Source].[SourceCode] ELSE N'zzzzz'
    END AS [SourceCode], CASE
        WHEN [r].[JobsiteID] IS NOT NULL
        THEN [r.Jobsite].[JobsiteName] ELSE N'zzzzz'
    END AS [JobsiteName], CASE
        WHEN [r].[ShipID] IS NOT NULL
        THEN [r.Ship].[ShipName] ELSE N'zzzzz'
    END AS [ShipName], CASE
        WHEN [r].[EmployerID] IS NOT NULL
        THEN [r.Employer].[DefendantCode] ELSE N'zzzzz'
    END AS [EmployerCode]
    FROM [Records] AS [r]
    LEFT JOIN [Ships] AS [r.Ship] ON [r].[ShipID] = [r.Ship].[ShipID]
    LEFT JOIN [Jobsites] AS [r.Jobsite] ON [r].[JobsiteID] = [r.Jobsite].[JobsiteID]
    LEFT JOIN [Sources] AS [r.Source] ON [r].[SourceID] = [r.Source].[SourceID]
    LEFT JOIN [Witnesses] AS [r.Witness] ON [r].[WitnessID] = [r.Witness].[WitnessID]
    LEFT JOIN [Defendants] AS [r.Contractor] ON [r].[ContractorID] = [r.Contractor].[DefendantID]
    LEFT JOIN [Defendants] AS [r.Employer] ON [r].[EmployerID] = [r.Employer].[DefendantID]
    WHERE ([r].[IsActive] = 1) AND (([r.Employer].[DefendantCode] LIKE (N'%' + @__input_DefendantCode_1) + N'%' OR [r.Contractor].[DefendantCode] LIKE (N'%' + @__input_DefendantCode_3) + N'%') OR EXISTS (
        SELECT 1
        FROM [Records_Products] AS [rp]
        INNER JOIN [Product_Defendant] AS [rp.ProductDefendant] ON [rp].[DefendantProductID] = [rp.ProductDefendant].[DefendantProductID]
        INNER JOIN [Defendants] AS [rp.ProductDefendant.Defendant] ON [rp.ProductDefendant].[DefendantID] = [rp.ProductDefendant.Defendant].[DefendantID]
        WHERE ([rp.ProductDefendant.Defendant].[DefendantCode] LIKE (N'%' + @__input_DefendantCode_5) + N'%' AND ([rp].[IsActive] = 1)) AND ([r].[RecordID] = [rp].[RecordID])))
) AS [t]
ORDER BY [t].[SourceCode]
OFFSET @__p_6 ROWS FETCH NEXT @__p_7 ROWS ONLY

Answer 1

很难给您一个很好的建议，因为生成的SQL查询对于该模型而言看起来不错，并且如今的SQL查询优化器（CBO）不应像旧的RBO一样受到编写查询方式的影响（CBO代表Cost基于优化器，RBO-基于规则的优化器）。他们应该能够将EXISTS或IN变成JOIN（产生与JOIN相同的执行计划）。当前SQL与原始SQL之间的唯一区别是一个附加联接，该联接具有集群PK索引查找不会显着影响性能。

但是，既然您这样说，显然有一些未知因素导致CBO选择了错误的计划。而且由于该计划取决于我没有的数据，所以我所能做的就是建议尝试两个功能等效的替代查询。

首先，您当前的（慢速）查询看起来像这样：

var input = new { DefendantCode = "Abc", Skip = 4, Take = 2 };
var defendantCodePattern = "%" + input.DefendantCode + "%";

var query = db.Set<Record>()
    .Where(r => r.IsActive)
    .Where(r => EF.Functions.Like(r.Employer.DefendantCode, defendantCodePattern)
        || EF.Functions.Like(r.Contractor.DefendantCode, defendantCodePattern)
        || r.RecordProducts.Any(rp => EF.Functions.Like(rp.ProductDefendant.Defendant.DefendantCode, defendantCodePattern))
    )
    .Select(r => new
    {
        ID = r.RecordID,
        StartDate = r.StartDate,
        EndDate = r.EndDate,
        WitnessName = r.Witness.FullName,
        SourceCode = r.Source != null ? r.Source.SourceCode : "zzzzz",
        JobsiteName = r.Jobsite != null ? r.Jobsite.JobsiteName : "zzzzz",
        ShipName = r.Ship != null ? r.Ship.ShipName : "zzzzz",
        EmployeeCode = r.Employer != null ? r.Employer.DefendantCode : "zzzzz",
    })
    //.Distinct()
    .OrderBy(t => t.SourceCode)
    .Skip(input.Skip).Take(input.Take);

有些事情要提。首先，查询使用投影（Select），因此不需要Include / ThenInclude（因为它们是ignored）。其次，创建了通用搜索模式并将其存储在查询之外，因此以sing参数而不是3结尾。第三，此查询不需要Distinct，因此已将其删除。

现在有可能尝试提高生成的SQL查询的执行速度。

（1）如果Defendant相关表不大，则可以预取与搜索过滤器匹配的DefendantID，然后使用Contains（转换为SQL {{1} }）进行过滤，这将有助于消除某些联接。例如

IN

，然后（第二个var defendantIds = db.Set<Defendant>() .Where(d => EF.Functions.Like(d.DefendantCode, defendantCodePattern)) .Select(d => d.DefendantID) .ToList();）：

Where

（2）以下技巧将.Where(r => defendantIds.Contains(r.Employer.DefendantID) || defendantIds.Contains(r.Contractor.DefendantID) || r.RecordProducts.Any(rp => defendantIds.Contains(rp.ProductDefendant.Defendant.DefendantID)) )替换为EXISTS。将第二个LEFT JOIN替换为：

Where

并取消注释.SelectMany(r => r.RecordProducts.DefaultIfEmpty(), (r, rp) => new { r, rp }) .Where(x => EF.Functions.Like(x.r.Employer.DefendantCode, defendantCodePattern) || EF.Functions.Like(x.r.Contractor.DefendantCode, defendantCodePattern) || EF.Functions.Like(x.rp.ProductDefendant.Defendant.DefendantCode, defendantCodePattern) ) .Select(x => x.r)的注释（此处是必需的，因为.Distinct()（来自LEFT JOIN）乘以源记录。在这种情况下，生成的SQL如下所示：

SelectMany

正如我一开始所说，通常这不应影响CBO计划。但是我肯定会看到与原始计划不同的估计执行计划，因此值得尝试（尽管LINQ查询看起来很丑）。

重新映射表后修改实体框架表达式

1 个答案: