refactor handling of span and offset

Author: Schultzer

bench.exs

@@ -4,14 +4,18 @@ defmodule SQL.Repo do
   use Ecto.Repo, otp_app: :sql, adapter: Ecto.Adapters.Postgres
   use SQL, adapter: SQL.Adapters.Postgres, repo: __MODULE__
 
-  def test() do
-    ~SQL[select 1]
-    |> SQL.map(fn row -> row end)
-    |> Enum.to_list
+  def sql() do
+    Enum.to_list ~SQL[select 1]
+  end
+
+  def ecto() do
+    {sql, params} = to_sql(:all, select(from("users"), 1))
+    {:ok, %{columns: columns, rows: rows}} = query(sql, params)
+    Enum.map(rows, &Map.new(Enum.zip(columns, &1)))
   end
 end
 Application.put_env(:sql, :ecto_repos, [SQL.Repo])
-Application.put_env(:sql, SQL.Repo, username: "postgres", password: "postgres", hostname: "localhost", database: "sql_test#{System.get_env("MIX_TEST_PARTITION")}", pool: Ecto.Adapters.SQL.Sandbox, pool_size: 10)
+Application.put_env(:sql, SQL.Repo, log: false, username: "postgres", password: "postgres", hostname: "localhost", database: "sql_test#{System.get_env("MIX_TEST_PARTITION")}", pool: Ecto.Adapters.SQL.Sandbox, pool_size: 10)
 SQL.Repo.__adapter__().storage_up(SQL.Repo.config())
 SQL.Repo.start_link()
 query = "temp" |> recursive_ctes(true) |> with_cte("temp", as: ^union_all(select("temp", [t], %{n: 0, fact: 1}), ^where(select("temp", [t], [t.n+1, t.n+1*t.fact]), [t], t.n < 9))) |> select([t], [t.n])
@@ -34,13 +38,14 @@ Benchee.run(
     {:ok, pcontext, tokens} = SQL.Parser.parse(tokens, context)
     pcontext.module.to_iodata(tokens, pcontext)
   end,
-  "parse" => fn _ -> SQL.parse("with recursive temp (n, fact) as (select 0, 1 union all select n+1, (n+1)*fact from temp where n < 9)") end,
-  "runtime dynamic" => fn _ -> ~SQL[from users] |> ~SQL[select *] |> ~SQL[where id = {{1+2*3}}] end,
-  "runtime ecto dynamic" => fn _ -> SQL.Repo.to_sql(:all, from("users") |> select([t], t.id) |> where([t], t.id == ^(1+2*3))) end,
+  "parse/1" => fn _ -> SQL.parse("with recursive temp (n, fact) as (select 0, 1 union all select n+1, (n+1)*fact from temp where n < 9)") end,
+  "sql" => fn _ -> SQL.Repo.sql() end,
+  "ecto" => fn _ -> SQL.Repo.ecto() end,
   "runtime to_string" => fn _ -> to_string(~SQL[with recursive temp (n, fact) as (select 0, 1 union all select n+1, (n+1)*fact from temp where n < 9)]) end,
   "runtime to_sql" => fn _ -> SQL.to_sql(~SQL[with recursive temp (n, fact) as (select 0, 1 union all select n+1, (n+1)*fact from temp where n < 9)]) end,
   "runtime inspect" => fn _ -> inspect(~SQL[with recursive temp (n, fact) as (select 0, 1 union all select n+1, (n+1)*fact from temp where n < 9)]) end,
-  "runtime ecto" => fn _ -> SQL.Repo.to_sql(:all, "temp" |> recursive_ctes(true) |> with_cte("temp", as: ^union_all(select("temp", [t], %{n: 0, fact: 1}), ^where(select("temp", [t], [t.n+1, t.n+1*t.fact]), [t], t.n < 9))) |> select([t], [t.n])) end
+  "runtime ecto" => fn _ -> SQL.Repo.to_sql(:all, "temp" |> recursive_ctes(true) |> with_cte("temp", as: ^union_all(select("temp", [t], %{n: 0, fact: 1}), ^where(select("temp", [t], [t.n+1, t.n+1*t.fact]), [t], t.n < 9))) |> select([t], [t.n])) end,
+  "comptime ecto" => fn _ -> SQL.Repo.to_sql(:all, query) end
   },
   inputs: %{"1..100_000" => Enum.to_list(1..100_000)},
   memory_time: 2,

lib/format.ex

@@ -5,43 +5,59 @@ defmodule SQL.Format do
   @moduledoc false
   @moduledoc since: "0.4.0"
 
