amnesia

v0.2.2

amnesia v0.2.2 Amnesia.Table

Summary

Types

c()
cv()
o()

Functions

add_copy(name, node, type \\ :disk)

Add a copy of the table to the given node with the given mode, see mnesia:add_table_copy

add_index(name, attribute)

Add an index to the given table for the given attribute, see mnesia:add_table_index

at!(name, position)

Read a slot from the given table, see mnesia:dirty_slot

bag?(name)

Check if the given table is a bag

clear(name)

Clear the given table, see mnesia:clear_table

copying(name, node, to)

Change the copying mode of the given table on the given node, see mnesia:change_table_copy_type

count(name)

Get the number of records in the given table

create(name, definition \\ [])

Create a table with the given name and definition, see mnesia:create_table

create!(name, definition \\ [])

Create a table with the given name and definition, see mnesia:create_table, raises in case of error

delete(name, key, lock \\ :write)

Delete the given record in the given table, see mnesia:delete

delete!(name, key)

Delete the given record in the given table, see mnesia:dirty_delete

delete_copy(name, node)

Delete a copy of the table on the given node, see mnesia:del_table_copy

delete_index(name, attribute)

Delete an index on the given table for the given attribute, see mnesia:del_table_index

destroy(name)

Destroy the given table, see mnesia:delete_table

destroy!(name)

Destroy the given table, see mnesia:delete_table, raising in case of error

exists?(name)

Checks if a table exists or not

first(name)

Get the first key in the table, see mnesia:first

first!(name)

Get the first key in the table, see mnesia:dirty_read

foldl(name, acc, fun)

Fold the whole given table from the left, see mnesia:foldl

foldr(name, acc, fun)

Fold the whole given table from the right, see mnesia:foldr

force(name)

Force the loading of the given table, see mnesia:force_load_table

info(name, key)

Get information about a given table, see mnesia:table_info

keys(name)

Read all keys in the given table, see mnesia:all_keys

keys!(name)

Read all keys in the given table, see mnesia:dirty_all_keys

last(name)

Get the last key in the table, see mnesia:last

last!(name)

Get the last key in the table, see mnesia:dirty_last

lock(name, mode)

Lock the given table for the given kind of lock, see mnesia:lock

majority(name, value)

Change the given table majority, see mnesia:change_table_majority

master_nodes(name, nodes)

Set master nodes for the given table, see mnesia:set_master_nodes

match(name, lock \\ :read, pattern)

Select records in the given table using simple don't care values, see mnesia:match_object

match!(name, pattern)

Select records in the given table using simple don't care values, see mnesia:dirty_match_object

member?(name, key)

Check if the key is present in the given table

mode(name, value)

Change the access mode of the given table, see mnesia:change_table_access_mode

move_copy(name, from, to)

Move the copy of the given table from the given node to another given node, see mnesia:move_table_copy

next(name, key)

Get the next key in the table starting from the given key, see mnesia:next

next!(name, key)

Get the next key in the table starting from the given key, see mnesia:dirty_next

ordered_set?(name)

Check if the given table is an ordered set

prev(name, key)

Get the previous key in the table starting from the given key, see mnesia:prev

prev!(name, key)

Get the previous key in the table starting from the given key, see mnesia:dirty_prev

priority(name, value)

Change the given table loading priority

properties(name)

Return properties of the given table

read(name, key, lock \\ :read)

Read records from the given table with the given key, locking in the given mode, see mnesia:read

read!(name, key)

Read records from the given table with the given key, see mnesia:dirty_read

read_at(name, key, position)

Read records on the given table based on a secondary index given as position, see mnesia:index_read

read_at!(name, key, position)

Read records on the given table based on a secondary index given as position, see mnesia:dirty_index_read

select(name, spec)

Select records in the given table using a match_spec, see mnesia:select

select(name, limit, spec)

Select records in the given table using a match_spec passing a limit or a lock kind, see mnesia:select

select(name, lock, limit, spec)

Select records in the given table using a match_spec passing a limit and a lock kind, see mnesia:select

select!(name, spec)

Select records in the given table using a match_spec, see mnesia:dirty_select

set?(name)

Check if the given table is a set

stream(name, lock \\ :read)
stream!(name)
transform(name, attributes)

Transform a table, useful to change tables in a running instance, see mnesia:transform_table

transform(name, attributes, fun)

Transform a table, useful to change tables in a running instance, see mnesia:transform_table

transform(name, new_name, attributes, fun)

Transform a table, renaming it, useful to change tables in a running instance, see mnesia:transform_table

type(name)

Return the type of the given table

wait(names, timeout \\ :infinity)

Wait for the passed tables for the given timeout, see mnesia:wait_for_tables

write(name, data, lock \\ :write)

Write the given record in the given table, using the given lock, see mnesia:write

write!(name, data)

Write the given record in the given table, see mnesia:dirty_write

Types 

c :: [{cv, [node]}]
cv :: :disk | :disk! | :memory
o :: :ok | {:error, any}

Functions

add_copy(name, node, type \\ :disk)

Specs

