Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

replace db_connection with rw lock #255

Closed
wants to merge 2 commits into from
Closed

replace db_connection with rw lock #255

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
f04a0b2
replace db_connection with rw lock
ruslandoga Jul 19, 2023
c07b537
simplify concurrent test
ruslandoga Jul 19, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
208 changes: 104 additions & 104 deletions lib/exqlite.ex
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,104 +1,104 @@
defmodule Exqlite do
@moduledoc """
SQLite3 driver for Elixir.
"""

alias Exqlite.Connection
alias Exqlite.Error
alias Exqlite.Query
alias Exqlite.Result

@doc "See `Exqlite.Connection.connect/1`"
@spec start_link([Connection.connection_opt()]) :: {:ok, pid()} | {:error, Error.t()}
def start_link(opts) do
DBConnection.start_link(Connection, opts)
end

@spec query(DBConnection.conn(), iodata(), list(), list()) ::
{:ok, Result.t()} | {:error, Exception.t()}
def query(conn, statement, params \\ [], opts \\ []) do
query = %Query{name: "", statement: IO.iodata_to_binary(statement)}

case DBConnection.prepare_execute(conn, query, params, opts) do
{:ok, _query, result} ->
{:ok, result}

otherwise ->
otherwise
end
end

@spec query!(DBConnection.conn(), iodata(), list(), list()) :: Result.t()
def query!(conn, statement, params \\ [], opts \\ []) do
case query(conn, statement, params, opts) do
{:ok, result} -> result
{:error, err} -> raise err
end
end

@spec prepare(DBConnection.conn(), iodata(), list()) ::
{:ok, Query.t()} | {:error, Exception.t()}
def prepare(conn, name, statement, opts \\ []) do
query = %Query{name: name, statement: statement}
DBConnection.prepare(conn, query, opts)
end

@spec prepare!(DBConnection.conn(), iodata(), iodata(), list()) :: Query.t()
def prepare!(conn, name, statement, opts \\ []) do
query = %Query{name: name, statement: statement}
DBConnection.prepare!(conn, query, opts)
end

@spec prepare_execute(DBConnection.conn(), iodata(), iodata(), list(), list()) ::
{:ok, Query.t(), Result.t()} | {:error, Error.t()}
def prepare_execute(conn, name, statement, params, opts \\ []) do
query = %Query{name: name, statement: statement}
DBConnection.prepare_execute(conn, query, params, opts)
end

@spec prepare_execute!(DBConnection.conn(), iodata(), iodata(), list(), list()) ::
{Query.t(), Result.t()}
def prepare_execute!(conn, name, statement, params, opts \\ []) do
query = %Query{name: name, statement: statement}
DBConnection.prepare_execute!(conn, query, params, opts)
end

@spec execute(DBConnection.conn(), Query.t(), list(), list()) ::
{:ok, Result.t()} | {:error, Error.t()}
def execute(conn, query, params, opts \\ []) do
DBConnection.execute(conn, query, params, opts)
end

@spec execute!(DBConnection.conn(), Query.t(), list(), list()) :: Result.t()
def execute!(conn, query, params, opts \\ []) do
DBConnection.execute!(conn, query, params, opts)
end

@spec close(DBConnection.conn(), Query.t(), list()) :: :ok | {:error, Exception.t()}
def close(conn, query, opts \\ []) do
with {:ok, _} <- DBConnection.close(conn, query, opts) do
:ok
end
end

@spec close!(DBConnection.conn(), Query.t(), list()) :: :ok
def close!(conn, query, opts \\ []) do
DBConnection.close!(conn, query, opts)
:ok
end

@spec transaction(DBConnection.conn(), (DBConnection.t() -> result), list()) ::
{:ok, result} | {:error, any}
when result: var
def transaction(conn, fun, opts \\ []) do
DBConnection.transaction(conn, fun, opts)
end

@spec rollback(DBConnection.t(), term()) :: no_return()
def rollback(conn, reason), do: DBConnection.rollback(conn, reason)

@spec child_spec([Connection.connection_opt()]) :: :supervisor.child_spec()
def child_spec(opts) do
DBConnection.child_spec(Connection, opts)
end
end
# defmodule Exqlite do
# @moduledoc """
# SQLite3 driver for Elixir.
# """

# alias Exqlite.Connection
# alias Exqlite.Error
# alias Exqlite.Query
# alias Exqlite.Result

# @doc "See `Exqlite.Connection.connect/1`"
# @spec start_link([Connection.connection_opt()]) :: {:ok, pid()} | {:error, Error.t()}
# def start_link(opts) do
# DBConnection.start_link(Connection, opts)
# end

# @spec query(DBConnection.conn(), iodata(), list(), list()) ::
# {:ok, Result.t()} | {:error, Exception.t()}
# def query(conn, statement, params \\ [], opts \\ []) do
# query = %Query{name: "", statement: IO.iodata_to_binary(statement)}

# case DBConnection.prepare_execute(conn, query, params, opts) do
# {:ok, _query, result} ->
# {:ok, result}

# otherwise ->
# otherwise
# end
# end

# @spec query!(DBConnection.conn(), iodata(), list(), list()) :: Result.t()
# def query!(conn, statement, params \\ [], opts \\ []) do
# case query(conn, statement, params, opts) do
# {:ok, result} -> result
# {:error, err} -> raise err
# end
# end

