Pull in mmzeeman#31

Author: connor rigby

.circleci/config.yml

@@ -26,7 +26,7 @@ jobs:
       - run: mix dialyzer --halt-exit-status
       - run: mix credo --strict --ignore linelength -a
       - run:
-          command: mix coveralls.circle
+          command: mix coveralls.circle --include bench
           environment:
             MIX_ENV: test
       - run:

Makefile

@@ -11,6 +11,9 @@ OBJ=$(SRC:.c=.o)
 
 LDFLAGS ?= -fPIC -shared -pedantic
 CFLAGS ?= -fPIC -O2
+SQLITE_CFLAGS = -DSQLITE_THREADSAFE=1 -DSQLITE_USE_URI -DSQLITE_ENABLE_FTS3 \
+-DSQLITE_ENABLE_FTS3_PARENTHESIS -DSQLITE_ENABLE_FTS5 -DSQLITE_ENABLE_JSON1 \
+-DSQLITE_ENABLE_RTREE
 
 NIF=priv/esqlite3_nif.so
 
@@ -20,7 +23,7 @@ priv:
 	mkdir -p priv
 
 %.o: %.c
-	$(CC) -c $(ERL_CFLAGS) $(CFLAGS) -o $@ $<
+	$(CC) -c $(ERL_CFLAGS) $(CFLAGS) $(SQLITE_CFLAGS) -o $@ $<
 
 $(NIF): $(OBJ)
 	$(CC) $^ $(ERL_LDFLAGS) $(LDFLAGS) -o $@

c_src/esqlite3_nif.c

