Question

（编辑：添加了数据库表示形式并更新了试用版）

在我们的数据库中，有一个成员和一个成员身份模式。会员有许多会员资格。成员资格具有开始日期和结束日期的字段。我正在尝试查询具有多个成员资格的那些成员，并选择这些成员资格的开始日期和结束日期。我的问题是，有没有一种方法可以在不使用preload / 3函数的情况下一次查询调用？

我们的数据库可以用元组表示：

# {Membership.member_id, Membership.start_date, Membership.end_date}

[
  {1, ~D[2019-03-12], ~D[2020-03-11]},
  {1, ~D[2019-04-05], ~D[2020-04-04]},
  {3, ~D[2019-04-25], ~D[2020-04-24]},
  {3, ~D[2020-06-12], ~D[2021-06-12]}
]

我尝试做

Repo.all from m in Member,
      left_join: s in assoc(m, :memberships),
      group_by: [s.start_date, s.end_date],
      having: count(s) > 1,
      select: {s.start_date, s.end_date}

# Output: [{~D[2019-04-25], ~D[2020-04-24]}]

但是它给我的只是数据库中的第三个元素。

这些是我当前正在使用的两个查询：

member_ids =
      Repo.all from m in Member,
      left_join: s in assoc(m, :memberships),
      group_by: s.member_id,
      having: count(s) > 1,
      select: s.member_id

# Output: [1, 3]

data =
      Repo.all from m in Member,
      left_join: s in assoc(m, :memberships),
      where: m.id in ^member_ids,
      select: {s.start_date, s.end_date}

# Output:
# [
#   {~D[2019-04-05], ~D[2020-04-04]},
#   {~D[2019-03-12], ~D[2020-03-11]},
#   {~D[2019-04-25], ~D[2020-04-24]},
#   {~D[2020-06-12], ~D[2021-06-12]}
# ]

预期结果将是一个元组列表，例如：

[
  {~D[2019-03-12], ~D[2020-03-11]},
  {~D[2019-04-05], ~D[2020-04-04]},
  {~D[2019-04-25], ~D[2020-04-24]},
  {~D[2020-06-12], ~D[2021-06-12]}
]

Answer 1

您可以结合使用array_agg和unnest函数来获得所需的结果。

根据提供的信息，您似乎不需要连接members表即可实现：在memberships上进行查询就足够了。

一个纯SQL查询来获得与您提供的结果非常相似的结果将是这样：

# select unnest(array_agg((start_date, end_date))) from memberships group by member_id having count(1) > 1;
         unnest
-------------------------
 (2019-03-12,2020-03-11)
 (2019-04-05,2020-04-04)
 (2019-04-25,2020-04-24)
 (2020-06-12,2021-06-12)
(4 rows)

如您所见，这里的每一行都是记录类型。但是，如果将其翻译为Ecto，我们将完全得到您概述的内容：

iex(1)> import Ecto.Query
Ecto.Query
iex(2)> query =
...(2)>   from m in "memberships",
...(2)>     having: count(1) > 1,
...(2)>     group_by: m.member_id,
...(2)>     select: fragment("unnest(array_agg((?, ?)))", m.start_date, m.end_date)
#Ecto.Query<from m0 in "memberships", group_by: [m0.member_id],
 having: count(1) > 1,
 select: fragment("unnest(array_agg((?, ?)))", m0.start_date, m0.end_date)>
iex(3)> Repo.all(query)
11:21:51.490 [debug] QUERY OK source="memberships" db=3.4ms
SELECT unnest(array_agg((m0."start_date", m0."end_date"))) FROM "memberships" AS m0 GROUP BY m0."member_id" HAVING (count(1) > 1) []
[
  {~D[2019-03-12], ~D[2020-03-11]},
  {~D[2019-04-05], ~D[2020-04-04]},
  {~D[2019-04-25], ~D[2020-04-24]},
  {~D[2020-06-12], ~D[2021-06-12]}
]
iex(4)>

如果您需要加入members表（例如进行某些记录资格），您仍然可以使用建议的方法来做到这一点。例如：

  select unnest(array_agg((start_date, end_date)))
    from memberships
    join members on members.id = memberships.member_id
   where members.active
group by member_id
  having count(1) > 1;

以Ecto表示的等效查询如下：

from m in "memberships",
  join: member in "members", on: member.id == m.member_id,
  having: count(1) > 1,
  where: member.active,
  group_by: m.member_id,
  select: fragment("unnest(array_agg((?, ?)))", m.start_date, m.end_date))

在Ecto查询中使用hading / 3导致select / 3出现问题

1 个答案: