continue

Author: ruslandoga

c_src/sqlite3_nif.c

@@ -29,7 +29,6 @@ typedef struct connection
 
 typedef struct statement
 {
-    connection_t* conn;
     sqlite3_stmt* statement;
 } statement_t;
 
@@ -384,9 +383,6 @@ exqlite_prepare(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
     }
     statement->statement = NULL;
 
-    enif_keep_resource(conn);
-    statement->conn = conn;
-
     // ensure connection is not getting closed by parallel thread
     enif_mutex_lock(conn->mutex);
     if (conn->db == NULL) {
@@ -907,11 +903,6 @@ statement_type_destructor(ErlNifEnv* env, void* arg)
         sqlite3_finalize(statement->statement);
         statement->statement = NULL;
     }
-
-    if (statement->conn) {
-        enif_release_resource(statement->conn);
-        statement->conn = NULL;
-    }
 }
 
 static int

lib/exqlite.ex

@@ -270,13 +270,13 @@ defmodule Exqlite do
 
   # TODO sql / statement
   @compile inline: [wrap_error: 1]
-  defp wrap_error({:error, reason}) when is_binary(reason) do
-    {:error, UsageError.exception(message: reason)}
-  end
-
   defp wrap_error({:error, error}) when is_list(error) do
     {:error, SQLiteError.exception(error)}
   end
 
+  defp wrap_error({:error, reason}) do
+    {:error, UsageError.exception(message: reason)}
+  end
+
   defp wrap_error(success), do: success
 end

lib/exqlite/nif.ex

@@ -4,6 +4,7 @@ defmodule Exqlite.Nif do
   @compile {:autoload, false}
   @on_load {:load_nif, 0}
 
+  # TODO it's not just a string
   @type error :: String.t() | Keyword.t()
 
   def load_nif do

lib/exqlite/usage_error.ex

@@ -4,11 +4,19 @@ defmodule Exqlite.UsageError do
 
   Examples:
 
