amnesia v0.2.8 Amnesia

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)

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

transaction!(fun, args)

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

transaction!(fun, args, retries)

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?()

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

Link to this section Types

debug_level()

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

Link to this section Functions

abort(reason)

abort(any()) :: no_return()

Abort the current transaction.

async(term)

(macro)

async([{: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)

debug(debug_level()) :: 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([{: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([{: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([{: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!([{: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.