amnesia v0.2.7 Amnesia

Summary

Functions

Abort the current transaction

Run the passed function or block in a dirty asynchronous context, see mnesia:async_dirty

Run the passed function in a dirty asynchronous context passing over the passed arguments, see mnesia:async_dirty

Cancel the current transaction

Change the debug level

Define a database with the given name and the various definitions in the block

Dump the database to a text file, see mnesia:dump_to_textfile

Get an error description from an error code, see mnesia:error_description

Run the passed function or block in the ETS context, see mnesia:ets

Run the passed function in the ETS context passing over the passed arguments, see mnesia:ets

Print information about the mnesia database, see mnesia:info

Return information about the running instance, see mnesia:system_info

Load a dump from a text file, see mnesia:load_textfile

Lock the whole database on the given node for the given keys with the given lock, see mnesia:lock

Set master nodes, see mnesia:set_master_nodes

Start the database, see mnesia:start

Stop the database, see mnesia:stop

Run the passed function or block in a dirty synchronous context, see mnesia:sync_dirty

Run the passed function in a dirty synchronous context passing over the passed arguments, see mnesia:sync_dirty

Start a transaction with the given block or function, see mnesia:transaction

Start a transaction with the given function passing the passed arguments to it, see mnesia:transaction

Start a transaction with the given function passing the passed arguments to it, trying to take a lock maximum retries times, see mnesia:transaction

Start a synchronous transaction with the given block or function, see mnesia:sync_transaction

Start a synchronous transaction with the given function passing the passed arguments to it, see mnesia:sync_transaction

Start a synchronous transaction with the given function passing the passed arguments to it, trying to take a lock maximum retries times, see mnesia:sync_transaction

Check if it’s inside a transaction or not, see mnesia:is_transaction

Types

debug_level()
debug_level() :: :none | :verbose | :debug | :trace | false | true

Functions

abort(reason)
abort(any) :: no_return

Abort the current transaction.

async(term) (macro)
async(term, [{:do, term}] | term) :: any

Run the passed function or block in a dirty asynchronous context, see mnesia:async_dirty.

async(fun, args)
async(function, list) :: any

Run the passed function in a dirty asynchronous context passing over the passed arguments, see mnesia:async_dirty.

cancel(value \\ nil)
cancel(any) :: no_return

Cancel the current transaction.

debug(level)

Change the debug level.

defdatabase(name, list) (macro)

Define a database with the given name and the various definitions in the block.

Example

use Amnesia

defdatabase Foo do
  deftable Bar, [:id, :a], type: :bag

  deftable Baz, [:id, :a, :b] do
    def foo(self)
      42
    end
  end
end
dump(path)
dump(String.t) :: none

Dump the database to a text file, see mnesia:dump_to_textfile.

error(code)
error(atom) :: String.t

Get an error description from an error code, see mnesia:error_description.

ets(term) (macro)
ets(term, [{:do, term}] | term) :: any

Run the passed function or block in the ETS context, see mnesia:ets.

ets(fun, args)
ets(function, list) :: any

Run the passed function in the ETS context passing over the passed arguments, see mnesia:ets.

info()
info() :: :ok

Print information about the mnesia database, see mnesia:info.

info(key)
info(atom) :: any

Return information about the running instance, see mnesia:system_info.

load(path)
load(String.t) :: none

Load a dump from a text file, see mnesia:load_textfile.

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

Lock the whole database on the given node for the given keys with the given lock, see mnesia:lock.

Locks

  • :write sets a :write lock
  • :write! sets a :sticky_write lock
  • :read sets a :read lock
master_nodes(nodes)
master_nodes([node]) :: :ok | {:error, any}

Set master nodes, see mnesia:set_master_nodes.

start()
start() :: :ok | {:error, any}

Start the database, see mnesia:start.

stop()
stop() :: :stopped

Stop the database, see mnesia:stop.

sync(term) (macro)
sync(term, [{:do, term}] | term) :: any

Run the passed function or block in a dirty synchronous context, see mnesia:sync_dirty.

sync(fun, args)
sync(function, list) :: any

Run the passed function in a dirty synchronous context passing over the passed arguments, see mnesia:sync_dirty.

transaction(term) (macro)
transaction(term, [{:do, term}] | term) :: any | no_return

Start a transaction with the given block or function, see mnesia:transaction.

transaction(fun, args)
transaction(function, list) :: any | no_return

Start a transaction with the given function passing the passed arguments to it, see mnesia:transaction.

transaction(fun, args, retries)
transaction(function, list, integer) :: any | no_return

Start a transaction with the given function passing the passed arguments to it, trying to take a lock maximum retries times, see mnesia:transaction.

transaction!(term) (macro)
transaction!(term, [{:do, term}] | term) :: any | no_return

Start a synchronous transaction with the given block or function, see mnesia:sync_transaction.

transaction!(fun, args)
transaction!(function, list) :: any | no_return

Start a synchronous transaction with the given function passing the passed arguments to it, see mnesia:sync_transaction.

transaction!(fun, args, retries)
transaction!(function, list, integer) :: any | no_return

Start a synchronous transaction with the given function passing the passed arguments to it, trying to take a lock maximum retries times, see mnesia:sync_transaction.

transaction?()
transaction?() :: boolean

Check if it’s inside a transaction or not, see mnesia:is_transaction.