Packages
krug
1.1.23
2.0.36
2.0.35
2.0.34
2.0.33
2.0.32
2.0.31
2.0.30
2.0.29
2.0.27
2.0.26
2.0.25
2.0.24
2.0.23
2.0.22
2.0.20
2.0.19
2.0.18
2.0.17
2.0.16
2.0.15
2.0.14
2.0.13
2.0.12
2.0.11
2.0.10
2.0.9
2.0.8
2.0.7
2.0.6
2.0.5
2.0.4
2.0.1
2.0.0
1.1.53
1.1.52
1.1.50
1.1.49
1.1.48
1.1.47
1.1.46
1.1.45
1.1.44
1.1.43
1.1.42
1.1.41
1.1.40
1.1.39
1.1.38
1.1.37
1.1.36
1.1.35
1.1.34
1.1.33
1.1.32
1.1.31
1.1.30
1.1.29
1.1.28
1.1.27
1.1.26
1.1.25
1.1.24
1.1.23
1.1.22
1.1.21
1.1.20
1.1.19
1.1.18
1.1.17
1.1.16
1.1.15
1.1.14
1.1.12
1.1.10
1.1.9
1.1.8
1.1.7
1.1.6
1.1.5
1.1.4
1.1.3
1.1.2
1.1.1
1.1.0
1.0.9
1.0.8
1.0.7
1.0.6
1.0.5
1.0.4
1.0.3
1.0.2
1.0.1
1.0.0
0.5.5
0.5.4
0.5.3
0.5.2
0.5.1
0.5.0
0.4.31
0.4.30
0.4.29
0.4.28
0.4.27
0.4.26
0.4.25
0.4.24
0.4.23
0.4.22
0.4.20
0.4.19
0.4.18
0.4.17
0.4.16
0.4.15
0.4.14
0.4.13
0.4.12
0.4.11
0.4.10
0.4.9
0.4.8
0.4.7
0.4.6
0.4.5
0.4.4
0.4.3
0.4.2
0.4.1
0.4.0
0.3.9
0.3.8
0.3.7
0.3.6
0.3.5
0.3.4
0.3.3
0.3.2
0.3.1
0.3.0
0.2.1
0.2.0
0.1.0
A Utilitary package functionalities modules for improve a secure performatic development.
Current section
Files
Jump to
Current section
Files
lib/krug/util/mnesia.util.ex
defmodule Krug.MnesiaUtil do
@moduledoc """
Utilitary module to handle some mnesia operations
"""
@moduledoc since: "1.1.17"
@doc """
Provides encapsulated behaviour for data storage
using transaction for call
```elixir
data = [table_name | [id_row | data_row]]
data = data |> List.to_tuple() # result in {table_name,id_row,data_row[0] ... data_row[n]}
:mnesia.write(data)
```
Works in key value storage style, where "id_row" is the key, and "data_row"
the value. Both values could be of any data type. "table_name" should be an atom.
This run fine for normal mnesia usage way (storing objects as in database row).
Return true or false.
Requires mnesia already be started.
"""
def store(table_name,id_row,data_row) do
write_data = fn ->
[table_name | [id_row | data_row]]
|> List.to_tuple()
|> :mnesia.write()
end
write_data
|> :mnesia.transaction()
|> put_cache_result()
end
@doc """
Provides encapsulated behaviour for data storage
using transaction for call
```elixir
:mnesia.write({table_name,id_row,data_row})
```
Works in key value storage style, where "id_row" is the key, and "data_row"
the value. Both values could be of any data type. "table_name" should be an atom.
This is intended to be more key-value object storage (like Redis), where
"data_row" could be anything from a simple string to a list, a map, a sql
resultset, and many others.
Return true or false.
Requires mnesia already be started.
"""
def put_cache(table_name,id_row,data_row) do
write_data = fn ->
:mnesia.write({table_name,id_row,data_row})
end
write_data
|> :mnesia.transaction()
|> put_cache_result()
end
@doc """
Provides encapsulated behaviour for load the stored key value
using transaction for
```elixir
:mnesia.read({table_name,id_row})
```
for an key "id_row" from an table "table_name". Return the stored value or nil.
Requires mnesia already be started.
"""
def load_from_cache(table_name,id_row) do
read_data = fn ->
:mnesia.read({table_name,id_row})
end
read_data
|> :mnesia.transaction()
|> load_from_cache_result()
end
@doc """
Provides cache functionality to clear cached results of all key value rows
from a table "table_name". Return true or false.
Requires mnesia already be started.
"""
def clear_cache(table_name) do
table_name
|> :mnesia.clear_table()
|> clear_cache_result()
true
end
##########################################
### store functions
##########################################
defp put_cache_result({:atomic, :ok}) do
true
end
defp put_cache_result(error) do
error |> IO.inspect()
false
end
##########################################
### load functions
##########################################
defp load_from_cache_result({:atomic,key_entry_array}) do
cond do
(nil == key_entry_array
or Enum.empty?(key_entry_array))
-> nil
true
-> key_entry_array
|> hd()
end
end
defp load_from_cache_result(_) do
nil
end
##########################################
### clear cache functions
##########################################
defp clear_cache_result({:atomic,:ok}) do
true
end
defp clear_cache_result(_) do
false
end
end