add_copy(atom, node, cv) :: o

Add a copy of the table to the given node with the given mode, see mnesia:add_table_copy.

  • :disk sets :disc_copies mode
  • :disk! sets :disc_only_copies mode
  • :memory sets :ram_copies mode
add_index(name, attribute)

Specs

add_index(atom, atom) :: o

Add an index to the given table for the given attribute, see mnesia:add_table_index.

at!(name, position)

Specs

at!(atom, integer) :: tuple | nil | no_return

Read a slot from the given table, see mnesia:dirty_slot.

bag?(name)

Specs

bag?(atom) :: boolean

Check if the given table is a bag.

clear(name)

Specs

clear(atom) :: o

Clear the given table, see mnesia:clear_table.

copying(name, node, to)

Specs

copying(atom, node, cv) :: o

Change the copying mode of the given table on the given node, see mnesia:change_table_copy_type.

Modes

  • :disk sets :disc_copies mode
  • :disk! sets :disc_only_copies mode
  • :memory sets :ram_copies mode
count(name)

Specs

count(atom) :: non_neg_integer

Get the number of records in the given table.

create(name, definition \\ [])

Specs

create(atom, c) :: o

Create a table with the given name and definition, see mnesia:create_table.

The definition is a keyword list of options which have a correspondence with mnesia options, to know what they do check the mnesia documentation.

  • :record => :record_name

  • :attributes

  • :mode => :access_mode
  • :both => :read_write

  • :read! => :read_only

  • :type
  • :index
  • :majority
  • :priority => :load_order
  • :user => :user_properties

  • :local => :local_content

  • :copying (a keyword list composed of)
  • :memory => :ram_copies
  • :disk => :disc_copies

  • :disk! => :disc_only_copies

  • :fragmentation => :frag_properties (a keyword list composed of)
  • :number => :n_fragments
  • :nodes => :node_pool

  • :foreign => :foreign_key

  • :hash (a keyword list composed of)
    • :module => :hash_module
    • :state => :hash_state
  • :copying (a keyword list composed of)
    • :memory => :n_ram_copies
    • :disk => :n_disc_copies
    • :disk! => :n_disc_only_copies
create!(name, definition \\ [])

Specs

create!(atom, c) :: :ok | no_return

Create a table with the given name and definition, see mnesia:create_table, raises in case of error.

delete(name, key, lock \\ :write)

Specs

delete(atom, any, :write | :write!) ::
  :ok |
  no_return

Delete the given record in the given table, see mnesia:delete.

Locks

  • :write sets a :write lock
  • :write! sets a :sticky_write lock
delete!(name, key)

Specs

delete!(atom, any) :: :ok | no_return

Delete the given record in the given table, see mnesia:dirty_delete.

delete_copy(name, node)

Specs

delete_copy(atom, node) :: o

Delete a copy of the table on the given node, see mnesia:del_table_copy.

delete_index(name, attribute)

Specs

delete_index(atom, atom) :: o

Delete an index on the given table for the given attribute, see mnesia:del_table_index.

destroy(name)

Specs

destroy(atom) :: o

Destroy the given table, see mnesia:delete_table.

destroy!(name)

Specs

destroy!(atom) :: :ok | no_return

Destroy the given table, see mnesia:delete_table, raising in case of error.

exists?(name)

Specs

exists?(atom) :: boolean

Checks if a table exists or not.

first(name)

Specs

first(atom) :: any | nil | no_return

Get the first key in the table, see mnesia:first.

first!(name)

Specs

first!(atom) :: any | nil | no_return

Get the first key in the table, see mnesia:dirty_read.

foldl(name, acc, fun)

Specs

foldl(atom, any, (tuple, any -> any)) ::
  any |
  no_return
foldl(atom, any, (tuple, any -> any)) ::
  any |
  no_return

Fold the whole given table from the left, see mnesia:foldl.

foldr(name, acc, fun)

Fold the whole given table from the right, see mnesia:foldr.

force(name)

Specs

force(atom) :: :yes | {:error, any}

Force the loading of the given table, see mnesia:force_load_table.

info(name, key)

Specs

info(atom, atom) :: any

Get information about a given table, see mnesia:table_info.

keys(name)

Specs

keys(atom) :: list | no_return

Read all keys in the given table, see mnesia:all_keys.

keys!(name)

Specs

keys!(atom) :: list | no_return

Read all keys in the given table, see mnesia:dirty_all_keys.

last(name)

Specs

last(atom) :: any | nil | no_return

Get the last key in the table, see mnesia:last.

last!(name)

Specs

last!(atom) :: any | nil | no_return

Get the last key in the table, see mnesia:dirty_last.

lock(name, mode)

Specs

lock(atom, :write | :write! | :read) ::
  [node] |
  :ok |
  no_return

Lock the given table for the given kind of lock, see mnesia:lock.

Locks

  • :write sets a :write lock
  • :write! sets a :sticky_write lock
  • :read sets a :read lock
majority(name, value)

Specs

majority(atom, boolean) :: o

Change the given table majority, see mnesia:change_table_majority.

