[WIP] start implementing convient Elixir api

Author: connor rigby

coveralls.json

@@ -1,7 +1,7 @@
 {
-  "skip_files": [
-    "lib/esqlite3_nif.ex",
-    "lib/esqlite_erlang_def.ex",
-    "erl_test/"
-  ]
+ "skip_files": [
+  "lib/esqlite3/esqlite3_nif.ex",
+  "lib/esqlite3/esqlite_erlang_def.ex",
+  "erl_test/"
+ ]
 }

lib/esqlite3.ex lib/esqlite3/esqlite3.exlib/esqlite3.ex renamed to lib/esqlite3/esqlite3.ex

@@ -0,0 +1,244 @@
+defmodule Sqlite do
+  @moduledoc """
+  SQLite3 driver for Elixir.
+  """
+
+  alias Sqlite.Query
+
+  defmodule Connection do
+    @moduledoc false
+    defstruct [
+      :pid,
+      :ref,
+      :database
+    ]
+
+    @typedoc false
+    @type t :: %__MODULE__{
+            pid: GenServer.server(),
+            ref: reference,
+            database: Esqlite3.filename()
+          }
+
+    defimpl Inspect, for: __MODULE__ do
+      def inspect(%{ref: ref}, _opts) when is_reference(ref) do
+        String.replace(inspect(ref), "Reference", "Sqlite3")
+      end
+    end
+  end
+
+  @typedoc "Connection identifier for your Sqlite instance."
+  @opaque conn :: Connection.t()
+
+  @doc """
+  Start the connection process and connect to sqlite.
+  ## Options
+    * `:database` -> Databse uri.
+  ## Examples
+      iex> {:ok, pid} = Sqlite.open(database: "sqlite.db")
+      {:ok, #PID<0.69.0>}
+      iex> {:ok, pid} = Sqlite.open(database: ":memory:")
+      {:ok, #PID<0.69.0>}
+  """
+  @spec open(Keyword.t(), GenServer.options()) :: {:ok, conn} | {:error, term}
+  def open(opts, gen_server_opts \\ []) when is_list(opts) do
+    opts = Sqlite.Utils.default_opts(opts)
+
+    case GenServer.start_link(Sqlite.Server, opts, gen_server_opts) do
+      {:ok, pid} ->
+        conn =
+          struct(
+            Connection,
+            pid: pid,
+            database: opts[:database],
+            ref: make_ref()
+          )
+
+        {:ok, conn}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  @doc """
+  Runs an (extended) query and returns the result as `{:ok, %Sqlite.Result{}}`
+  or `{:error, %Sqlite.Error{}}` if there was a database error. Parameters can
+  be set in the query as `$1` embedded in the query string. Parameters are given
+  as a list of elixir values. See the README for information on how Sqlite
+  encodes and decodes Elixir values by default. See `Sqlite.Result` for the
+  result data.
+  ## Examples
+      Sqlite.query(conn, "CREATE TABLE posts (id serial, title text)", [])
+      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}
+    opts = opts |> defaults()
+
+    GenServer.call(conn.pid, {:query, query, params, opts}, call_timeout(opts))
+    |> case do
+      {:ok, %Sqlite.Result{}} = ok -> ok
+      {:error, %Sqlite.Error{}} = ok -> ok
+      err -> unexpected_response(err, :query)
+    end
+  end
+
+  @doc """
+  Runs an (extended) query and returns the result or raises `Sqlite.Error` if
+  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
+      {:ok, result} -> result
+      {:error, reason} -> raise Sqlite.Error, %{reason: reason}
+    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.
+
+  ## Examples
+      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}
+    opts = opts |> defaults()
+
+    GenServer.call(conn.pid, {:prepare, query, 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`.
+  """
+  @spec prepare!(conn, iodata, iodata, Keyword.t()) :: Sqlite.Query.t()
+  def prepare!(conn, name, statement, opts \\ []) do
+    case prepare(conn, name, statement, opts) do
+      {:ok, result} -> result
+      {:error, reason} -> raise Sqlite.Error, %{reason: reason}
+    end
+  end
+
+  @doc """
+  Runs an (extended) prepared query and returns the result as
+  `{:ok, %Sqlite.Result{}}` or `{:error, %Sqlite.Error{}}` if there was an
+  error. Parameters are given as part of the prepared query, `%Sqlite.Query{}`.
+  See the README for information on how Sqlite encodes and decodes Elixir
+  values by default. See `Sqlite.Query` for the query data and
+  `Sqlite.Result` for the result data.
+
+  ## Examples
+      query = Sqlite.prepare!(conn, "", "CREATE TABLE posts (id serial, title text)")
+      Sqlite.execute(conn, query, [])
+      query = Sqlite.prepare!(conn, "", "SELECT id FROM posts WHERE title like $1")
+      Sqlite.execute(conn, query, ["%my%"])
+  """
+  @spec execute(conn, Sqlite.Query.t(), list, Keyword.t()) ::
+          {:ok, Sqlite.Result.t()} | {:error, Sqlite.Error.t()}
+  def execute(conn, query, params, opts \\ []) do
+    opts = defaults(opts)
+
+    GenServer.call(conn.pid, {:execute, query, params, opts}, call_timeout(opts))
+    |> case do
+      {:ok, %Sqlite.Result{}} = ok -> ok
+      {:error, %Sqlite.Error{}} = ok -> ok
+      err -> unexpected_response(err, :execute)
+    end
+  end
+
+  @doc """
+  Runs an (extended) prepared query and returns the result or raises
+  `Sqlite.Error` if there was an error. See `execute/4`.
+  """
+  @spec execute!(conn, Sqlite.Query.t(), list, Keyword.t()) :: Sqlite.Result.t()
+  def execute!(conn, query, params, opts \\ []) do
+    case execute(conn, query, params, opts) do
+      {:ok, result} -> result
+      {:error, reason} -> raise Sqlite.Error, %{reason: reason}
+    end
+  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)
+  """
+  @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
+    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)
+    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
+      :ok -> :ok
+      {:error, reason} -> raise Sqlite.Error, %{reason: reason}
+    end
+  end
+
+  @spec call_timeout(Keyword.t()) :: timeout
+  defp call_timeout(opts) do
+    case Keyword.fetch!(opts, :timeout) do
+      number when is_integer(number) -> number + 100
+      other -> other
+    end
+  end
+
+  @spec defaults(Keyword.t()) :: Keyword.t()
+  defp defaults(opts) do
+    defaults = [
+      timeout: Application.get_env(:esqlite, :default_timeout, 5000)
+    ]
+
+    Keyword.merge(defaults, opts)
+  end
+
+  defp unexpected_response(err, fun) do
+    raise "Unexpected response to #{fun}: #{inspect(err)}"
+  end
+end

lib/esqlite3_nif.ex lib/esqlite3/esqlite3_nif.exlib/esqlite3_nif.ex renamed to lib/esqlite3/esqlite3_nif.ex

@@ -0,0 +1,16 @@
+defmodule Sqlite.Error do
+  @moduledoc false
+
+  defexception [:message]
+
+  @typedoc "Various SQLite error."
+  @type t :: %Sqlite.Error{}
+
+  def exception(%{reason: message}) do
+    %Sqlite.Error{message: message}
+  end
+
+  def message(e) do
+    e.message
+  end
+end

lib/esqlite_erlang_def.ex lib/esqlite3/esqlite_erlang_def.exlib/esqlite_erlang_def.ex renamed to lib/esqlite3/esqlite_erlang_def.ex

@@ -0,0 +1,11 @@
+defmodule Sqlite.Query do
+  @moduledoc "This module handles creation of SQL queries."
+
+  defstruct [:name, :statement]
+
+  @typedoc "Sqlite Query for execution."
+  @type t :: %__MODULE__{
+          name: String.t(),
+          statement: iodata
+        }
+end

lib/sqlite.ex

@@ -0,0 +1,15 @@
+defmodule Sqlite.Result do
+  @moduledoc "Results of a Query."
+
+  defstruct [
+    :columns,
+    :rows,
+    :num_rows
+  ]
+
+  @type t :: %Sqlite.Result{
+          columns: [String.t()],
+          rows: [[term] | binary],
+          num_rows: integer
+        }
+end

lib/sqlite/error.ex

@@ -0,0 +1,60 @@
+defmodule Sqlite.Server do
+  @moduledoc "GenServer implementation for Sqlite."
+  use GenServer
+  # alias Sqlite.{Query, Error, Result}
+
+  defmodule State do
+    @moduledoc false
+    defstruct [:database, :filename]
+    @typedoc false
+    @type t :: %__MODULE__{
+      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}
+    end
+  end
+
+  @impl GenServer
+  def terminate(_, state) 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
+    {: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
+    {: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
+    {:reply, {:error, %Sqlite.Error{message: "Not implemented"}}, state}
+  end
+
+  def handle_call({:close, _opts}, _from, state) do
+    case Esqlite3.close(state.database) do
+      :ok -> {:stop, :normal, :ok, %{state | database: :closed}}
+      {:error, reason} -> {:stop, reason, error(reason, state), state}
+    end
+  end
+
+  defp error(reason, _state), do: %Sqlite.Error{message: reason}
+
+end

lib/sqlite/query.ex

@@ -0,0 +1,8 @@
+defmodule Sqlite.Utils do
+  @moduledoc false
+
+  @spec default_opts(Keyword.t()) :: Keyword.t()
+  def default_opts(opts) do
+    Keyword.merge([timeout: Application.get_env(:esqlite, :default_timeout, 5000)], opts)
+  end
+end