1937 lines
57 KiB
Elixir
1937 lines
57 KiB
Elixir
if Code.ensure_loaded?(Tds) do
|
|
defmodule Ecto.Adapters.Tds.Connection do
|
|
@moduledoc false
|
|
require Logger
|
|
alias Tds.Query
|
|
alias Ecto.Query.Tagged
|
|
alias Ecto.Adapters.SQL
|
|
require Ecto.Schema
|
|
|
|
@behaviour Ecto.Adapters.SQL.Connection
|
|
|
|
@impl true
|
|
def child_spec(opts) do
|
|
opts
|
|
|> Keyword.put_new(:use_elixir_calendar_types, true)
|
|
|> Tds.child_spec()
|
|
end
|
|
|
|
@impl true
|
|
def prepare_execute(pid, _name, statement, params, opts \\ []) do
|
|
query = %Query{statement: statement}
|
|
params = prepare_params(params)
|
|
|
|
opts = Keyword.put(opts, :parameters, params)
|
|
DBConnection.prepare_execute(pid, query, params, opts)
|
|
end
|
|
|
|
@impl true
|
|
def execute(pid, statement, params, opts) when is_binary(statement) or is_list(statement) do
|
|
query = %Query{statement: statement}
|
|
params = prepare_params(params)
|
|
opts = Keyword.put(opts, :parameters, params)
|
|
|
|
case DBConnection.prepare_execute(pid, query, params, opts) do
|
|
{:ok, _, %Tds.Result{columns: nil, num_rows: num_rows, rows: []}}
|
|
when num_rows >= 0 ->
|
|
{:ok, %Tds.Result{columns: nil, num_rows: num_rows, rows: nil}}
|
|
|
|
{:ok, _, query} ->
|
|
{:ok, query}
|
|
|
|
{:error, _} = err ->
|
|
err
|
|
end
|
|
end
|
|
|
|
def execute(pid, %{} = query, params, opts) do
|
|
opts = Keyword.put_new(opts, :parameters, params)
|
|
params = prepare_params(params)
|
|
opts = Keyword.put(opts, :parameters, params)
|
|
|
|
case DBConnection.prepare_execute(pid, query, params, opts) do
|
|
{:ok, _, query} -> {:ok, query}
|
|
{:error, _} = err -> err
|
|
end
|
|
end
|
|
|
|
@impl true
|
|
def stream(_conn, _sql, _params, _opts) do
|
|
error!(nil, "Repo.stream is not supported in the Tds adapter")
|
|
end
|
|
|
|
@impl true
|
|
def query(conn, sql, params, opts) do
|
|
params = prepare_params(params)
|
|
Tds.query(conn, sql, params, opts)
|
|
end
|
|
|
|
@impl true
|
|
def query_many(_conn, _sql, _params, _opts) do
|
|
error!(nil, "query_many is not supported in the Tds adapter")
|
|
end
|
|
|
|
@impl true
|
|
def to_constraints(%Tds.Error{mssql: %{number: code, msg_text: message}}, _opts) do
|
|
Tds.Error.get_constraint_violations(code, message)
|
|
end
|
|
|
|
def to_constraints(_, _opts), do: []
|
|
|
|
def prepare_params(params) do
|
|
unless is_list(params) do
|
|
raise ArgumentError, "expected params to be a list, got: #{inspect(params)}"
|
|
end
|
|
|
|
{params, _} =
|
|
Enum.map_reduce(params, 1, fn param, acc ->
|
|
case prepare_param(param) do
|
|
{value, type} -> {%Tds.Parameter{name: "@#{acc}", value: value, type: type}, acc + 1}
|
|
%Tds.Parameter{name: ""} = param -> {%{param | name: "@#{acc}"}, acc + 1}
|
|
%Tds.Parameter{name: <<"@", _::binary>>} = param -> {param, acc}
|
|
_ -> error!(nil, "Tds parameter names must begin with @")
|
|
end
|
|
end)
|
|
|
|
params
|
|
end
|
|
|
|
# Decimal
|
|
defp prepare_param(%Decimal{} = value) do
|
|
{value, :decimal}
|
|
end
|
|
|
|
defp prepare_param(%NaiveDateTime{} = value) do
|
|
{value, :datetime2}
|
|
end
|
|
|
|
defp prepare_param(%DateTime{} = value) do
|
|
{value, :datetimeoffset}
|
|
end
|
|
|
|
defp prepare_param(%Date{} = value) do
|
|
{value, :date}
|
|
end
|
|
|
|
defp prepare_param(%Time{} = value) do
|
|
{value, :time}
|
|
end
|
|
|
|
defp prepare_param(%Tds.Parameter{type: nil, value: value} = param) do
|
|
{_value, type} = prepare_param(value)
|
|
%{param | type: type}
|
|
end
|
|
|
|
defp prepare_param(%Tds.Parameter{} = param) do
|
|
param
|
|
end
|
|
|
|
defp prepare_param(%{__struct__: module} = _value) do
|
|
# just in case dumpers/loaders are not defined for the this struct
|
|
error!(
|
|
nil,
|
|
"Tds adapter is unable to convert struct `#{inspect(module)}` into supported MSSQL types"
|
|
)
|
|
end
|
|
|
|
defp prepare_param(%{} = value), do: {json_library().encode!(value), :string}
|
|
defp prepare_param(value), do: prepare_raw_param(value)
|
|
|
|
defp prepare_raw_param(value) when is_binary(value) do
|
|
type = if String.printable?(value), do: :string, else: :binary
|
|
{value, type}
|
|
end
|
|
|
|
defp prepare_raw_param(value) when value == true, do: {1, :boolean}
|
|
defp prepare_raw_param(value) when value == false, do: {0, :boolean}
|
|
defp prepare_raw_param({_, :varchar} = value), do: value
|
|
defp prepare_raw_param(value), do: {value, nil}
|
|
|
|
defp json_library(), do: Application.get_env(:tds, :json_library, Jason)
|
|
|
|
## Query
|
|
|
|
@parent_as __MODULE__
|
|
alias Ecto.Query
|
|
alias Ecto.Query.{BooleanExpr, ByExpr, JoinExpr, QueryExpr, WithExpr}
|
|
|
|
@impl true
|
|
def all(query, as_prefix \\ []) do
|
|
sources = create_names(query, as_prefix)
|
|
|
|
cte = cte(query, sources)
|
|
from = from(query, sources)
|
|
select = select(query, sources)
|
|
join = join(query, sources)
|
|
where = where(query, sources)
|
|
group_by = group_by(query, sources)
|
|
having = having(query, sources)
|
|
_window = window(query, sources)
|
|
combinations = combinations(query, as_prefix)
|
|
order_by = order_by(query, sources)
|
|
# limit = is handled in select (TOP X)
|
|
offset = offset(query, sources)
|
|
lock = lock(query, sources)
|
|
|
|
if query.offset != nil and query.order_bys == [],
|
|
do: error!(query, "ORDER BY is mandatory when OFFSET is set")
|
|
|
|
[cte, select, from, join, where, group_by, having, combinations, order_by, lock | offset]
|
|
end
|
|
|
|
@impl true
|
|
def update_all(query) do
|
|
sources = create_names(query, [])
|
|
cte = cte(query, sources)
|
|
{table, name, _model} = elem(sources, 0)
|
|
|
|
fields = update_fields(query, sources)
|
|
from = " FROM #{table} AS #{name}"
|
|
join = join(query, sources)
|
|
where = where(query, sources)
|
|
lock = lock(query, sources)
|
|
|
|
[
|
|
cte,
|
|
"UPDATE ",
|
|
name,
|
|
" SET ",
|
|
fields,
|
|
returning(query, 0, "INSERTED"),
|
|
from,
|
|
join,
|
|
where | lock
|
|
]
|
|
end
|
|
|
|
@impl true
|
|
def delete_all(query) do
|
|
sources = create_names(query, [])
|
|
cte = cte(query, sources)
|
|
{table, name, _model} = elem(sources, 0)
|
|
|
|
delete = "DELETE #{name}"
|
|
from = " FROM #{table} AS #{name}"
|
|
join = join(query, sources)
|
|
where = where(query, sources)
|
|
lock = lock(query, sources)
|
|
|
|
[cte, delete, returning(query, 0, "DELETED"), from, join, where | lock]
|
|
end
|
|
|
|
@impl true
|
|
def insert(prefix, table, header, rows, on_conflict, returning, placeholders) do
|
|
counter_offset = length(placeholders) + 1
|
|
[] = on_conflict(on_conflict, header)
|
|
returning = returning(returning, "INSERTED")
|
|
|
|
values =
|
|
if header == [] do
|
|
[returning, " DEFAULT VALUES"]
|
|
else
|
|
[
|
|
?\s,
|
|
?(,
|
|
quote_names(header),
|
|
?),
|
|
returning
|
|
| insert_all(rows, counter_offset)
|
|
]
|
|
end
|
|
|
|
["INSERT INTO ", quote_table(prefix, table), values]
|
|
end
|
|
|
|
defp on_conflict({:raise, _, []}, _header) do
|
|
[]
|
|
end
|
|
|
|
defp on_conflict({_, _, _}, _header) do
|
|
error!(nil, "Tds adapter supports only on_conflict: :raise")
|
|
end
|
|
|
|
defp insert_all(%Ecto.Query{} = query, _counter) do
|
|
[?\s, all(query)]
|
|
end
|
|
|
|
defp insert_all(rows, counter) do
|
|
sql =
|
|
intersperse_reduce(rows, ",", counter, fn row, counter ->
|
|
{row, counter} = insert_each(row, counter)
|
|
{[?(, row, ?)], counter}
|
|
end)
|
|
|> elem(0)
|
|
|
|
[" VALUES " | sql]
|
|
end
|
|
|
|
defp insert_each(values, counter) do
|
|
intersperse_reduce(values, ", ", counter, fn
|
|
nil, counter ->
|
|
{"DEFAULT", counter}
|
|
|
|
{%Query{} = query, params_counter}, counter ->
|
|
{[?(, all(query), ?)], counter + params_counter}
|
|
|
|
{:placeholder, placeholder_index}, counter ->
|
|
{[?@ | placeholder_index], counter}
|
|
|
|
_, counter ->
|
|
{[?@ | Integer.to_string(counter)], counter + 1}
|
|
end)
|
|
end
|
|
|
|
@impl true
|
|
def update(prefix, table, fields, filters, returning) do
|
|
{fields, count} =
|
|
intersperse_reduce(fields, ", ", 1, fn field, acc ->
|
|
{[quote_name(field), " = @", Integer.to_string(acc)], acc + 1}
|
|
end)
|
|
|
|
{filters, _count} =
|
|
intersperse_reduce(filters, " AND ", count, fn
|
|
{field, nil}, acc ->
|
|
{[quote_name(field), " IS NULL"], acc + 1}
|
|
|
|
{field, _value}, acc ->
|
|
{[quote_name(field), " = @", Integer.to_string(acc)], acc + 1}
|
|
|
|
field, acc ->
|
|
{[quote_name(field), " = @", Integer.to_string(acc)], acc + 1}
|
|
end)
|
|
|
|
[
|
|
"UPDATE ",
|
|
quote_table(prefix, table),
|
|
" SET ",
|
|
fields,
|
|
returning(returning, "INSERTED"),
|
|
" WHERE " | filters
|
|
]
|
|
end
|
|
|
|
@impl true
|
|
def delete(prefix, table, filters, returning) do
|
|
{filters, _} =
|
|
intersperse_reduce(filters, " AND ", 1, fn
|
|
{field, nil}, acc ->
|
|
{[quote_name(field), " IS NULL"], acc + 1}
|
|
|
|
{field, _value}, acc ->
|
|
{[quote_name(field), " = @", Integer.to_string(acc)], acc + 1}
|
|
|
|
field, acc ->
|
|
{[quote_name(field), " = @", Integer.to_string(acc)], acc + 1}
|
|
end)
|
|
|
|
[
|
|
"DELETE FROM ",
|
|
quote_table(prefix, table),
|
|
returning(returning, "DELETED"),
|
|
" WHERE " | filters
|
|
]
|
|
end
|
|
|
|
@impl true
|
|
def explain_query(conn, query, params, opts) do
|
|
params = prepare_params(params)
|
|
|
|
case Tds.query_multi(conn, build_explain_query(query), params, opts) do
|
|
{:ok, [_, %Tds.Result{} = result, _]} ->
|
|
{:ok, SQL.format_table(result)}
|
|
|
|
error ->
|
|
error
|
|
end
|
|
end
|
|
|
|
def build_explain_query(query) do
|
|
[
|
|
"SET STATISTICS XML ON; ",
|
|
"SET STATISTICS PROFILE ON; ",
|
|
query,
|
|
"; ",
|
|
"SET STATISTICS XML OFF; ",
|
|
"SET STATISTICS PROFILE OFF;"
|
|
]
|
|
|> IO.iodata_to_binary()
|
|
end
|
|
|
|
## Query generation
|
|
|
|
binary_ops = [
|
|
==: " = ",
|
|
!=: " <> ",
|
|
<=: " <= ",
|
|
>=: " >= ",
|
|
<: " < ",
|
|
>: " > ",
|
|
+: " + ",
|
|
-: " - ",
|
|
*: " * ",
|
|
/: " / ",
|
|
and: " AND ",
|
|
or: " OR ",
|
|
ilike: " LIKE ",
|
|
like: " LIKE "
|
|
]
|
|
|
|
@binary_ops Keyword.keys(binary_ops)
|
|
|
|
Enum.map(binary_ops, fn {op, str} ->
|
|
defp handle_call(unquote(op), 2), do: {:binary_op, unquote(str)}
|
|
end)
|
|
|
|
defp handle_call(fun, _arity), do: {:fun, Atom.to_string(fun)}
|
|
|
|
defp select(%{select: %{fields: fields}, distinct: distinct} = query, sources) do
|
|
[
|
|
"SELECT ",
|
|
distinct(distinct, sources, query),
|
|
limit(query, sources),
|
|
select(fields, sources, query)
|
|
]
|
|
end
|
|
|
|
defp distinct(nil, _sources, _query), do: []
|
|
defp distinct(%ByExpr{expr: true}, _sources, _query), do: "DISTINCT "
|
|
defp distinct(%ByExpr{expr: false}, _sources, _query), do: []
|
|
|
|
defp distinct(%ByExpr{expr: exprs}, _sources, query) when is_list(exprs) do
|
|
error!(
|
|
query,
|
|
"DISTINCT with multiple columns is not supported by MsSQL. " <>
|
|
"Please use distinct(true) if you need distinct resultset"
|
|
)
|
|
end
|
|
|
|
defp select([], _sources, _query) do
|
|
"CAST(1 as bit)"
|
|
end
|
|
|
|
defp select(fields, sources, query) do
|
|
Enum.map_intersperse(fields, ", ", fn
|
|
{:&, _, [idx]} ->
|
|
case elem(sources, idx) do
|
|
{nil, source, nil} ->
|
|
error!(
|
|
query,
|
|
"Tds adapter does not support selecting all fields from fragment #{source}. " <>
|
|
"Please specify exactly which fields you want to select"
|
|
)
|
|
|
|
{source, _, nil} ->
|
|
error!(
|
|
query,
|
|
"Tds adapter does not support selecting all fields from #{source} without a schema. " <>
|
|
"Please specify a schema or specify exactly which fields you want in projection"
|
|
)
|
|
|
|
{_, source, _} ->
|
|
source
|
|
end
|
|
|
|
{key, value} ->
|
|
[select_expr(value, sources, query), " AS ", quote_name(key)]
|
|
|
|
value ->
|
|
select_expr(value, sources, query)
|
|
end)
|
|
end
|
|
|
|
defp select_expr({:not, _, [expr]}, sources, query) do
|
|
[?~, ?(, select_expr(expr, sources, query), ?)]
|
|
end
|
|
|
|
defp select_expr(value, sources, query), do: expr(value, sources, query)
|
|
|
|
defp from(%{from: %{source: source, hints: hints}} = query, sources) do
|
|
{from, name} = get_source(query, sources, 0, source)
|
|
|
|
[" FROM ", from, " AS ", name, hints(hints)]
|
|
end
|
|
|
|
defp cte(%{with_ctes: %WithExpr{queries: [_ | _] = queries}} = query, sources) do
|
|
ctes = Enum.map_intersperse(queries, ", ", &cte_expr(&1, sources, query))
|
|
["WITH ", ctes, " "]
|
|
end
|
|
|
|
defp cte(%{with_ctes: _}, _), do: []
|
|
|
|
defp cte_expr({_name, %{materialized: materialized}, _cte}, _sources, query)
|
|
when is_boolean(materialized) do
|
|
error!(query, "Tds adapter does not support materialized CTEs")
|
|
end
|
|
|
|
defp cte_expr({name, opts, cte}, sources, query) do
|
|
operation_opt = Map.get(opts, :operation)
|
|
|
|
[
|
|
quote_name(name),
|
|
cte_header(cte, query),
|
|
" AS ",
|
|
cte_query(cte, sources, query, operation_opt)
|
|
]
|
|
end
|
|
|
|
defp cte_header(%QueryExpr{}, query) do
|
|
error!(
|
|
query,
|
|
"Tds adapter does not support fragment in CTE"
|
|
)
|
|
end
|
|
|
|
defp cte_header(%Ecto.Query{select: %{fields: fields}} = query, _) do
|
|
[
|
|
" (",
|
|
Enum.map_intersperse(fields, ",", fn
|
|
{key, _} ->
|
|
quote_name(key)
|
|
|
|
other ->
|
|
error!(
|
|
query,
|
|
"Tds adapter expected field name or alias in CTE header," <>
|
|
" instead got #{inspect(other)}"
|
|
)
|
|
end),
|
|
?)
|
|
]
|
|
end
|
|
|
|
defp cte_query(query, sources, parent_query, nil) do
|
|
cte_query(query, sources, parent_query, :all)
|
|
end
|
|
|
|
defp cte_query(%Ecto.Query{} = query, sources, parent_query, :all) do
|
|
query = put_in(query.aliases[@parent_as], {parent_query, sources})
|
|
[?(, all(query, subquery_as_prefix(sources)), ?)]
|
|
end
|
|
|
|
defp cte_query(%Ecto.Query{} = query, _sources, _parent_query, operation) do
|
|
error!(query, "Tds adapter does not support data-modifying CTEs (operation: #{operation})")
|
|
end
|
|
|
|
defp update_fields(%Query{updates: updates} = query, sources) do
|
|
for(
|
|
%{expr: expr} <- updates,
|
|
{op, kw} <- expr,
|
|
{key, value} <- kw,
|
|
do: update_op(op, key, value, sources, query)
|
|
)
|
|
|> Enum.intersperse(", ")
|
|
end
|
|
|
|
defp update_op(:set, key, value, sources, query) do
|
|
{_table, name, _model} = elem(sources, 0)
|
|
[name, ?., quote_name(key), " = " | expr(value, sources, query)]
|
|
end
|
|
|
|
defp update_op(:inc, key, value, sources, query) do
|
|
{_table, name, _model} = elem(sources, 0)
|
|
quoted = quote_name(key)
|
|
|
|
[name, ?., quoted, " = ", name, ?., quoted, " + " | expr(value, sources, query)]
|
|
end
|
|
|
|
defp update_op(command, _key, _value, _sources, query) do
|
|
error!(query, "Unknown update operation #{inspect(command)} for TDS")
|
|
end
|
|
|
|
defp join(%{joins: []}, _sources), do: []
|
|
|
|
defp join(%{joins: joins} = query, sources) do
|
|
[
|
|
?\s,
|
|
Enum.map_intersperse(joins, ?\s, fn
|
|
%JoinExpr{on: %QueryExpr{expr: expr}, qual: qual, ix: ix, source: source, hints: hints} ->
|
|
{join, name} = get_source(query, sources, ix, source)
|
|
qual_text = join_qual(qual, query)
|
|
join = join || ["(", expr(source, sources, query) | ")"]
|
|
[qual_text, join, " AS ", name, hints(hints) | join_on(qual, expr, sources, query)]
|
|
end)
|
|
]
|
|
end
|
|
|
|
defp join_on(:cross, true, _sources, _query), do: []
|
|
defp join_on(:inner_lateral, true, _sources, _query), do: []
|
|
defp join_on(:left_lateral, true, _sources, _query), do: []
|
|
defp join_on(_qual, true, _sources, _query), do: [" ON 1 = 1"]
|
|
defp join_on(_qual, expr, sources, query), do: [" ON " | expr(expr, sources, query)]
|
|
|
|
defp join_qual(:inner, _), do: "INNER JOIN "
|
|
defp join_qual(:left, _), do: "LEFT OUTER JOIN "
|
|
defp join_qual(:right, _), do: "RIGHT OUTER JOIN "
|
|
defp join_qual(:full, _), do: "FULL OUTER JOIN "
|
|
defp join_qual(:cross, _), do: "CROSS JOIN "
|
|
defp join_qual(:inner_lateral, _), do: "CROSS APPLY "
|
|
defp join_qual(:left_lateral, _), do: "OUTER APPLY "
|
|
|
|
defp join_qual(qual, query),
|
|
do: error!(query, "join qualifier #{inspect(qual)} is not supported in the Tds adapter")
|
|
|
|
defp where(%Query{wheres: wheres} = query, sources) do
|
|
boolean(" WHERE ", wheres, sources, query)
|
|
end
|
|
|
|
defp having(%Query{havings: havings} = query, sources) do
|
|
boolean(" HAVING ", havings, sources, query)
|
|
end
|
|
|
|
defp window(%{windows: []}, _sources), do: []
|
|
|
|
defp window(_query, _sources),
|
|
do: raise(RuntimeError, "Tds adapter does not support window functions")
|
|
|
|
defp group_by(%{group_bys: []}, _sources), do: []
|
|
|
|
defp group_by(%{group_bys: group_bys} = query, sources) do
|
|
[
|
|
" GROUP BY "
|
|
| Enum.map_intersperse(group_bys, ", ", fn %ByExpr{expr: expr} ->
|
|
Enum.map_intersperse(expr, ", ", &top_level_expr(&1, sources, query))
|
|
end)
|
|
]
|
|
end
|
|
|
|
defp order_by(%{order_bys: []}, _sources), do: []
|
|
|
|
defp order_by(%{order_bys: order_bys} = query, sources) do
|
|
[
|
|
" ORDER BY "
|
|
| Enum.map_intersperse(order_bys, ", ", fn %ByExpr{expr: expr} ->
|
|
Enum.map_intersperse(expr, ", ", &order_by_expr(&1, sources, query))
|
|
end)
|
|
]
|
|
end
|
|
|
|
defp order_by_expr({dir, expr}, sources, query) do
|
|
str = top_level_expr(expr, sources, query)
|
|
|
|
case dir do
|
|
:asc -> str
|
|
:desc -> [str | " DESC"]
|
|
_ -> error!(query, "#{dir} is not supported in ORDER BY in MSSQL")
|
|
end
|
|
end
|
|
|
|
defp limit(%Query{limit: nil}, _sources), do: []
|
|
|
|
defp limit(%Query{limit: %{with_ties: true}} = query, _sources) do
|
|
error!(query, "Tds adapter does not support the `:with_ties` limit option")
|
|
end
|
|
|
|
defp limit(
|
|
%Query{
|
|
limit: %{
|
|
expr: expr
|
|
}
|
|
} = query,
|
|
sources
|
|
) do
|
|
case Map.get(query, :offset) do
|
|
nil ->
|
|
["TOP(", expr(expr, sources, query), ") "]
|
|
|
|
_ ->
|
|
[]
|
|
end
|
|
end
|
|
|
|
defp offset(%{offset: nil}, _sources), do: []
|
|
|
|
defp offset(%Query{offset: _, limit: nil} = query, _sources) do
|
|
error!(query, "You must provide a limit while using an offset")
|
|
end
|
|
|
|
defp offset(%{offset: offset, limit: limit} = query, sources) do
|
|
[
|
|
" OFFSET ",
|
|
expr(offset.expr, sources, query),
|
|
" ROW",
|
|
" FETCH NEXT ",
|
|
expr(limit.expr, sources, query),
|
|
" ROWS ONLY"
|
|
]
|
|
end
|
|
|
|
defp hints([_ | _] = hints), do: [" WITH (", Enum.intersperse(hints, ", "), ?)]
|
|
defp hints([]), do: []
|
|
|
|
defp lock(%{lock: nil}, _sources), do: []
|
|
defp lock(%{lock: binary}, _sources) when is_binary(binary), do: [" OPTION (", binary, ?)]
|
|
defp lock(%{lock: expr} = query, sources), do: [" OPTION (", expr(expr, sources, query), ?)]
|
|
|
|
defp combinations(%{combinations: combinations}, as_prefix) do
|
|
Enum.map(combinations, fn
|
|
{:union, query} -> [" UNION (", all(query, as_prefix), ")"]
|
|
{:union_all, query} -> [" UNION ALL (", all(query, as_prefix), ")"]
|
|
{:except, query} -> [" EXCEPT (", all(query, as_prefix), ")"]
|
|
{:except_all, query} -> [" EXCEPT ALL (", all(query, as_prefix), ")"]
|
|
{:intersect, query} -> [" INTERSECT (", all(query, as_prefix), ")"]
|
|
{:intersect_all, query} -> [" INTERSECT ALL (", all(query, as_prefix), ")"]
|
|
end)
|
|
end
|
|
|
|
defp boolean(_name, [], _sources, _query), do: []
|
|
|
|
defp boolean(name, [%{expr: expr, op: op} | query_exprs], sources, query) do
|
|
[
|
|
name
|
|
| Enum.reduce(query_exprs, {op, paren_expr(expr, sources, query)}, fn
|
|
%BooleanExpr{expr: expr, op: op}, {op, acc} ->
|
|
{op, [acc, operator_to_boolean(op), paren_expr(expr, sources, query)]}
|
|
|
|
%BooleanExpr{expr: expr, op: op}, {_, acc} ->
|
|
{op, [?(, acc, ?), operator_to_boolean(op), paren_expr(expr, sources, query)]}
|
|
end)
|
|
|> elem(1)
|
|
]
|
|
end
|
|
|
|
defp operator_to_boolean(:and), do: " AND "
|
|
defp operator_to_boolean(:or), do: " OR "
|
|
|
|
defp parens_for_select([first_expr | _] = expr) do
|
|
if is_binary(first_expr) and String.match?(first_expr, ~r/^\s*select\s/i) do
|
|
[?(, expr, ?)]
|
|
else
|
|
expr
|
|
end
|
|
end
|
|
|
|
defp paren_expr(true, _sources, _query) do
|
|
["(1 = 1)"]
|
|
end
|
|
|
|
defp paren_expr(false, _sources, _query) do
|
|
["(1 = 0)"]
|
|
end
|
|
|
|
defp paren_expr(expr, sources, query) do
|
|
[?(, expr(expr, sources, query), ?)]
|
|
end
|
|
|
|
defp top_level_expr(%Ecto.SubQuery{query: query}, sources, parent_query) do
|
|
combinations =
|
|
Enum.map(query.combinations, fn {type, combination_query} ->
|
|
{type, put_in(combination_query.aliases[@parent_as], {parent_query, sources})}
|
|
end)
|
|
|
|
query = put_in(query.combinations, combinations)
|
|
query = put_in(query.aliases[@parent_as], {parent_query, sources})
|
|
[all(query, subquery_as_prefix(sources))]
|
|
end
|
|
|
|
defp top_level_expr(other, sources, parent_query) do
|
|
expr(other, sources, parent_query)
|
|
end
|
|
|
|
# :^ - represents parameter ix is index number
|
|
defp expr({:^, [], [idx]}, _sources, _query) do
|
|
"@#{idx + 1}"
|
|
end
|
|
|
|
defp expr({{:., _, [{:parent_as, _, [as]}, field]}, _, []}, _sources, query)
|
|
when is_atom(field) do
|
|
{ix, sources} = get_parent_sources_ix(query, as)
|
|
{_, name, _} = elem(sources, ix)
|
|
[name, ?. | quote_name(field)]
|
|
end
|
|
|
|
defp expr({{:., _, [{:&, _, [idx]}, field]}, _, []}, sources, _query)
|
|
when is_atom(field) or is_binary(field) do
|
|
{_, name, _} = elem(sources, idx)
|
|
[name, ?. | quote_name(field)]
|
|
end
|
|
|
|
defp expr({:&, _, [idx]}, sources, _query) do
|
|
{_table, source, _schema} = elem(sources, idx)
|
|
source
|
|
end
|
|
|
|
defp expr({:&, _, [idx, fields, _counter]}, sources, query) do
|
|
{_table, name, schema} = elem(sources, idx)
|
|
|
|
if is_nil(schema) and is_nil(fields) do
|
|
error!(
|
|
query,
|
|
"Tds adapter requires a schema module when using selector #{inspect(name)} but " <>
|
|
"none was given. Please specify schema " <>
|
|
"or specify exactly which fields from #{inspect(name)} you what in projection"
|
|
)
|
|
end
|
|
|
|
Enum.map_join(fields, ", ", &"#{name}.#{quote_name(&1)}")
|
|
end
|
|
|
|
# example from {:in, [], [1, {:^, [], [0, 0]}]}
|
|
defp expr({:in, _, [_left, []]}, _sources, _query) do
|
|
"0=1"
|
|
end
|
|
|
|
# example from(p in Post, where: p.id in [1,2, ^some_id])
|
|
defp expr({:in, _, [left, right]}, sources, query) when is_list(right) do
|
|
args = Enum.map_join(right, ",", &expr(&1, sources, query))
|
|
[expr(left, sources, query), " IN (", args | ")"]
|
|
end
|
|
|
|
# example from(p in Post, where: p.id in [])
|
|
defp expr({:in, _, [_, {:^, _, [_, 0]}]}, _sources, _query), do: "0=1"
|
|
|
|
# example from(p in Post, where: p.id in ^some_list)
|
|
# or from(p in Post, where: p.id in ^[])
|
|
defp expr({:in, _, [left, {:^, _, [idx, length]}]}, sources, query) do
|
|
args = list_param_to_args(idx, length)
|
|
[expr(left, sources, query), " IN (", args | ")"]
|
|
end
|
|
|
|
defp expr({:in, _, [left, %Ecto.SubQuery{} = subquery]}, sources, query) do
|
|
[expr(left, sources, query), " IN ", expr(subquery, sources, query)]
|
|
end
|
|
|
|
defp expr({:in, _, [left, right]}, sources, query) do
|
|
[expr(left, sources, query), " = ANY(", expr(right, sources, query) | ")"]
|
|
end
|
|
|
|
defp expr({:is_nil, _, [arg]}, sources, query) do
|
|
"#{expr(arg, sources, query)} IS NULL"
|
|
end
|
|
|
|
defp expr({:not, _, [expr]}, sources, query) do
|
|
["NOT (", expr(expr, sources, query) | ")"]
|
|
end
|
|
|
|
defp expr({:filter, _, _}, _sources, query) do
|
|
error!(query, "Tds adapter does not support aggregate filters")
|
|
end
|
|
|
|
defp expr(%Ecto.SubQuery{} = subquery, sources, parent_query) do
|
|
[?(, top_level_expr(subquery, sources, parent_query), ?)]
|
|
end
|
|
|
|
defp expr({:fragment, _, [kw]}, _sources, query) when is_list(kw) or tuple_size(kw) == 3 do
|
|
error!(query, "Tds adapter does not support keyword or interpolated fragments")
|
|
end
|
|
|
|
defp expr({:fragment, _, parts}, sources, query) do
|
|
Enum.map(parts, fn
|
|
{:raw, part} -> part
|
|
{:expr, expr} -> expr(expr, sources, query)
|
|
end)
|
|
|> parens_for_select
|
|
end
|
|
|
|
defp expr({:values, _, [types, idx, num_rows]}, _, _query) do
|
|
[?(, values_list(types, idx + 1, num_rows), ?)]
|
|
end
|
|
|
|
defp expr({:literal, _, [literal]}, _sources, _query) do
|
|
quote_name(literal)
|
|
end
|
|
|
|
defp expr({:splice, _, [{:^, _, [idx, length]}]}, _sources, _query) do
|
|
list_param_to_args(idx, length)
|
|
end
|
|
|
|
defp expr({:selected_as, _, [name]}, _sources, _query) do
|
|
[quote_name(name)]
|
|
end
|
|
|
|
defp expr({:datetime_add, _, [datetime, count, interval]}, sources, query) do
|
|
[
|
|
"DATEADD(",
|
|
interval,
|
|
", ",
|
|
interval_count(count, sources, query),
|
|
", CAST(",
|
|
expr(datetime, sources, query),
|
|
" AS datetime2(6)))"
|
|
]
|
|
end
|
|
|
|
defp expr({:date_add, _, [date, count, interval]}, sources, query) do
|
|
[
|
|
"CAST(DATEADD(",
|
|
interval,
|
|
", ",
|
|
interval_count(count, sources, query),
|
|
", CAST(",
|
|
expr(date, sources, query),
|
|
" AS datetime2(6))" | ") AS date)"
|
|
]
|
|
end
|
|
|
|
defp expr({:count, _, []}, _sources, _query), do: "count(*)"
|
|
|
|
defp expr({:json_extract_path, _, _}, _sources, query) do
|
|
error!(
|
|
query,
|
|
"Tds adapter does not support json_extract_path expression" <>
|
|
", use fragment with JSON_VALUE/JSON_QUERY"
|
|
)
|
|
end
|
|
|
|
defp expr({fun, _, args}, sources, query) when is_atom(fun) and is_list(args) do
|
|
{modifier, args} =
|
|
case args do
|
|
[rest, :distinct] -> {"DISTINCT ", [rest]}
|
|
_ -> {"", args}
|
|
end
|
|
|
|
case handle_call(fun, length(args)) do
|
|
{:binary_op, op} ->
|
|
[left, right] = args
|
|
[op_to_binary(left, sources, query), op | op_to_binary(right, sources, query)]
|
|
|
|
{:fun, fun} ->
|
|
[
|
|
fun,
|
|
?(,
|
|
modifier,
|
|
Enum.map_intersperse(args, ", ", &top_level_expr(&1, sources, query)),
|
|
?)
|
|
]
|
|
end
|
|
end
|
|
|
|
defp expr(list, sources, query) when is_list(list) do
|
|
Enum.map_join(list, ", ", &expr(&1, sources, query))
|
|
end
|
|
|
|
defp expr({string, :varchar}, _sources, _query)
|
|
when is_binary(string) do
|
|
"'#{escape_string(string)}'"
|
|
end
|
|
|
|
defp expr(string, _sources, _query) when is_binary(string) do
|
|
"N'#{escape_string(string)}'"
|
|
end
|
|
|
|
defp expr(%Decimal{exp: exp} = decimal, _sources, _query) do
|
|
# this should help gaining precision for decimals values embedded in query
|
|
# but this is still not good enough, for instance:
|
|
#
|
|
# from(p in Post, select: type(2.0 + ^"2", p.cost())))
|
|
#
|
|
# Post.cost is :decimal, but we don't know precision and scale since
|
|
# such info is only available in migration files. So query compilation
|
|
# will yield
|
|
#
|
|
# SELECT CAST(CAST(2.0 as decimal(38, 1)) + @1 AS decimal)
|
|
# FROM [posts] AS p0
|
|
#
|
|
# as long as we have CAST(... as DECIMAL) without precision and scale
|
|
# value could be truncated
|
|
[
|
|
"CAST(",
|
|
Decimal.to_string(decimal, :normal),
|
|
" as decimal(38, #{abs(exp)})",
|
|
?)
|
|
]
|
|
end
|
|
|
|
defp expr(%Tagged{value: binary, type: :binary}, _sources, _query) when is_binary(binary) do
|
|
hex = Base.encode16(binary, case: :lower)
|
|
"0x#{hex}"
|
|
end
|
|
|
|
defp expr(%Tagged{value: binary, type: :uuid}, _sources, _query) when is_binary(binary) do
|
|
case binary do
|
|
<<_::64, ?-, _::32, ?-, _::32, ?-, _::32, ?-, _::96>> ->
|
|
{:ok, value} = Tds.Ecto.UUID.dump(binary)
|
|
value
|
|
|
|
any ->
|
|
any
|
|
end
|
|
end
|
|
|
|
defp expr(%Tagged{value: other, type: type}, sources, query)
|
|
when type in [:varchar, :nvarchar] do
|
|
"CAST(#{expr(other, sources, query)} AS #{column_type(type, [])}(max))"
|
|
end
|
|
|
|
defp expr(%Tagged{value: other, type: :integer}, sources, query) do
|
|
"CAST(#{expr(other, sources, query)} AS bigint)"
|
|
end
|
|
|
|
defp expr(%Tagged{value: other, type: type}, sources, query) do
|
|
"CAST(#{expr(other, sources, query)} AS #{column_type(type, [])})"
|
|
end
|
|
|
|
defp expr(nil, _sources, _query), do: "NULL"
|
|
defp expr(true, _sources, _query), do: "1"
|
|
defp expr(false, _sources, _query), do: "0"
|
|
|
|
defp expr(literal, _sources, _query) when is_binary(literal) do
|
|
"'#{escape_string(literal)}'"
|
|
end
|
|
|
|
defp expr(literal, _sources, _query) when is_integer(literal) do
|
|
Integer.to_string(literal)
|
|
end
|
|
|
|
defp expr(literal, _sources, _query) when is_float(literal) do
|
|
Float.to_string(literal)
|
|
end
|
|
|
|
defp expr(field, _sources, query) do
|
|
error!(query, "unsupported MSSQL expressions: `#{inspect(field)}`")
|
|
end
|
|
|
|
defp values_list(types, idx, num_rows) do
|
|
rows = Enum.to_list(1..num_rows)
|
|
|
|
[
|
|
"VALUES ",
|
|
intersperse_reduce(rows, ?,, idx, fn _, idx ->
|
|
{value, idx} = values_expr(types, idx)
|
|
{[?(, value, ?)], idx}
|
|
end)
|
|
|> elem(0)
|
|
]
|
|
end
|
|
|
|
defp values_expr(types, idx) do
|
|
intersperse_reduce(types, ?,, idx, fn {_field, type}, idx ->
|
|
{["CAST(", ?@, Integer.to_string(idx), " AS ", column_type(type, []), ?)], idx + 1}
|
|
end)
|
|
end
|
|
|
|
defp op_to_binary({op, _, [_, _]} = expr, sources, query) when op in @binary_ops do
|
|
paren_expr(expr, sources, query)
|
|
end
|
|
|
|
defp op_to_binary({:is_nil, _, [_]} = expr, sources, query) do
|
|
paren_expr(expr, sources, query)
|
|
end
|
|
|
|
defp op_to_binary(expr, sources, query) do
|
|
expr(expr, sources, query)
|
|
end
|
|
|
|
defp interval_count(count, _sources, _query) when is_integer(count) do
|
|
Integer.to_string(count)
|
|
end
|
|
|
|
defp interval_count(count, _sources, _query) when is_float(count) do
|
|
:erlang.float_to_binary(count, [:compact, decimals: 16])
|
|
end
|
|
|
|
defp interval_count(count, sources, query) do
|
|
expr(count, sources, query)
|
|
end
|
|
|
|
defp returning([], _verb), do: []
|
|
|
|
defp returning(returning, verb) when is_list(returning) do
|
|
[" OUTPUT ", Enum.map_intersperse(returning, ", ", &[verb, ?., quote_name(&1)])]
|
|
end
|
|
|
|
defp returning(%{select: nil}, _, _),
|
|
do: []
|
|
|
|
defp returning(%{select: %{fields: fields}} = query, idx, verb),
|
|
do: [
|
|
" OUTPUT "
|
|
| Enum.map_intersperse(fields, ", ", fn
|
|
{{:., _, [{:&, _, [^idx]}, key]}, _, _} -> [verb, ?., quote_name(key)]
|
|
_ -> error!(query, "MSSQL can only return table #{verb} columns")
|
|
end)
|
|
]
|
|
|
|
defp create_names(%{sources: sources}, as_prefix) do
|
|
create_names(sources, 0, tuple_size(sources), as_prefix) |> List.to_tuple()
|
|
end
|
|
|
|
defp create_names(sources, pos, limit, as_prefix) when pos < limit do
|
|
[create_name(sources, pos, as_prefix) | create_names(sources, pos + 1, limit, as_prefix)]
|
|
end
|
|
|
|
defp create_names(_sources, pos, pos, as_prefix) do
|
|
[as_prefix]
|
|
end
|
|
|
|
defp subquery_as_prefix(sources) do
|
|
[?s | :erlang.element(tuple_size(sources), sources)]
|
|
end
|
|
|
|
defp create_name(sources, pos, as_prefix) do
|
|
case elem(sources, pos) do
|
|
{:fragment, _, _} ->
|
|
{nil, as_prefix ++ [?f | Integer.to_string(pos)], nil}
|
|
|
|
{:values, _, _} ->
|
|
{nil, as_prefix ++ [?v | Integer.to_string(pos)], nil}
|
|
|
|
{table, model, prefix} ->
|
|
name = as_prefix ++ [create_alias(table) | Integer.to_string(pos)]
|
|
{quote_table(prefix, table), name, model}
|
|
|
|
%Ecto.SubQuery{} ->
|
|
{nil, as_prefix ++ [?s | Integer.to_string(pos)], nil}
|
|
end
|
|
end
|
|
|
|
defp create_alias(<<first, _rest::binary>>) when first in ?a..?z when first in ?A..?Z do
|
|
first
|
|
end
|
|
|
|
defp create_alias(_) do
|
|
?t
|
|
end
|
|
|
|
# DDL
|
|
alias Ecto.Migration.{Table, Index, Reference, Constraint}
|
|
|
|
@creates [:create, :create_if_not_exists]
|
|
@drops [:drop, :drop_if_exists]
|
|
|
|
@impl true
|
|
def execute_ddl({command, %Table{} = table, columns}) when command in @creates do
|
|
prefix = table.prefix
|
|
|
|
pk_name =
|
|
if table.prefix,
|
|
do: "#{table.prefix}_#{table.name}",
|
|
else: table.name
|
|
|
|
table_structure =
|
|
table
|
|
|> column_definitions(columns)
|
|
|> Kernel.++(pk_definitions(columns, ", CONSTRAINT [#{pk_name}_pkey] "))
|
|
|> case do
|
|
[] -> []
|
|
list -> [" (", list, ?)]
|
|
end
|
|
|
|
create_if_not_exists =
|
|
if_table_not_exists(command == :create_if_not_exists, table.name, prefix)
|
|
|
|
[
|
|
[
|
|
create_if_not_exists,
|
|
"CREATE TABLE ",
|
|
quote_table(prefix, table.name),
|
|
table_structure,
|
|
engine_expr(table.engine),
|
|
options_expr(table.options),
|
|
"; "
|
|
]
|
|
]
|
|
end
|
|
|
|
def execute_ddl({command, %Table{}, :cascade}) when command in @drops,
|
|
do: error!(nil, "MSSQL does not support `CASCADE` in DROP TABLE commands")
|
|
|
|
def execute_ddl({command, %Table{} = table, :restrict}) when command in @drops do
|
|
prefix = table.prefix
|
|
|
|
[
|
|
[
|
|
if_table_exists(command == :drop_if_exists, table.name, prefix),
|
|
"DROP TABLE ",
|
|
quote_table(prefix, table.name),
|
|
"; "
|
|
]
|
|
]
|
|
end
|
|
|
|
def execute_ddl({:alter, %Table{} = table, changes}) do
|
|
statement_prefix = ["ALTER TABLE ", quote_table(table.prefix, table.name), " "]
|
|
|
|
pk_name =
|
|
if table.prefix,
|
|
do: "#{table.prefix}_#{table.name}",
|
|
else: table.name
|
|
|
|
pkeys =
|
|
case pk_definitions(changes, " CONSTRAINT [#{pk_name}_pkey] ") do
|
|
[] -> []
|
|
sql -> [statement_prefix, "ADD", sql]
|
|
end
|
|
|
|
[
|
|
[
|
|
column_changes(statement_prefix, table, changes),
|
|
pkeys
|
|
]
|
|
]
|
|
end
|
|
|
|
def execute_ddl({command, %Index{} = index}) when command in @creates do
|
|
prefix = index.prefix
|
|
|
|
if index.using do
|
|
error!(nil, "MSSQL does not support `using` in indexes")
|
|
end
|
|
|
|
if index.nulls_distinct == true do
|
|
error!(nil, "MSSQL does not support nulls_distinct set to true in indexes")
|
|
end
|
|
|
|
with_options =
|
|
if index.concurrently or index.options != nil do
|
|
[
|
|
" WITH",
|
|
?(,
|
|
if_do(index.concurrently, "ONLINE=ON"),
|
|
if_do(index.concurrently and index.options != nil, ","),
|
|
if_do(index.options != nil, index.options),
|
|
?)
|
|
]
|
|
else
|
|
[]
|
|
end
|
|
|
|
include =
|
|
index.include
|
|
|> List.wrap()
|
|
|> Enum.map_intersperse(", ", &index_expr/1)
|
|
|
|
[
|
|
[
|
|
if_index_not_exists(
|
|
command == :create_if_not_exists,
|
|
index.name,
|
|
unquoted_name(prefix, index.table)
|
|
),
|
|
"CREATE",
|
|
if_do(index.unique, " UNIQUE"),
|
|
" INDEX ",
|
|
quote_name(index.name),
|
|
" ON ",
|
|
quote_table(prefix, index.table),
|
|
" (",
|
|
Enum.map_intersperse(index.columns, ", ", &index_expr/1),
|
|
?),
|
|
if_do(include != [], [" INCLUDE ", ?(, include, ?)]),
|
|
if_do(index.where, [" WHERE (", index.where, ?)]),
|
|
with_options,
|
|
?;
|
|
]
|
|
]
|
|
end
|
|
|
|
def execute_ddl({:create, %Constraint{exclude: exclude}}) when exclude != nil do
|
|
msg =
|
|
"`:exclude` is not supported Tds adapter check constraint parameter, instead " <>
|
|
"set `:check` attribute with negated expression."
|
|
|
|
error!(nil, msg)
|
|
end
|
|
|
|
def execute_ddl({:create, %Constraint{validate: false}}) do
|
|
error!(nil, "`:validate` is not supported by the Tds adapter")
|
|
end
|
|
|
|
def execute_ddl({:create, %Constraint{} = constraint}) do
|
|
table_name = quote_table(constraint.prefix, constraint.table)
|
|
|
|
[
|
|
[
|
|
"ALTER TABLE ",
|
|
table_name,
|
|
" ADD CONSTRAINT ",
|
|
quote_name(constraint.name),
|
|
" ",
|
|
"CHECK (",
|
|
constraint.check,
|
|
"); "
|
|
]
|
|
]
|
|
end
|
|
|
|
def execute_ddl({:rename, %Index{} = current_index, new_name}) do
|
|
[
|
|
[
|
|
"sp_rename ",
|
|
"N'#{current_index.table}.#{current_index.name}', ",
|
|
"N'#{new_name}', ",
|
|
"N'INDEX'"
|
|
]
|
|
]
|
|
end
|
|
|
|
def execute_ddl({command, %Index{}, :cascade}) when command in @drops,
|
|
do: error!(nil, "MSSQL does not support `CASCADE` in DROP INDEX commands")
|
|
|
|
def execute_ddl({command, %Index{} = index, :restrict}) when command in @drops do
|
|
prefix = index.prefix
|
|
|
|
[
|
|
[
|
|
if_index_exists(
|
|
command == :drop_if_exists,
|
|
index.name,
|
|
unquoted_name(prefix, index.table)
|
|
),
|
|
"DROP INDEX ",
|
|
quote_name(index.name),
|
|
" ON ",
|
|
quote_table(prefix, index.table),
|
|
if_do(index.concurrently, " LOCK=NONE"),
|
|
"; "
|
|
]
|
|
]
|
|
end
|
|
|
|
def execute_ddl({command, %Constraint{}, :cascade}) when command in @drops,
|
|
do: error!(nil, "MSSQL does not support `CASCADE` in DROP CONSTRAINT commands")
|
|
|
|
def execute_ddl({command, %Constraint{} = constraint, _}) when command in @drops do
|
|
table_name = quote_table(constraint.prefix, constraint.table)
|
|
|
|
[
|
|
[
|
|
if_check_constraint_exists(
|
|
command == :drop_if_exists,
|
|
constraint.name,
|
|
constraint.prefix
|
|
),
|
|
"ALTER TABLE ",
|
|
table_name,
|
|
" DROP CONSTRAINT ",
|
|
quote_name(constraint.name),
|
|
"; "
|
|
]
|
|
]
|
|
end
|
|
|
|
def execute_ddl({:rename, %Table{} = current_table, %Table{} = new_table}) do
|
|
[
|
|
[
|
|
"EXEC sp_rename '",
|
|
unquoted_name(current_table.prefix, current_table.name),
|
|
"', '",
|
|
unquoted_name(new_table.prefix, new_table.name),
|
|
"'"
|
|
]
|
|
]
|
|
end
|
|
|
|
def execute_ddl({:rename, table, current_column, new_column}) do
|
|
[
|
|
[
|
|
"EXEC sp_rename '",
|
|
unquoted_name(table.prefix, table.name, current_column),
|
|
"', '",
|
|
unquoted_name(new_column),
|
|
"', 'COLUMN'"
|
|
]
|
|
]
|
|
end
|
|
|
|
def execute_ddl(string) when is_binary(string), do: [string]
|
|
|
|
def execute_ddl(keyword) when is_list(keyword),
|
|
do: error!(nil, "Tds adapter does not support keyword lists in execute")
|
|
|
|
@impl true
|
|
def ddl_logs(_), do: []
|
|
|
|
@impl true
|
|
def table_exists_query(table) do
|
|
{"SELECT 1 FROM sys.tables WHERE [name] = @1", [table]}
|
|
end
|
|
|
|
defp pk_definitions(columns, prefix) do
|
|
pks =
|
|
for {action, name, _, opts} <- columns,
|
|
action != :remove,
|
|
opts[:primary_key],
|
|
do: name
|
|
|
|
case pks do
|
|
[] ->
|
|
[]
|
|
|
|
_ ->
|
|
[prefix, "PRIMARY KEY CLUSTERED (", quote_names(pks), ?)]
|
|
end
|
|
end
|
|
|
|
defp column_definitions(table, columns) do
|
|
Enum.map_intersperse(columns, ", ", &column_definition(table, &1))
|
|
end
|
|
|
|
defp column_definition(table, {:add, name, %Reference{} = ref, opts}) do
|
|
[
|
|
quote_name(name),
|
|
" ",
|
|
reference_column_type(ref.type, opts),
|
|
column_options(table, name, opts),
|
|
reference_expr(ref, table, name)
|
|
]
|
|
end
|
|
|
|
defp column_definition(table, {:add, name, type, opts}) do
|
|
[quote_name(name), " ", column_type(type, opts), column_options(table, name, opts)]
|
|
end
|
|
|
|
defp column_changes(statement, table, columns) do
|
|
for column <- columns do
|
|
column_change(statement, table, column)
|
|
end
|
|
end
|
|
|
|
defp column_change(_, _, {_, _, %Reference{validate: false}, _}) do
|
|
error!(nil, "validate: false on references is not supported in Tds")
|
|
end
|
|
|
|
defp column_change(statement_prefix, table, {:add, name, %Reference{} = ref, opts}) do
|
|
[
|
|
[
|
|
statement_prefix,
|
|
"ADD ",
|
|
quote_name(name),
|
|
" ",
|
|
reference_column_type(ref.type, opts),
|
|
column_options(table, name, opts),
|
|
"; "
|
|
],
|
|
[statement_prefix, "ADD", constraint_expr(ref, table, name), "; "]
|
|
]
|
|
end
|
|
|
|
defp column_change(statement_prefix, table, {:add, name, type, opts}) do
|
|
[
|
|
[
|
|
statement_prefix,
|
|
"ADD ",
|
|
quote_name(name),
|
|
" ",
|
|
column_type(type, opts),
|
|
column_options(table, name, opts),
|
|
"; "
|
|
]
|
|
]
|
|
end
|
|
|
|
defp column_change(
|
|
statement_prefix,
|
|
%{name: table_name, prefix: prefix} = table,
|
|
{:add_if_not_exists, column_name, type, opts}
|
|
) do
|
|
[
|
|
[
|
|
if_column_not_exists(prefix, table_name, column_name),
|
|
statement_prefix,
|
|
"ADD ",
|
|
quote_name(column_name),
|
|
" ",
|
|
column_type(type, opts),
|
|
column_options(table, column_name, opts),
|
|
"; "
|
|
]
|
|
]
|
|
end
|
|
|
|
defp column_change(statement_prefix, table, {:modify, name, %Reference{} = ref, opts}) do
|
|
[
|
|
drop_constraint_from_expr(opts[:from], table, name, statement_prefix),
|
|
maybe_drop_default_expr(statement_prefix, table, name, opts),
|
|
[
|
|
statement_prefix,
|
|
"ALTER COLUMN ",
|
|
quote_name(name),
|
|
" ",
|
|
reference_column_type(ref.type, opts),
|
|
column_options(table, name, opts),
|
|
"; "
|
|
],
|
|
[statement_prefix, "ADD", constraint_expr(ref, table, name), "; "],
|
|
[column_default_value(statement_prefix, table, name, opts)]
|
|
]
|
|
end
|
|
|
|
defp column_change(statement_prefix, table, {:modify, name, type, opts}) do
|
|
[
|
|
drop_constraint_from_expr(opts[:from], table, name, statement_prefix),
|
|
maybe_drop_default_expr(statement_prefix, table, name, opts),
|
|
[
|
|
statement_prefix,
|
|
"ALTER COLUMN ",
|
|
quote_name(name),
|
|
" ",
|
|
column_type(type, opts),
|
|
null_expr(Keyword.get(opts, :null)),
|
|
"; "
|
|
],
|
|
[column_default_value(statement_prefix, table, name, opts)]
|
|
]
|
|
end
|
|
|
|
defp column_change(statement_prefix, _table, {:remove, name}) do
|
|
[statement_prefix, "DROP COLUMN ", quote_name(name), "; "]
|
|
end
|
|
|
|
defp column_change(statement_prefix, _table, {:remove, name, _type, _opts}),
|
|
do: [statement_prefix, "DROP COLUMN ", quote_name(name)]
|
|
|
|
defp column_change(statement_prefix, table, {:remove_if_exists, column_name, _}),
|
|
do: column_change(statement_prefix, table, {:remove_if_exists, column_name})
|
|
|
|
defp column_change(
|
|
statement_prefix,
|
|
%{name: table, prefix: prefix},
|
|
{:remove_if_exists, column_name}
|
|
) do
|
|
[
|
|
[
|
|
if_column_exists(prefix, table, column_name),
|
|
statement_prefix,
|
|
"DROP COLUMN ",
|
|
quote_name(column_name),
|
|
"; "
|
|
]
|
|
]
|
|
end
|
|
|
|
defp column_options(table, name, opts) do
|
|
default = Keyword.fetch(opts, :default)
|
|
null = Keyword.get(opts, :null)
|
|
[null_expr(null), default_expr(table, name, default)]
|
|
end
|
|
|
|
defp column_default_value(statement_prefix, table, name, opts) do
|
|
default_expression = default_expr(table, name, Keyword.fetch(opts, :default))
|
|
|
|
case default_expression do
|
|
[] -> []
|
|
_ -> [statement_prefix, "ADD", default_expression, " FOR ", quote_name(name), "; "]
|
|
end
|
|
end
|
|
|
|
defp null_expr(false), do: [" NOT NULL"]
|
|
defp null_expr(true), do: [" NULL"]
|
|
defp null_expr(_), do: []
|
|
|
|
defp default_expr(_table, _name, {:ok, nil}),
|
|
do: []
|
|
|
|
defp default_expr(table, name, {:ok, literal}) when is_binary(literal),
|
|
do: [
|
|
" CONSTRAINT ",
|
|
constraint_name("DF", table, name),
|
|
" DEFAULT (N'",
|
|
escape_string(literal),
|
|
"')"
|
|
]
|
|
|
|
defp default_expr(table, name, {:ok, true}),
|
|
do: [" CONSTRAINT ", constraint_name("DF", table, name), " DEFAULT (1)"]
|
|
|
|
defp default_expr(table, name, {:ok, false}),
|
|
do: [" CONSTRAINT ", constraint_name("DF", table, name), " DEFAULT (0)"]
|
|
|
|
defp default_expr(table, name, {:ok, literal}) when is_number(literal),
|
|
do: [
|
|
" CONSTRAINT ",
|
|
constraint_name("DF", table, name),
|
|
" DEFAULT (",
|
|
to_string(literal),
|
|
")"
|
|
]
|
|
|
|
defp default_expr(table, name, {:ok, {:fragment, expr}}),
|
|
do: [" CONSTRAINT ", constraint_name("DF", table, name), " DEFAULT (", expr, ")"]
|
|
|
|
defp default_expr(_table, _name, :error), do: []
|
|
|
|
defp drop_constraint_from_expr({%Reference{} = ref, _opts}, table, name, stm_prefix),
|
|
do: drop_constraint_from_expr(ref, table, name, stm_prefix)
|
|
|
|
defp drop_constraint_from_expr(%Reference{} = ref, table, name, stm_prefix) do
|
|
[stm_prefix, "DROP CONSTRAINT ", reference_name(ref, table, name), "; "]
|
|
end
|
|
|
|
defp drop_constraint_from_expr(_, _, _, _),
|
|
do: []
|
|
|
|
defp maybe_drop_default_expr(statement_prefix, table, name, opts) do
|
|
if Keyword.has_key?(opts, :default) do
|
|
constraint_name = constraint_name("DF", table, name)
|
|
if_exists_drop_constraint(constraint_name, statement_prefix)
|
|
else
|
|
[]
|
|
end
|
|
end
|
|
|
|
defp constraint_name(type, table, name),
|
|
do: quote_name("#{type}_#{table.prefix}_#{table.name}_#{name}")
|
|
|
|
defp index_expr(literal) when is_binary(literal), do: literal
|
|
defp index_expr(literal), do: quote_name(literal)
|
|
|
|
defp engine_expr(_storage_engine), do: [""]
|
|
|
|
defp options_expr(nil), do: []
|
|
|
|
defp options_expr(keyword) when is_list(keyword),
|
|
do: error!(nil, "Tds adapter does not support keyword lists in :options")
|
|
|
|
defp options_expr(options), do: [" ", to_string(options)]
|
|
|
|
defp column_type(type, opts) do
|
|
size = Keyword.get(opts, :size)
|
|
precision = Keyword.get(opts, :precision)
|
|
scale = Keyword.get(opts, :scale)
|
|
generated = Keyword.get(opts, :generated)
|
|
[ecto_to_db(type, size, precision, scale), generated_expr(generated)]
|
|
end
|
|
|
|
defp generated_expr(nil), do: []
|
|
|
|
defp generated_expr(expr) when is_binary(expr) do
|
|
[" AS ", expr]
|
|
end
|
|
|
|
defp generated_expr(other) do
|
|
raise ArgumentError,
|
|
"the `:generated` option only accepts strings, received: #{inspect(other)}"
|
|
end
|
|
|
|
defp constraint_expr(%Reference{} = ref, table, name) do
|
|
{current_columns, reference_columns} = Enum.unzip([{name, ref.column} | ref.with])
|
|
|
|
if ref.match do
|
|
error!(nil, ":match is not supported in references for tds")
|
|
end
|
|
|
|
[
|
|
" CONSTRAINT ",
|
|
reference_name(ref, table, name),
|
|
" FOREIGN KEY (#{quote_names(current_columns)})",
|
|
" REFERENCES ",
|
|
quote_table(Keyword.get(ref.options, :prefix, table.prefix), ref.table),
|
|
"(#{quote_names(reference_columns)})",
|
|
reference_on_delete(ref.on_delete),
|
|
reference_on_update(ref.on_update)
|
|
]
|
|
end
|
|
|
|
defp reference_expr(%Reference{} = ref, table, name) do
|
|
[",", constraint_expr(ref, table, name)]
|
|
end
|
|
|
|
defp reference_name(%Reference{name: nil}, table, column),
|
|
do: quote_name("#{table.name}_#{column}_fkey")
|
|
|
|
defp reference_name(%Reference{name: name}, _table, _column), do: quote_name(name)
|
|
|
|
defp reference_column_type(:id, _opts), do: "BIGINT"
|
|
defp reference_column_type(:serial, _opts), do: "INT"
|
|
defp reference_column_type(:bigserial, _opts), do: "BIGINT"
|
|
defp reference_column_type(type, opts), do: column_type(type, opts)
|
|
|
|
defp reference_on_delete(:nilify_all), do: " ON DELETE SET NULL"
|
|
|
|
defp reference_on_delete({:nilify, _columns}) do
|
|
error!(nil, "Tds adapter does not support the `{:nilify, columns}` action for `:on_delete`")
|
|
end
|
|
|
|
defp reference_on_delete(:delete_all), do: " ON DELETE CASCADE"
|
|
defp reference_on_delete(:nothing), do: " ON DELETE NO ACTION"
|
|
defp reference_on_delete(_), do: []
|
|
|
|
defp reference_on_update(:nilify_all), do: " ON UPDATE SET NULL"
|
|
defp reference_on_update(:update_all), do: " ON UPDATE CASCADE"
|
|
defp reference_on_update(:nothing), do: " ON UPDATE NO ACTION"
|
|
defp reference_on_update(_), do: []
|
|
|
|
## Helpers
|
|
|
|
defp get_source(query, sources, ix, source) do
|
|
{expr, name, _schema} = elem(sources, ix)
|
|
name = maybe_add_column_names(source, name)
|
|
{expr || expr(source, sources, query), name}
|
|
end
|
|
|
|
defp get_parent_sources_ix(query, as) do
|
|
case query.aliases[@parent_as] do
|
|
{%{aliases: %{^as => ix}}, sources} -> {ix, sources}
|
|
{%{} = parent, _sources} -> get_parent_sources_ix(parent, as)
|
|
end
|
|
end
|
|
|
|
defp maybe_add_column_names({:values, _, [types, _, _]}, name) do
|
|
fields = Keyword.keys(types)
|
|
[name, ?\s, ?(, quote_names(fields), ?)]
|
|
end
|
|
|
|
defp maybe_add_column_names(_, name), do: name
|
|
|
|
defp quote_name(name) when is_atom(name) do
|
|
quote_name(Atom.to_string(name))
|
|
end
|
|
|
|
defp quote_name(name) when is_binary(name) do
|
|
if String.contains?(name, ["[", "]"]) do
|
|
error!(
|
|
nil,
|
|
"bad literal/field/table name #{inspect(name)} ('[' and ']' are not permitted)"
|
|
)
|
|
end
|
|
|
|
"[#{name}]"
|
|
end
|
|
|
|
defp quote_names(names), do: Enum.map_intersperse(names, ?,, "e_name/1)
|
|
|
|
defp quote_table(nil, name), do: quote_table(name)
|
|
|
|
defp quote_table({server, db, schema}, name),
|
|
do: [
|
|
quote_table(server),
|
|
".",
|
|
quote_table(db),
|
|
".",
|
|
quote_table(schema),
|
|
".",
|
|
quote_table(name)
|
|
]
|
|
|
|
defp quote_table({db, schema}, name),
|
|
do: [quote_table(db), ".", quote_table(schema), ".", quote_table(name)]
|
|
|
|
defp quote_table(prefix, name),
|
|
do: [quote_table(prefix), ".", quote_table(name)]
|
|
|
|
defp quote_table(name) when is_atom(name), do: quote_table(Atom.to_string(name))
|
|
|
|
defp quote_table(name) do
|
|
if String.contains?(name, "[") or String.contains?(name, "]") do
|
|
error!(nil, "bad table name #{inspect(name)} '[' and ']' are not permitted")
|
|
end
|
|
|
|
"[#{name}]"
|
|
end
|
|
|
|
defp unquoted_name(prefix, name, column_name),
|
|
do: unquoted_name(unquoted_name(prefix, name), column_name)
|
|
|
|
defp unquoted_name(nil, name), do: unquoted_name(name)
|
|
|
|
defp unquoted_name(prefix, name) do
|
|
prefix = if is_atom(prefix), do: Atom.to_string(prefix), else: prefix
|
|
name = if is_atom(name), do: Atom.to_string(name), else: name
|
|
|
|
[prefix, ".", name]
|
|
end
|
|
|
|
defp unquoted_name(name) when is_atom(name), do: unquoted_name(Atom.to_string(name))
|
|
|
|
defp unquoted_name(name) do
|
|
if String.contains?(name, ["[", "]"]) do
|
|
error!(nil, "bad table name #{inspect(name)} '[' and ']' are not permitted")
|
|
end
|
|
|
|
name
|
|
end
|
|
|
|
defp intersperse_reduce(list, separator, user_acc, reducer, acc \\ [])
|
|
|
|
defp intersperse_reduce([], _separator, user_acc, _reducer, acc),
|
|
do: {acc, user_acc}
|
|
|
|
defp intersperse_reduce([elem], _separator, user_acc, reducer, acc) do
|
|
{elem, user_acc} = reducer.(elem, user_acc)
|
|
{[acc | elem], user_acc}
|
|
end
|
|
|
|
defp intersperse_reduce([elem | rest], separator, user_acc, reducer, acc) do
|
|
{elem, user_acc} = reducer.(elem, user_acc)
|
|
intersperse_reduce(rest, separator, user_acc, reducer, [acc, elem, separator])
|
|
end
|
|
|
|
defp if_do(condition, value) do
|
|
if condition, do: value, else: []
|
|
end
|
|
|
|
defp escape_string(value) when is_binary(value) do
|
|
value |> :binary.replace("'", "''", [:global])
|
|
end
|
|
|
|
defp ecto_to_db(type, size, precision, scale, query \\ nil)
|
|
|
|
defp ecto_to_db({:array, _}, _, _, _, query),
|
|
do: error!(query, "Array type is not supported by TDS")
|
|
|
|
defp ecto_to_db(:id, _, _, _, _), do: "bigint"
|
|
defp ecto_to_db(:serial, _, _, _, _), do: "int IDENTITY(1,1)"
|
|
defp ecto_to_db(:bigserial, _, _, _, _), do: "bigint IDENTITY(1,1)"
|
|
defp ecto_to_db(:binary_id, _, _, _, _), do: "uniqueidentifier"
|
|
defp ecto_to_db(:boolean, _, _, _, _), do: "bit"
|
|
defp ecto_to_db(:string, nil, _, _, _), do: "nvarchar(255)"
|
|
defp ecto_to_db(:string, :max, _, _, _), do: "nvarchar(max)"
|
|
defp ecto_to_db(:string, s, _, _, _) when s in 1..4_000, do: "nvarchar(#{s})"
|
|
defp ecto_to_db(:float, nil, _, _, _), do: "float"
|
|
defp ecto_to_db(:float, s, _, _, _) when s in 1..53, do: "float(#{s})"
|
|
defp ecto_to_db(:binary, nil, _, _, _), do: "varbinary(max)"
|
|
defp ecto_to_db(:binary, s, _, _, _) when s in 1..8_000, do: "varbinary(#{s})"
|
|
defp ecto_to_db(:uuid, _, _, _, _), do: "uniqueidentifier"
|
|
defp ecto_to_db(:map, nil, _, _, _), do: "nvarchar(max)"
|
|
defp ecto_to_db(:map, s, _, _, _) when s in 0..4_000, do: "nvarchar(#{s})"
|
|
defp ecto_to_db({:map, _}, nil, _, _, _), do: "nvarchar(max)"
|
|
defp ecto_to_db({:map, _}, s, _, _, _) when s in 1..4_000, do: "nvarchar(#{s})"
|
|
defp ecto_to_db(:time, _, _, _, _), do: "time(0)"
|
|
defp ecto_to_db(:time_usec, _, p, _, _) when p in 0..7, do: "time(#{p})"
|
|
defp ecto_to_db(:time_usec, _, _, _, _), do: "time(6)"
|
|
defp ecto_to_db(:utc_datetime, _, _, _, _), do: "datetime"
|
|
defp ecto_to_db(:utc_datetime_usec, _, p, _, _) when p in 0..7, do: "datetime2(#{p})"
|
|
defp ecto_to_db(:utc_datetime_usec, _, _, _, _), do: "datetime2(6)"
|
|
defp ecto_to_db(:naive_datetime, _, _, _, _), do: "datetime"
|
|
defp ecto_to_db(:naive_datetime_usec, _, p, _, _) when p in 0..7, do: "datetime2(#{p})"
|
|
defp ecto_to_db(:naive_datetime_usec, _, _, _, _), do: "datetime2(6)"
|
|
|
|
defp ecto_to_db(other, size, _, _, _) when is_integer(size) do
|
|
"#{Atom.to_string(other)}(#{size})"
|
|
end
|
|
|
|
defp ecto_to_db(other, _, precision, scale, _) when is_integer(precision) do
|
|
"#{Atom.to_string(other)}(#{precision},#{scale || 0})"
|
|
end
|
|
|
|
defp ecto_to_db(atom, nil, nil, nil, _) when is_atom(atom) do
|
|
Atom.to_string(atom)
|
|
end
|
|
|
|
defp ecto_to_db(type, _, _, _, _) do
|
|
raise ArgumentError,
|
|
"unsupported type `#{inspect(type)}`. The type can either be an atom, a string " <>
|
|
"or a tuple of the form `{:map, t}` where `t` itself follows the same conditions."
|
|
end
|
|
|
|
defp error!(nil, message) do
|
|
raise ArgumentError, message
|
|
end
|
|
|
|
defp error!(query, message) do
|
|
raise Ecto.QueryError, query: query, message: message
|
|
end
|
|
|
|
defp if_table_not_exists(condition, name, prefix) do
|
|
if_do(condition, [
|
|
"IF NOT EXISTS (SELECT * FROM [INFORMATION_SCHEMA].[TABLES] ",
|
|
"WHERE ",
|
|
"[TABLE_NAME] = ",
|
|
?',
|
|
"#{name}",
|
|
?',
|
|
if_do(prefix != nil, [
|
|
" AND [TABLE_SCHEMA] = ",
|
|
?',
|
|
"#{prefix}",
|
|
?'
|
|
]),
|
|
") "
|
|
])
|
|
end
|
|
|
|
defp if_table_exists(condition, name, prefix) do
|
|
if_do(condition, [
|
|
"IF EXISTS (SELECT * FROM [INFORMATION_SCHEMA].[TABLES] ",
|
|
"WHERE ",
|
|
"[TABLE_NAME] = ",
|
|
?',
|
|
"#{name}",
|
|
?',
|
|
if_do(prefix != nil, [
|
|
" AND [TABLE_SCHEMA] = ",
|
|
?',
|
|
"#{prefix}",
|
|
?'
|
|
]),
|
|
") "
|
|
])
|
|
end
|
|
|
|
defp if_column_exists(prefix, table, column_name) do
|
|
[
|
|
"IF EXISTS (SELECT 1 FROM [sys].[columns] ",
|
|
"WHERE [name] = N'#{column_name}' AND ",
|
|
"[object_id] = OBJECT_ID(N'",
|
|
if_do(prefix != nil, ["#{prefix}", ?.]),
|
|
"#{table}",
|
|
"')) "
|
|
]
|
|
end
|
|
|
|
defp if_column_not_exists(prefix, table, column_name) do
|
|
[
|
|
"IF NOT EXISTS (SELECT 1 FROM [sys].[columns] ",
|
|
"WHERE [name] = N'#{column_name}' AND ",
|
|
"[object_id] = OBJECT_ID(N'",
|
|
if_do(prefix != nil, ["#{prefix}", ?.]),
|
|
"#{table}",
|
|
"')) "
|
|
]
|
|
end
|
|
|
|
defp list_param_to_args(idx, length) do
|
|
Enum.map_join(1..length, ",", &"@#{idx + &1}")
|
|
end
|
|
|
|
defp as_string(atom) when is_atom(atom), do: Atom.to_string(atom)
|
|
defp as_string(str), do: str
|
|
|
|
defp if_index_exists(condition, index_name, table_name) do
|
|
if_do(condition, [
|
|
"IF EXISTS (SELECT name FROM sys.indexes WHERE name = N'",
|
|
as_string(index_name),
|
|
"' AND object_id = OBJECT_ID(N'",
|
|
as_string(table_name),
|
|
"')) "
|
|
])
|
|
end
|
|
|
|
defp if_index_not_exists(condition, index_name, table_name) do
|
|
if_do(condition, [
|
|
"IF NOT EXISTS (SELECT name FROM sys.indexes WHERE name = N'",
|
|
as_string(index_name),
|
|
"' AND object_id = OBJECT_ID(N'",
|
|
as_string(table_name),
|
|
"')) "
|
|
])
|
|
end
|
|
|
|
defp if_check_constraint_exists(condition, name, prefix) do
|
|
if_do(condition, [
|
|
"IF NOT EXISTS (SELECT * ",
|
|
"FROM [INFORMATION_SCHEMA].[CHECK_CONSTRAINTS] ",
|
|
"WHERE [CONSTRAINT_NAME] = N'#{name}'",
|
|
if_do(prefix != nil, [
|
|
" AND [CONSTRAINT_SCHEMA] = N'#{prefix}'"
|
|
]),
|
|
") "
|
|
])
|
|
end
|
|
|
|
# types
|
|
# "U" - table,
|
|
# "C", "PK", "UQ", "F ", "D " - constraints
|
|
defp if_object_exists(name, type, statement) do
|
|
[
|
|
"IF (OBJECT_ID(N'",
|
|
name,
|
|
"', '",
|
|
type,
|
|
"') IS NOT NULL) ",
|
|
statement
|
|
]
|
|
end
|
|
|
|
defp if_exists_drop_constraint(name, statement_prefix) do
|
|
[
|
|
if_object_exists(
|
|
name,
|
|
"D",
|
|
"#{statement_prefix}DROP CONSTRAINT #{name}; "
|
|
)
|
|
]
|
|
end
|
|
end
|
|
end
|