-  @compile {:inline, indention: 3, newline: 2}
+  @error IO.ANSI.red()
+  @reset IO.ANSI.reset()
+  @keyword IO.ANSI.magenta()
+  @literal IO.ANSI.yellow()
+  @enclosed IO.ANSI.green()
+
+  @compile {:inline, indention: 3, newline: 2, pad: 1}
 
   @doc false
   @doc since: "0.4.0"
-  def to_iodata(tokens, context, indent \\ 0), do: newline(to_iodata(tokens, context.binding, context.case, context.errors, indent, []), indent)
+  def to_iodata(tokens, context, indent \\ 0), do: pad(to_iodata(tokens, context.binding, context.case, context.errors, indent, []))
 
-  defp indention(acc, [{:preset, {_,0}},_,{:offset, {_,0,_,_}}|_], _), do: acc
-  defp indention(acc, [_,{:offset, {_,0}}|_], 0), do: acc
-  defp indention(["\e[33m"|_]=acc, [_,{:offset, {_,0}}|_], _), do: acc
+  defp indention(acc, [{_, {_,_,_,_,_,0}}|_], _), do: acc
+  defp indention(acc, [{_, {_,_,_,_,_,0,_,_}}|_], _), do: acc
+  defp indention(acc, 0, 0), do: acc
   defp indention(acc, _, 0), do: [?\s|acc]
   defp indention(acc, _, 1), do: [?\s,?\s|acc]
-  defp indention(acc, _, 2), do: [?\s,?\s,?\s,?\s|acc]
-  defp indention(acc, _, indent), do: [:lists.duplicate(?\s, indent*2)|acc]
+  defp indention(acc, m, indent), do: indention([?\s,?\s|acc], m, indent-1)
+
+  defp newline(acc, indent), do: [?\n|indention(acc, 0, indent)]
 
-  defp newline([?\n, ?\s|acc], 0), do: [?\n|acc]
-  defp newline([?\s|acc], 0), do: [?\n|acc]
-  defp newline([?\n|_]=acc, _indent), do: acc
-  defp newline(acc, _indent), do: [?\n|acc]
+  defp pad([?\n|_]=acc), do: acc
+  defp pad(acc), do: [?\n|acc]
 
-  newline = ~w[select from join where group having window order limit offset fetch]a
+  newline = ~w[select from join where having window limit offset fetch]a
   {reserved, non_reserved, operators} = SQL.BNF.get_rules()
   for atom <- Enum.uniq(Enum.map(reserved++non_reserved++operators,&elem(&1, 0))), atom not in newline do
     defp to_iodata(unquote(atom), _binding ,:lower, _errors, _indent, acc) do
-      ["\e[35m", unquote("#{atom}"), "\e[0m"|acc]
+      [@keyword, unquote("#{atom}"), @reset|acc]
     end
     defp to_iodata(unquote(atom), _binding, :upper, _errors, _indent, acc) do
-     ["\e[35m", unquote(String.upcase("#{atom}")), "\e[0m"|acc]
+     [@keyword, unquote(String.upcase("#{atom}")), @reset|acc]
     end
   end
   for atom <- newline do
-    defp to_iodata({unquote(atom), m, values}, binding, :lower=case, errors, indent, acc) do
-      newline(indention(["\e[35m", unquote("#{atom}"), "\e[0m"|newline(to_iodata(values, binding, case, errors, indent+1, acc), indent+1)], m, indent), indent)
+    defp to_iodata({unquote(atom), _m, values}, binding, :lower=case, errors, indent, acc) do
+      newline([@keyword, unquote("#{atom}"), @reset|newline(to_iodata(values, binding, case, errors, indent, acc), indent)], indent)
+    end
+    defp to_iodata({unquote(atom), _m, values}, binding, :upper=case, errors, indent, acc) do
+      newline([@keyword, unquote(String.upcase("#{atom}")), @reset|newline(to_iodata(values, binding, case, errors, indent, acc), indent)], indent)
+    end
+  end
+  for atom <- ~w[group order]a do
+    defp to_iodata({unquote(atom), _m, values}, binding, :lower=case, errors, indent, acc) do
+      newline([@keyword, unquote("#{atom}"), @reset|to_iodata(values, binding, case, errors, indent, acc)], indent)
     end
-    defp to_iodata({unquote(atom), m, values}, binding, :upper=case, errors, indent, acc) do
-      newline(indention(["\e[35m", unquote(String.upcase("#{atom}")), "\e[0m"|newline(to_iodata(values, binding, case, errors, indent+1, acc), indent+1)], m, indent), indent)
+    defp to_iodata({unquote(atom), _m, values}, binding, :upper=case, errors, indent, acc) do
+      newline([@keyword, unquote(String.upcase("#{atom}")), @reset|to_iodata(values, binding, case, errors, indent, acc)], indent)
     end
   end
