Nebo15 / ecto_mnesia / 186

pending completion

Build # 186

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/Nebo15/ecto_mnesia/commit/<a class=hub.com/Nebo15/ecto_mnesia/commit/<a class="double-link" href="https://git"><a class=hub.com/Nebo15/ecto_mnesia/commit/<a class="double-link" href="https://git"><a class=hub.com/Nebo15/ecto_mnesia/commit/<a class="double-link" href="https://git"><a class=hub.com/Nebo15/ecto_mnesia/commit/bc0fb46d210eb1be63bcc8f0383212f0633b8c52">bc0fb46d2">&lt;a href=&quot;https://github.com/Nebo15/ecto_mnesia/commit/</a><a class="double-link" href="https://github.com/Nebo15/ecto_mnesia/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Nebo15/ecto_mnesia/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Nebo15/ecto_mnesia/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Nebo15/ecto_mnesia/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Nebo15/ecto_mnesia/commit/bc0fb46d210eb1be63bcc8f0383212f0633b8c52">bc0fb46d2</a><a href="https://github.com/Nebo15/ecto_mnesia/commit/bc0fb46d210eb1be63bcc8f0383212f0633b8c52">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/Nebo15/ecto_mnesia/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/Nebo15/ecto_mnesia/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Nebo15/ecto_mnesia/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Nebo15/ecto_mnesia/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Nebo15/ecto_mnesia/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Nebo15/ecto_mnesia/commit/bc0fb46d210eb1be63bcc8f0383212f0633b8c52&quot;&gt;bc0fb46d2&lt;/a&gt;&lt;a href=&quot;https://github.com/Nebo15/ecto_mnesia/commit/bc0fb46d210eb1be63bcc8f0383212f0633b8c52&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/Nebo15/ecto_mnesia/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/Nebo15/ecto_mnesia/comm... (continued)

Run Details

35 of 35 new or added lines in 2 files covered. (100.0%)

348 of 398 relevant lines covered (87.44%)

63.43 hits per line

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

86.21

/lib/ecto_mnesia/planner.ex

