refactor sql.lock and validation

Author: Schultzer

lib/formatter.ex

@@ -10,7 +10,7 @@ defmodule SQL.MixFormatter do
 
   @impl Mix.Tasks.Format
   def format(source, opts) do
-    opts = Map.new(Keyword.merge([sql_lock: nil], opts))
+    opts = Map.new(Keyword.merge([validate: nil], opts))
     {:ok, context, tokens} = SQL.Lexer.lex(source)
     {:ok, context, tokens} = SQL.Parser.parse(tokens, Map.merge(context, opts))
     iodata = SQL.Format.to_iodata(tokens, context)

lib/lexer.ex

@@ -7,7 +7,7 @@ defmodule SQL.Lexer do
   @zero "illegal zero width character"
   @bidi "illegal bidi character"
   @cgj "illegal cgj character"
-  @context %{idx: 0, file: "nofile", binding: [], aliases: [], errors: [], module: nil, format: :static, case: :lower, sql_lock: nil}
+  @context %{idx: 0, file: "nofile", binding: [], aliases: [], errors: [], module: nil, format: :static, case: :lower, validate: nil}
   def lex(binary, <<file::binary>> \\ "nofile", idx \\ 0) do
     case lex(binary, %{@context | file: file, idx: idx}, 0, 0, []) do
       {:error, error} -> raise TokenMissingError, [{:snippet, binary} | error]

lib/parser.ex

@@ -259,28 +259,27 @@ defmodule SQL.Parser do
   @order %{select: 0, from: 1, join: 2, where: 3, group: 4, having: 5, window: 6, order: 7, limit: 8, offset: 9, fetch: 10}
   defp sort(acc), do: Enum.sort_by(acc, fn {tag, _, _} -> Map.get(@order, tag) end, :asc)
 
-  defp validate(_, %{sql_lock: nil}, errors), do: errors
-  defp validate({tag, _, _}, %{sql_lock: %{columns: []}}, errors) when tag in ~w[select having where on by order group]a, do: errors
-  defp validate({tag, _, values}, %{sql_lock: %{columns: columns}}, errors) when tag in ~w[select having where on by order group]a do
-    case validate_columns(columns, values, []) do
+  defp validate(_, %{validate: nil}, errors), do: errors
+  defp validate({tag, _, values}, %{validate: fun}, errors) when tag in ~w[select having where on by order group]a do
+    case validate_columns(fun, values, []) do
       [] -> errors
       e -> e++errors
     end
   end
-  defp validate({tag, _, _}, %{sql_lock: %{tables: []}}, errors) when tag in ~w[from join]a, do: errors
-  defp validate({tag, _, values}, %{sql_lock: %{tables: tables}} = context, errors) when tag in ~w[from join]a do
+  defp validate({tag, _, _}, %{validate: nil}, errors) when tag in ~w[from join]a, do: errors
+  defp validate({tag, _, values}, %{validate: fun} = context, errors) when tag in ~w[from join]a do
     values
     |> Enum.reduce([], fn
       {:paren, _, _}, acc -> acc
       {:on, _, _} = node, acc -> validate(node, context, acc)
-      {tag, _, _}=node, acc when tag in ~w[ident double_quote]a -> validate_table(tables, node, acc)
-      {:as, _, [{tag, _, _}=node, _]}, acc when tag in ~w[ident double_quote]a  -> validate_table(tables, node, acc)
-      {:dot, _, [_, {tag, _, _}=node]}, acc when tag in ~w[ident double_quote]a -> validate_table(tables, node, acc)
-      {:dot, _, [_, {:bracket, _, [{:ident, _, _}=node]}]}, acc -> validate_table(tables, node, acc)
-      {:comma, _, [{:dot, _, [_, {:bracket, _, [{:ident, _, _}=node]}]}]}, acc -> validate_table(tables, node, acc)
-      {:comma, _, [{:dot, _, [_, {tag, _, _}=node]}]}, acc when tag in ~w[ident double_quote]a -> validate_table(tables, node, acc)
-      {:comma, _, [{:as, _, [{tag, _, _}=node, _]}]}, acc when tag in ~w[ident double_quote]a  -> validate_table(tables, node, acc)
-      {:comma, _, [{tag, _, _}=node]}, acc when tag in ~w[ident double_quote]a -> validate_table(tables, node, acc)
+      {tag, _, _}=node, acc when tag in ~w[ident double_quote]a -> validate_table(fun, node, acc)
+      {:as, _, [{tag, _, _}=node, _]}, acc when tag in ~w[ident double_quote]a  -> validate_table(fun, node, acc)
+      {:dot, _, [_, {tag, _, _}=node]}, acc when tag in ~w[ident double_quote]a -> validate_table(fun, node, acc)
+      {:dot, _, [_, {:bracket, _, [{:ident, _, _}=node]}]}, acc -> validate_table(fun, node, acc)
+      {:comma, _, [{:dot, _, [_, {:bracket, _, [{:ident, _, _}=node]}]}]}, acc -> validate_table(fun, node, acc)
+      {:comma, _, [{:dot, _, [_, {tag, _, _}=node]}]}, acc when tag in ~w[ident double_quote]a -> validate_table(fun, node, acc)
+      {:comma, _, [{:as, _, [{tag, _, _}=node, _]}]}, acc when tag in ~w[ident double_quote]a  -> validate_table(fun, node, acc)
+      {:comma, _, [{tag, _, _}=node]}, acc when tag in ~w[ident double_quote]a -> validate_table(fun, node, acc)
     end)
     |> case do
       [] -> errors
