Preload tables in ecto dynamically

@script Can you please share your code for collecting preload list and how preload should work for more levels deep? Also some people may not know what you said, so I would just like to your previous question.

Thanks, @Eiji for providing the link to the question. Below is the code. It’s not optimized as your code looks but it’s doing the work for now.

def build_preload_query(include) do
Enum.reduce(include, [], fn {k, v}, acc ->
  case v["$binding"] do
    :first ->
      acc ++ preload_last(k, v)

    _ ->
      acc
  end
end)
end

def preload_last(k, v) do
if is_nil(v["$include"]) do
  [string_to_atom(k)]
else
  {include, _map} = Map.pop(v, "$include")

  case include do
    include when is_map(include) ->
      key = Map.keys(include) |> hd()
      [{string_to_atom(k), string_to_atom(key)}]

    _ ->
      []
  end
end
end

This code is looping through the params and if the $include is a map it will use a tuple to preload the nested table with the outer table else just the first table.
The output is this:

    [customer: :users, facilities: :instance]

If I add another $include map inside users as I showed above in my second example. This function should produce preload like this:

 [customer: [users: :items], facilities: :instance]

And if there is another nested include inside items the list looks like this:

[customer: [users: [items: :other_table], facilities: :instance]

Here is my first version:

defmodule Example do
  def sample(map) when is_map(map), do: do_sample(map)

  defp do_sample(map), do: Enum.reduce(map, [], &do_sample/2)

  defp do_sample({key, %{"$include" => include}}, acc) when is_map(include),
    do: [{String.to_atom(key), do_sample(include)} | acc]

  defp do_sample({key, %{"$include" => include}}, acc) when is_bitstring(include),
    do: [{String.to_atom(key), String.to_atom(include)} | acc]

  defp do_sample({key, %{"$binding" => :last}}, _acc), do: String.to_atom(key)

  defp do_sample({_key, _value}, acc), do: acc
end

Please let me know if it works as expected for you in all cases.

Thanks @Eiji. I will let you know.

Hi @Eiji. so, I give it a try with below params.

%{
  "$include" => %{
    "facilities" => %{
      "$include" => %{"instance" => %{}}
    },
    "instances" => %{"$include" => %{"facilities" => %{}}},
    "customer" => %{
      "$include" => %{"users" => %{"$include" => %{"facilities" => %{}}}}
    }
  }
} 

The output it produced is this:

facilities
[users: :facilities]
:instance
:facilities
[instances: :facilities, facilities: :instance, customer: [users: :facilities]] 

The last line has correct output but it’s returning all other values before the final result. I think it’s reducing over the params and instead if returning the final output returns all the value it’s reducing over.

@script Sorry, I completely don’t understand.

For me Example.sample(data) returns [] for such input. I have no idea how it become like that. Looks like you did not gave a correct input here.

This is not even 1 list. How 1 call could turn into multiple results? Here looks like you pass few different inputs.

I have no information what happen on your side. Please send me all cases with their expected results. Something like in TDD, so if all tests would pass then implementation is correct.

If you have a public repo simply add tests like:

defmodule ExampleTest do
  use ExUnit.Case

  @first_input […]
  @second_input […]
  @third_input […]

  @first_expected […]
  @second_expected […]
  @third_expected […]

  test "all" do
    assert Example.sample(@first_input) == @first_expected
    assert Example.sample(@second_input) == @second_expected
    assert Example.sample(@third_input) == @third_expected
  end
end

and I will just make a PR for that.

Sorry, @Eiji. you are right. it is an issue on my end. I am debugging it. I will let you know.
Thanks for your quick insight.

@Eiji Thanks. It works perfectly as always.

@Eiji sorry Just his one case I forgot to mention if there is a list.

           “instances” => %{"$binding" => :first, “$include” => [“facilities”, “units”]} }

The prelod list looks like this:

                [instances: [:facilities, :units]]

@script Here we go:

defmodule Example do
  def sample(map) when is_map(map), do: do_sample(map)

  defp do_sample(map), do: Enum.reduce(map, [], &do_sample/2)

  defp do_sample({key, %{"$include" => include}}, acc) when is_map(include),
    do: [{String.to_atom(key), do_sample(include)} | acc]

  defp do_sample({key, %{"$include" => include}}, acc) when is_bitstring(include),
    do: [{String.to_atom(key), String.to_atom(include)} | acc]

  defp do_sample({key, %{"$include" => include}}, acc) when is_list(include),
    do: [{String.to_atom(key), Enum.map(include, &String.to_atom/1)} | acc]

  defp do_sample({key, %{"$binding" => :last}}, _acc), do: String.to_atom(key)

  defp do_sample({_key, _value}, acc), do: acc
end

Just one extra function clausule. It’s why I love writing configurable and easy to maintain code!