Building a dynamic query using ecto's `dynamic` macro

The solution here is Enum.map, Enum.reduce/2 over Enum.reduce/3:

params
|> Enum.map(fn 
  {"author", value} -> dynamic([p], p.author == ^value)
end)
|> Enum.reduce(fn a, b -> dynamic(^a and ^b) end)

Nice!!! Thank you so much @LostKobrakai!

Macros look so magical sometimes …
So all that was needed was to build a list of dynamic conditions through map and reducing them into a single dynamic expression.

One more question building on this. I adjusted the code like this following your suggestion:

defmodule MyMacro4Test do
  use ExUnit.Case, async: true
  import Ecto.Query

  def filter_where(params) do
    Enum.map(params, fn
      {"author", value} -> dynamic([p], p.author == ^value)
      {"category", value} -> dynamic([p], p.category == ^value)
      {"title", value} -> dynamic([p], p.title == ^value)
    end)
    |> Enum.reverse()
    |> Enum.reduce(fn a, b -> dynamic(^a and ^b) end)
  end

  @q from(p in "post")

  test "author" do
    query = %{"author" => "foo"}
    assert inspect(where(@q, ^filter_where(query))) ==
             inspect(where(@q, [p], p.author == ^query["author"]))

    query = %{"author" => "foo", "category" => "macros", "title" => "the secret sauce"}
    assert inspect(where(@q, ^filter_where(query))) ==
             inspect(where(@q, [p],
                p.author == ^query["author"]
                and p.category == ^query["category"]
                and p.title == ^query["title"]))
  end
end

It works in order to build a functional query for the filter struct given. But there is one thing still bothering me a bit (for the sake of macros I guess ).

     Assertion with == failed
     code:  assert inspect(where(@q, ^filter_where(query))) ==
              inspect(
                where(
                  @q,
                  [p],
                  p.author == ^query["author"] and p.category == ^query["category"] and
                    p.title == ^query["title"]
                )
              )
     left:  "#Ecto.Query<from p0 in \"post\", where: p0.author == ^\"foo\" and (p0.category == ^\"macros\" and p0.title == ^\"the secret sauce\")>"
     right: "#Ecto.Query<from p0 in \"post\", where: p0.author == ^\"foo\" and p0.category == ^\"macros\" and p0.title == ^\"the secret sauce\">"

Note the additional ( and ) braces. I guess that is inherent to the way the dynamic expressions are folded into one.

Even though it seems to me that a and (b and c) and a and b and c are equivalent, is there a way to somehow construct an AST of and expressions and put that inside a single final call to dynamic?

You shouldn’t be testing queries based on their internals. They might change at any time. Also e.g. reordering your conditions would break your tests even though the query would be functionally equal to before. You don’t want brittle tests like that.

I can see that and testing it like that only served exploration purposes

Furthermore I think I might have mixed up compile time vs run time with regards to a bit there too. So it may even not be possible at all to eliminate the braces (even if it was only for cosmetic purposes).

I guess I will have to dive deeper into macros soon to get a firmer grip on how they work.

Anyway, thank you very much for your time @LostKobrakai!

I love the Enum.reduce/2 approach, but from past experience, I recommend you protect against an empty list, because it’ll raise.

@LostKobrakai … you know what? I literally just had to adjust that call to dynamic from dynamic(^a and ^b) to dynamic(^b and ^a)

for reference …

defmodule MyMacro4Test do
  use ExUnit.Case, async: true
  import Ecto.Query

  def filter_where(params) do
    Enum.map(params, fn
      {"author", value} -> dynamic([p], p.author == ^value)
      {"category", value} -> dynamic([p], p.category == ^value)
      {"title", value} -> dynamic([p], p.title == ^value)
    end)
    |> Enum.reduce(fn a, b -> dynamic(^b and ^a) end)
  end

  @q from(p in "post")

  test "author" do
    query = %{"author" => "foo"}
    assert inspect(where(@q, ^filter_where(query))) ==
             inspect(where(@q, [p], p.author == ^query["author"]))

    query = %{"author" => "foo", "category" => "macros", "title" => "the secret sauce"}
    assert inspect(where(@q, ^filter_where(query))) ==
             inspect(where(@q, [p],
                p.author == ^query["author"]
                and p.category == ^query["category"]
                and p.title == ^query["title"]))
  end
end

Cannot wait to fully understand macros

@gregvaughn I will take care to correctly check the list of valid query conditions before proceeding with the rest of the filter logic. Good advice! Thank you.