+  defp to_iodata({tag, m, values}, binding, case, errors, indent, acc) when tag in ~w[by on]a do
+    indention(to_iodata(tag, binding, case, errors, 0, newline(to_iodata(values, binding, case, errors, indent, acc), indent)), m, 0)
+  end
   defp to_iodata(:comma, _binding, _case, _errors, 0, acc) do
     [?,|acc]
   end
@@ -67,53 +83,68 @@ defmodule SQL.Format do
     [?\\,?*,value,?*,?\\|acc]
   end
   defp to_iodata({:quote, m, value}, _binding, _case, _errors, indent, acc) do
-    indention([?',"\e[32m" , value, "\e[0m",?'|acc], m, indent)
+    indention([?',@enclosed, value, @reset,?'|acc], m, indent)
   end
   defp to_iodata({:backtick, m, value}, _binding, _case, _errors, indent, acc) do
-    indention([?`,"\e[32m" , value, "\e[0m",?`|acc], m, indent)
+    indention([?`,@enclosed, value, @reset,?`|acc], m, indent)
   end
   defp to_iodata({tag, m, []}, binding, case, errors, indent, acc) do
     indention(to_iodata(tag, binding, case, errors, indent, acc), m, indent)
   end
-  defp to_iodata({:paren, m, [{t, _, _}|_]=values}, binding, case, errors, indent, acc) when t in unquote(newline++~w[union except intersect]a) do
+  defp to_iodata({:paren, m, [{t, _, _}|_]=values}, binding, case, errors, indent, acc) when t in unquote(newline++~w[group order union except intersect]a) do
     indention([?(|to_iodata(values, binding, case, errors, indent+1, [?\n,?)|acc])], m, indent)
   end
   defp to_iodata({:paren, m, values}, binding, case, errors, indent, acc) do
     indention([?(|to_iodata(values, binding, case, errors, 0, [?)|acc])], m, indent)
   end
-  defp to_iodata({:bracket, _m, values}, binding, case, errors, indent, acc) do
-    [?[|to_iodata(values, binding, case, errors, indent, [?]|acc])]
+  defp to_iodata({:bracket, m, values}, binding, case, errors, indent, acc) do
+    indention([?[|to_iodata(values, binding, case, errors, 0, [?]|acc])], m, indent)
+  end
+  defp to_iodata({:brace, m, values}, binding, case, errors, indent, acc) do
+    indention([?{|to_iodata(values, binding, case, errors, 0, [?}|acc])], m, indent)
   end
   defp to_iodata({_, [], values}, binding, case, errors, indent, acc) do
     to_iodata(values, binding, case, errors, indent, acc)
   end
-  defp to_iodata({:ident, [_,_,_,{:tag, tag}|_]=m, [{:paren, _, _}]=values}, binding, case, errors, indent, acc) do
+  defp to_iodata({:ident, [_,_,{:tag, tag}|_]=m, [{:paren, _, _}]=values}, binding, case, errors, indent, acc) do
     indention(to_iodata(tag, binding, case, errors, indent, to_iodata(values, binding, case, errors, indent, acc)), m, indent)
   end
