Before I dive into the topic, I need to make sure I’m not getting misunderstood.
Since I started working with Phoenix, I’ve been enjoying using Ecto A LOT. It is some fresh air to me coming from a Rails background. I have gone through nightmares with suboptimal, weird and slow queries because of the layer of abstraction that ActiveRecord imposes.
Ecto made me think in SQL again, and I love it for that. It allows me to fine-tune my queries a lot more, and avoid unexpected N+1 and other shenanigans.
That’s for the good part. The bad part, or rather, the annoying part, is that Ecto is quite a bit more verbose for even the simplest tasks. This is not a big deal when writing production code - give or take a couple of lines does not change anything. BUT when I’m in the interactive shell, I really, really dislike having to write multiple lines of code for what could be done in one line.
Let’s see an example. Imagine I want to collect all the ids of a given model / table. In ActiveRecord, one can do:
User.pluck(:id)
Done! To do the same in Ecto, you need to write the following 3 lines of code:
require Ecto.Query
query = Ecto.Query.from u in MyApp.User, select: u.id
MyApp.Repo.all(query)
This gets old pretty quick!
So I’ve decided to write some shortcuts for some of the Ecto queries I use the most when working in the REPL. I’m not sure if this approach has any major caveats, but it’s been working really nicely for me. I’d be happy to see some feedback from you, since it’s the first time I write an Elixir macro myself.
This is the utility macro:
defmodule EctoPlus.SimpleQueries do
defmacro __using__(repo: repo) do
quote do
def count do
unquote(repo).aggregate(__MODULE__, :count, :id)
end
def find(id) do
unquote(repo).get(__MODULE__, id)
end
def find_by(statement) do
query =
Ecto.Query.from rec in __MODULE__,
where: ^statement,
limit: 1
unquote(repo).one(query)
end
def select(columns) when is_list(columns) do
query =
Ecto.Query.from rec in __MODULE__,
select: ^columns
unquote(repo).all(query)
end
def select(column) when is_atom(column), do: select([column])
def pluck(columns) when is_list(columns) do
for record <- select(columns), do: Map.take(record, columns)
end
def pluck(column) when is_atom(column) do
for record <- select(column), do: Map.get(record, column)
end
def where(statement) do
query =
Ecto.Query.from rec in __MODULE__,
where: ^statement
unquote(repo).all(query)
end
end
end
end
And to have it available in the models, I add the following line in web/web.ex, under the model definition:
use EctoPlus.SimpleQueries, repo: MyApp.Repo
And then I can run stuff in the iex like:
MyApp.User.count()
MyApp.User.pluck(:email)
And so on… I even have aliases for the most common models in my .iex.exs file so that I can just write:
User.count()
User.pluck(:email)
What do you think? And just to be sure: these functions are not meant to be used inside of my production code. The idea is to keep those reserved for iex / debugging sessions. Cheers!
