@spec 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

@spec add_index(atom(), atom()) :: o()

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

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

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

@spec bag?(atom()) :: boolean()

Check if the given table is a bag.

@spec clear(atom()) :: o()

Clear the given table, see mnesia:clear_table.

@spec 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

@spec count(atom()) :: non_neg_integer()

Get the number of records in the given table.

@spec 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
  • :rock! => :rocksdb_copies -- [Will be moved to a formal plug-in, extension system - noizu]

• :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
    • :rock! => :n_rocksdb_copies

  @see storage options @see ets options @see dets options

  • :ets_options => :compressed
  • :dets_options => {:auto_save, 5000}
  • :compressed => true

  @see rock options

  • :rock_options => plugin specific -- [Will be moved to a formal plug-in, extension system, each plugin should expose it's own option set even if folded into user_props internalls - noizu]

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

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

@spec 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

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

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

@spec delete_copy(atom(), node()) :: o()

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

@spec delete_index(atom(), atom()) :: o()

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

@spec destroy(atom()) :: o()

Destroy the given table, see mnesia:delete_table.

@spec destroy!(atom()) :: :ok | no_return()

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

@spec exists?(atom()) :: boolean()

Checks if a table exists or not.

@spec first(atom()) :: any() | nil | no_return()

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

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

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

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

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

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

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

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

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

@spec info(atom(), atom()) :: any()

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

@spec keys(atom()) :: list() | no_return()

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

@spec keys!(atom()) :: list() | no_return()

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

@spec last(atom()) :: any() | nil | no_return()

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

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

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

@spec 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

@spec majority(atom(), boolean()) :: o()

Change the given table majority, see mnesia:change_table_majority.

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

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

@spec 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.

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

@spec member?(atom(), any()) :: boolean()

Check if the key is present in the given table.

@spec 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.

@spec 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.

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

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

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

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

@spec ordered_set?(atom()) :: boolean()

Check if the given table is an ordered set.

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

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

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

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

@spec priority(atom(), integer()) :: o()

Change the given table loading priority.

@spec properties(atom()) :: Keyword.t()

Return properties of the given table.

@spec 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

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

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

@spec 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.

@spec 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.

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

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

@spec 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.

@spec 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.

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

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

@spec set?(atom()) :: boolean()

Check if the given table is a set.

@spec transform(atom(), [atom()]) :: o()

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

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

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

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

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

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

Return the type of the given table.

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

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

@spec 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

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

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