Building a dynamic query using recursion

Questions / Help
, , , ,
1

Hi :wave:, I’ve been playing around with Elixir and its ecosystem for a few weeks now and I really like it so far. Also, this is my first post here so please bear with me :bowing_man:t2:‍♂.

I’m trying to mimic how Amazon’s Amplify generates the filters for its GraphQL schemas using Absinthe.
So far I was able to get ne, eq, le, ge, gt, contains, and between to work. The hard part, however, is implementing and, or, and not (lines 88 - 90) since it involves recursion and Ecto.

I’ve created a small repl.it that shows what I’ve tried so far (maybe lots of code commented off as well :sweat_smile:). In the repl.it, I’m using strings to abstract things but the goal is to use Ecto’s dynamic query feature.

The input will look something like this:

input = %{
  and: [%{ and: [%{ b: %{ eq: "4"}}], c: %{ eq: "3"}}],
  or: [%{ d: %{ eq: "2"}}],
  a: %{ eq: "1"}
}

and the output will be expressed as something like:

# a and (b == 4 and c == 3) or (d == 2)

I think I’m on the right track. I know that I eventually have to reduce a tree-like structure to a single query, but I’m not sure how to deal with a binary operator such and and or within Enum.reduce so any help would be greatly appreciated.

Thank you.

Random thought:

I think it would be super neat if Absinthe could just build the tables and hook everything up including filtering, relay, etc with just a schema like Amplify… this would be a game changer.

2

I interpret that document as describing a different structure where both and and or take the terms they apply to in a list. For your example, start by writing the expression with explicit parentheses:

(a == 1 and (b == 4 and c == 3)) or (d == 2)

Rules:

  • %{variable_name: %{eq: value}} corresponds to variable_name == value
  • %{var1: %{eq: v1}, var2: %{eq: v2}} corresponds to (var1 == v1) and (var2 == v2)
  • %{and: [X, Y, Z]} corresponds to the expression (X and (Y and Z))
  • %{or: [X, Y, Z]} corresponds to the expression (X or (Y or Z))

so

%{
  a: %{eq: 1},
  b: %{eq: 4},
  c: %{eq: 3}
}

corresponds to (a == 1 and (b == 4 and c == 3)). So finally

%{
  or: [
    %{
      a: %{eq: 1},
      b: %{eq: 4},
      c: %{eq: 3}
    },
    %{
      d: %{eq: 2}
    }
  ]
}

corresponds to the original expression.

The recursion you’ll need to turn the map above into Ecto operations is the derivation in reverse. You’ll likely want to use explicit recursion for this, as it’s a depth-first traversal of the input.

1 Like
3

Thanks Matt for the reply! So it’s almost like restructuring the input into a format that makes it easier to evaluate. I’ll give that a shot.

4

Just wanted to update and say thank you for taking your time and input! I was able to get something working (after lots of head banging :laughing:).

I’ll leave a repl.it here in case someone finds it helpful/useful and maybe even improve it.