-  defp to_iodata({tag, [{:span, {l, c, _, _}}|_]=m, [{_, [{:span, {ll, cc, _, _}}|_], _}]=values}, binding, case, errors, indent, acc) when l >= ll and c >= cc do
+  defp to_iodata({tag, [{_, {l,c,_,_,_,_}}|_]=m, [{_, [{_, {l,lc,_,_,_,_}}|_], _}=left, {_, [{_, {l,rc,_,_,_,_}}|_], _}=right]}, binding, case, errors, indent, acc) when (c > lc and c < rc) do
+    to_iodata(left, binding, case, errors, indent, indention(to_iodata(tag, binding, case, errors, 0, to_iodata(right, binding, case, errors, 0, acc)), m, 0))
+  end
+  defp to_iodata({tag, [{_, {l,c,_,_,_,_}}|_]=m, [{_, [{_, {l,lc,_,_,_,_,_,_}}|_], _}=left, {_, [{_, {l,rc,_,_,_,_,_,_}}|_], _}=right]}, binding, case, errors, indent, acc) when (c > lc and c < rc) do
+    to_iodata(left, binding, case, errors, indent, indention(to_iodata(tag, binding, case, errors, 0, to_iodata(right, binding, case, errors, 0, acc)), m, 0))
+  end
+  defp to_iodata({tag, [{_, {l,c,_,_,_,_}}|_]=m, [{_, [{_, {l,lc,_,_,_,_}}|_], _}=left, {_, [{_, {l,rc,_,_,_,_,_,_}}|_], _}=right]}, binding, case, errors, indent, acc) when (c > lc and c < rc) do
+    to_iodata(left, binding, case, errors, indent, indention(to_iodata(tag, binding, case, errors, 0, to_iodata(right, binding, case, errors, 0, acc)), m, 0))
+  end
+  defp to_iodata({tag, [{_, {l,c,_,_,_,_}}|_]=m, [{_, [{_, {l,lc,_,_,_,_,_,_}}|_], _}=left, {_, [{_, {l,rc,_,_,_,_}}|_], _}=right]}, binding, case, errors, indent, acc) when (c > lc and c < rc) do
+    to_iodata(left, binding, case, errors, indent, indention(to_iodata(tag, binding, case, errors, 0, to_iodata(right, binding, case, errors, 0, acc)), m, 0))
+  end
+  defp to_iodata({tag, [{_, {l,c,_,_,_,_}}|_]=m, [{_, [{_, {ll,cc,_,_,_,_}}|_], _}]=values}, binding, case, errors, indent, acc) when (l == ll and c < cc and tag in ~w[desc asc not]a) do
+    to_iodata(values, binding, case, errors, indent, indention(to_iodata(tag, binding, case, errors, indent, acc), m, 0))
+  end
+  defp to_iodata({tag, [{_, {l,c,_,_,_,_}}|_]=m, [{_, [{_, {ll,cc,_,_,_,_,_,_}}|_], _}]=values}, binding, case, errors, indent, acc) when (l == ll and c < cc and tag in ~w[desc asc not]a) do
     to_iodata(values, binding, case, errors, indent, indention(to_iodata(tag, binding, case, errors, indent, acc), m, 0))
   end
-  defp to_iodata({tag, m, [left, right]}, binding, case, errors, indent, acc) when tag in ~w[union except intersect]a do
-    to_iodata(left, binding, case, errors, indent, newline(indention(to_iodata(tag, binding, case, errors, indent, to_iodata(right, binding, case, errors, indent, acc)), m, indent), indent))
+  defp to_iodata({tag, _m, [left, right]}, binding, case, errors, indent, acc) when tag in ~w[union except intersect]a do
+    to_iodata(left, binding, case, errors, indent, newline(to_iodata(tag, binding, case, errors, indent, to_iodata(right, binding, case, errors, indent, acc)), indent))
   end
-  defp to_iodata({tag, [_,_,{:type, type}|_]=m, [left, right]}, binding, case, errors, indent, acc) when type == :operator or tag in ~w[between cursor for to]a do
-    to_iodata(left, binding, case, errors, indent, indention(to_iodata(tag, binding, case, errors, indent, to_iodata(right, binding, case, errors, 0, acc)), m, 0))
+  defp to_iodata({tag, m, [{_,_,_}|_]=values}, binding, case, errors, indent, acc) do
+    indention(to_iodata(tag, binding, case, errors, indent, to_iodata(values, binding, case, errors, indent, acc)), m, 0)
   end
   defp to_iodata({tag, m, value}=node, _binding, _case, errors, indent, acc) when tag in ~w[ident numeric special]a do
     case node in errors do
-      true -> indention(["\e[31m", value, "\e[0m"|acc], m, indent)
-      false -> indention(["\e[33m", value, "\e[0m"|acc], m, indent)
+      true -> indention([@error, value, @reset|acc], m, indent)
+      false -> indention([@literal, value, @reset|acc], m, indent)
     end
   end
   defp to_iodata({:double_quote, m, value}=node, _binding, _case, errors, indent, acc) do
     case node in errors do
-      true -> indention([?","\e[31m",value, "\e[0m", ?"|acc], m, indent)
-      false -> indention([?", "\e[32m" , value, "\e[0m", ?"|acc], m, indent)
+      true -> indention([?",@error,value, @reset, ?"|acc], m, indent)
+      false -> indention([?", @enclosed , value, @reset, ?"|acc], m, indent)
     end
   end
-  defp to_iodata({tag, m, values}, binding, case, errors, indent, acc) do
-    indention(to_iodata(tag, binding, case, errors, indent, to_iodata(values, binding, case, errors, indent, acc)), m, 0)
-  end
   defp to_iodata([token|tokens], binding, case, errors, indent, acc) do
     to_iodata(token, binding, case, errors, indent, to_iodata(tokens, binding, case, errors, indent, acc))
   end