Adds Sqlite3.release/2 for prepared statements

Author: warmwaffles

c_src/sqlite3_nif.c

@@ -712,6 +712,35 @@ exqlite_deserialize(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
     return make_atom(env, "ok");
 }
 
+static ERL_NIF_TERM
+exqlite_release(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    assert(env);
+
+    statement_t* statement = NULL;
+    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_resource(env, argv[1], statement_type, (void**)&statement)) {
+        return make_error_tuple(env, "invalid_statement");
+    }
+
+    if (statement->statement) {
+        sqlite3_finalize(statement->statement);
+        statement->statement = NULL;
+    }
+    enif_release_resource(statement);
+
+    return make_atom(env, "ok");
+}
+
 static void
 connection_type_destructor(ErlNifEnv* env, void* arg)
 {
@@ -788,6 +817,7 @@ static ErlNifFunc nif_funcs[] = {
   {"transaction_status", 1, exqlite_transaction_status, ERL_NIF_DIRTY_JOB_IO_BOUND},
   {"serialize", 2, exqlite_serialize, ERL_NIF_DIRTY_JOB_IO_BOUND},
   {"deserialize", 3, exqlite_deserialize, ERL_NIF_DIRTY_JOB_IO_BOUND},
+  {"release", 2, exqlite_release, ERL_NIF_DIRTY_JOB_IO_BOUND},
 };
 
 ERL_NIF_INIT(Elixir.Exqlite.Sqlite3NIF, nif_funcs, on_load, NULL, NULL, NULL)

lib/exqlite/connection.ex

@@ -259,7 +259,8 @@ defmodule Exqlite.Connection do
   This callback is called in the client process.
   """
   @impl true
-  def handle_close(_query, _opts, state) do
+  def handle_close(query, _opts, state) do
+    Sqlite3.release(state.db, query.ref)
     {:ok, nil, state}
   end
 
@@ -274,10 +275,8 @@ defmodule Exqlite.Connection do
   end
 
   @impl true
-  def handle_deallocate(%Query{} = _query, _cursor, _opts, state) do
-    # We actually don't need to do anything about the cursor. Since it is a
-    # prepared statement, it will be garbage collected by erlang when it loses
-    # references.
+  def handle_deallocate(%Query{} = query, _cursor, _opts, state) do
+    Sqlite3.release(state.db, query.ref)
     {:ok, nil, state}
   end
 

lib/exqlite/sqlite3.ex

@@ -166,6 +166,15 @@ defmodule Exqlite.Sqlite3 do
     Sqlite3NIF.deserialize(conn, String.to_charlist(database), serialized)
   end
 
+  @doc """
+  Once finished with the prepared statement, call this to release the underlying
+  resources.
+  """
+  @spec release(db(), statement()) :: :ok | {:error, reason()}
+  def release(conn, statement) do
+    Sqlite3NIF.release(conn, statement)
+  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

@@ -56,5 +56,8 @@ defmodule Exqlite.Sqlite3NIF do
   @spec deserialize(db(), String.Chars.t(), binary()) :: :ok | {:error, reason()}
   def deserialize(_conn, _database, _serialized), do: :erlang.nif_error(:not_loaded)
 
+  @spec release(db(), statement()) :: :ok | {:error, reason()}
+  def release(_conn, _statement), do: :erlang.nif_error(:not_loaded)
+
   # TODO: add statement inspection tooling https://sqlite.org/c3ref/expanded_sql.html
 end

test/exqlite/connection_test.exs

@@ -188,4 +188,22 @@ defmodule Exqlite.ConnectionTest do
       assert {:ok, conn} == Connection.ping(conn)
     end
   end
+
+  describe ".handle_close/3" do
+    test "releases the underlying prepared statement" do
+      {:ok, conn} = Connection.connect(database: :memory)
+
+      {:ok, query, _result, conn} =
+        %Query{statement: "create table users (id integer primary key, name text)"}
+        |> Connection.handle_execute([], [], conn)
+
+      assert {:ok, nil, conn} == Connection.handle_close(query, [], conn)
+
+      {:ok, query, conn} =
+        %Query{statement: "select * from users where id < ?"}
+        |> Connection.handle_prepare([], conn)
+
+      assert {:ok, nil, conn} == Connection.handle_close(query, [], conn)
+    end
+  end
 end