-      iex> Exqlite.open(:not_a_path)
+      iex> Exqlite.open('TODO')
       {:error, %Exqlite.UsageError{message: "TODO"}}
 
   """
 
   defexception [:message]
-  @type t :: %__MODULE__{message: String.t()}
+
+  @type t :: %__MODULE__{
+          message:
+            String.t()
+            | :invalid_statement
+            | :invalid_connection
+            | :arguments_wrong_length
+            | {:wrong_type, term}
+        }
 end

test/exqlite/extensions_test.exs

@@ -20,7 +20,7 @@ defmodule Exqlite.ExtensionsTest do
 
       assert :ok = Exqlite.disable_load_extension(conn)
 
-      assert {:error, %Exqlite.Error{message: "not authorized"}} =
+      assert {:error, %Exqlite.UsageError{message: "not authorized"}} =
                Exqlite.prepare_fetch_all(
                  conn,
                  "select load_extension(?)",

test/exqlite/integration_test.exs

@@ -124,7 +124,7 @@ defmodule Exqlite.IntegrationTest do
     :ok = Exqlite.execute(conn1, "begin immediate")
     assert {:ok, :transaction} = Exqlite.transaction_status(conn1)
 
-    assert {:error, %Exqlite.Error{} = error} =
+    assert {:error, %Exqlite.UsageError{} = error} =
              Exqlite.execute(conn2, "begin immediate")
 
     assert error.message == "database is locked"

test/exqlite/sqlite_error_test.exs

@@ -4,7 +4,7 @@ defmodule Exqlite.SQLiteErrorTest do
 
   describe "message/1" do
     test "with :statement" do
-      assert "a\nb" == Exception.message(%SQLiteError{message: "a", statement: "b"})
+      assert "a: b" == Exception.message(%SQLiteError{message: "a", statement: "b"})
     end
 
     test "without :statement" do

test/exqlite_test.exs

@@ -68,7 +68,8 @@ defmodule ExqliteTest do
                )
 
       assert {:error,
-              %Exqlite.Error{message: "attempt to write a readonly database"} = error} =
+              %Exqlite.UsageError{message: "attempt to write a readonly database"} =
+                error} =
                Exqlite.execute(
                  conn,
                  "insert into test (stuff) values ('This is a test')"
@@ -109,7 +110,7 @@ defmodule ExqliteTest do
 
       {:ok, stmt} = Exqlite.prepare(conn, "insert into test(col) values(?)")
       :ok = Exqlite.bind(conn, stmt, ["something"])
-      {:error, %Exqlite.Error{} = error} = Exqlite.step(conn, stmt)
+      {:error, %Exqlite.UsageError{} = error} = Exqlite.step(conn, stmt)
 
       assert error.message == "attempt to write a readonly database"
     end
@@ -124,7 +125,7 @@ defmodule ExqliteTest do
   describe ".close/2" do
     test "doesn't crash on invalid conn handle" do
       conn = make_ref()
-      assert {:error, %Exqlite.Error{} = error} = Exqlite.close(conn)
+      assert {:error, %Exqlite.UsageError{} = error} = Exqlite.close(conn)
       assert error.message == :invalid_connection
     end
 
@@ -171,7 +172,7 @@ defmodule ExqliteTest do
     end
 
     test "handles incorrect syntax", %{conn: conn} do
-      assert {:error, %Exqlite.Error{message: "near \"a\": syntax error"}} =
+      assert {:error, %Exqlite.UsageError{message: "near \"a\": syntax error"}} =
                Exqlite.execute(
                  conn,
                  "create a dumb table test (id integer primary key, stuff text)"
@@ -325,14 +326,14 @@ defmodule ExqliteTest do
     end
 
     test "users table does not exist", %{conn: conn} do
-      assert {:error, %Exqlite.Error{} = error} =
+      assert {:error, %Exqlite.UsageError{} = error} =
                Exqlite.prepare(conn, "select * from users where id < ?")
 
       assert Exception.message(error) == "no such table: users"
     end
 
     test "supports utf8 in error messages", %{conn: conn} do
-      assert {:error, %Exqlite.Error{message: "no such table: 🌍"}} =
+      assert {:error, %Exqlite.UsageError{message: "no such table: 🌍"}} =
                Exqlite.prepare(conn, "select * from 🌍")
     end
   end
@@ -394,7 +395,7 @@ defmodule ExqliteTest do
     end
 
     test "releasing a nil statement" do
-      assert {:error, %Exqlite.Error{message: :invalid_statement}} =
+      assert {:error, %Exqlite.UsageError{message: :invalid_statement}} =
                Exqlite.release(nil)
     end
   end
@@ -421,13 +422,13 @@ defmodule ExqliteTest do
     end
 
     test "trying to bind with incorrect amount of arguments", %{conn: conn, stmt: stmt} do
-      assert {:error, %Exqlite.Error{message: :arguments_wrong_length}} =
+      assert {:error, %Exqlite.UsageError{message: :arguments_wrong_length}} =
                Exqlite.bind(conn, stmt, [])
     end
 
     test "doesn't bind datetime value as string", %{conn: conn, stmt: stmt} do
       assert {:error,
-              %Exqlite.Error{message: {:wrong_type, %DateTime{}}} =
+              %Exqlite.UsageError{message: {:wrong_type, %DateTime{}}} =
                 error} =
                Exqlite.bind(conn, stmt, [DateTime.utc_now()])
 
@@ -436,7 +437,7 @@ defmodule ExqliteTest do
 
     test "doesn't bind date value as string", %{conn: conn, stmt: stmt} do
       assert {:error,
-              %Exqlite.Error{message: {:wrong_type, %Date{}}} =
+              %Exqlite.UsageError{message: {:wrong_type, %Date{}}} =
                 error} =
                Exqlite.bind(conn, stmt, [Date.utc_today()])
 
@@ -522,7 +523,7 @@ defmodule ExqliteTest do
       assert :ok = Exqlite.bind(conn, stmt, ["this is a test"])
 
       assert {:error,
-              %Exqlite.Error{message: "Sqlite3 was invoked incorrectly."} = error} =
+              %Exqlite.UsageError{message: "Sqlite3 was invoked incorrectly."} = error} =
                Exqlite.execute(
                  conn,
                  "create table test (id integer primary key, stuff text)"
@@ -636,7 +637,7 @@ defmodule ExqliteTest do
     test "can receive errors", %{conn: conn} do
       assert :ok = Exqlite.set_log_hook(self())
 
-      assert {:error, %Exqlite.Error{message: "near \"some\": syntax error"}} =
+      assert {:error, %Exqlite.UsageError{message: "near \"some\": syntax error"}} =
                Exqlite.prepare(conn, "some invalid sql")
 
       assert_receive {:log, rc, msg}
@@ -652,7 +653,7 @@ defmodule ExqliteTest do
         Task.async(fn ->
           :ok = Exqlite.set_log_hook(self())
 
-          assert {:error, %Exqlite.Error{message: "near \"some\": syntax error"}} =
+          assert {:error, %Exqlite.UsageError{message: "near \"some\": syntax error"}} =
                    Exqlite.prepare(conn, "some invalid sql")
 
           assert_receive {:log, rc, msg}