@spec abort(any()) :: no_return()

Abort the current transaction.

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

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

@spec async(function(), list()) :: any()

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

@spec cancel(any()) :: no_return()

Cancel the current transaction.

@spec debug(debug_level()) :: debug_level()

Change the debug level.

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

@spec dump(String.t()) :: none()

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

@spec error(atom()) :: String.t()

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

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

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

@spec ets(function(), list()) :: any()

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

@spec info() :: :ok

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

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

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

@spec load(String.t()) :: none()

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

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

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

Set master nodes, see mnesia:set_master_nodes.

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

Start the database, see mnesia:start.

@spec stop() :: :stopped

Stop the database, see mnesia:stop.

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

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

@spec sync(function(), list()) :: any()

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

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

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

@spec transaction(function(), list()) :: any() | no_return()

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

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

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

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

@spec transaction!(function(), list()) :: any() | no_return()

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

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

@spec transaction?() :: boolean()

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