How to expose (or use) a module attribute that is built using macros

Not only outside the module, neither inside after the module has been compiled.
That is why you need a helper like Ecto does in the example defining __changeset__/0

Btw, where is the function that uses the stored values in @counter_cache_fields?

If you register the attribute with persist: true you can get at those attributes after compilation using <Module>.__info__(:attributes)

thank you @ityonemo TIL,
I guess I was assuming all attributes were acceded with @, but I can see that was a wrong assumption.

Hi @eksperimental, I’m not sure I understood what you mean, but the attribute @counter_cache_fields could be passed to __query__/2 as the fields param, for instance. I purposefully didn’t include the function because I didn’t know where exactly to put it, but if you care to leave an example I’d appreciate that.

Interesting, I read the docs but it wasn’t immediately clear what this option did tbh. I’ll test that trick but I’d like to understand first if that’s really necessary (since Ecto doesn’t use this, I figure perhaps there’s another way).

Please share a gist with your code.

The code is in the post, that’s how far I got with it… The CounterCache module is the one I intend to use inside schemas to expose the query function I mentioned (which is where we’re at).

how do you call __query__(module, fields)
If you can share the module where you call use ?

Just by reviewing your code (I haven’t run any code yet), i can tell a few things.:

• Enum.each/2 is used for side effects where you don’t expect any value to be returned. It always return :ok. So the second clause of your counter_cache_field macro will always return :ok. You probably are looking for for and make sure it is valid the desired AST what you return.

2. def __query__(module, fields) do is a function and you are returning a quoted expression. Are you sure about this? I don’t know how you are calling this. Usually you create these helpers and call them within the macro you are building.

3. I fail to see how you read the stored counter_cache_fields attributes.
   That is why I am asking you for the code

My advice is: Create a module that stores and read the attribute and does something similar to what you want to do, but without the Ecto layer.
Once you managed to properly register attributes and access them, port that code to interact with Ecto.

Hey @eksperimental, let me try to improve on the latest comment then…

I’m not calling it yet, I just left the example of the API I want to consume to make the use case a little clearer. It should be something like this: Post.counter_cache_query(Reactions), where counter_cache_query/1 is a function that is defined by CounterCache (perhaps) which is then use-d by a hypothetical Post module… If you care to take a look at my previous examples, you’ll see that I mentioned trying to define this function on the __using__ macro only to find that the attribute was actually empty.

What you mentioned makes complete sense, but if you run the code I think it works (and now I’m curious about it as well, I’d have to make some more tests to confirm).

Like I mentioned previously, this is just “pseudo-code”, to make the spec clearer. I was defining counter_cache_query and using this function as a helper in my tests (hence the quoted expression).

This is exactly the part I’m seeking help to accomplish . What I’ve tried before was something like this if I recall properly (tried so many different approaches I won’t remember everything right now):

defmacro __using__(_) do
  quote do
    # ...
    defmacro counter_cache_query(module) do
        # CounterCache.__query__(unquote(module), @counter_cache_fields)
    end
  end
end

I think there’s a gap in my macro knowledge that I’m failing to transmit properly, and I believe that even though this makes complete sense to you, I’m not sure what you mean by that. However, I can tell you this: If you test the code, you’ll see that registering the module attribute and defining the Ecto fields in the schema works properly (more or less), so the difficulty is actually accessing the @counter_cache_fields module attribute. A simple example to visualize it would be something like this (except the function should be injected inside the module that uses it):

defmodule Module do
  @counter_cache_fields [{:feeling, :dislike_count}, {:feeling, :like_count}]

  def counter_cache_query(module) do
    Enum.reduce(@counter_cache_fields, from(module), fn ->
      # generate query using field definitions inside attribute
    end
  end
end