defmodule EctoMnesia.Planner do
  @moduledoc """
  Core Ecto Mnesia adapter implementation.
  """
  require Logger
  alias :mnesia, as: Mnesia
  alias EctoMnesia.{Record, Table}
  alias EctoMnesia.Record.{Context, Ordering, Update}

  @behaviour Ecto.Adapter

  @required_apps [:mnesia]

  defmacro __before_compile__(_env), do: :ok

  @doc """
  Ensure all applications necessary to run the adapter are started.
  """
  def ensure_all_started(_repo, type) do
    Enum.each(@required_apps, fn app ->
      {:ok, _} = Application.ensure_all_started(app, type)
    end)

    {:ok, @required_apps}
  end

  @doc """
  Returns the childspec that starts the adapter process.
  This method is called from `Ecto.Repo.Supervisor.init/2`.
  """
  def child_spec(_repo, _opts), do: Supervisor.Spec.supervisor(Supervisor, [[], [strategy: :one_for_one]])

  @doc """
  Automatically generate next ID for binary keys, leave sequence keys empty for generation on insert.
  """
  def autogenerate(:id), do: nil
  def autogenerate(:embed_id), do: Ecto.UUID.generate()
  def autogenerate(:binary_id), do: Ecto.UUID.autogenerate()

  @doc """
  Prepares are called by Ecto before `execute/6` methods.
  """
  def prepare(operation, %Ecto.Query{from: {table, schema}, order_bys: order_bys, limit: limit} = query) do
    ordering_fn = Ordering.get_ordering_fn(order_bys)
    limit = get_limit(limit)
    limit_fn = if limit == nil, do: & &1, else: &Enum.take(&1, limit)
    context = Context.new(table, schema)
    {:nocache, {operation, query, {limit, limit_fn}, context, ordering_fn}}
  end

  @doc """
  Perform `mnesia:select` on prepared query and convert the results to Ecto Schema.
  """
  def execute(
        _repo,
        %{sources: {{table, _schema}}},
        {:nocache, {:all, %Ecto.Query{} = query, {limit, limit_fn}, context, ordering_fn}},
        sources,
        preprocess,
        _opts
      ) do
    fields = context.query.select
    context = Context.assign_query(context, query, sources)
    match_spec = Context.get_match_spec(context)

    Logger.debug(fn ->
      "Selecting all records by match specification `#{inspect(match_spec)}` with limit #{inspect(limit)}"
    end)

    mapper = processor(preprocess, fields, sources)

    result =
      table
      |> Table.select(match_spec)
      |> Enum.map(mapper)
      |> ordering_fn.()
      |> limit_fn.()

    {length(result), result}
  end

  @doc """
  Deletes all records that match Ecto.Query
  """
  def execute(
        _repo,
        %{sources: {{table, _schema}}},
        {:nocache, {:delete_all, %Ecto.Query{} = query, {limit, limit_fn}, context, ordering_fn}},
        sources,
        preprocess,
        opts
      ) do
    fields = context.query.select
    context = Context.assign_query(context, query, sources)
    match_spec = Context.get_match_spec(context)

    mapper = processor(preprocess, fields, sources)

    Logger.debug(fn ->
      "Deleting all records by match specification `#{inspect(match_spec)}` with limit #{inspect(limit)}"
    end)

    table = Table.get_name(table)

    Table.transaction(fn ->
      table
      |> Table.select(match_spec)
      |> Enum.map(fn record ->
        {:ok, _} = Table.delete(table, List.first(record))
        record
      end)
      |> return_all(ordering_fn, mapper, {limit, limit_fn}, opts)
    end)
  end

  @doc """
  Update all records by a Ecto.Query.
  """
  def execute(
        _repo,
        %{sources: {{table, _schema}}},
        {:nocache, {:update_all, %Ecto.Query{updates: updates} = query, {limit, limit_fn}, context, ordering_fn}},
        sources,
        preprocess,
        opts
      ) do
    fields = context.query.select
    context = Context.assign_query(context, query, sources)
    match_spec = Context.get_match_spec(context)

    mapper = processor(preprocess, fields, sources)

    Logger.debug(fn ->
      "Updating all records by match specification `#{inspect(match_spec)}` with limit #{inspect(limit)}"
    end)

    table = Table.get_name(table)
    update = Update.update_record(updates, sources, context)

    Table.transaction(fn ->
      table
      |> Table.select(match_spec)
      |> Enum.map(fn [record_id | _] ->
        {:ok, result} = Table.update(table, record_id, update)
        result
      end)
      |> return_all(ordering_fn, mapper, {limit, limit_fn}, opts)
    end)
  end

  # Constructs return for `*_all` methods.
  defp return_all(records, ordering_fn, preprocess_fn, {limit, limit_fn}, opts) do
    case Keyword.get(opts, :returning) do
      true ->
        result =
          records
          |> Enum.map(fn record ->
            record
            |> Tuple.to_list()
            |> List.delete_at(0)
            |> preprocess_fn.()
          end)
          |> ordering_fn.()
          |> limit_fn.()

        {length(result), result}

      _ ->
        {min(limit, length(records)), nil}
    end
  end

  defp processor(process, fields, sources) when is_function(process, 3) do
    &process_row(&1, process, fields, sources)
  end

  defp processor(process, _fields, _source) when is_function(process, 1) do
    process
  end

  defp processor(nil, _fields, _source) do
    nil
  end

  defp process_row(row, process, fields, _sources) do
    fields
    |> Enum.map_reduce(row, fn
      {:&, _, [_, _, counter]} = field, acc ->
        case split_and_not_nil(acc, counter, true, []) do
          {nil, rest} -> {nil, rest}
          {val, rest} -> {process.(field, val, nil), rest}
        end

      field, [h | t] ->
        {process.(field, h, nil), t}
    end)
    |> elem(0)
  end

  defp split_and_not_nil(rest, 0, true, _acc), do: {nil, rest}
  defp split_and_not_nil(rest, 0, false, acc), do: {:lists.reverse(acc), rest}

  defp split_and_not_nil([nil | t], count, all_nil?, acc) do
    split_and_not_nil(t, count - 1, all_nil?, [nil | acc])
  end

  defp split_and_not_nil([h | t], count, _all_nil?, acc) do
    split_and_not_nil(t, count - 1, false, [h | acc])
  end

  @doc """
  Insert Ecto Schema struct to Mnesia database.
  """
  def insert(
        _repo,
        %{autogenerate_id: autogenerate_id, schema: schema, source: {_, table}},
        sources,
        _on_conflict,
        returning,
        _opts
      ) do
    case do_insert(table, schema, autogenerate_id, sources) do
      {:ok, _fields} when returning == [] ->
        {:ok, []}

      {:ok, fields} ->
        {:ok, Keyword.take(fields, returning)}

      {:invalid, [{type, field} | _]} ->
        raise Ecto.ConstraintError,
          type: type,
          constraint: "#{type}.#{field}",
          changeset: Ecto.Changeset.change(%{__struct__: schema}),
          action: :insert
    end
  end

  @doc """
  Insert all
  """
  # TODO: deal with `opts`: `on_conflict` and `returning`
  def insert_all(
        repo,
        %{autogenerate_id: autogenerate_id, schema: schema, source: {_, table}},
        _header,
        rows,
        _on_conflict,
        returning,
        _opts
      ) do
    table = Table.get_name(table)

    result =
      Table.transaction(fn ->
        Enum.reduce(rows, {0, []}, &insert_record(&1, &2, repo, table, schema, autogenerate_id))
      end)

    case {result, returning} do
      {{:error, _reason}, _returning} ->
        {0, nil}

      {{count, _records}, []} ->
        {count, nil}

      {{count, records}, _returning} ->
        {count, records}
    end
  end

  defp insert_record(params, {index, acc}, repo, table, schema, autogenerate_id) do
    case do_insert(table, schema, autogenerate_id, params) do
      {:ok, record} ->
        {index + 1, [record] ++ acc}

      {:invalid, [{:unique, _pk_field}]} ->
        rollback(repo, nil)

      {:error, _reason} ->
        rollback(repo, nil)
    end
  end

  # Insert schema without primary keys
  defp do_insert(table, schema, nil, params) do
    record = Record.new(schema, table, params)

    case Mnesia.transaction(fn ->
      case Table.insert(table, record) do
        {:ok, ^record} ->
          {:ok, params}
        {:error, reason} ->
          {:error, reason}
      end
    end) do
      {:atomic, res} -> res
      {:abort, reason} -> {:error, reason}
    end
  end

  # Insert schema with auto-generating primary key value
  defp do_insert(table, schema, {pk_field, _pk_type}, params) do
    params = put_new_pk(params, pk_field, table)
    record = Record.new(schema, table, params)

    case Mnesia.transaction(fn ->
      case Table.insert(table, record) do
        {:ok, ^record} ->
          {:ok, params}
        {:error, :already_exists} ->
          {:invalid, [{:unique, pk_field}]}
        {:error, reason} ->
          {:error, reason}
      end
    end) do
      {:atomic, res} -> res
      {:abort, reason} -> {:error, reason}
    end
  end

  # Generate new sequenced primary key for table
  defp put_new_pk(params, pk_field, table) when is_list(params) and is_atom(pk_field) do
    {_, params} =
      Keyword.get_and_update(params, pk_field, fn
        nil -> {nil, Table.next_id(table)}
        val -> {val, val}
      end)

    params
  end

  @doc """
  Run `fun` inside a Mnesia transaction
  """
  def transaction(_repo, _opts, fun) do
    case Table.transaction(fun) do
      {:error, reason} ->
        {:error, reason}

      result ->
        {:ok, result}
    end
  end

  @doc """
  Returns true when called inside a transaction.
  """
  def in_transaction?(_repo), do: Mnesia.is_transaction()

  @doc """
  Transaction rollbacks is not fully supported.
  """
  def rollback(_repo, _tid), do: Mnesia.abort(:rollback)

  @doc """
  Deletes a record from a Mnesia database.
  """
  def delete(_repo, %{schema: schema, source: {_, table}, autogenerate_id: _autogenerate_id}, filter, _opts) do
    pk = get_pk!(filter, schema.__schema__(:primary_key))

    case Table.delete(table, pk) do
      {:ok, ^pk} -> {:ok, []}
      {:error, reason} -> {:error, reason}
    end
  end

  @doc """
  Updates record stored in a Mnesia database.
  """
  def update(
        _repo,
        %{schema: schema, source: {_, table}, autogenerate_id: _autogenerate_id},
        changes,
        filter,
        returning,
        _opts
      ) do
    pk = get_pk!(filter, schema.__schema__(:primary_key))
    context = Context.new(table, schema)
    update = Update.from_keyword(schema, table, changes, context)

    case Table.update(table, pk, update) do
      {:ok, _record} when returning == [] ->
        {:ok, []}

      {:ok, _record} ->
        {:ok, changes}
      error -> error
    end
  end

  # Extract primary key value or raise an error
  defp get_pk!(params, {pk_field, _pk_type}), do: get_pk!(params, pk_field)
  defp get_pk!(params, [pk_field]), do: get_pk!(params, pk_field)

  defp get_pk!(params, pk_field) do
    case Keyword.fetch(params, pk_field) do
      :error -> raise Ecto.NoPrimaryKeyValueError
      {:ok, pk} -> pk
    end
  end

  # Extract limit from an `Ecto.Query`
  defp get_limit(nil), do: nil
  defp get_limit(%Ecto.Query.QueryExpr{expr: limit}), do: limit

  # Required methods for Ecto type casing
  def loaders({:embed, _value} = primitive, _type), do: [&Ecto.Adapters.SQL.load_embed(primitive, &1)]
  def loaders(:binary_id, type), do: [Ecto.UUID, type]
  def loaders(_primitive, type), do: [type]

  def dumpers({:embed, _value} = primitive, _type), do: [&Ecto.Adapters.SQL.dump_embed(primitive, &1)]
  def dumpers(:binary_id, type), do: [type, Ecto.UUID]
  def dumpers(_primitive, type), do: [type]
