e96ba6431fbbe9fec7239b5c3a438ecc3d1ac8b1

Committed 24 Aug 2025 07:51PM UTC coverage: 85.96% (+0.03%) from 85.931%

Build # e96ba6431fbbe9fec7239b5c3a438ecc3d1ac8b1

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #27 from renatomassaro/bump-dependencies

Bump dependencies

Coverage Stats

5 of 6 new or added lines in 2 files covered. (83.33%)

1 existing line in 1 file now uncovered.

1249 of 1453 relevant lines covered (85.96%)

19891.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.38

/lib/feeb/db/sqlite.ex

defmodule Feeb.DB.SQLite do
  @moduledoc """
  - Useful link:
    - List of error codes and their meaning: https://www.sqlite.org/rescode.html
  """

  require Logger

  alias Exqlite.Sqlite3, as: Driver

  @type conn :: reference()
  @type stmt :: reference()

  @default_chunk_size 50

  def open(path) when is_binary(path), do: Driver.open(path)

  def close(conn), do: Driver.close(conn)

  def exec(conn, sql), do: Driver.execute(conn, sql)

  def raw(conn, sql) do
    with {:ok, stmt} <- prepare(conn, sql) do
      all(conn, stmt)
    end
  end

  def raw!(conn, sql) do
    {:ok, r} = raw(conn, sql)
    r
  end

  def raw2(sql, conn), do: raw(conn, sql)
  def raw2!(sql, conn), do: raw!(conn, sql)

  # TODO: What is the error type? Add typespecs and review Repo code
  def prepare(conn, sql) do
    Driver.prepare(conn, sql)
  end

  def bind(_, _, []),
    do: :ok

  def bind(stmt, bindings) when is_list(bindings) do
    try do
      Driver.bind(stmt, bindings)
    rescue
      e in ArgumentError ->
        Logger.error(e)
        {:error, :arguments_wrong_length}
    end
  end

  @doc """
  Convenience wrapper for functions that do not expect a return value
  """
  def perform(conn, stmt) do
    case step_all(conn, stmt) do
      {:ok, _} -> :ok
      {:error, _} = error -> error
    end
  end

  def all(conn, stmt) do
    step_all(conn, stmt)
  end

  def one(conn, stmt) do
    case step_chunk(conn, stmt, 2) do
      {:ok, :not_done, _} -> raise "MultipleResultsError"
      {:ok, :done, [row]} -> {:ok, row}
      {:ok, :done, []} -> {:ok, nil}
      {:error, _} = error -> error
    end
  end

  defp step_all(conn, stmt, acc \\ []) do
    case step_chunk(conn, stmt, @default_chunk_size) do
      {:ok, :not_done, rows} -> step_all(conn, stmt, acc ++ rows)
      {:ok, :done, rows} -> {:ok, acc ++ rows}
      {:error, _} = error -> error
    end
  end

  defp step_chunk(conn, stmt, chunk_size) do
    case Driver.multi_step(conn, stmt, chunk_size) do
      {:rows, rows} -> {:ok, :not_done, rows}
      {:done, rows} -> {:ok, :done, rows}
      {:error, _} = error -> error
    end
  end
end

1	defmodule Feeb.DB.SQLite do
2	@moduledoc """
3	- Useful link:
4	- List of error codes and their meaning: https://www.sqlite.org/rescode.html
5	"""
6
7	require Logger
8
9	alias Exqlite.Sqlite3, as: Driver
10
11	@type conn :: reference()
12	@type stmt :: reference()
13
14	@default_chunk_size 50
15
16	def open(path) when is_binary(path), do: Driver.open(path)	215✔
17
18	def close(conn), do: Driver.close(conn)	13✔
19
20	def exec(conn, sql), do: Driver.execute(conn, sql)	201,233✔
21
22	def raw(conn, sql) do
23	with {:ok, stmt} <- prepare(conn, sql) do	849✔
24	all(conn, stmt)	846✔
25	end
26	end
27
28	def raw!(conn, sql) do
29	{:ok, r} = raw(conn, sql)	781✔
30	r	779✔
31	end
32
33	def raw2(sql, conn), do: raw(conn, sql)	×
34	def raw2!(sql, conn), do: raw!(conn, sql)	422✔
35
36	# TODO: What is the error type? Add typespecs and review Repo code
37	def prepare(conn, sql) do
38	Driver.prepare(conn, sql)	101,082✔
39	end
40
UNCOV 41	def bind(_, _, []),	×
42	do: :ok
43
44	def bind(stmt, bindings) when is_list(bindings) do
45	try do	100,223✔
46	Driver.bind(stmt, bindings)	100,223✔
47	rescue
48	e in ArgumentError ->	3✔
49	Logger.error(e)	3✔
50	{:error, :arguments_wrong_length}
51	end
52	end
53
54	@doc """
55	Convenience wrapper for functions that do not expect a return value
56	"""
57	def perform(conn, stmt) do
58	case step_all(conn, stmt) do	2✔
59	{:ok, _} -> :ok	2✔
60	{:error, _} = error -> error	×
61	end
62	end
63
64	def all(conn, stmt) do
65	step_all(conn, stmt)	101,064✔
66	end
67
68	def one(conn, stmt) do
69	case step_chunk(conn, stmt, 2) do	5✔
70	{:ok, :not_done, _} -> raise "MultipleResultsError"	1✔
71	{:ok, :done, [row]} -> {:ok, row}	3✔
72	{:ok, :done, []} -> {:ok, nil}	1✔
73	{:error, _} = error -> error	×
74	end
75	end
76
77	defp step_all(conn, stmt, acc \\ []) do
78	case step_chunk(conn, stmt, @default_chunk_size) do	101,066✔
79	{:ok, :not_done, rows} -> step_all(conn, stmt, acc ++ rows)	×
80	{:ok, :done, rows} -> {:ok, acc ++ rows}	101,062✔
81	{:error, _} = error -> error	4✔
82	end
83	end
84
85	defp step_chunk(conn, stmt, chunk_size) do
86	case Driver.multi_step(conn, stmt, chunk_size) do	101,071✔
87	{:rows, rows} -> {:ok, :not_done, rows}	1✔
88	{:done, rows} -> {:ok, :done, rows}	101,066✔
89	{:error, _} = error -> error	4✔
90	end
91	end
92	end

renatomassaro / FeebDB / e96ba6431fbbe9fec7239b5c3a438ecc3d1ac8b1

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous