I misunderstood that function title.

Author: Connor Rigby

lib/sqlite.ex

@@ -55,7 +55,9 @@ defmodule Sqlite do
           )
 
         {:ok, conn}
-      {:error, reason} -> {:error, reason}
+
+      {:error, reason} ->
+        {:error, reason}
     end
   end
 
@@ -175,47 +177,26 @@ defmodule Sqlite do
   end
 
   @doc """
-  Closes an (extended) prepared query and returns `:ok` or
-  `{:error, %Sqlite.Error{}}` if there was an error. Closing a query releases
-  any resources held by sqlite3 for a prepared query with that name. See
-  `Sqlite.Query` for the query data.
-
-  ## Examples
-      query = Sqlite.prepare!(conn, "", "CREATE TABLE posts (id serial, title text)")
-      Sqlite.close(conn, query)
+  Closes the connection to the database.
   """
-  @spec close(conn, Sqlite.Query.t(), Keyword.t()) :: :ok | {:error, Sqlite.Error.t()}
-
-  def close(conn, query \\ nil, opts \\ [])
-  def close(conn, query, opts) do
+  @spec close(conn, Keyword.t()) :: :ok | {:error, Sqlite.Error.t()}
+  def close(conn, opts \\ []) when is_list(opts) do
     opts = defaults(opts)
-
-    do_close = fn(conn, opts) ->
-      GenServer.call(conn.pid, {:close, opts}, call_timeout(opts))
-      |> case do
-        :ok -> :ok
-        {:error, %Sqlite.Error{}} = ok -> ok
-        err -> unexpected_response(err, :close)
-      end
-    end
-
-    if query do
-      case execute(query, [], opts) do
-        {:error, reason} -> {:error, reason}
-        {:ok, _result} -> do_close.(conn, opts)
-      end
-    else
-      do_close.(conn, opts)
+    GenServer.call(conn.pid, {:close, opts}, call_timeout(opts))
+    |> case do
+      :ok -> :ok
+      {:error, %Sqlite.Error{}} = ok -> ok
+      err -> unexpected_response(err, :close)
     end
   end
 
   @doc """
   Closes an (extended) prepared query and returns `:ok` or raises
   `Sqlite.Error` if there was an error. See `close/3`.
   """
-  @spec close!(conn, Sqlite.Query.t(), Keyword.t()) :: :ok
-  def close!(conn, query \\ nil, opts \\ []) do
-    case close(conn, query, opts) do
+  @spec close!(conn, Keyword.t()) :: :ok
+  def close!(conn, opts \\ []) do
+    case close(conn, opts) do
       :ok -> :ok
       {:error, reason} -> raise Sqlite.Error, %{reason: reason}
     end

lib/sqlite/server.ex

@@ -8,19 +8,22 @@ defmodule Sqlite.Server do
     defstruct [:database, :filename]
     @typedoc false
     @type t :: %__MODULE__{
-      database: Esqlite3.connection | :closed,
-      filename: Esqlite3.filename,
-    }
+            database: Esqlite3.connection() | :closed,
+            filename: Esqlite3.filename()
+          }
   end
 
   @impl GenServer
   def init(opts) do
     filename = Keyword.fetch!(opts, :database)
     timeout = Keyword.fetch!(opts, :timeout)
+
     case Esqlite3.open(filename, timeout) do
       {:ok, db} ->
-        {:ok, struct(State, [database: db, filename: filename])}
-      err -> {:stop, err}
+        {:ok, struct(State, database: db, filename: filename)}
+
+      err ->
+        {:stop, err}
     end
   end
 
@@ -29,22 +32,23 @@ defmodule Sqlite.Server do
     unless state.database == :closed do
       :ok = Esqlite3.close(state.database)
     end
+
     :ok
   end
 
   @impl GenServer
   def handle_call({:query, query, params, _opts}, _from, state) do
-    Esqlite3.q(query.statement, params, state.database) |> IO.inspect
+    Esqlite3.q(query.statement, params, state.database) |> IO.inspect()
     {:reply, {:error, %Sqlite.Error{message: "Not implemented"}}, state}
   end
 
   def handle_call({:prepare, query, opts}, _from, state) do
-    Esqlite3.prepare(query.statement, state.database, opts[:timeout]) |> IO.inspect
+    Esqlite3.prepare(query.statement, state.database, opts[:timeout]) |> IO.inspect()
     {:reply, {:error, %Sqlite.Error{message: "Not implemented"}}, state}
   end
 
   def handle_call({:execute, query, params, opts}, _from, state) do
-    Esqlite3.exec(query.statement, params, state.database, opts[:timeout]) |> IO.inspect
+    Esqlite3.exec(query.statement, params, state.database, opts[:timeout]) |> IO.inspect()
     {:reply, {:error, %Sqlite.Error{message: "Not implemented"}}, state}
   end
 
@@ -55,6 +59,5 @@ defmodule Sqlite.Server do
     end
   end
 
-  defp error(reason, _state), do: %Sqlite.Error{message: reason}
-
+  defp error(reason, _state), do: {:error, %Sqlite.Error{message: reason}}
 end