amnesia v0.2.2 Amnesia

Summary

Functions

Abort the current transaction

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

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 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 in a dirty synchronous context passing over the passed arguments, see mnesia:sync_dirty

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

Macros

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

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

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

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

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

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

Types

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

Functions

abort(reason)

Specs

abort(any) :: no_return

Abort the current transaction.

async(fun, args)

Specs

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)

Specs

cancel(any) :: no_return

Cancel the current transaction.

debug(level)

Specs

Change the debug level.

dump(path)

Specs

dump(String.t) :: none

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

error(code)

Specs

error(atom) :: String.t

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

ets(fun, args)

Specs

ets(function, list) :: any

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

info()

Specs

info :: :ok

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

info(key)

Specs

info(atom) :: any

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

load(path)

Specs

load(String.t) :: none

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

lock(key, nodes, mode)

Specs

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)

Specs

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

Set master nodes, see mnesia:set_master_nodes.

start()

Specs

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

Start the database, see mnesia:start.

stop()

Specs

stop :: :stopped

Stop the database, see mnesia:stop.

sync(fun, args)

Specs

sync(function, list) :: any

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

transaction(fun, args)

Specs

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)

Specs

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!(fun, args)

Specs

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)

Specs

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

Specs

transaction? :: boolean

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

Macros

async(term)

Specs

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

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

defdatabase(name, list)

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
ets(term)

Specs

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

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

sync(term)

Specs

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

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

transaction(term)

Specs

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

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

transaction!(term)

Specs

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

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