fireproofsocks
Dynamic Queries in Ecto
I have once again nose-dived into the treeline while attempting to follow the official docs… I’m trying to stay positive here, but I am really feeling malnourished when it comes to nutritious examples. I would love some help clarifying the mystery presented on https://hexdocs.pm/ecto/Ecto.Query.html#dynamic/2
dynamic = false
dynamic =
if params["is_public"] do
dynamic([p], p.is_public or ^dynamic)
else
dynamic
end
dynamic =
if params["allow_reviewers"] do
dynamic([p, a], a.reviewer == true or ^dynamic)
else
dynamic
end
from query, where: ^dynamic
-
First off, how might we actually pass in a value from the parameters into the where condition? The examples conveniently sidesteps that critical use-case. Like what if you want to filter a list of posts by the author? Would that be something like this?
dynamic =
if params[“author”] do
dynamic([p], p.author = params[“author”] or ^dynamic)
else
dynamic
end -
What’s up with the
orandandin these? If I assume all the filtering parameters I provide must be fulfilled, doesn’t that mean that I should always use “and”? What’s up with thisor ^dynamic? Can someone explain how and/or affects this and can someone explain this bizarre syntax? The only toe-hold my brain can get on this at present comes from some old-school query-string concatenation where the select criteria would beWHERE 1– then each subsequent clause could always begin with “AND condition=something”. Is that what’s going on? -
What’s up with the naked
from query, where: ^dynamic? What’s going on there? How can I actually use that in a query? I’m used to seeing something likequery = from p in Post– I don’t understand that at all, really, but at least it’s pervasive throughout the Ecto Query docs. -
How do we use this in a query that involves a join? It seems that it trips over the “where” clause that defines the join?
If I can get some help wrapping my head around this I can put together a PR that provides some examples that are easier to follow. Thanks for any guidance!
Most Liked
fireproofsocks
Sorry, you’re right: there’s nothing positive in commentary like that. I apologize. I was writing from a point of extreme frustration and exhaustion. I would like to submit some examples once I can get things working.
6
peerreynders
iex(1)> alias MusicDB.{Repo,Album,Track}
[MusicDB.Repo, MusicDB.Album, MusicDB.Track]
iex(2)> import Ecto.Query
Ecto.Query
iex(3)> dynamic_where = fn (album_id, params) ->
...(3)> default = dynamic([t], t.album_id == ^album_id)
...(3)> case params do
...(3)> %{name: name, value: value, op: :gt} ->
...(3)> dynamic([t], field(t, ^name) > ^value and ^default)
...(3)> %{name: name, value: value} ->
...(3)> dynamic([t], field(t, ^name) <= ^value and ^default)
...(3)> _ ->
...(3)> default
...(3)> end
...(3)> end
#Function<12.127694169/2 in :erl_eval.expr/5>
iex(4)> album_id = 2
2
iex(5)> from(t in Track, where: ^dynamic_where.(album_id, %{})) |> Repo.all()
17:49:20.001 [debug] QUERY OK source="tracks" db=2.9ms decode=2.3ms
SELECT t0."id", t0."title", t0."duration", t0."index", t0."number_of_plays", t0."inserted_at", t0."updated_at", t0."album_id" FROM "tracks" AS t0 WHERE (t0."album_id" = $1) [2]
[
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 1061,
duration_string: nil,
id: 10,
index: 5,
inserted_at: ~N[2018-06-16 20:29:41.480612],
number_of_plays: 0,
title: "No Blues",
updated_at: ~N[2018-06-16 20:29:41.480618]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 754,
duration_string: nil,
id: 9,
index: 4,
inserted_at: ~N[2018-06-16 20:29:41.480045],
number_of_plays: 0,
title: "Miles",
updated_at: ~N[2018-06-16 20:29:41.480051]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 896,
duration_string: nil,
id: 8,
index: 3,
inserted_at: ~N[2018-06-16 20:29:41.479460],
number_of_plays: 0,
title: "Walkin'",
updated_at: ~N[2018-06-16 20:29:41.479465]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 774,
duration_string: nil,
id: 7,
index: 2,
inserted_at: ~N[2018-06-16 20:29:41.478857],
number_of_plays: 0,
title: "Stella By Starlight",
updated_at: ~N[2018-06-16 20:29:41.478864]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 1006,
duration_string: nil,
id: 6,
index: 1,
inserted_at: ~N[2018-06-16 20:29:41.478296],
number_of_plays: 0,
title: "If I Were A Bell",
updated_at: ~N[2018-06-16 20:29:41.478302]
}
]
iex(6)> from(t in Track, where: ^dynamic_where.(album_id, %{name: :duration, value: 800})) |> Repo.all()
17:49:20.013 [debug] QUERY OK source="tracks" db=2.0ms
SELECT t0."id", t0."title", t0."duration", t0."index", t0."number_of_plays", t0."inserted_at", t0."updated_at", t0."album_id" FROM "tracks" AS t0 WHERE ((t0."duration" <= $1) AND (t0."album_id" = $2)) [800, 2]
[
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 754,
duration_string: nil,
id: 9,
index: 4,
inserted_at: ~N[2018-06-16 20:29:41.480045],
number_of_plays: 0,
title: "Miles",
updated_at: ~N[2018-06-16 20:29:41.480051]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 774,
duration_string: nil,
id: 7,
index: 2,
inserted_at: ~N[2018-06-16 20:29:41.478857],
number_of_plays: 0,
title: "Stella By Starlight",
updated_at: ~N[2018-06-16 20:29:41.478864]
}
]
iex(7)> from(t in Track, where: ^dynamic_where.(album_id, %{name: :duration, value: 800, op: :gt})) |> Repo.all()
17:49:20.016 [debug] QUERY OK source="tracks" db=1.8ms
SELECT t0."id", t0."title", t0."duration", t0."index", t0."number_of_plays", t0."inserted_at", t0."updated_at", t0."album_id" FROM "tracks" AS t0 WHERE ((t0."duration" > $1) AND (t0."album_id" = $2)) [800, 2]
[
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 1061,
duration_string: nil,
id: 10,
index: 5,
inserted_at: ~N[2018-06-16 20:29:41.480612],
number_of_plays: 0,
title: "No Blues",
updated_at: ~N[2018-06-16 20:29:41.480618]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 896,
duration_string: nil,
id: 8,
index: 3,
inserted_at: ~N[2018-06-16 20:29:41.479460],
number_of_plays: 0,
title: "Walkin'",
updated_at: ~N[2018-06-16 20:29:41.479465]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 1006,
duration_string: nil,
id: 6,
index: 1,
inserted_at: ~N[2018-06-16 20:29:41.478296],
number_of_plays: 0,
title: "If I Were A Bell",
updated_at: ~N[2018-06-16 20:29:41.478302]
}
]
iex(8)>
Though frankly:
iex(1)> alias MusicDB.{Repo,Album,Track}
[MusicDB.Repo, MusicDB.Album, MusicDB.Track]
iex(2)> import Ecto.Query
Ecto.Query
iex(3)> make_where = fn (query, album_id, params) ->
...(3)> case params do
...(3)> %{name: name, value: value, op: :gt} ->
...(3)> from(p in query, where: field(p, ^name) > ^value and p.album_id == ^album_id)
...(3)> %{name: name, value: value} ->
...(3)> from(p in query, where: field(p, ^name) <= ^value and p.album_id == ^album_id)
...(3)> _ ->
...(3)> from(p in query, where: p.album_id == ^album_id)
...(3)> end
...(3)> end
#Function<18.127694169/3 in :erl_eval.expr/5>
iex(4)> album_id = 2
2
iex(5)> from(t in Track) |> make_where.(album_id, %{}) |> Repo.all()
18:08:35.201 [debug] QUERY OK source="tracks" db=2.7ms decode=2.0ms
SELECT t0."id", t0."title", t0."duration", t0."index", t0."number_of_plays", t0."inserted_at", t0."updated_at", t0."album_id" FROM "tracks" AS t0 WHERE (t0."album_id" = $1) [2]
[
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 1061,
duration_string: nil,
id: 10,
index: 5,
inserted_at: ~N[2018-06-16 20:29:41.480612],
number_of_plays: 0,
title: "No Blues",
updated_at: ~N[2018-06-16 20:29:41.480618]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 754,
duration_string: nil,
id: 9,
index: 4,
inserted_at: ~N[2018-06-16 20:29:41.480045],
number_of_plays: 0,
title: "Miles",
updated_at: ~N[2018-06-16 20:29:41.480051]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 896,
duration_string: nil,
id: 8,
index: 3,
inserted_at: ~N[2018-06-16 20:29:41.479460],
number_of_plays: 0,
title: "Walkin'",
updated_at: ~N[2018-06-16 20:29:41.479465]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 774,
duration_string: nil,
id: 7,
index: 2,
inserted_at: ~N[2018-06-16 20:29:41.478857],
number_of_plays: 0,
title: "Stella By Starlight",
updated_at: ~N[2018-06-16 20:29:41.478864]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 1006,
duration_string: nil,
id: 6,
index: 1,
inserted_at: ~N[2018-06-16 20:29:41.478296],
number_of_plays: 0,
title: "If I Were A Bell",
updated_at: ~N[2018-06-16 20:29:41.478302]
}
]
iex(6)> from(t in Track) |> make_where.(album_id, %{name: :duration, value: 800}) |> Repo.all()
18:08:35.213 [debug] QUERY OK source="tracks" db=2.0ms
SELECT t0."id", t0."title", t0."duration", t0."index", t0."number_of_plays", t0."inserted_at", t0."updated_at", t0."album_id" FROM "tracks" AS t0 WHERE ((t0."duration" <= $1) AND (t0."album_id" = $2)) [800, 2]
[
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 754,
duration_string: nil,
id: 9,
index: 4,
inserted_at: ~N[2018-06-16 20:29:41.480045],
number_of_plays: 0,
title: "Miles",
updated_at: ~N[2018-06-16 20:29:41.480051]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 774,
duration_string: nil,
id: 7,
index: 2,
inserted_at: ~N[2018-06-16 20:29:41.478857],
number_of_plays: 0,
title: "Stella By Starlight",
updated_at: ~N[2018-06-16 20:29:41.478864]
}
]
iex(7)> from(t in Track) |> make_where.(album_id, %{name: :duration, value: 800, op: :gt}) |> Repo.all()
18:08:35.216 [debug] QUERY OK source="tracks" db=2.1ms
SELECT t0."id", t0."title", t0."duration", t0."index", t0."number_of_plays", t0."inserted_at", t0."updated_at", t0."album_id" FROM "tracks" AS t0 WHERE ((t0."duration" > $1) AND (t0."album_id" = $2)) [800, 2]
[
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 1061,
duration_string: nil,
id: 10,
index: 5,
inserted_at: ~N[2018-06-16 20:29:41.480612],
number_of_plays: 0,
title: "No Blues",
updated_at: ~N[2018-06-16 20:29:41.480618]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 896,
duration_string: nil,
id: 8,
index: 3,
inserted_at: ~N[2018-06-16 20:29:41.479460],
number_of_plays: 0,
title: "Walkin'",
updated_at: ~N[2018-06-16 20:29:41.479465]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 1006,
duration_string: nil,
id: 6,
index: 1,
inserted_at: ~N[2018-06-16 20:29:41.478296],
number_of_plays: 0,
title: "If I Were A Bell",
updated_at: ~N[2018-06-16 20:29:41.478302]
}
]
iex(8)>
Ecto queries are composable. Ecto.Query.dynamic/2 comes in handy when you need your where conditions to be composable.
Conditions are composed with and or or:
- when you compose with
orand you don’t need the condition, you default tofalseinstead. - when you compose with
andand you don’t need the condition, you default totrueinstead.
Furthermore if you are simply anding the conditions you need, you probably don’t need Ecto.Query.dynamic/2:
iex(1)> alias MusicDB.{Repo,Album,Track}
[MusicDB.Repo, MusicDB.Album, MusicDB.Track]
iex(2)> import Ecto.Query
Ecto.Query
iex(3)> make_where = fn (query, album_id, params) ->
...(3)> default = from(q in query, where: q.album_id == ^album_id)
...(3)> case params do
...(3)> %{name: name, value: value, op: :gt} ->
...(3)> from(p in default, where: field(p, ^name) > ^value)
...(3)> %{name: name, value: value} ->
...(3)> from(p in default, where: field(p, ^name) <= ^value)
...(3)> _ ->
...(3)> default
...(3)> end
...(3)> end
#Function<18.127694169/3 in :erl_eval.expr/5>
iex(4)> album_id = 2
2
iex(5)> from(t in Track) |> make_where.(album_id, %{}) |> Repo.all()
18:47:30.295 [debug] QUERY OK source="tracks" db=2.8ms decode=2.2ms
SELECT t0."id", t0."title", t0."duration", t0."index", t0."number_of_plays", t0."inserted_at", t0."updated_at", t0."album_id" FROM "tracks" AS t0 WHERE (t0."album_id" = $1) [2]
[
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 1061,
duration_string: nil,
id: 10,
index: 5,
inserted_at: ~N[2018-06-16 20:29:41.480612],
number_of_plays: 0,
title: "No Blues",
updated_at: ~N[2018-06-16 20:29:41.480618]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 754,
duration_string: nil,
id: 9,
index: 4,
inserted_at: ~N[2018-06-16 20:29:41.480045],
number_of_plays: 0,
title: "Miles",
updated_at: ~N[2018-06-16 20:29:41.480051]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 896,
duration_string: nil,
id: 8,
index: 3,
inserted_at: ~N[2018-06-16 20:29:41.479460],
number_of_plays: 0,
title: "Walkin'",
updated_at: ~N[2018-06-16 20:29:41.479465]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 774,
duration_string: nil,
id: 7,
index: 2,
inserted_at: ~N[2018-06-16 20:29:41.478857],
number_of_plays: 0,
title: "Stella By Starlight",
updated_at: ~N[2018-06-16 20:29:41.478864]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 1006,
duration_string: nil,
id: 6,
index: 1,
inserted_at: ~N[2018-06-16 20:29:41.478296],
number_of_plays: 0,
title: "If I Were A Bell",
updated_at: ~N[2018-06-16 20:29:41.478302]
}
]
iex(6)> from(t in Track) |> make_where.(album_id, %{name: :duration, value: 800}) |> Repo.all()
18:47:30.307 [debug] QUERY OK source="tracks" db=2.0ms
SELECT t0."id", t0."title", t0."duration", t0."index", t0."number_of_plays", t0."inserted_at", t0."updated_at", t0."album_id" FROM "tracks" AS t0 WHERE (t0."album_id" = $1) AND (t0."duration" <= $2) [2, 800]
[
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 754,
duration_string: nil,
id: 9,
index: 4,
inserted_at: ~N[2018-06-16 20:29:41.480045],
number_of_plays: 0,
title: "Miles",
updated_at: ~N[2018-06-16 20:29:41.480051]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 774,
duration_string: nil,
id: 7,
index: 2,
inserted_at: ~N[2018-06-16 20:29:41.478857],
number_of_plays: 0,
title: "Stella By Starlight",
updated_at: ~N[2018-06-16 20:29:41.478864]
}
]
iex(7)> from(t in Track) |> make_where.(album_id, %{name: :duration, value: 800, op: :gt}) |> Repo.all()
18:47:30.311 [debug] QUERY OK source="tracks" db=1.9ms
SELECT t0."id", t0."title", t0."duration", t0."index", t0."number_of_plays", t0."inserted_at", t0."updated_at", t0."album_id" FROM "tracks" AS t0 WHERE (t0."album_id" = $1) AND (t0."duration" > $2) [2, 800]
[
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 1061,
duration_string: nil,
id: 10,
index: 5,
inserted_at: ~N[2018-06-16 20:29:41.480612],
number_of_plays: 0,
title: "No Blues",
updated_at: ~N[2018-06-16 20:29:41.480618]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 896,
duration_string: nil,
id: 8,
index: 3,
inserted_at: ~N[2018-06-16 20:29:41.479460],
number_of_plays: 0,
title: "Walkin'",
updated_at: ~N[2018-06-16 20:29:41.479465]
},
%MusicDB.Track{
__meta__: #Ecto.Schema.Metadata<:loaded, "tracks">,
album: #Ecto.Association.NotLoaded<association :album is not loaded>,
album_id: 2,
duration: 1006,
duration_string: nil,
id: 6,
index: 1,
inserted_at: ~N[2018-06-16 20:29:41.478296],
number_of_plays: 0,
title: "If I Were A Bell",
updated_at: ~N[2018-06-16 20:29:41.478302]
}
]
iex(8)>
For relatively simple condition composition (more like “chaining” really) with or Ecto.Query.or_where/3 can be used in exactly the same manner.
dynamic/2 becomes necessary when you are composing deeply nested, optional conditions
WHERE
(... AND ... AND ... AND (... OR (... AND ...)))
OR (.. AND ((... AND ...) OR ...) AND ...)
OR (... AND ... AND ...)
OR ((... OR (... AND ...)) AND ...)
5
benwilson512
Author of Craft GraphQL APIs in Elixir with Absinthe
I’m not entirely sure what the point of commentary like this is. The Elixir community is still relatively small, and the docs and code that exist are almost always the work of a limited number of people doing the best they can with the time they have available.
That isn’t to say that they’re perfect or even close. I’m confident that you’re right, that the docs could use more examples. Nonetheless, as the recipient of code, docs (even if flawed), personalized help, starting a post with a complaint just depresses those you’re seeking help from.
3
josevalim
Creator of Elixir
Such clarifications to dynamic/2 docs would be really welcome too. 
3
LostKobrakai
author = params[“author”]
author_selection = dynamic([p], p.author == ^author)
https://hexdocs.pm/ecto/Ecto.Query.html#module-interpolation-and-casting
-
There’s
where: …andor_where: …orwhere: (p.published == true or p.preview == true) and p.id > 100
https://hexdocs.pm/ecto/Ecto.Query.html#where/3
https://hexdocs.pm/ecto/Ecto.Query.html#or_where/3 -
There are bindingless operations and dynamic does probably also handle it’s own “binding”.
https://hexdocs.pm/ecto/Ecto.Query.html#module-bindingless-operations -
joindoes not usewhere: …, buton:to determine the join condition.wherein dynamic does work on joined resources just like without dynamic:
from a in Article.
join: c in Comment, on: a.id == c.article_id
where: c.author_id == ^id
or
Article
|> join(:inner, [a], c in Comment, a.id == c.article_id)
|> where([_, c], c.author_id == ^id)
The a.id == c.article_id part could by replaced with a “dynamic”.
https://hexdocs.pm/ecto/Ecto.Query.html#join/5
I’m aware that ecto queries are complex, especially as they support two syntaxes, but all of the things you asked about seem to be already documented in that module. I can certainly understand that this example might not be optimal, but you should keep in mind that those are a ongoing effort and especially as someone knowing the system it’s sometimes hard to anticipate the difficulties someone less knowledgeable might have reading any of those examples.
1
Popular in Questions
Background
Let’s assume I have a typical GenServer that receives messages as requests, does some operation in a DB and returns responses....
New
I’m working on defining a simple Ecto schema for a table (in PostGres), but I don’t see where I can define a column as NOT NULL. Conside...
New
I believe there are people here who are dealing with CSV files import on the daily basis, and since Excel is a really popular tool there ...
New
I want to try my hand at web scraping. What tools/libraries do I need to use. I’m hoping to turn this into something professional so don’...
New
What is most correct way to open, read and parse JSON file with poison?
For example if we have example.json file in root of some projec...
New
I am using Ecto timestamps with postgres, I can see the timestamps() use the :naive_dateime but for my use case I wanted to store the ti...
New
When I run the Plug and I recompile I wind up having to use Ctrl C to quit iex and start again. Witht the help of rlwrap I can use the cu...
New
Forgive me if this is obvious, but how does one delete a database record WITHOUT selecting it first? https://hexdocs.pm/ecto/Ecto.Repo.h...
New
Hi guys, i’m new in the Elixir world, and i have to say, that i love it!
i’m having some problem to understand anonymous functions with ...
New
Original source of discussion: This topic on the Pragmatic Programmers' Functional Web Development with Elixir, OTP, and Phoenix forum.
...
New
Other popular topics
I have seen a lot of code which picks the first element from a list using Enum.at(0) instead of List.first. Is there a reason why people ...
New
We have an ECS cluster with 4 services, where each task joins a single cluster, via discovery ECS discovery service.
Currently when I de...
New
Okay, I'm having a heck of a time trying to figure out how to best handle the validation of belongs_to associations in Ecto. I'm sure I'...
New
Hello!
Sorry for this astonishing simple question, but I’m really stuck. I try to set up the intellij-elixir plugin, but I don’t know ho...
New
This post is a wiki (feel free to hit the edit button near the bottom right of this post to add your own changes!)
This post collects co...
New
How to set Jason to encode all fields in ecto schema, I don’t care about security and implementing only is taking long list of attributes...
New
As many of you may have realized by now (sorry for all the posts here) I’ve been working on a db problem where I’m trying to aggregate a ...
New
What is the difference between System.get_env and Application.get_env? For example, what are best practices to use one versus another.
New
Hi guys, i’m new in the Elixir world, and i have to say, that i love it!
i’m having some problem to understand anonymous functions with ...
New
by Lance Halvorsen
Elixir and Phoenix are generating tremendous excitement as an unbeatable platform for building modern web application...
New
Latest on Elixir Forum
Sponsor Spotlight
Courses that'll move you from confusion to "Aha, now I get it!"
Categories:
Sub Categories:
Forums
Our Sponsors
Build Elixir applications with speed and confidence.
Supporting innovation across the BEAM ecosystem.
We build reliable cloud platforms for business-critical systems.
Catch errors, track performance, monitor hosts and more.
Develop your skills with books, videos, and courses.
Producing high quality Elixir screencasts since 2017.
The deployment platform built for Elixir: PaaS ease, VPS control.
Courses that'll move you from confusion to "Aha, now I get it!"