不以指数方式加入所有内容的最佳方法是什么？

Question

我在 Linq To SQL、.Net Core 3.1.1 中有这个查询。

我想先过滤客户，然后然后对组和角色进行连接，这是非常不言自明的，这可能会占用大量资源：

await (from customer in _dbContext.Customers
    let groupIds = _dbContext.Groups.Where(x => x.CustomerId == customer.Id).Select(x => x.Id)
    let roleIds = _dbContext.Roles.Where(x => x.CustomerId == customer.Id).Select(x => x.Id)

    where customer.Id == customerId
    select new ResultViewModel
    {
        GroupIds = groupIds.ToList(),
        RoleIds = roleIds.ToList(),
    }).FirstOrDefaultAsync();

当我查看控制台时，我看到它被翻译成这个 SQL 查询：

  SELECT [t].[Id], [g].[Id], [r].[Id], 
  FROM (
      SELECT TOP(1) [c].[Id]
      FROM [Customer] AS [c]
      WHERE [c].[Id] = @__customerId_0
  ) AS [t]
  LEFT JOIN [Group] AS [g] ON [t].[Id] = [g].[CustomerId]
  LEFT JOIN [Role] AS [r] ON [t].[Id] = [r].[CustomerId]

  ORDER BY [t].[Id], [g].[Id], [r].[Id],

这个查询使我的数据库爆炸。当我在 Azure Data studio 中运行它时，我看到连接使结果数据呈指数级复杂化，因为我得到了每个组和角色的可能组合。机器上的过滤有助于减少结果，并在最后应用。 Azure Data Studio 的状态栏显示涉及百万行，尽管它应该只有几千。

这甚至不是真正的查询。在真实的情况下，我不是只加入角色和组，而是加入其他 8 个领域。

作为测试，我运行这个和它立即运行s :

var customer = _dbContext.Customers.Where(c => c.Id == customerId);
var groupIds = _dbContext.Groups.Where(r => r.CustomerId == customerId).Select(x => x.Id);
var roleIds = _dbContext.Roles.Where(r => r.CustomerId == customerId).Select(x => x.Id);

return new ResultViewModel
{
    GroupIds = groupIds.ToList(),
    RoleIds = roleIds.ToList(),
};

但这并不是一个真正可以接受的解决方案，因为它是 3 个查询（即来自我后端的 3 个数据库连接）而不是一个。

我猜这只是我错误地编写了原始 Ling To Sql 查询的问题。我做错了什么？如何避免那些不必要的连接？

Answer 1

不经过client-sidepost处理就没有快速解。所以，建议快点。

class ConcatSet
{
   public int? GroupId;
   public int? RoleId;
}

var groupIds = _dbContext.Groups.Where(r => r.CustomerId == customerId)
  .Select(x => new ConcatSet { GroupId = x.Id } );

var roleIds  = _dbContext.Roles.Where(r => r.CustomerId == customerId)
  .Select(x => new ConcatSet { RoleId = x.Id } );

var rawData = groupIds.Concat(roleIds).ToList();

// for sure the following lists can be generated more effective by just enumerating rawdData
return new ResultViewModel
{
    GroupIds = rawData.Where(r => r.GroupId != null).Select(r => r.GroupId.Value).ToList(),
    RoleIds  = rawData.Where(r => r.RoleId != null).Select(r => r.RoleId.Value).ToList(),
};

你有一次数据库往返，它应该是最快的变体。

不以指数方式加入所有内容的最佳方法是什么？

What's the best way to not join on everything exponentially?

linq

.net-core

linq-to-sql