# @spec prepare(DBConnection.conn(), iodata(), list()) ::
# {:ok, Query.t()} | {:error, Exception.t()}
# def prepare(conn, name, statement, opts \\ []) do
# query = %Query{name: name, statement: statement}
# DBConnection.prepare(conn, query, opts)
# end

# @spec prepare!(DBConnection.conn(), iodata(), iodata(), list()) :: Query.t()
# def prepare!(conn, name, statement, opts \\ []) do
# query = %Query{name: name, statement: statement}
# DBConnection.prepare!(conn, query, opts)
# end

# @spec prepare_execute(DBConnection.conn(), iodata(), iodata(), list(), list()) ::
# {:ok, Query.t(), Result.t()} | {:error, Error.t()}
# def prepare_execute(conn, name, statement, params, opts \\ []) do
# query = %Query{name: name, statement: statement}
# DBConnection.prepare_execute(conn, query, params, opts)
# end

# @spec prepare_execute!(DBConnection.conn(), iodata(), iodata(), list(), list()) ::
# {Query.t(), Result.t()}
# def prepare_execute!(conn, name, statement, params, opts \\ []) do
# query = %Query{name: name, statement: statement}
# DBConnection.prepare_execute!(conn, query, params, opts)
# end

# @spec execute(DBConnection.conn(), Query.t(), list(), list()) ::
# {:ok, Result.t()} | {:error, Error.t()}
# def execute(conn, query, params, opts \\ []) do
# DBConnection.execute(conn, query, params, opts)
# end

# @spec execute!(DBConnection.conn(), Query.t(), list(), list()) :: Result.t()
# def execute!(conn, query, params, opts \\ []) do
# DBConnection.execute!(conn, query, params, opts)
# end

# @spec close(DBConnection.conn(), Query.t(), list()) :: :ok | {:error, Exception.t()}
# def close(conn, query, opts \\ []) do
# with {:ok, _} <- DBConnection.close(conn, query, opts) do
# :ok
# end
# end

# @spec close!(DBConnection.conn(), Query.t(), list()) :: :ok
# def close!(conn, query, opts \\ []) do
# DBConnection.close!(conn, query, opts)
# :ok
# end

# @spec transaction(DBConnection.conn(), (DBConnection.t() -> result), list()) ::
# {:ok, result} | {:error, any}
# when result: var
# def transaction(conn, fun, opts \\ []) do
# DBConnection.transaction(conn, fun, opts)
# end

# @spec rollback(DBConnection.t(), term()) :: no_return()
# def rollback(conn, reason), do: DBConnection.rollback(conn, reason)

# @spec child_spec([Connection.connection_opt()]) :: :supervisor.child_spec()
# def child_spec(opts) do
# DBConnection.child_spec(Connection, opts)
# end
# end
42 changes: 18 additions & 24 deletions lib/exqlite/basic.ex
View file
Open in desktop
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This module could be deleted and ignored until you are completely done. I don't know of anyone using this module directly.

Original file line number Diff line number Diff line change
Expand Up @@ -3,46 +3,40 @@ defmodule Exqlite.Basic do
A very basis API without lots of options to allow simpler usage for basic needs.
"""

alias Exqlite.Connection
alias Exqlite.Query
alias Exqlite.Sqlite3
alias Exqlite.Error
alias Exqlite.Result

def open(path) do
Connection.connect(database: path)
Sqlite3.open(path)
end

def close(%Connection{} = conn) do
case Sqlite3.close(conn.db) do
def close(db) do
case Sqlite3.close(db) do
:ok -> :ok
{:error, reason} -> {:error, %Error{message: to_string(reason)}}
{:error, reason} -> {:error, Error.exception(message: to_string(reason))}
end
end

def exec(%Connection{} = conn, stmt, args \\ []) do
%Query{statement: stmt} |> Connection.handle_execute(args, [], conn)
def exec(db, stmt, args \\ []) do
with {:ok, stmt} <- Sqlite3.prepare(db, stmt),
:ok <- maybe_bind(db, stmt, args),
{:ok, columns} <- Sqlite3.columns(db, stmt),
{:ok, rows} <- Sqlite3.fetch_all(db, stmt),
do: {:ok, rows, columns}
end

def rows(exec_result) do
case exec_result do
{:ok, %Query{}, %Result{rows: rows, columns: columns}, %Connection{}} ->
{:ok, rows, columns}

{:error, %Error{message: message}, %Connection{}} ->
{:error, to_string(message)}
end
def load_extension(db, path) do
exec(db, "select load_extension(?)", [path])
end

def load_extension(conn, path) do
exec(conn, "select load_extension(?)", [path])
def enable_load_extension(db) do
Sqlite3.enable_load_extension(db, true)
end

def enable_load_extension(conn) do
Sqlite3.enable_load_extension(conn.db, true)
def disable_load_extension(db) do
Sqlite3.enable_load_extension(db, false)
end

def disable_load_extension(conn) do
Sqlite3.enable_load_extension(conn.db, false)
end
defp maybe_bind(_db, _stmt, []), do: :ok
defp maybe_bind(db, stmt, params), do: Sqlite3.bind(db, stmt, params)
end
Loading
Loading