zf

connection.ex (54133B)

---

 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: []
 
     defp prepare_params(params) do
       {params, _} =
         Enum.map_reduce(params, 1, fn param, acc ->
           {value, type} = prepare_param(param)
           {%Tds.Parameter{name: "@#{acc}", value: value, type: type}, acc + 1}
         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(%{__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, 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)
       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(%QueryExpr{expr: true}, _sources, _query), do: "DISTINCT "
     defp distinct(%QueryExpr{expr: false}, _sources, _query), do: []
 
     defp distinct(%QueryExpr{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
       intersperse_map(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 = intersperse_map(queries, ", ", &cte_expr(&1, sources, query))
       ["WITH ", ctes, " "]
     end
 
     defp cte(%{with_ctes: _}, _), do: []
 
     defp cte_expr({name, cte}, sources, query) do
       [quote_name(name), cte_header(cte, query), " AS ", cte_query(cte, sources, query)]
     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
       [
         " (",
         intersperse_map(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(%Ecto.Query{} = query, sources, parent_query) do
       query = put_in(query.aliases[@parent_as], {parent_query, sources})
       [?(, all(query, subquery_as_prefix(sources)), ?)]
     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,
         intersperse_map(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)
             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(:inner_loop), do: "INNER LOOP JOIN "
     defp join_qual(:inner_hash), do: "INNER HASH JOIN "
     defp join_qual(:inner_merge), do: "INNER MERGE JOIN "
     defp join_qual(:inner_remote), do: "INNER REMOTE 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 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 "
         | intersperse_map(group_bys, ", ", fn %QueryExpr{expr: expr} ->
             intersperse_map(expr, ", ", &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 "
         | intersperse_map(order_bys, ", ", fn %QueryExpr{expr: expr} ->
             intersperse_map(expr, ", ", &order_by_expr(&1, sources, query))
           end)
       ]
     end
 
     defp order_by_expr({dir, expr}, sources, query) do
       str = 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: %QueryExpr{
                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}) do
       Enum.map(combinations, fn
         {:union, query} -> [" UNION (", all(query), ")"]
         {:union_all, query} -> [" UNION ALL (", all(query), ")"]
         {:except, query} -> [" EXCEPT (", all(query), ")"]
         {:except_all, query} -> [" EXCEPT ALL (", all(query), ")"]
         {:intersect, query} -> [" INTERSECT (", all(query), ")"]
         {:intersect_all, query} -> [" INTERSECT ALL (", all(query), ")"]
       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/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
 
     # :^ - 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{query: query}, sources, parent_query) do
       query = put_in(query.aliases[@parent_as], {parent_query, sources})
       [?(, all(query, subquery_as_prefix(sources)), ?)]
     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({:literal, _, [literal]}, _sources, _query) do
       quote_name(literal)
     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, intersperse_map(args, ", ", &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 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 ", intersperse_map(returning, ", ", &[verb, ?., quote_name(&1)])]
     end
 
     defp returning(%{select: nil}, _, _),
       do: []
 
     defp returning(%{select: %{fields: fields}} = query, idx, verb),
       do: [
         " OUTPUT "
         | intersperse_map(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}
 
         {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()
         |> intersperse_map(", ", &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),
           " (",
           intersperse_map(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({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 {_, name, _, opts} <- columns,
             opts[:primary_key],
             do: name
 
       case pks do
         [] ->
           []
 
         _ ->
           [prefix, "PRIMARY KEY CLUSTERED (", quote_names(pks), ?)]
       end
     end
 
     defp column_definitions(table, columns) do
       intersperse_map(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(_statement_prefix, _table, {_command, _name, %Reference{validate: false}, _opts}) 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,
            %{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, 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)
       ecto_to_db(type, size, precision, scale)
     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(ref.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(: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)
       {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 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: intersperse_map(names, ?,, &quote_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_map([], _separator, _mapper), do: []
     defp intersperse_map([elem], _separator, mapper), do: mapper.(elem)
 
     defp intersperse_map([elem | rest], separator, mapper) do
       [mapper.(elem), separator | intersperse_map(rest, separator, mapper)]
     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