这个关于查找丢失键的查询可以改进吗？ （SQL 或 LINQ）

Question

我正在开发一个 ASP.NET MVC 网站，并且正在寻找一种方法来改进这个例程。它可以在 LINQ 级别或 SQL Server 级别进行改进。我希望我们最多可以在一个查询调用中完成。

以下是涉及的表格和一些示例数据：

我们没有限制每个Key 必须有每个LanguageId 值，实际上业务逻辑不允许这样的限制。但是，在应用程序级别，我们想警告管理员密钥缺少一个/某些语言值。所以我有这个类和查询：

public class LocalizationKeyWithMissingCodes
{
    public string Key { get; set; }
    public IEnumerable<string> MissingCodes { get; set; }
}

此方法获取密钥列表，以及任何缺失的代码（例如，如果我们有 en + jp + ch 语言代码，并且密钥只有 en + ch 的值，则列表将包含 jp）：

    public IEnumerable<LocalizationKeyWithMissingCodes> GetAllKeysWithMissingCodes()
    {
        var languageList = Utils.ResolveDependency<ILanguageRepository>().GetActive();
        var languageIdList = languageList.Select(q => q.Id);
        var languageIdDictionary = languageList.ToDictionary(q => q.Id);

        var keyList = this.GetActive()
            .Select(q => q.Key)
            .Distinct();

        var result = new List<LocalizationKeyWithMissingCodes>();
        foreach (var key in keyList)
        {
            // Get missing codes
            var existingCodes = this.Get(q => q.Active && q.Key == key)
                .Select(q => q.LanguageId);

            // ToList to make sure it is processed at application
            var missingLangId = languageList.Where(q => !existingCodes.Contains(q.Id))
                .ToList();
            result.Add(new LocalizationKeyWithMissingCodes()
            {
                Key = key,
                MissingCodes = missingLangId
                    .Select(q => languageIdDictionary[q.Id].Code),
            });
        }

        result = result.OrderByDescending(q => q.MissingCodes.Count() > 0)
            .ThenBy(q => q.Key)
            .ToList();

        return result;
    }

我认为我当前的解决方案不好，因为它对每个键进行查询调用。有没有办法改进它，或者让它更快，或者在一个查询调用中打包？

编辑：这是答案的最终查询：

    public IQueryable<LocalizationKeyWithMissingCodes> GetAllKeysWithMissingCodes()
    {
        var languageList = Utils.ResolveDependency<ILanguageRepository>().GetActive();
        var localizationList = this.GetActive();

        return localizationList
            .GroupBy(q => q.Key, (key, items) => new LocalizationKeyWithMissingCodes()
            {
                Key = key,
                MissingCodes = languageList
                    .GroupJoin(
                        items,
                        lang => lang.Id,
                        loc => loc.LanguageId,
                        (lang, loc) => loc.Any() ? null : lang)
                    .Where(q => q != null)
                    .Select(q => q.Code)
            }).OrderByDescending(q => q.MissingCodes.Count() > 0) // Show the missing keys on the top
            .ThenBy(q => q.Key);
    }

Answer 1

另一种可能性，使用 LINQ：

public IEnumerable<LocalizationKeyWithMissingCodes> GetAllKeysWithMissingCodes(
    List<Language> languages,
    List<Localization> localizations)
{
    return localizations
        .GroupBy(x => x.Key, (key, items) => new LocalizationKeyWithMissingCodes
        {
            Key = key,
            MissingCodes = languages
                .GroupJoin( // check if there is one or more match for each language
                    items,
                    x => x.Id,
                    y => y.LanguageId,
                    (x, ys) => ys.Any() ? null : x)
                .Where(x => x != null) // eliminate all languages with a match
                .Select(x => x.Code) // grab the code
        })
        .Where(x => x.MissingCodes.Any()); // eliminate all complete keys 
}

Answer 2

以下是用于识别缺少“完整”语言分配的键的 SQL 逻辑：

SELECT
    all.[Key],
    all.LanguageId
FROM
    (
    SELECT
        loc.[Key],
        lang.LanguageId
    FROM
        Language lang
    FULL OUTER JOIN
        Localization loc
        ON (1 = 1)
    WHERE
        lang.Active = 1
    ) all
LEFT JOIN
    Localization loc
    ON (loc.[Key] = all.[Key])
    AND (loc.LanguageId = all.LanguageId)
WHERE
    loc.[Key] IS NULL;

查看所有键（而不是过滤）：

SELECT
    all.[Key],
    all.LanguageId,
    CASE WHEN loc.[Key] IS NULL THEN 1 ELSE 0 END AS Flagged
FROM
    (
    SELECT
        loc.[Key],
        lang.LanguageId
    FROM
        Language lang
    FULL OUTER JOIN
        Localization loc
        ON (1 = 1)
    WHERE
        lang.Active = 1
    ) all
LEFT JOIN
    Localization loc
    ON (loc.[Key] = all.[Key])
    AND (loc.LanguageId = all.LanguageId);

Answer 3

您的代码似乎在进行大量的数据库查询和具体化..

就 LINQ 而言，单个查询看起来像这样......

我们采用语言和本地化表的笛卡尔积来获得 (key, code) 的所有组合，然后减去关系中存在的 (key, code) 元组。这给了我们不存在的（键，代码）组合。

var result = context.Languages.Join(context.Localizations, lang => true, 
loc => true, (lang, loc) => new { Key = loc.Key, Code = lang.Code })
.Except(context.Languages.Join(context.Localizations, lang => lang.Id, 
loc => loc.LanguageId, (lang, loc) => new { Key = loc.Key, Code = lang.Code }))
.GroupBy(r => r.Key).Select(r => new LocalizationKeyWithMissingCodes 
{ 
 Key = r.Key, 
 MissingCodes = r.Select(kc => kc.Code).ToList()
})
.ToList()
.OrderByDescending(lkmc => lkmc.MissingCodes.Count())
.ThenBy(lkmc => lkmc.Key).ToList();

附言我在旅途中输入了这个 LINQ 查询，所以如果它有语法问题，请告诉我.. 查询的要点是我们采用笛卡尔积并减去匹配的行。