add set_error_log/2

Author: ruslandoga

c_src/sqlite3_nif.c

@@ -22,6 +22,7 @@ typedef struct connection
     sqlite3* db;
     ErlNifMutex* mutex;
     ErlNifPid update_hook_pid;
+    ErlNifPid error_log_pid;
 } connection_t;
 
 typedef struct statement
@@ -1065,6 +1066,55 @@ exqlite_set_update_hook(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
     return make_atom(env, "ok");
 }
 
+//
+// Error Notifications
+//
+
+void
+error_callback(void* arg, int iErrCode, const char* zMsg)
+{
+    connection_t* conn = (connection_t*)arg;
+
+    if (conn == NULL) {
+        return;
+    }
+
+    ErlNifEnv* msg_env = enif_alloc_env();
+    ERL_NIF_TERM error = make_binary(msg_env, zMsg, strlen(zMsg));
+    ERL_NIF_TERM msg   = enif_make_tuple3(msg_env, make_atom(msg_env, "error"), enif_make_int(msg_env, iErrCode), error);
+
+    if (!enif_send(NULL, &conn->error_log_pid, msg_env, msg)) {
+        sqlite3_config(SQLITE_CONFIG_LOG, NULL, NULL);
+    }
+
+    enif_free_env(msg_env);
+}
+
+static ERL_NIF_TERM
+exqlite_set_error_log(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    assert(env);
+    connection_t* conn = NULL;
+
+    if (argc != 2) {
+        return enif_make_badarg(env);
+    }
+
+    if (!enif_get_resource(env, argv[0], connection_type, (void**)&conn)) {
+        return make_error_tuple(env, "invalid_connection");
+    }
+
+    if (!enif_get_local_pid(env, argv[1], &conn->error_log_pid)) {
+        return make_error_tuple(env, "invalid_pid");
+    }
+
+    // Passing the connection as the third argument causes it to be
+    // passed as the first argument to error_callback. This allows us
+    // to extract the hook pid and reset the hook if the pid is not alive.
+    sqlite3_config(SQLITE_CONFIG_LOG, error_callback, conn);
+    return make_atom(env, "ok");
+}
+
 //
 // Most of our nif functions are going to be IO bounded
 //
@@ -1086,6 +1136,7 @@ static ErlNifFunc nif_funcs[] = {
   {"release", 2, exqlite_release, ERL_NIF_DIRTY_JOB_IO_BOUND},
   {"enable_load_extension", 2, exqlite_enable_load_extension, ERL_NIF_DIRTY_JOB_IO_BOUND},
   {"set_update_hook", 2, exqlite_set_update_hook, ERL_NIF_DIRTY_JOB_IO_BOUND},
+  {"set_error_log", 2, exqlite_set_error_log, ERL_NIF_DIRTY_JOB_IO_BOUND},
 };
 
 ERL_NIF_INIT(Elixir.Exqlite.Sqlite3NIF, nif_funcs, on_load, NULL, NULL, on_unload)

lib/exqlite/sqlite3.ex

@@ -223,7 +223,7 @@ defmodule Exqlite.Sqlite3 do
     * Only one pid can listen to the changes on a given database connection at a time.
       If this function is called multiple times for the same connection, only the last pid will
       receive the notifications
-    * Updates only happen for the connection that is opened. For example, there 
+    * Updates only happen for the connection that is opened. For example, there
       are two connections A and B. When an update happens on connection B, the
       hook set for connection A will not receive the update, but the hook for
       connection B will receive the update.
@@ -233,6 +233,16 @@ defmodule Exqlite.Sqlite3 do
     Sqlite3NIF.set_update_hook(conn, pid)
   end
 
+  @doc """
+  Send error messages to a process.
+
+  Similar to `set_update_hook/2`, see `SQLITE_CONFIG_LOG` for [more details.](https://www.sqlite.org/c3ref/c_config_covering_index_scan.html)
+  """
+  @spec set_error_log(db(), pid()) :: :ok | {:error, reason()}
+  def set_error_log(conn, pid) do
+    Sqlite3NIF.set_error_log(conn, pid)
+  end
+
   defp convert(%Date{} = val), do: Date.to_iso8601(val)
   defp convert(%Time{} = val), do: Time.to_iso8601(val)
   defp convert(%NaiveDateTime{} = val), do: NaiveDateTime.to_iso8601(val)

lib/exqlite/sqlite3_nif.ex

@@ -67,5 +67,8 @@ defmodule Exqlite.Sqlite3NIF do
   @spec set_update_hook(db(), pid()) :: :ok | {:error, reason()}
   def set_update_hook(_conn, _pid), do: :erlang.nif_error(:not_loaded)
 
+  @spec set_error_log(db(), pid()) :: :ok | {:error, reason()}
+  def set_error_log(_conn, _pid), do: :erlang.nif_error(:not_loaded)
+
   # add statement inspection tooling https://sqlite.org/c3ref/expanded_sql.html
 end

test/exqlite/sqlite3_test.exs

@@ -491,4 +491,68 @@ defmodule Exqlite.Sqlite3Test do
       refute_receive {{:insert, "main", "test", 1}, _}, 1000
     end
   end
+
+  describe "set_error_log/2" do
+    setup do
+      {:ok, path} = Temp.path()
+      {:ok, conn} = Sqlite3.open(path)
+
+      on_exit(fn ->
+        Sqlite3.close(conn)
+        File.rm(path)
+      end)
+
+      {:ok, conn: conn, path: path}
+    end
+
+    test "can receive errors", %{conn: conn} do
+      assert :ok = Sqlite3.set_error_log(conn, self())
+
+      assert {:error, reason} = Sqlite3.prepare(conn, "some invalid sql")
+      assert reason == "near \"some\": syntax error"
+
+      assert_receive {:error, rc, msg}
+      assert rc == 1
+      assert msg == "near \"some\": syntax error in \"some invalid sql\""
+      refute_receive _anything_else
+    end
+
+    test "only one pid can listen at a time", %{conn: conn} do
+      test = self()
+      assert :ok = Sqlite3.set_error_log(conn, test)
+
+      spawn(fn ->
+        :ok = Sqlite3.set_error_log(conn, self())
+        assert {:error, reason} = Sqlite3.prepare(conn, "some invalid sql")
+        assert reason == "near \"some\": syntax error"
+        assert_receive {:error, rc, msg}
+        assert rc == 1
+        assert msg == "near \"some\": syntax error in \"some invalid sql\""
+        refute_receive _anything_else
+        send(test, :done)
+      end)
+
+      assert_receive :done, 1000
+      refute_receive _anything_else
+    end
+
+    test "notifications don't cross connections", %{conn: conn1, path: path} do
+      assert {:ok, conn2} = Sqlite3.open(path)
+
+      assert :ok = Sqlite3.set_error_log(conn1, self())
+      assert :ok = Sqlite3.set_error_log(conn2, self())
+
+      assert {:error, _reason} = Sqlite3.prepare(conn1, "some invalid sql 1")
+      assert_receive {:error, rc, msg}
+      assert rc == 1
+      assert msg == "near \"some\": syntax error in \"some invalid sql 1\""
+      refute_receive _anything_else
+
+      assert {:error, _reason} = Sqlite3.prepare(conn2, "some invalid sql 2")
+      assert_receive {:error, rc, msg}
+      assert rc == 1
+      assert msg == "near \"some\": syntax error in \"some invalid sql 2\""
+      refute_receive _anything_else
+    end
+  end
 end