Question

我有一个包含这些实体的数据库：

public class User
{
   public GUID UserId { get; set;}
   public IEnumerable<Item> items { get; set;}
} 

public class Item
{
   public GUID ItemId { get; set;}
   public GUID ownerId { get; set;}
   public int boughtCount{ get; set;}
}

我需要返回按购买项目排序的商品的用户列表。

例如，如果我们有这样的用户：

A: userId: ..
   items: 1. itemId: .. | boughtCount: 2
          2. itemId: .. | boughtCount: 1

B: userId: ..
   items: 1. itemId: .. | boughtCount: 7

C: userId: ..
   items: 1. itemId: .. | boughtCount: 3

D: userId: ..
   items: none

查询需要按以下顺序返回用户：B，C，A（D不会返回，因为他没有任何项目）

我使用以下查询：

users = await _context.Items.OrderByDescending(c => c.BoughtCount)
                    .Join(_context.Users,
                           i => i.OwnerId,
                           u => u.Id,
                           (i, u) => new { i, u })
                    .OrderByDescending(x => x.i.BoughtCount)
                    .Select(x => x.u)
                    .Distinct()
                    .Skip(skip)
                    .Take(take)
                    .Include(u => u.Items)
                    .ToListAsync();

此查询以正确的顺序返回用户，但我的问题是，对于每个用户，它返回最多15个他拥有的项目，因此如果例如用户A将有30个项目，我将只获得他的前15个

这15项限制是多少？

我做了什么导致这个限制的事情，或者它只是＆＃34;硬编码＆＃34;某处？

如果是，我该如何删除/更改限制？

注意：我的sql数据库托管在Azure中。

更新这是我的linq查询生成的sql查询：

 SELECT [I].[ItemId], [I].[ownerId], [I].[boughtCount]
  FROM [Items] AS [I]
  INNER JOIN (
      SELECT DISTINCT [t0].*
      FROM (
          SELECT DISTINCT [u].[UserId]
          FROM [Items] AS [I]
          INNER JOIN [User] AS [u] ON [c].[ownerId] = [u].[UserId]
          ORDER BY [u].[UserId]
          OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY
      ) AS [t0]
  ) AS [u] ON [I].[ownerId] = [u].[UserId]

谢谢！

实体框架 - .Include不会加载所有记录

0 个答案: