Add a benchmark, update readme.

Author: connor rigby

.formatter.exs

@@ -1,4 +1,4 @@
 # Used by "mix format"
 [
-  inputs: ["mix.exs", "{config,lib,test}/**/*.{ex,exs}"]
+  inputs: ["mix.exs", "{config,lib,test,bench}/**/*.{ex,exs}"]
 ]

README.md

@@ -3,11 +3,8 @@
 [![Inline docs](http://inch-ci.org/github/connorrigby/esqlite.svg?branch=master)](http://inch-ci.org/github/connorrigby/esqlite)
 [![Deps Status](https://beta.hexfaktor.org/badge/all/github/ConnorRigby/esqlite.svg)](https://beta.hexfaktor.org/github/ConnorRigby/esqlite)
 
-An Erlang nif library for sqlite3.
-
-Introduction
-------------
-
+# Sqlite
+Elixir API for interacting with SQLite databases.
 This library allows you to use the accelent sqlite engine from
 erlang. The library is implemented as a nif library, which allows for
 the fastest access to a sqlite database. This can be risky, as a bug
@@ -19,3 +16,32 @@ Special care has been taken not to block the scheduler of the calling
 process. This is done by handling all commands from erlang within a
 lightweight thread. The erlang scheduler will get control back when
 the command has been added to the command-queue of the thread.
+
+# Usage
+```elixir
+{:ok, database} = Sqlite.open(database: "/tmp/database.sqlite3")
+{:ok, statement} = Sqlite.prepare(database, "CREATE TABLE data (id int, data text)")
+{:ok, _} = Sqlite.execute(database, statement, [])
+{:ok, statement} = Sqlite.prepare(database, "INSERT INTO data (data) VALUES ($1)")
+{:ok, _} = Sqlite.execute(database, statement, ["neat!"])
+{:ok, %Sqlite.Result{columns: [:data], num_rows: 1, rows: [["neat!"]]}} = Sqlite.query(database, "SELECT data FROM data", [])
+```
+
+# Tests
+Since this project was originally an Erlang package, I chose to maintain the
+original module name (as an alias) and it's tests to try to maintain
+backwards compatibility. By default these tests get ran by default.
+`mix test` will execute them.
+
+# Benchmarks
+There is also a benchmark suite located in the `bench` directory.
+It does not get ran with the test suite since it can take quite a while.
+You can run the benchmarks with
+```bash
+mix test --include bench
+```
+
+# Thanks and License
+This project is originally a fork of [esqlite](https://github.com/mmzeeman/esqlite)
+Which was originally an Erlang implementation. The underlying NIF code (in `c_src`),
+and the test file in `erl_test` both retain the original Apache v2 license.

bench/big_data_test.exs

@@ -0,0 +1,55 @@
+defmodule BigDataTest do
+  use ExUnit.Case
+  @timeout :infinity
+
+  @tag :bench
+  @tag timeout: @timeout
+  test "BIG DATA" do
+    {:ok, conn} = Sqlite.open(database: ":memory:")
+
+    column_names_and_types =
+      "a int, b int, c int, d int, e int, f int, g int, h int, i int, j int, " <>
+        "k int, l int, m int, n int, o int, p int, q int, r int, s int, t int, " <>
+        "u int, v int, w int, x int, y int, z int"
+
+    column_names = "a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z"
+
+    subs =
+      "$1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26"
+
+    {:ok, q} = Sqlite.prepare(conn, "CREATE TABLE posts (#{column_names_and_types})")
+    {:ok, _} = Sqlite.execute(conn, q, [])
+
+    {:ok, statement} =
+      Sqlite.prepare(conn, "INSERT INTO posts (#{column_names}) VALUES (#{subs})")
+
+    {:ok, _} = Sqlite.execute(conn, statement, Enum.to_list(1..26))
+    range = 0..800_000
+
+    inserts_fun = fn ->
+      {time, _} =
+        :timer.tc(fn ->
+          for _i <- range do
+            {:ok, _} = Sqlite.execute(conn, statement, Enum.to_list(1..26))
+          end
+        end)
+
+      IO.puts("#{Enum.count(range)} INSERT's took #{time} µs to execute.")
+    end
+
+    query_fun = fn ->
+      {time, res} =
+        :timer.tc(fn ->
+          Sqlite.query!(conn, "SELECT * FROM posts;", [], timeout: @timeout)
+        end)
+
+      IO.puts("Query took: #{time} µs.")
+      assert match?(%Sqlite.Result{}, res)
+    end
+
+    insert_task = Task.async(inserts_fun)
+    Task.await(insert_task, @timeout)
+    query_task = Task.async(query_fun)
+    Task.await(query_task, @timeout)
+  end
+end

bench/test_helper.exs

@@ -0,0 +1 @@
+

erl_test/test_helper.exs

@@ -0,0 +1,2 @@
+:code.ensure_loaded(:esqlite_test)
+:esqlite_test.test()

lib/esqlite3/esqlite3.ex

@@ -327,7 +327,8 @@ defmodule Esqlite3 do
     end
   end
 
-  defp receive_answer(ref, timeout) when is_reference(ref) and is_integer(timeout) do
+  defp receive_answer(ref, timeout)
+       when is_reference(ref) and (is_integer(timeout) or timeout == :infinity) do
     start = :os.timestamp()
 
     receive do

lib/sqlite.ex

@@ -29,14 +29,21 @@ defmodule Sqlite do
   @typedoc "Connection identifier for your Sqlite instance."
   @opaque conn :: Connection.t()
 
+  @default_start_opts [
+    timeout: Application.get_env(:esqlite, :default_timeout, 5000)
+  ]
+
   @doc """
   Start the connection process and connect to sqlite.
   ## Options
     * `:database` -> Databse uri.
+    * `:timeout` ->  Max amount of time for commands to take. (default: 5000)
+  ## GenServer opts
+    These get passed directly to [GenServer](GenServer.html)
   ## Examples
       iex> {:ok, pid} = Sqlite.open(database: "sqlite.db")
       {:ok, #PID<0.69.0>}
-      iex> {:ok, pid} = Sqlite.open(database: ":memory:")
+      iex> {:ok, pid} = Sqlite.open(database: ":memory:", timeout: 6000)
       {:ok, #PID<0.69.0>}
   """
   @spec open(Keyword.t(), GenServer.options()) :: {:ok, conn} | {:error, term}
@@ -77,8 +84,8 @@ defmodule Sqlite do
           {:ok, Sqlite.Result.t()} | {:error, Sqlite.Error.t()}
   def query(conn, sql, params, opts \\ []) do
     opts = opts |> defaults()
-
-    r = GenServer.call(conn.pid, {:query, sql, params, opts}, call_timeout(opts))
+    call = {:query, sql, params, opts}
+    r = GenServer.call(conn.pid, call, call_timeout(opts))
 
     case r do
       {:ok, %Sqlite.Result{}} = ok -> ok
@@ -110,8 +117,8 @@ defmodule Sqlite do
   @spec prepare(conn, iodata, Keyword.t()) :: {:ok, Sqlite.Query.t()} | {:error, Sqlite.Error.t()}
   def prepare(conn, sql, opts \\ []) do
     opts = opts |> defaults()
-
-    r = GenServer.call(conn.pid, {:prepare, sql, opts}, call_timeout(opts))
+    call = {:prepare, sql, opts}
+    r = GenServer.call(conn.pid, call, call_timeout(opts))
 
     case r do
       {:ok, %Sqlite.Query{}} = ok -> ok
@@ -141,8 +148,8 @@ defmodule Sqlite do
   @spec release_query(conn, Sqlite.Query.t(), Keyword.t()) :: :ok | {:error, Sqlite.Error.t()}
   def release_query(conn, query, opts \\ []) do
     opts = opts |> defaults()
-
-    r = GenServer.call(conn.pid, {:release_query, query, opts}, call_timeout(opts))
+    call = {:release_query, query, opts}
+    r = GenServer.call(conn.pid, call, call_timeout(opts))
 
     case r do
       :ok -> :ok
@@ -186,8 +193,8 @@ defmodule Sqlite do
           {:ok, Sqlite.Result.t()} | {:error, Sqlite.Error.t()}
   def execute(conn, query, params, opts \\ []) do
     opts = defaults(opts)
-
-    r = GenServer.call(conn.pid, {:execute, query, params, opts}, call_timeout(opts))
+    call = {:execute, query, params, opts}
+    r = GenServer.call(conn.pid, call, call_timeout(opts))
 
     case r do
       {:ok, %Sqlite.Result{}} = ok -> ok
@@ -239,8 +246,9 @@ defmodule Sqlite do
     Keyword.merge(defaults, opts)
   end
 
+  @doc false
   @spec default_opts(Keyword.t()) :: Keyword.t()
-  def default_opts(opts) do
-    Keyword.merge([timeout: Application.get_env(:esqlite, :default_timeout, 5000)], opts)
+  defp default_opts(opts) do
+    Keyword.merge(@default_start_opts, opts)
   end
 end

mix.exs

@@ -13,6 +13,7 @@ defmodule Esqlite.MixProject do
       plt_add_apps: [],
       dialyzer: [flags: [:unmatched_returns, :race_conditions, :no_unused]],
       erlc_paths: erlc_paths(Mix.env()),
+      test_paths: ["test", "bench", "erl_test"],
       start_permanent: Mix.env() == :prod,
       test_coverage: [tool: ExCoveralls],
       preferred_cli_env: [

test/test_helper.exs

@@ -1,4 +1,4 @@
 {:module, Esqlite3Nif} = :code.ensure_loaded(Esqlite3Nif)
 {:module, mod} = :code.ensure_loaded(:esqlite_test)
 :eunit.test({:inparallel, mod})
-ExUnit.start()
+ExUnit.start(exclude: :bench)