end

1	defmodule EctoMnesia.Planner do
2	@moduledoc """
3	Core Ecto Mnesia adapter implementation.
4	"""
5	require Logger
6	alias :mnesia, as: Mnesia
7	alias EctoMnesia.{Record, Table}
8	alias EctoMnesia.Record.{Context, Ordering, Update}
9
10	@behaviour Ecto.Adapter
11
12	@required_apps [:mnesia]
13
14	defmacro __before_compile__(_env), do: :ok
15
16	@doc """
17	Ensure all applications necessary to run the adapter are started.
18	"""
19	def ensure_all_started(_repo, type) do
20	Enum.each(@required_apps, fn app ->	1✔
21	{:ok, _} = Application.ensure_all_started(app, type)	1✔
22	end)
23
24	{:ok, @required_apps}
25	end
26
27	@doc """
28	Returns the childspec that starts the adapter process.
29	This method is called from `Ecto.Repo.Supervisor.init/2`.
30	"""
31	def child_spec(_repo, _opts), do: Supervisor.Spec.supervisor(Supervisor, [[], [strategy: :one_for_one]])	3✔
32
33	@doc """
34	Automatically generate next ID for binary keys, leave sequence keys empty for generation on insert.
35	"""
36	def autogenerate(:id), do: nil
37	def autogenerate(:embed_id), do: Ecto.UUID.generate()	×
38	def autogenerate(:binary_id), do: Ecto.UUID.autogenerate()	×
39
40	@doc """
41	Prepares are called by Ecto before `execute/6` methods.
42	"""
43	def prepare(operation, %Ecto.Query{from: {table, schema}, order_bys: order_bys, limit: limit} = query) do
44	ordering_fn = Ordering.get_ordering_fn(order_bys)	76✔
45	limit = get_limit(limit)	76✔
46	limit_fn = if limit == nil, do: & &1, else: &Enum.take(&1, limit)	76✔
47	context = Context.new(table, schema)	76✔
48	{:nocache, {operation, query, {limit, limit_fn}, context, ordering_fn}}
49	end
50
51	@doc """
52	Perform `mnesia:select` on prepared query and convert the results to Ecto Schema.
53	"""
54	def execute(
55	_repo,
56	%{sources: {{table, _schema}}},
57	{:nocache, {:all, %Ecto.Query{} = query, {limit, limit_fn}, context, ordering_fn}},
58	sources,
59	preprocess,
60	_opts
61	) do
62	fields = context.query.select	53✔
63	context = Context.assign_query(context, query, sources)	53✔
64	match_spec = Context.get_match_spec(context)	52✔
65
66	Logger.debug(fn ->	52✔
67	"Selecting all records by match specification `#{inspect(match_spec)}` with limit #{inspect(limit)}"	52✔
68	end)
69
70	mapper = processor(preprocess, fields, sources)	52✔
71
72	result =	52✔
73	table
74	\|> Table.select(match_spec)
75	\|> Enum.map(mapper)
76	\|> ordering_fn.()
77	\|> limit_fn.()
78
79	{length(result), result}
80	end
81
82	@doc """
83	Deletes all records that match Ecto.Query
84	"""
85	def execute(
86	_repo,
87	%{sources: {{table, _schema}}},
88	{:nocache, {:delete_all, %Ecto.Query{} = query, {limit, limit_fn}, context, ordering_fn}},
89	sources,
90	preprocess,
91	opts
92	) do
93	fields = context.query.select	15✔
94	context = Context.assign_query(context, query, sources)	15✔
95	match_spec = Context.get_match_spec(context)	15✔
96
97	mapper = processor(preprocess, fields, sources)	15✔
98
99	Logger.debug(fn ->	15✔
100	"Deleting all records by match specification `#{inspect(match_spec)}` with limit #{inspect(limit)}"	15✔
101	end)
102
103	table = Table.get_name(table)	15✔
104
105	Table.transaction(fn ->	15✔
106	table
107	\|> Table.select(match_spec)
108	\|> Enum.map(fn record ->
109	{:ok, _} = Table.delete(table, List.first(record))	19✔
110	record	19✔
111	end)
112	\|> return_all(ordering_fn, mapper, {limit, limit_fn}, opts)	15✔
113	end)
114	end
115
116	@doc """
117	Update all records by a Ecto.Query.
118	"""
119	def execute(
120	_repo,
121	%{sources: {{table, _schema}}},
122	{:nocache, {:update_all, %Ecto.Query{updates: updates} = query, {limit, limit_fn}, context, ordering_fn}},
123	sources,
124	preprocess,
125	opts
126	) do
127	fields = context.query.select	7✔
128	context = Context.assign_query(context, query, sources)	7✔
129	match_spec = Context.get_match_spec(context)	7✔
130
131	mapper = processor(preprocess, fields, sources)	7✔
132
133	Logger.debug(fn ->	7✔
134	"Updating all records by match specification `#{inspect(match_spec)}` with limit #{inspect(limit)}"	7✔
135	end)
136
137	table = Table.get_name(table)	7✔
138	update = Update.update_record(updates, sources, context)	7✔
139
140	Table.transaction(fn ->	7✔
141	table
142	\|> Table.select(match_spec)
143	\|> Enum.map(fn [record_id \| _] ->
144	{:ok, result} = Table.update(table, record_id, update)	12✔
145	result	12✔
146	end)
147	\|> return_all(ordering_fn, mapper, {limit, limit_fn}, opts)	7✔
148	end)
149	end
150
151	# Constructs return for `*_all` methods.
152	defp return_all(records, ordering_fn, preprocess_fn, {limit, limit_fn}, opts) do
153	case Keyword.get(opts, :returning) do	22✔
154	true ->
155	result =	1✔
156	records
157	\|> Enum.map(fn record ->
158	record
159	\|> Tuple.to_list()
160	\|> List.delete_at(0)
161	\|> preprocess_fn.()	3✔
162	end)
163	\|> ordering_fn.()
164	\|> limit_fn.()
165
166	{length(result), result}
167
168	_ ->
169	{min(limit, length(records)), nil}
170	end
171	end
172
173	defp processor(process, fields, sources) when is_function(process, 3) do
174	&process_row(&1, process, fields, sources)	×
175	end
176
177	defp processor(process, _fields, _source) when is_function(process, 1) do
178	process	53✔
179	end
180
181	defp processor(nil, _fields, _source) do
182	nil
183	end
184
185	defp process_row(row, process, fields, _sources) do
186	fields
187	\|> Enum.map_reduce(row, fn
188	{:&, _, [_, _, counter]} = field, acc ->
189	case split_and_not_nil(acc, counter, true, []) do	×
190	{nil, rest} -> {nil, rest}
191	{val, rest} -> {process.(field, val, nil), rest}
192	end
193
194	field, [h \| t] ->
195	{process.(field, h, nil), t}
196	end)
197	\|> elem(0)	×
198	end
199
200	defp split_and_not_nil(rest, 0, true, _acc), do: {nil, rest}
201	defp split_and_not_nil(rest, 0, false, acc), do: {:lists.reverse(acc), rest}
202
203	defp split_and_not_nil([nil \| t], count, all_nil?, acc) do
204	split_and_not_nil(t, count - 1, all_nil?, [nil \| acc])	×
205	end
206
207	defp split_and_not_nil([h \| t], count, _all_nil?, acc) do
208	split_and_not_nil(t, count - 1, false, [h \| acc])	×
209	end
210
211	@doc """
212	Insert Ecto Schema struct to Mnesia database.
213	"""
214	def insert(
215	_repo,
216	%{autogenerate_id: autogenerate_id, schema: schema, source: {_, table}},
217	sources,
218	_on_conflict,
219	returning,
220	_opts
221	) do
222	case do_insert(table, schema, autogenerate_id, sources) do	101✔
223	{:ok, _fields} when returning == [] ->
224	{:ok, []}
225
226	{:ok, fields} ->
227	{:ok, Keyword.take(fields, returning)}
228
229	{:invalid, [{type, field} \| _]} ->
230	raise Ecto.ConstraintError,	1✔
231	type: type,
232	constraint: "#{type}.#{field}",	1✔
233	changeset: Ecto.Changeset.change(%{__struct__: schema}),
234	action: :insert
235	end
236	end
237
238	@doc """
239	Insert all
240	"""
241	# TODO: deal with `opts`: `on_conflict` and `returning`
242	def insert_all(
243	repo,
244	%{autogenerate_id: autogenerate_id, schema: schema, source: {_, table}},
245	_header,
246	rows,
247	_on_conflict,
248	returning,
249	_opts
250	) do
251	table = Table.get_name(table)	2✔
252
253	result =	2✔
254	Table.transaction(fn ->
255	Enum.reduce(rows, {0, []}, &insert_record(&1, &2, repo, table, schema, autogenerate_id))	2✔
256	end)
257
258	case {result, returning} do	2✔
259	{{:error, _reason}, _returning} ->
260	{0, nil}
261
262	{{count, _records}, []} ->
263	{count, nil}
264
265	{{count, records}, _returning} ->
266	{count, records}
267	end
268	end
269
270	defp insert_record(params, {index, acc}, repo, table, schema, autogenerate_id) do
271	case do_insert(table, schema, autogenerate_id, params) do	5✔
272	{:ok, record} ->
273	{index + 1, [record] ++ acc}
274
275	{:invalid, [{:unique, _pk_field}]} ->
276	rollback(repo, nil)	1✔
277
278	{:error, _reason} ->
279	rollback(repo, nil)	×
280	end
281	end
282
283	# Insert schema without primary keys
284	defp do_insert(table, schema, nil, params) do
285	record = Record.new(schema, table, params)	13✔
286
287	case Mnesia.transaction(fn ->	13✔
288	case Table.insert(table, record) do	13✔
289	{:ok, ^record} ->
290	{:ok, params}
291	{:error, reason} ->
292	{:error, reason}
293	end
294	end) do
295	{:atomic, res} -> res	13✔
296	{:abort, reason} -> {:error, reason}
297	end
298	end
299
300	# Insert schema with auto-generating primary key value
301	defp do_insert(table, schema, {pk_field, _pk_type}, params) do
302	params = put_new_pk(params, pk_field, table)	93✔
303	record = Record.new(schema, table, params)	93✔
304
305	case Mnesia.transaction(fn ->	93✔
306	case Table.insert(table, record) do	93✔
307	{:ok, ^record} ->
308	{:ok, params}
309	{:error, :already_exists} ->
310	{:invalid, [{:unique, pk_field}]}
311	{:error, reason} ->
312	{:error, reason}
313	end
314	end) do
315	{:atomic, res} -> res	93✔
316	{:abort, reason} -> {:error, reason}
317	end
318	end
319
320	# Generate new sequenced primary key for table
321	defp put_new_pk(params, pk_field, table) when is_list(params) and is_atom(pk_field) do
322	{_, params} =	93✔
323	Keyword.get_and_update(params, pk_field, fn
324	nil -> {nil, Table.next_id(table)}
325	val -> {val, val}
326	end)
327
328	params	93✔
329	end
330
331	@doc """
332	Run `fun` inside a Mnesia transaction
333	"""
334	def transaction(_repo, _opts, fun) do
335	case Table.transaction(fun) do	1✔
336	{:error, reason} ->
337	{:error, reason}
338
339	result ->
340	{:ok, result}
341	end
342	end
343
344	@doc """
345	Returns true when called inside a transaction.
346	"""
347	def in_transaction?(_repo), do: Mnesia.is_transaction()	×
348
349	@doc """
350	Transaction rollbacks is not fully supported.
351	"""
352	def rollback(_repo, _tid), do: Mnesia.abort(:rollback)	1✔
353
354	@doc """
355	Deletes a record from a Mnesia database.
356	"""
357	def delete(_repo, %{schema: schema, source: {_, table}, autogenerate_id: _autogenerate_id}, filter, _opts) do
358	pk = get_pk!(filter, schema.__schema__(:primary_key))	7✔
359
360	case Table.delete(table, pk) do	7✔
361	{:ok, ^pk} -> {:ok, []}
362	{:error, reason} -> {:error, reason}
363	end
364	end
365
366	@doc """
367	Updates record stored in a Mnesia database.
368	"""
369	def update(
370	_repo,
371	%{schema: schema, source: {_, table}, autogenerate_id: _autogenerate_id},
372	changes,
373	filter,
374	returning,
375	_opts
376	) do
377	pk = get_pk!(filter, schema.__schema__(:primary_key))	4✔
378	context = Context.new(table, schema)	4✔
379	update = Update.from_keyword(schema, table, changes, context)	4✔
380
381	case Table.update(table, pk, update) do	3✔
382	{:ok, _record} when returning == [] ->
383	{:ok, []}
384
385	{:ok, _record} ->
386	{:ok, changes}
387	error -> error	×
388	end
389	end
390
391	# Extract primary key value or raise an error
392	defp get_pk!(params, {pk_field, _pk_type}), do: get_pk!(params, pk_field)	×
393	defp get_pk!(params, [pk_field]), do: get_pk!(params, pk_field)	11✔
394
395	defp get_pk!(params, pk_field) do
396	case Keyword.fetch(params, pk_field) do	11✔
397	:error -> raise Ecto.NoPrimaryKeyValueError	×
398	{:ok, pk} -> pk	11✔
399	end
400	end
401
402	# Extract limit from an `Ecto.Query`
403	defp get_limit(nil), do: nil
404	defp get_limit(%Ecto.Query.QueryExpr{expr: limit}), do: limit	2✔
405
406	# Required methods for Ecto type casing
407	def loaders({:embed, _value} = primitive, _type), do: [&Ecto.Adapters.SQL.load_embed(primitive, &1)]	1✔
408	def loaders(:binary_id, type), do: [Ecto.UUID, type]
409	def loaders(_primitive, type), do: [type]
410
411	def dumpers({:embed, _value} = primitive, _type), do: [&Ecto.Adapters.SQL.dump_embed(primitive, &1)]	1✔
412	def dumpers(:binary_id, type), do: [type, Ecto.UUID]
413	def dumpers(_primitive, type), do: [type]
414	end

Nebo15 / ecto_mnesia / 186

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