The implementation is currently checking for the presence of a limit in the query.

When a limit is applied, the query used to load the association is run in a lateral subquery, which would have the effect of applying the distinct separately to each parent .

If you’d like to send a PR that ensures distinct queries are always applied per-parent, the code that needs updating is: here and here

Amazing, that’s great to hear! As far as a pattern for implementing this goes, would you do something like the following:

    field :views, list_of(:view) do
      arg(:limit, type: :integer)
      arg(:order, type: :sort_order, default_value: :desc)

      resolve(dataloader(Scribe.Analytics))
    end

then in Scribe.Analytics (the context module) have:

  def query(View, args) do
    view_query(args)
  end

  defp view_query(args) do
    Enum.reduce(args, View, fn
      {:order, order}, query ->
        query |> order_by({^order, :inserted_at})
      {:limit, limit_to}, query ->
         query |> limit(limit_to)
    end)
  end

I think that should work fine!

Sorry for the slow response! @mbuhot I’ve just modified the code to ensure the query used to load the association always runs in a lateral join but I don’t really know enough to know if it is correct.

Why did you only apply the lateral join subquery when we detected the presence of limit? Is it safe to run it for every query type?