@@ -244,16 +244,28 @@ do_open(ErlNifEnv *env, esqlite_connection *db, const ERL_NIF_TERM arg)
 {
     char filename[MAX_PATHNAME];
     unsigned int size;
-    int rc;
+    int rc, count_args, flag_number;
     ERL_NIF_TERM error;
+    const ERL_NIF_TERM *args;
+
+    /*
+    unpack the arg, the first argument is the filename, the second is the flag count
+    */
+    if(!enif_get_tuple(env, arg, &count_args, &args))
+    return make_error_tuple(env, "wrong_unpack_of_args_from_open");
+    if(count_args != 2)
+      return make_error_tuple(env, "wrong_number_of_args_from_open");
 
-    size = enif_get_string(env, arg, filename, MAX_PATHNAME, ERL_NIF_LATIN1);
+    size = enif_get_string(env, args[0], filename, MAX_PATHNAME, ERL_NIF_LATIN1);
     if(size <= 0)
         return make_error_tuple(env, "invalid_filename");
 
+    if(!enif_get_int(env, args[1], &flag_number))
+      return make_error_tuple(env, "unable_to_get_flag_number_from_open");
+
     /* Open the database.
      */
-    rc = sqlite3_open(filename, &db->db);
+    rc = sqlite3_open_v2(filename, &db->db, flag_number, NULL);
     if(rc != SQLITE_OK) {
 	    error = make_sqlite3_error_tuple(env, rc, db->db);
 	    sqlite3_close_v2(db->db);
@@ -738,6 +750,41 @@ esqlite_start(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
     return make_ok_tuple(env, db_conn);
 }
 
+int
+count_flag(ErlNifEnv *env, const ERL_NIF_TERM array[], int tuple_count)
+{
+    char flag[30];
+    int i, flag_count=0;
+    unsigned int flag_len=0;
+
+    for(i = 0; i < tuple_count; i++)
+    {
+	enif_get_atom_length(env, array[i], &flag_len, ERL_NIF_LATIN1);
+	enif_get_atom(env, array[i], flag, flag_len + 1, ERL_NIF_LATIN1);
+	if (strcmp(flag, "readonly") == 0)
+	    flag_count = flag_count | SQLITE_OPEN_READONLY;
+	else if (strcmp(flag, "readwrite") == 0)
+	    flag_count = flag_count | SQLITE_OPEN_READWRITE;
+	else if (strcmp(flag, "create") == 0)
+	    flag_count = flag_count | SQLITE_OPEN_CREATE;
+	else if (strcmp(flag, "uri") == 0)
+	    flag_count = flag_count | SQLITE_OPEN_URI;
+	else if (strcmp(flag, "memory") == 0)
+	    flag_count = flag_count | SQLITE_OPEN_MEMORY;
+	else if (strcmp(flag, "nomutex") == 0)
+	    flag_count = flag_count | SQLITE_OPEN_NOMUTEX;
+	else if (strcmp(flag, "fullmutex") == 0)
+	    flag_count = flag_count | SQLITE_OPEN_FULLMUTEX;
+	else if (strcmp(flag, "sharedcache") == 0)
+	    flag_count = flag_count | SQLITE_OPEN_SHAREDCACHE;
+	else if (strcmp(flag, "privatecache") == 0)
+	    flag_count = flag_count | SQLITE_OPEN_PRIVATECACHE;
+	else
+	    return -1;
+    }
+    return flag_count;
+}
+
 /*
  * Open the database
  */
@@ -747,18 +794,27 @@ esqlite_open(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
     esqlite_connection *db;
     esqlite_command *cmd = NULL;
     ErlNifPid pid;
+    const ERL_NIF_TERM *array;
+    int tuple_count, flag_count;
 
-    if(argc != 4)
+    if(argc != 5)
 	    return enif_make_badarg(env);
     if(!enif_get_resource(env, argv[0], esqlite_connection_type, (void **) &db))
 	    return enif_make_badarg(env);
     if(!enif_is_ref(env, argv[1]))
 	    return make_error_tuple(env, "invalid_ref");
     if(!enif_get_local_pid(env, argv[2], &pid))
 	    return make_error_tuple(env, "invalid_pid");
-
     if(!sqlite3_threadsafe())
 	    return make_error_tuple(env, "sqlite3 not thread safe.");
+    if(!enif_get_tuple(env, argv[4], &tuple_count, &array))
+            return make_error_tuple(env, "invalid_tuple");
+
+    flag_count = count_flag(env, array, tuple_count);
+
+    if (flag_count == -1)
+	    return make_error_tuple(env, "unrecognize_flag");
+
 
     /* Note, no check is made for the type of the argument */
     cmd = command_create();
@@ -768,7 +824,7 @@ esqlite_open(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
     cmd->type = cmd_open;
     cmd->ref = enif_make_copy(cmd->env, argv[1]);
     cmd->pid = pid;
-    cmd->arg = enif_make_copy(cmd->env, argv[3]);
+    cmd->arg = enif_make_tuple2(cmd->env, enif_make_copy(cmd->env, argv[3]), enif_make_int(cmd->env, flag_count));
 
     return push_command(env, db, cmd);
 }
@@ -1153,7 +1209,7 @@ static int on_upgrade(ErlNifEnv* env, void** priv, void** old_priv_data, ERL_NIF
 
 static ErlNifFunc nif_funcs[] = {
     {"start", 0, esqlite_start},
-    {"open", 4, esqlite_open},
+    {"open", 5, esqlite_open},
     {"exec", 4, esqlite_exec},
     {"changes", 3, esqlite_changes},
     {"prepare", 4, esqlite_prepare},

lib/esqlite3/esqlite3.ex

@@ -21,16 +21,19 @@ defmodule Esqlite3 do
 
   @doc "Opens a sqlite3 database mentioned in filename."
   @spec open(filename) :: {:ok, connection} | error_tup2
-  def open(filename), do: open(filename, @default_timeout)
+  def open(filename), do: open(filename, {:readwrite, :create}, @default_timeout)
 
-  @doc "Opens a sqlite3 database mentioned in filename."
-  @spec open(filename, timeout) :: {:ok, connection} | error_tup2
-  def open(filename, timeout) do
+  @doc "Opens a sqlite3 database mentioned in filename with flags."
+  def open(filename, flags) when is_tuple(flags), do: open(filename, flags, @default_timeout)
+
+  @doc "Opens a sqlite3 database with a flags tuple and a timeout."
+  @spec open(filename, tuple, timeout) :: {:ok, connection} | error_tup2
+  def open(filename, flags, timeout) when is_tuple(flags) do
     filename = to_charlist(filename)
 
     with {:ok, connection} <- Esqlite3Nif.start(),
          ref when is_reference(ref) <- make_ref(),
-         :ok <- Esqlite3Nif.open(connection, ref, self(), filename),
+         :ok <- Esqlite3Nif.open(connection, ref, self(), filename, flags),
          :ok <- receive_answer(ref, timeout) do
       {:ok, {:connection, make_ref(), connection}}
     else

lib/esqlite3/esqlite3_nif.ex

@@ -27,8 +27,8 @@ defmodule Esqlite3Nif do
   def start, do: :erlang.nif_error(:nif_library_not_loaded)
 
   @doc "Open the specified sqlite3 database."
-  @spec open(connection, reference, pid, Path.t()) :: :ok | error_tup2
-  def open(_db, _ref, _dest, _filename), do: :erlang.nif_error(:nif_library_not_loaded)
+  @spec open(connection, reference, pid, Path.t(), tuple) :: :ok | error_tup2
+  def open(_db, _ref, _dest, _filename, _flags), do: :erlang.nif_error(:nif_library_not_loaded)
 
   @doc """
   Exec the query.

lib/sqlite.ex

@@ -30,14 +30,29 @@ defmodule Sqlite do
   @opaque conn :: Connection.t()
 
   @default_start_opts [
-    timeout: Application.get_env(:esqlite, :default_timeout, 5000)
+    timeout: Application.get_env(:esqlite, :default_timeout, 5000),
+    flags: [:readwrite, :create]
   ]
 
   @doc """
   Start the connection process and connect to sqlite.
   ## Options
     * `:database` -> Databse uri.
     * `:timeout` ->  Max amount of time for commands to take. (default: 5000)
+    * `:flags` -> List of flags to be passed to SQLite.
+  ## Flags
+  Flags to be passed to Sqlite on `open`.
+  See [here](https://www.sqlite.org/c3ref/c_open_autoproxy.html) for more
+  details.
+    * `:readwrite`
+    * `:readonly`
+    * `:create`
+    * `:uri`
+    * `:memory`
+    * `:nomutex`
+    * `:fullmutex`
+    * `:sharedcache`
+    * `:privatecache`
   ## GenServer opts
     These get passed directly to [GenServer](GenServer.html)
   ## Examples

lib/sqlite/server.ex

@@ -17,8 +17,9 @@ defmodule Sqlite.Server do
   def init(opts) do
     filename = Keyword.fetch!(opts, :database)
     timeout = Keyword.fetch!(opts, :timeout)
+    flags = Keyword.fetch!(opts, :flags)
 
-    case Esqlite3.open(filename, timeout) do
+    case Esqlite3.open(filename, List.to_tuple(flags), timeout) do
       {:ok, db} ->
         {:ok, struct(State, database: db, filename: filename)}
 

test/esqlite3/esqlite3_test.exs

@@ -16,6 +16,13 @@ defmodule Esqlite3Test do
     assert match?({:ok, _c2}, Esqlite3.open("test2.db"))
   end
 
+  test "open with flags" do
+    {:ok, db} = Esqlite3.open(":memory:", {:readonly})
+
+    {:error, {:readonly, 'attempt to write a readonly database'}} =
+      Esqlite3.exec("create table test_table(one varchar(10), two int);", db)
+  end
+
   test "simple query" do
     {:ok, db} = Esqlite3.open(":memory:")
     :ok = Esqlite3.exec("begin;", db)