@@ -290,21 +289,21 @@ defmodule SQL.Parser do
   defp validate({tag, _, [{t, _, _}]}, _, errors) when tag in ~w[offset limit]a and t in ~w[numeric binary hexadecimal octal]a, do: errors
   defp validate({tag, _, _} = node, _, errors) when tag in ~w[offset limit]a, do: [node|errors]
 
-  defp validate_table(tables, {_, _, value}=node, acc)  do
-    case Enum.find(tables, false, fn %{table_name: {_, _, fun}} -> fun.(value) end) do
+  defp validate_table(fun, {_, _, value}=node, acc)  do
+    case fun.(value) do
       true -> acc
       false -> [node|acc]
     end
   end
 
-  defp validate_columns(columns, {tag, _, value}=node, acc) when tag in ~w[ident double_quote]a do
-    case Enum.find(columns, false, fn %{column_name: {_, _, fun}} -> fun.(value) end) do
+  defp validate_columns(fun, {tag, _, value}=node, acc) when tag in ~w[ident double_quote]a do
+    case fun.(value) do
       true -> acc
       false -> [node|acc]
     end
   end
-  defp validate_columns(columns, [node|values], acc) do
-    validate_columns(columns, values, validate_columns(columns, node, acc))
+  defp validate_columns(fun, [node|values], acc) do
+    validate_columns(fun, values, validate_columns(fun, node, acc))
   end
-  defp validate_columns(_columns, _, acc), do: acc
+  defp validate_columns(_fun, _, acc), do: acc
 end

lib/sql.ex

@@ -14,14 +14,12 @@ defmodule SQL do
       @doc false
       import SQL
       if File.exists?(Path.relative_to_cwd("sql.lock")) do
-        config = Keyword.merge([case: :lower, adapter: Application.compile_env(:sql, :adapter, ANSI), lock: build_lock()], opts)
-        Module.put_attribute(__MODULE__, :sql_config, Map.new(config))
-        def sql_config, do: unquote(Macro.escape(Map.new(config)))
+        Module.put_attribute(__MODULE__, :sql_config, %{case: opts[:case] || :lower, adapter: opts[:adapter] || Application.compile_env(:sql, :adapter, ANSI), validate: &__MODULE__.sql_validate/1})
+        def sql_validate, do: unquote(build_lock())
       else
-        IO.warn("Could not find a sql.lock, please run mix sql.get")
-        config = Keyword.merge([case: :lower, adapter: Application.compile_env(:sql, :adapter, ANSI), lock: nil], opts)
-        Module.put_attribute(__MODULE__, :sql_config, Map.new(config))
-        def sql_config, do: unquote(Macro.escape(Map.new(config)))
+        # IO.warn("Could not find a sql.lock, please run mix sql.get")
+        Module.put_attribute(__MODULE__, :sql_config, %{case: opts[:case] || :lower, adapter: opts[:adapter] || Application.compile_env(:sql, :adapter, ANSI), validate: nil})
+        def sql_validate, do: fn _ -> true end
       end
     end
   end
@@ -95,7 +93,7 @@ defmodule SQL do
 
   @doc false
   def build(left, {:<<>>, _, _} = right, _modifiers, env) do
-    config = %{case: :lower, adapter: Application.get_env(:sql, :adapter, ANSI), lock: nil}
+    config = %{case: :lower, adapter: Application.get_env(:sql, :adapter, ANSI), validate: nil}
     config = if env.module, do: Module.get_attribute(env.module, :sql_config, config), else: config
     sql = struct(SQL, module: config.adapter)
     stack = if env.function do
@@ -107,7 +105,7 @@ defmodule SQL do
       {:static, data} ->
         id = id(data)
         {:ok, context, tokens} = SQL.Lexer.lex(data, env.file)
-        {:ok, context, tokens} = SQL.Parser.parse(tokens, %{context|sql_lock: config.lock, module: config.adapter, case: config.case})
+        {:ok, context, tokens} = SQL.Parser.parse(tokens, %{context|validate: config.validate, module: config.adapter, case: config.case})
         sql = %{sql | idx: context.idx, tokens: tokens, string: IO.iodata_to_binary(context.module.to_iodata(tokens, context)), inspect: __inspect__(tokens, context, stack), id: id}
         case context.binding do
           []     -> Macro.escape(sql)