master_nodes(name, nodes)

Specs

master_nodes(atom, [node]) :: :ok | {:error, any}

Set master nodes for the given table, see mnesia:set_master_nodes.

match(name, lock \\ :read, pattern)

Specs

match(atom, :read | :write, any) ::
  [tuple] |
  nil |
  no_return

Select records in the given table using simple don't care values, see mnesia:match_object.

match!(name, pattern)

Select records in the given table using simple don't care values, see mnesia:dirty_match_object.

member?(name, key)

Specs

member?(atom, any) :: boolean

Check if the key is present in the given table.

mode(name, value)

Specs

mode(atom, :both | :read!) :: o

Change the access mode of the given table, see mnesia:change_table_access_mode.

Modes

  • :both sets read and write mode, it's the default.
  • :read! sets read-only mode.
move_copy(name, from, to)

Specs

move_copy(atom, node, node) :: o

Move the copy of the given table from the given node to another given node, see mnesia:move_table_copy.

next(name, key)

Specs

next(atom, any) :: any | nil | no_return

Get the next key in the table starting from the given key, see mnesia:next.

next!(name, key)

Specs

next!(atom, any) :: any | nil | no_return

Get the next key in the table starting from the given key, see mnesia:dirty_next.

ordered_set?(name)

Specs

ordered_set?(atom) :: boolean

Check if the given table is an ordered set.

prev(name, key)

Specs

prev(atom, any) :: any | nil | no_return

Get the previous key in the table starting from the given key, see mnesia:prev.

prev!(name, key)

Specs

prev!(atom, any) :: any | nil | no_return

Get the previous key in the table starting from the given key, see mnesia:dirty_prev.

priority(name, value)

Specs

priority(atom, integer) :: o

Change the given table loading priority.

properties(name)

Specs

properties(atom) :: Keyword.t

Return properties of the given table.

read(name, key, lock \\ :read)

Specs

read(atom, any, :read | :write | :write!) ::
  [tuple] |
  nil |
  no_return

Read records from the given table with the given key, locking in the given mode, see mnesia:read.

  • :write sets a :write lock
  • :write! sets a :sticky_write lock
  • :read sets a :read lock
read!(name, key)

Specs

read!(atom, any) :: [tuple] | nil | no_return

Read records from the given table with the given key, see mnesia:dirty_read.

read_at(name, key, position)

Specs

read_at(atom, any, integer | atom) ::
  [tuple] |
  nil |
  no_return

Read records on the given table based on a secondary index given as position, see mnesia:index_read.

read_at!(name, key, position)

Specs

read_at!(atom, any, integer | atom) ::
  [tuple] |
  nil |
  no_return

Read records on the given table based on a secondary index given as position, see mnesia:dirty_index_read.

select(name, spec)

Specs

select(atom, any) ::
  Amnesia.Selection.t |
  nil |
  no_return

Select records in the given table using a match_spec, see mnesia:select.

select(name, limit, spec)

Specs

select(atom, integer | :read | :write, any) ::
  Amnesia.Selection.t |
  nil |
  no_return

Select records in the given table using a match_spec passing a limit or a lock kind, see mnesia:select.

select(name, lock, limit, spec)

Specs

select(atom, integer | :read | :write, integer | :read | :write, integer) ::
  Amnesia.Selection.t |
  nil |
  no_return

Select records in the given table using a match_spec passing a limit and a lock kind, see mnesia:select.

select!(name, spec)

Specs

select!(atom, any) ::
  Amnesia.Selection.t |
  nil |
  no_return

Select records in the given table using a match_spec, see mnesia:dirty_select.

set?(name)

Specs

set?(atom) :: boolean

Check if the given table is a set.

stream(name, lock \\ :read)
stream!(name)
transform(name, attributes)

Specs

transform(atom, [atom]) :: o

Transform a table, useful to change tables in a running instance, see mnesia:transform_table.

transform(name, attributes, fun)

Specs

transform(atom, [atom] | atom, (tuple -> tuple) | [atom]) :: o

Transform a table, useful to change tables in a running instance, see mnesia:transform_table.

transform(name, new_name, attributes, fun)

Specs

transform(atom, atom, [atom], (tuple -> tuple)) :: o

Transform a table, renaming it, useful to change tables in a running instance, see mnesia:transform_table.

type(name)

Specs

type(atom) :: :set | :ordered_set | :bag

Return the type of the given table.

wait(names, timeout \\ :infinity)

Specs

wait([atom], integer | :infinity) ::
  :ok |
  {:timeout, [atom]} |
  {:error, atom}

Wait for the passed tables for the given timeout, see mnesia:wait_for_tables.

write(name, data, lock \\ :write)

Specs

write(atom, tuple, :write | :write!) ::
  :ok |
  no_return

Write the given record in the given table, using the given lock, see mnesia:write.

Locks

  • :write sets a :write lock
  • :write! sets a :sticky_write lock
write!(name, data)

Specs

write!(atom, tuple) :: :ok | no_return

Write the given record in the given table, see mnesia:dirty_write.