Finish implementation of decent api.

Author: Connor Rigby

lib/sqlite.ex

@@ -3,8 +3,6 @@ defmodule Sqlite do
   SQLite3 driver for Elixir.
   """
 
-  alias Sqlite.Query
-
   defmodule Connection do
     @moduledoc false
     defstruct [
@@ -73,19 +71,16 @@ defmodule Sqlite do
       Sqlite.query(conn, "INSERT INTO posts (title) VALUES ('my title')", [])
       Sqlite.query(conn, "SELECT title FROM posts", [])
       Sqlite.query(conn, "SELECT id FROM posts WHERE title like $1", ["%my%"])
-      Sqlite.query(conn, "COPY posts TO STDOUT", [])
   """
   @spec query(conn, iodata, list, Keyword.t()) ::
           {:ok, Sqlite.Result.t()} | {:error, Sqlite.Error.t()}
-  def query(conn, statement, params, opts \\ []) do
-    query = %Query{name: "", statement: statement}
+  def query(conn, sql, params, opts \\ []) do
     opts = opts |> defaults()
 
-    GenServer.call(conn.pid, {:query, query, params, opts}, call_timeout(opts))
+    GenServer.call(conn.pid, {:query, sql, params, opts}, call_timeout(opts))
     |> case do
       {:ok, %Sqlite.Result{}} = ok -> ok
       {:error, %Sqlite.Error{}} = ok -> ok
-      err -> unexpected_response(err, :query)
     end
   end
 
@@ -94,46 +89,78 @@ defmodule Sqlite do
   there was an error. See `query/3`.
   """
   @spec query!(conn, iodata, list, Keyword.t()) :: Sqlite.Result.t()
-  def query!(conn, statement, params, opts \\ []) do
-    case query(conn, statement, params, opts) do
+  def query!(conn, sql, params, opts \\ []) do
+    case query(conn, sql, params, opts) do
       {:ok, result} -> result
-      {:error, reason} -> raise Sqlite.Error, %{reason: reason}
+      {:error, reason} -> raise Sqlite.Error, reason.message
     end
   end
 
   @doc """
   Prepares an (extended) query and returns the result as
   `{:ok, %Sqlite.Query{}}` or `{:error, %Sqlite.Error{}}` if there was an
   error. Parameters can be set in the query as `$1` embedded in the query
-  string. To execute the query call `execute/4`. To close the prepared query
-  call `close/3`. See `Sqlite.Query` for the query data.
+  string. To execute the query call `execute/4`.
 
   ## Examples
-      Sqlite.prepare(conn, "", "CREATE TABLE posts (id serial, title text)")
+      Sqlite.prepare(conn, "CREATE TABLE posts (id serial, title text)")
   """
-  @spec prepare(conn, iodata, iodata, Keyword.t()) ::
-          {:ok, Sqlite.Query.t()} | {:error, Sqlite.Error.t()}
-  def prepare(conn, name, statement, opts \\ []) do
-    query = %Query{name: name, statement: statement}
+  @spec prepare(conn, iodata, Keyword.t()) :: {:ok, Sqlite.Query.t()} | {:error, Sqlite.Error.t()}
+  def prepare(conn, sql, opts \\ []) do
     opts = opts |> defaults()
 
-    GenServer.call(conn.pid, {:prepare, query, opts}, call_timeout(opts))
+    GenServer.call(conn.pid, {:prepare, sql, opts}, call_timeout(opts))
     |> case do
       {:ok, %Sqlite.Query{}} = ok -> ok
       {:error, %Sqlite.Error{}} = ok -> ok
-      err -> unexpected_response(err, :prepare)
     end
   end
 
   @doc """
   Prepares an (extended) query and returns the prepared query or raises
