Current section

Files

Jump to
ecto lib ecto query builder cte.ex
Raw

lib/ecto/query/builder/cte.ex

import Kernel, except: [apply: 3]
defmodule Ecto.Query.Builder.CTE do
@moduledoc false
alias Ecto.Query.Builder
@doc """
Escapes the CTE name.
iex> escape(quote(do: "FOO"), __ENV__)
"FOO"
"""
@spec escape(Macro.t, Macro.Env.t) :: Macro.t
def escape(name, _env) when is_bitstring(name), do: name
def escape({:^, _, [expr]}, _env), do: expr
def escape(expr, env) do
case Macro.expand_once(expr, env) do
^expr ->
Builder.error! "`#{Macro.to_string(expr)}` is not a valid CTE name. " <>
"It must be a literal string or an interpolated variable."
expr ->
escape(expr, env)
end
end
@doc """
Builds a quoted expression.
The quoted expression should evaluate to a query at runtime.
If possible, it does all calculations at compile time to avoid
runtime work.
"""
@spec build(Macro.t, Macro.t, Macro.t, nil | boolean(), nil | :all | :update_all | :delete_all , Macro.Env.t) :: Macro.t
def build(query, name, cte, materialized, operation, env) do
Builder.apply_query(query, __MODULE__, [escape(name, env), build_cte(name, cte, env), materialized, operation], env)
end
@spec build_cte(Macro.t, Macro.t, Macro.Env.t) :: Macro.t
def build_cte(_name, {:^, _, [expr]}, _env) do
quote do: Ecto.Queryable.to_query(unquote(expr))
end
def build_cte(_name, {:fragment, _, _} = fragment, env) do
{expr, {params, _acc}} = Builder.escape(fragment, :any, {[], %{}}, [], env)
params = Builder.escape_params(params)
quote do
%Ecto.Query.QueryExpr{
expr: unquote(expr),
params: unquote(params),
file: unquote(env.file),
line: unquote(env.line)
}
end
end
def build_cte(name, cte, env) do
case Macro.expand_once(cte, env) do
^cte ->
Builder.error! "`#{Macro.to_string(cte)}` is not a valid CTE (named: #{Macro.to_string(name)}). " <>
"The CTE must be an interpolated query, such as ^existing_query or a fragment."
cte ->
build_cte(name, cte, env)
end
end
@doc """
The callback applied by `build/4` to build the query.
"""
@spec apply(Ecto.Queryable.t, bitstring, Ecto.Queryable.t, nil | boolean(), nil | :all | :update_all | :delete_all) :: Ecto.Query.t
# Runtime
def apply(query, name, with_query, materialized, nil) do
apply(query, name, with_query, materialized, :all)
end
def apply(_query, _name, _with_query, _materialized, operation)
when operation not in [:all, :update_all, :delete_all] do
Builder.error!("`operation` option must be one of :all, :update_all, or :delete_all")
end
def apply(%Ecto.Query{with_ctes: with_expr} = query, name, %_{} = with_query, materialized, operation) do
%{query | with_ctes: apply_cte(with_expr, name, with_query, materialized, operation)}
end
# Compile
def apply(%Ecto.Query{with_ctes: with_expr} = query, name, with_query, materialized, operation) do
update = quote do
Ecto.Query.Builder.CTE.apply_cte(unquote(with_expr), unquote(name), unquote(with_query), unquote(materialized), unquote(operation))
end
%{query | with_ctes: update}
end
# Runtime catch-all
def apply(query, name, with_query, materialized, operation) do
apply(Ecto.Queryable.to_query(query), name, with_query, materialized, operation)
end
@doc false
def apply_cte(nil, name, with_query, materialized, operation) when is_boolean(materialized) do
%Ecto.Query.WithExpr{queries: [{name, %{materialized: materialized, operation: operation}, with_query}]}
end
def apply_cte(nil, name, with_query, _materialized, operation) do
%Ecto.Query.WithExpr{queries: [{name, %{operation: operation}, with_query}]}
end
def apply_cte(%Ecto.Query.WithExpr{queries: queries} = with_expr, name, with_query, materialized, operation) when is_boolean(materialized) do
%{with_expr | queries: List.keystore(queries, name, 0, {name, %{materialized: materialized, operation: operation}, with_query})}
end
def apply_cte(%Ecto.Query.WithExpr{queries: queries} = with_expr, name, with_query, _materialized, operation) do
%{with_expr | queries: List.keystore(queries, name, 0, {name, %{operation: operation}, with_query})}
end
end