Styjun

I'm building an API that allows the end-user to specify the sort on a list of data, returning paginated results. For example, an API request might specify a sort of name: :asc, id: :asc, or age: :desc, id: :desc. In the implementation, I'm trying to use the row-value syntax for selecting subsequent pages from an existing Ecto query.

In Rails, this is easy — just interpolate a string and splat some arguments:

# @param [ActiveRecord::Relation] rel
def slice_query(rel, cursor_params)
 # A little hand-waving
 operator, comparisons = parse_params(cursor_params)
 # Suppose `operator` is `<` and comparisons looks like `name: "Last Row Value", id: "last-row-value"
 fragment = "(#comparisons.keys.join(',')) #operator (#comparisons.size.times.map '?' .join(','))"
 # fragment in this case should look like "(name, id) < (?, ?)"
 rel.where(fragment, *comparisons.values)
end

As an Ecto/Elixir newbie, I'm at a loss for how to do this with Ecto. The docs seem to indicate that custom fragments can be implemented via macros, but I'm at a loss for how to dynamically interpolate runtime values into a macro-based implementation.

I've tried something like this:

def slice_query(query, cursor_params)
 # More hand-waving; `parse_params` is a bit of pseudocode.
 # Full source is below
 operator, comparisons = parse_params(cursor_params)
 query |> where(row_value_comparison(operator, comparisons)
end

In particular, operator is a binary string, and comparisons is the result of an Enum.map.

Using row_value_comparison from here, but I've run into various compiler complaints depending on how I interpolate (or don't interpolate) operator and comparisons into that macro invocation:

• 
  query |> where(row_value_comparison(operator, comparisons) yields protocol Enumerable not implemented for :comparisons, [line: 114], nil
  


• 
  query |> where(row_value_comparison(operator, ^comparisons) yields protocol Enumerable not implemented for :^, [line: 114], [:comparisons, [line: 114], nil]
  


• 
  query |> where(row_value_comparison(operator, unquote(comparisons))) yields variable "comparisons" does not exist and is being expanded to "comparisons()", please use parentheses to remove the ambiguity or change the variable name
  


• 
  query |> where(row_value_comparison(comparator, unquote(^comparisons))) yields cannot use ^comparisons outside of match clauses
  

Full module source, as requested in comments:

defmodule MyProject.Resolvers.Connection do
 import Ecto.Query
 alias MyProject.Repo

 # `cursor_params` should be a Map containing either
 # :after (and optionally :first) (to paginate forward), or
 # :before (and optionally :last) (to paginate backwards).
 # :after or :before should be parsed Cursors.
 #
 # This method implements ApplyCursorsToEdges according to the spec:
 # https://facebook.github.io/relay/graphql/connections.htm#sec-Arguments
 def paginate_with_results(query, cursor_params) do
 total_count = query_count(query)
 query = slice_query(query, cursor_params)
 has_previous_page, has_next_page = query_page_info(query, cursor_params)
 query = limit_results(query, cursor_params)

 %
 results: Repo.all(query),
 page_info: %
 total_count: total_count,
 has_next_page: has_next_page,
 has_previous_page: has_previous_page
 
 
 end

 defp order_bys(query) do
 query.order_bys
 |> Enum.map(fn %Ecto.Query.QueryExprexpr: expr ->
 expr
 |> Enum.map(fn dir, ast ->
 > Macro.to_string()
 
 end)
 end)
 |> List.first()
 end

 defp single_sort_direction?(query) do
 directions = order_bys(query) |> Enum.map(fn dir, _ -> dir end) |> Enum.uniq()
 if Enum.count(directions) == 1, do: Enum.at(directions, 0), else: false
 end

 defp query_count(query) do
 query |> select([x], count(x.id)) |> Repo.one()
 end

 # https://elixirforum.com/t/building-an-ecto-macro-to-generate-a-row-value/19680/2
 defmacro row_value_comparison(operation, comparisons) do
 # when is_binary(operation) and is_list(comparisons) do
 question_marks = Enum.map(comparisons, fn _ -> "?" end) |> Enum.join(", ")
 frag_text = "(#question_marks) #operation (#question_marks)"

 frag_arguments =
 comparisons
 |> Enum.unzip()
 |> Tuple.to_list()
 |> List.flatten()

 quote do
 fragment(unquote(frag_text), unquote_splicing(frag_arguments))
 end
 end

 defp slice_query(query, cursor_params) do
 sort_descriptors = order_bys(query)

 query =
 if Map.has_key?(cursor_params, :after) do
 after_cursor = cursor_params.after

 if direction = single_sort_direction?(query) do
 comparator = if direction == :asc, do: ">", else: "<"

 comparisons =
 Enum.map(sort_descriptors, fn _dir, field ->
 field, after_cursor.sort_values[field]
 end)

 query |> where(row_value_comparison(comparator, unquote(comparisons)))
 else
 # TODO: Handle multi-direction sort
 query
 end
 end
 # Etc
 end
end