@@ -126,7 +124,7 @@ defmodule SQL do
             end)
           {:ok, context, tokens} = tokens(right, file, idx, sql.id)
           tokens = t++tokens
-          {string, inspect} = plan(tokens, %{context|sql_lock: config.lock, module: config.adapter, format: :dynamic}, sql.id, stack)
+          {string, inspect} = plan(tokens, %{context|validate: config.validate, module: config.adapter, format: :dynamic}, sql.id, stack)
           %{sql | params: p++cast_params(context.binding, binding(), env, []), tokens: tokens, string: string, inspect: inspect}
         end
     end
@@ -215,46 +213,18 @@ defmodule SQL do
   @doc false
   def build_lock() do
     case elem(Code.eval_file("sql.lock", File.cwd!()), 0) do
-      %{tables: tables, columns: columns} = data ->
-        %{data |
-        tables: Enum.map(tables, fn %{table_name: table_name} = table -> %{table | table_name: to_match(table_name)} end),
-        columns: Enum.map(columns, fn %{table_name: table_name, column_name: column_name} = column -> %{column | table_name: to_match(table_name), column_name: to_match(column_name)} end)
-      }
-      data -> data
-    end
-  end
-
-  @doc false
-  def to_match(value), do: {value, atom(value), function(value)}
-
-  @doc false
-  def function(value) do
-    {:fn, [], [head(value),{:->, [], [[{:_, [], Elixir}], false]}]}
-    |> Code.eval_quoted()
-    |> elem(0)
-  end
-
-  @doc false
-  def atom(value), do: String.to_atom(String.downcase(value))
-
-  @doc false
-  def match(value), do: Enum.reduce(1..byte_size(value), [], fn n, acc -> [acc | [{:"b#{n}", [], Elixir}]] end)
-
-  @doc false
-  def head(value), do: {:->, [], [[{:when, [],[match(value),guard(value)]}], true]}
-
-  @doc false
-  def guard(value, acc \\ []) do
-    {value, _n} = for <<k <- String.downcase(value)>>, reduce: {acc, 1} do
-      {[], n}  -> {__guard__(k, n), n+1}
-      {acc, n} -> {{:and, [context: Elixir, imports: [{2, Kernel}]], [acc,__guard__(k, n)]}, n+1}
+      %{tables: tables, columns: columns} ->
+      tables = Enum.map(tables, fn %{table_name: value} -> String.downcase(value) end)
+      columns = Enum.map(columns, fn %{table_name: table_name, column_name: column_name} -> {String.downcase(table_name), String.downcase(column_name)} end)
+      quote bind_quoted: [tables: tables, columns: columns] do
+        fn
+          {table, column} -> {String.downcase(table), String.downcase(column)} in columns
+          table -> String.downcase(table) in tables
+        end
+      end
+      _data ->
+        nil
     end
-    value
-  end
-
-  @doc false
-  def __guard__(k, n) do
-    {:in, [context: Elixir, imports: [{2, Kernel}]],[{:"b#{n}", [], Elixir},{:sigil_c, [delimiter: "\"", context: Elixir, imports: [{2, Kernel}]],[{:<<>>, [], ["#{<<k>>}#{String.upcase(<<k>>)}"]}, []]}]}
   end
 
   @doc false

sql.lock

@@ -31,13 +31,11 @@ defmodule SQL.ParserTest do
 
     test "missing table with sql.lock and without tables in it" do
       {:ok, context, tokens} = SQL.Lexer.lex(@query)
-      context = Map.put(context, :sql_lock, %{tables: [], columns: []})
       {:ok, %{errors: []}, _tokens} = SQL.Parser.parse(tokens, context)
     end
 
     test "missing table without sql.lock" do
       {:ok, context, tokens} = SQL.Lexer.lex(@query)
-      context = Map.put(context, :sql_lock, nil)
       {:ok, %{errors: []}, _tokens} = SQL.Parser.parse(tokens, context)
     end
   end

test/parser_test.exs

@@ -7,6 +7,6 @@ end
 defmodule SQLTest.Helpers do
   def table_name([[[[[], b1], b2], b3],b4]) when b1 in ~c"tT" and  b2 in ~c"eE" and  b3 in ~c"sS" and b4 in ~c"tT", do: true
   def table_name(_), do: false
-  def set_sql_lock(context \\ %{}), do: Map.merge(context, %{sql_lock: %{tables: [%{table_name: {"test", :test, &table_name/1}}], columns: [%{column_name: {"test", :test, &table_name/1}}]}, module: SQL.Adapters.ANSI})
+  def set_sql_lock(context \\ %{}), do: Map.merge(context, %{validate: &table_name/1, module: SQL.Adapters.ANSI})
 end
 ExUnit.start()