add named params

Author: ruslandoga

c_src/sqlite3_nif.c

@@ -561,6 +561,30 @@ exqlite_bind_parameter_count(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]
     return enif_make_int(env, bind_parameter_count);
 }
 
+///
+/// Get the bind parameter index
+///
+ERL_NIF_TERM
+exqlite_bind_parameter_index(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    statement_t* statement;
+    if (!enif_get_resource(env, argv[0], statement_type, (void**)&statement)) {
+        return raise_badarg(env, argv[0]);
+    }
+
+    ERL_NIF_TERM eos = enif_make_int(env, 0);
+    ErlNifBinary name;
+
+    if (!enif_inspect_iolist_as_binary(env, enif_make_list2(env, argv[1], eos), &name)) {
+        return raise_badarg(env, argv[1]);
+    }
+
+    statement_acquire_lock(statement);
+    int index = sqlite3_bind_parameter_index(statement->statement, (const char*)name.data);
+    statement_release_lock(statement);
+    return enif_make_int(env, index);
+}
+
 ///
 /// Binds a text parameter
 ///
@@ -1423,6 +1447,7 @@ static ErlNifFunc nif_funcs[] = {
   {"prepare", 2, exqlite_prepare, ERL_NIF_DIRTY_JOB_IO_BOUND},
   {"reset", 1, exqlite_reset, ERL_NIF_DIRTY_JOB_CPU_BOUND},
   {"bind_parameter_count", 1, exqlite_bind_parameter_count},
+  {"bind_parameter_index", 2, exqlite_bind_parameter_index},
   {"bind_text", 3, exqlite_bind_text},
   {"bind_blob", 3, exqlite_bind_blob},
   {"bind_integer", 3, exqlite_bind_integer},

lib/exqlite/sqlite3.ex

@@ -173,11 +173,20 @@ defmodule Exqlite.Sqlite3 do
       iex> Sqlite3.bind(stmt, [:erlang.list_to_pid(~c"<0.0.0>")])
       ** (ArgumentError) unsupported type: #PID<0.0.0>
 
+      iex> {:ok, conn} = Sqlite3.open(":memory:", [:readonly])
+      iex> {:ok, stmt} = Sqlite3.prepare(conn, "SELECT :a, :b")
+      iex> Sqlite3.bind(stmt, %{":a" => 42, ":b" => "Alice"})
+      iex> Sqlite3.step(conn, stmt)
+      {:row, [42, "Alice"]}
+
   """
-  @spec bind(statement, [bind_value] | nil) :: :ok
+  @spec bind(
+          statement,
+          [bind_value] | %{optional(String.t()) => bind_value} | nil
+        ) :: :ok
   def bind(stmt, nil), do: bind(stmt, [])
 
-  def bind(stmt, args) do
+  def bind(stmt, args) when is_list(args) do
     params_count = bind_parameter_count(stmt)
     args_count = length(args)
 
@@ -188,6 +197,20 @@ defmodule Exqlite.Sqlite3 do
     end
   end
 
+  def bind(stmt, args) when is_map(args) do
+    args =
+      Enum.map(args, fn {name, value} ->
+        case Sqlite3NIF.bind_parameter_index(stmt, name) do
+          0 -> raise ArgumentError, "unknown parameter: #{inspect(name)}"
+          idx -> {value, idx}
+        end
+      end)
+      |> Enum.sort_by(fn {_param, idx} -> idx end, :asc)
+      |> Enum.map(fn {param, _idx} -> param end)
+
+    bind(stmt, args)
+  end
+
   # credo:disable-for-next-line Credo.Check.Refactor.CyclomaticComplexity
   defp bind_all([param | params], stmt, idx) do
     case convert(param) do

lib/exqlite/sqlite3_nif.ex

@@ -72,6 +72,9 @@ defmodule Exqlite.Sqlite3NIF do
   @spec bind_parameter_count(statement) :: integer
   def bind_parameter_count(_stmt), do: :erlang.nif_error(:not_loaded)
 
+  @spec bind_parameter_index(statement, String.t()) :: integer
+  def bind_parameter_index(_stmt, _name), do: :erlang.nif_error(:not_loaded)
+
   @spec bind_text(statement, non_neg_integer, String.t()) :: integer()
   def bind_text(_stmt, _index, _text), do: :erlang.nif_error(:not_loaded)
 

test/exqlite/sqlite3_test.exs

@@ -298,6 +298,66 @@ defmodule Exqlite.Sqlite3Test do
         Sqlite3.bind(statement, [other_tz])
       end
     end
+
+    test "binds named parameters like :VVV" do
+      {:ok, conn} = Sqlite3.open(":memory:")
+
+      {:ok, statement} =
+        Sqlite3.prepare(conn, "select :42, :pi, :name, :emoji, :blob, :null")
+
+      :ok =
+        Sqlite3.bind(statement, %{
+          ":42" => 42,
+          ":pi" => 3.14,
+          ":name" => "Alice",
+          ":emoji" => "👋",
+          ":blob" => {:blob, <<0, 1, 2>>},
+          ":null" => nil
+        })
+
+      assert {:row, [42, 3.14, "Alice", "👋", <<0, 1, 2>>, nil]} =
+               Sqlite3.step(conn, statement)
+    end
+
+    test "binds named parameters like @VVV" do
+      {:ok, conn} = Sqlite3.open(":memory:")
+
+      {:ok, statement} =
+        Sqlite3.prepare(conn, "select @42, @pi, @name, @emoji, @blob, @null")
+
+      :ok =
+        Sqlite3.bind(statement, %{
+          "@42" => 42,
+          "@pi" => 3.14,
+          "@name" => "Alice",
+          "@emoji" => "👋",
+          "@blob" => {:blob, <<0, 1, 2>>},
+          "@null" => nil
+        })
+
+      assert {:row, [42, 3.14, "Alice", "👋", <<0, 1, 2>>, nil]} =
+               Sqlite3.step(conn, statement)
+    end
+
+    test "binds named parameters like $VVV" do
+      {:ok, conn} = Sqlite3.open(":memory:")
+
+      {:ok, statement} =
+        Sqlite3.prepare(conn, "select $42, $pi, $name, $emoji, $blob, $null")
+
+      :ok =
+        Sqlite3.bind(statement, %{
+          "$42" => 42,
+          "$pi" => 3.14,
+          "$name" => "Alice",
+          "$emoji" => "👋",
+          "$blob" => {:blob, <<0, 1, 2>>},
+          "$null" => nil
+        })
+
+      assert {:row, [42, 3.14, "Alice", "👋", <<0, 1, 2>>, nil]} =
+               Sqlite3.step(conn, statement)
+    end
   end
 
   describe ".bind_text/3" do
@@ -334,6 +394,11 @@ defmodule Exqlite.Sqlite3Test do
         Sqlite3.bind_text(stmt, 1, _not_text = 1)
       end
     end
+
+    test "handled null bytes in text", %{conn: conn, stmt: stmt} do
+      assert :ok = Sqlite3.bind_text(stmt, 1, "hello\0world")
+      assert {:row, ["hello\0world"]} = Sqlite3.step(conn, stmt)
+    end
   end
 
   describe ".bind_blob/3" do