-  `Sqlite.Error` if there was an error. See `prepare/4`.
+  `Sqlite.Error` if there was an error. See `prepare/3`.
   """
-  @spec prepare!(conn, iodata, iodata, Keyword.t()) :: Sqlite.Query.t()
-  def prepare!(conn, name, statement, opts \\ []) do
-    case prepare(conn, name, statement, opts) do
+  @spec prepare!(conn, iodata, Keyword.t()) :: Sqlite.Query.t()
+  def prepare!(conn, sql, opts \\ []) do
+    case prepare(conn, sql, opts) do
       {:ok, result} -> result
-      {:error, reason} -> raise Sqlite.Error, %{reason: reason}
+      {:error, reason} -> raise Sqlite.Error, reason.message
+    end
+  end
+
+  @doc """
+  Releases an (extended) query.
+
+  ## Examples
+      query = Sqlite.prepare!(conn, "CREATE TABLE posts (id serial, title text)")
+      Sqlite.release_query(query)
+  """
+  @spec release_query(conn, Sqlite.Query.t(), Keyword.t()) :: :ok | {:error, Sqlite.Error.t()}
+  def release_query(conn, query, opts \\ []) do
+    opts = opts |> defaults()
+
+    GenServer.call(conn.pid, {:release_query, query, opts}, call_timeout(opts))
+    |> case do
+      :ok -> :ok
+      {:error, %Sqlite.Error{}} = ok -> ok
+    end
+  end
+
+  @doc """
+  Releases an (extended) query or raises
+  `Sqlite.Error` if there was an error. See `release_query/3`.
+
+  ## Examples
+      query = Sqlite.prepare!(conn, "CREATE TABLE posts (id serial, title text)")
+      Sqlite.release_query(query)
+  """
+  @spec release_query!(conn, Sqlite.Query.t(), Keyword.t()) :: :ok
+  def release_query!(conn, query, opts \\ []) do
+    opts = opts |> defaults()
+
+    case release_query(conn, query, opts) do
+      :ok -> :ok
+      {:error, reason} -> raise Sqlite.Error, reason.message
     end
   end
 
@@ -160,7 +187,6 @@ defmodule Sqlite do
     |> case do
       {:ok, %Sqlite.Result{}} = ok -> ok
       {:error, %Sqlite.Error{}} = ok -> ok
-      err -> unexpected_response(err, :execute)
     end
   end
 
@@ -172,7 +198,7 @@ defmodule Sqlite do
   def execute!(conn, query, params, opts \\ []) do
     case execute(conn, query, params, opts) do
       {:ok, result} -> result
-      {:error, reason} -> raise Sqlite.Error, %{reason: reason}
+      {:error, reason} -> raise Sqlite.Error, reason.message
     end
   end
 
@@ -182,23 +208,11 @@ defmodule Sqlite do
   @spec close(conn, Keyword.t()) :: :ok | {:error, Sqlite.Error.t()}
   def close(conn, opts \\ []) when is_list(opts) do
     opts = defaults(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, Keyword.t()) :: :ok
-  def close!(conn, opts \\ []) do
-    case close(conn, opts) do
-      :ok -> :ok
-      {:error, reason} -> raise Sqlite.Error, %{reason: reason}
     end
   end
 
@@ -218,8 +232,4 @@ defmodule Sqlite do
 
     Keyword.merge(defaults, opts)
   end
-
-  defp unexpected_response(err, fun) do
-    raise "Unexpected response to #{fun}: #{inspect(err)}"
-  end
 end

lib/sqlite/error.ex

@@ -4,13 +4,9 @@ defmodule Sqlite.Error do
   defexception [:message]
 
   @typedoc "Various SQLite error."
-  @type t :: %Sqlite.Error{}
+  @type t :: %Sqlite.Error{
+          message: binary
+        }
 
-  def exception(%{reason: message}) do
-    %Sqlite.Error{message: message}
-  end
-
-  def message(e) do
-    e.message
-  end
+  def message(e), do: e.message
 end

lib/sqlite/query.ex

@@ -1,11 +1,26 @@
 defmodule Sqlite.Query do
   @moduledoc "This module handles creation of SQL queries."
 
-  defstruct [:name, :statement]
+  defstruct [
+    :statement,
+    :column_types,
+    :column_names,
+    :sql
+  ]
 
   @typedoc "Sqlite Query for execution."
   @type t :: %__MODULE__{
-          name: String.t(),
-          statement: iodata
+          statement: Esqlite3.prepared_statement(),
+          sql: iodata,
+          column_names: [iodata] | nil,
+          column_types: [atom] | nil
         }
+
+  defimpl Inspect, for: __MODULE__ do
+    def inspect(%{statement: {:statement, ref, _}}, _) when is_reference(ref) do
+      String.replace(inspect(ref), "Reference", "Statement")
+    end
+
+    def inspect(_, _), do: exit("Tried to inspect empty query!")
+  end
 end

lib/sqlite/result.ex

@@ -9,7 +9,7 @@ defmodule Sqlite.Result do
 
   @type t :: %Sqlite.Result{
           columns: [String.t()],
-          rows: [[term] | binary],
+          rows: [[term]],
           num_rows: integer
         }
 end

lib/sqlite/server.ex

@@ -1,7 +1,7 @@
 defmodule Sqlite.Server do
   @moduledoc "GenServer implementation for Sqlite."
   use GenServer
-  # alias Sqlite.{Query, Error, Result}
+  alias Sqlite.Query
 
   defmodule State do
     @moduledoc false
@@ -37,27 +37,102 @@ defmodule Sqlite.Server do
   end
 
   @impl GenServer
-  def handle_call({:query, query, params, _opts}, _from, state) do
-    Esqlite3.q(query.statement, params, state.database) |> IO.inspect()
-    {:reply, {:error, %Sqlite.Error{message: "Not implemented"}}, state}
+  def handle_call({:query, sql, params, opts}, _from, state) do
+    try do
+      with {:ok, %Query{} = q} <- build_query(sql, opts, state.database),
+           :ok <- Esqlite3.bind(q.statement, params) do
+        r = Esqlite3.fetchall(q.statement) |> build_result(q, state)
+        {:reply, r, state}
+      else
+        err -> {:reply, error(err, state), state}
+      end
+    catch
+      err -> {:reply, error(err, state), state}
+    end
   end
 
-  def handle_call({:prepare, query, opts}, _from, state) do
-    Esqlite3.prepare(query.statement, state.database, opts[:timeout]) |> IO.inspect()
-    {:reply, {:error, %Sqlite.Error{message: "Not implemented"}}, state}
+  def handle_call({:release_query, query, opts}, _from, state) do
+    try do
+      case Esqlite3.reset(query.statement, opts[:timeout]) do
+        :ok -> {:reply, :ok, state}
+        err -> {:reply, error(err, state), state}
+      end
+    catch
+      err -> {:reply, error(err, state), state}
+    end
+  end
+
+  def handle_call({:prepare, sql, opts}, _from, state) do
+    try do
+      case build_query(sql, opts, state.database) do
+        {:ok, %Query{} = q} ->
+          {:reply, {:ok, q}, state}
+        err ->
+          {:reply, error(err, state), state}
+      end
+    catch
+      err -> {:reply, error(err, state), state}
+    end
   end
 
   def handle_call({:execute, query, params, opts}, _from, state) do
-    Esqlite3.exec(query.statement, params, state.database, opts[:timeout]) |> IO.inspect()
-    {:reply, {:error, %Sqlite.Error{message: "Not implemented"}}, state}
+    try do
+      case Esqlite3.bind(query.statement, params, opts[:timeout]) do
+        :ok ->
+          r = Esqlite3.fetchall(query.statement) |> build_result(query, state)
+          {:reply, r, state}
+
+        err ->
+          {:reply, error(err, state), state}
+      end
+    catch
+      err -> {:reply, error(err, state), state}
+    end
   end
 
-  def handle_call({:close, _opts}, _from, state) do
-    case Esqlite3.close(state.database) do
+  def handle_call({:close, opts}, _from, state) do
+    case Esqlite3.close(state.database, opts[:timeout]) do
       :ok -> {:stop, :normal, :ok, %{state | database: :closed}}
       {:error, reason} -> {:stop, reason, error(reason, state), state}
     end
   end
 
+  @spec error(any, State.t()) :: {:error, Sqlite.Error.t()}
+
+  defp error({:error, {:sqlite_error, msg}}, _state),
+    do: {:error, %Sqlite.Error{message: to_string(msg)}}
+
+  defp error({:error, {:constraint, msg}}, _state),
+    do: {:error, %Sqlite.Error{message: to_string(msg)}}
+
+  defp error({:error, msg}, _state) when is_atom(msg),
+    do: {:error, %Sqlite.Error{message: to_string(msg)}}
+
   defp error(reason, _state), do: {:error, %Sqlite.Error{message: reason}}
+
+  @spec build_query(iodata, Keyword.t(), Esqlite3.connection()) ::
+          {:ok, Sqlite.Query.t()} | {:error, term}
+  defp build_query(sql, opts, database) do
+    timeout = opts[:timeout]
+
+    case Esqlite3.prepare(sql, database, timeout) do
+      {:ok, statement} ->
+        cn = Esqlite3.column_names(statement, timeout) |> Tuple.to_list()
+        ct = Esqlite3.column_types(statement, timeout) |> Tuple.to_list()
+        {:ok, %Sqlite.Query{column_names: cn, column_types: ct, statement: statement, sql: sql}}
+
+      err ->
+        err
+    end
+  end
+
+  @spec build_result(any, Sqlite.Query.t(), State.t()) ::
+          {:ok, Sqlite.Result.t()} | {:error, Sqlite.Error.t()}
+  defp build_result({:error, _} = err, _q, state), do: error(err, state)
+
+  defp build_result(result, %Query{} = q, _state) when is_list(result) do
+    rows = Enum.map(result, &Tuple.to_list(&1))
+    num_rows = Enum.count(rows)
+    {:ok, %Sqlite.Result{rows: rows, num_rows: num_rows, columns: q.column_names}}
+  end
 end