1. 创建数据库
在当前节点创建
PS E:\ERL\Mnesia> erl
Eshell V8.3 (abort with ^G)
1> node().
nonode@nohost
2> mnesia:create_schema([node()]).
ok
3> init:stop().
ok
4>
PS E:\ERL\Mnesia> ls
目录: E:\ERL\Mnesia
Mode LastWriteTime Length Name
---- ------------- ------ ----
d----- 2020/10/21 11:38 Mnesia.nonode@nohost
PS E:\ERL\Mnesia>

mnesia:create_schema(NodeList)会在NodeList（它必须是一个包含有效Erlang节点的列表）里的所有节点上都初始化一个新的Mnesia数据库。
Mnesia完成初始化并创建了一个名为Mnesia.nonode@nohost的目录结构来保存数据库。

在特定节点创建
PS E:\ERL\Mnesia> erl -sname dylan
Eshell V8.3 (abort with ^G)
(dylan@DESKTOP-FRA3DA2)1> mnesia:create_schema([node()]).
ok
(dylan@DESKTOP-FRA3DA2)2> init:stop().
ok
(dylan@DESKTOP-FRA3DA2)3>
PS E:\ERL\Mnesia> ls
目录: E:\ERL\Mnesia
Mode LastWriteTime Length Name
---- ------------- ------ ----
d----- 2020/10/21 11:46 Mnesia.dylan@DESKTOP-FRA3DA2
d----- 2020/10/21 11:38 Mnesia.nonode@nohost

另外，可以在启动erl时通过参数-mnesia dir Dir指定数据库目录的位置。

Mnesia常用方法
mnesia:start(). 启动mnesia数据库
mnesia:stop(). 关闭mnesia数据库
mnesia:info(). 显示mnesia数据库状态
2. 创建表
可以对Mnesia表进行多种方式的配置。首先，表可以位于内存或磁盘里。其次，表可以位于单台机器上，也可以在多台机器之间复制。

内存表
它们的速度非常快，但是里面的数据是易失的，所以如果机器崩溃或者停止了DBMS，数据就会丢失。
磁盘表
磁盘表应该不会受到系统崩溃的影响（前提是磁盘没有物理损坏）。当Mnesia事务写入一个表并且这个表是保存在磁盘上时，实际上是事务数据首先被写入了一个磁盘日志。
要创建一个表，则调用mnesia:create_table(Name, ArgS)，其中ArgS是一个由{Key,Val}元组构成的列表。如果表创建成功，create_table就会返回{atomic, ok}，否则返回{aborted, Reason}。常用参数：

Name
表的名称（一个原子）。按惯例是一个Erlang记录的名称，表里的各行是这个记录的实例。
{type, Type}
指定了表的类型。Type是set、ordered_set或bag中的一个。
{disc_copies, NodeList}
NodeList是一个Erlang节点列表，这些节点将保存表的磁盘副本。使用这个选项时，系统还会在执行这个操作的节点上创建一个表的内存副本。
可以既在一个节点上保存disc_copies类型的副本表，又在另一个节点上保存该表的不同类型。这种做法能满足以下要求：
读取操作非常快，并在内存里执行；
写入操作在持久性存储介质里执行。
{ram_copies, NodeList}
NodeList是一个Erlang节点列表，这些节点将保存表的内存副本。
{disc_only_copies, NodeList}
NodeList是一个Erlang节点列表，这些节点将只保存表的磁盘副本。这些表没有内存副本，访问起来会比较慢。
{attributes, AtomList}
这个列表包含表里各个值的列名。要创建一个包含Erlang记录xxx的表，可以用{attributes, record_info(fields, xxx)}这种语法（也可以显式指定一个记录字段名列表）。
常用的表属性组合：
mnesia:create_table(shop, [{attributes, record_info(fields, xxx)}]).
它会在单个节点上创建一个常驻内存的表。
如果节点崩溃了，表就会丢失。
它是所有表里快的一种。
内存必须能容纳这个表。

mnesia:create_table(shop, [{attributes, record_info(fields, xxx)}, {disc_copies, node()]}).
它会在单个节点上创建一个常驻内存的表和一个磁盘副本。
如果节点崩溃了，表就会从磁盘恢复。
表的读访问很快，但写访问较慢。
内存好能容纳这个表。

mnesia:create_table(shop, [{attributes, record_info(fields, xxx)}, {disc_only_copies, node()]}).
它只会在单个节点上创建一个磁盘副本。
它用于那些因为太大而无法放入内存的表。
它的访问速度比带有内存副本的方案更慢。

mnesia:create_table(shop, [{attributes, record_info(fields, xxx)}, {ram_copies, node(), soneOtherNode()]}).
它会在两个节点上各创建一个常驻内存的表。
如果两个节点都崩溃了，表就会丢失。
内存必须能容纳这个表。
可以在任何一个节点上访问这个表。

mnesia:create_table(shop, [{attributes, record_info(fields, xxx)}, {disc_copies, node(), soneOtherNode()]}).
它会在多个节点上创建磁盘副本。
无论哪个节点崩溃，我们都能恢复过来。
即使所有节点都崩溃了，表也不会丢失。

首先，通过执行test_mnesia:do_only_once()创建一个数据库及数据表：

1> test_mnesia:do_only_once().
stopped

=INFO REPORT==== 30-Oct-2020::15:06:32 ===
application: mnesia
exited: stopped
type: temporary
2> mnesia:info().
===> System info in version "4.14.3", debug level = none <===
opt_disc. Directory "e:/ERL/Mnesia/Mnesia.nonode@nohost" is used.
use fallback at restart = false
running db nodes = []
stopped db nodes = [nonode@nohost]
ok
3> mnesia:start().
ok
4> mnesia:info().
---> Processes holding locks <---
---> Processes waiting for locks <---
---> Participant transactions <---
---> Coordinator transactions <---
---> Uncertain transactions <---
---> Active tables <---
cost : with 0 records occupying 302 words of mem
shop : with 0 records occupying 302 words of mem
schema : with 3 records occupying 645 words of mem
===> System info in version "4.14.3", debug level = none <===
opt_disc. Directory "e:/ERL/Mnesia/Mnesia.nonode@nohost" is used.
use fallback at restart = false
running db nodes = [nonode@nohost]
stopped db nodes = []
master node tables = []
remote = []
ram_copies = [cost,shop]
disc_copies = [schema]
disc_only_copies = []
[{nonode@nohost,disc_copies}] = [schema]
[{nonode@nohost,ram_copies}] = [shop,cost]
2 transactions committed, 0 aborted, 0 restarted, 0 logged to disc
0 held locks, 0 in queue; 0 local transactions, 0 remote
0 transactions waits for other nodes: []
ok

test_mnesia:do_only_once()代码如下：

do_only_once() ->
mnesia:create_schema([node()]),
mnesia:start(),
create_table(),
mnesia:stop().
%% 创建数据表
create_table() ->
mnesia:create_table(shop, [{attributes, record_info(fields, shop)}]),
mnesia:create_table(cost, [{attributes, record_info(fields, cost)}]).

先通过test_mnesia:reset_tables()初始化数据表。

5> test_mnesia:reset_tables().
{atomic,ok}
3. 查询数据
查询所有行：
7> test_mnesia:demo(select_shop).
[{shop,potato,2456,1.2},
{shop,apple,20,2.3},
{shop,orange,100,3.8},
{shop,pear,200,3.6},
{shop,banana,420,4.5}]

test_mnesia:demo(select_shop)代码如下：

demo(select_shop) ->
do(qlc:q([X || X <- mnesia:table(shop)]));

[X || X <- mnesia:table(shop)]的意思是“一个由X组成的列表，X提取自shop这个Mnesia表”。X的值是Erlang的shop记录。
qlc:q()会把查询编译成一种用于查询数据库的内部格式。把编译后的查询传递给一个名为do()的函数，do()代码如下：

do(Q) ->
F = fun() -> qlc:e(Q) end,
{atomic, Val} = mnesia:transaction(F),
Val.

它在一个Mnesia事务内调用了qlc:e(Q)。Q是一个已编译的QLC查询，而qlc:e(Q)会执行这个查询，并把查询到的所有结果以列表的形式返回。返回值{atomic, Val}的意思是事务成功并得到了Val值。Val是这个事务函数的值。
需要注意：
qlc:q/1的参数必须是一个字面上的列表推导，不能是通过求值得出的。举个例子，下面的代码与示例里的代码不是等价的。

Val = [X || X <- mnesia:table(shop)],
qlc:q(Val).

查询部分字段：
8> test_mnesia:demo(select_some).
[{potato,2456},
{apple,20},
{orange,100},
{pear,200},
{banana,420}]

test_mnesia:demo(select_some)代码如下：

demo(select_some) ->
do(qlc:q([{X#shop.item, X#shop.quantity} || X <- mnesia:table(shop)]));

条件查询：
9> test_mnesia:demo(reorder).
[apple,orange,pear]

test_mnesia:demo(reorder)代码如下：

demo(reorder) ->
do(qlc:q([X#shop.item || X <- mnesia:table(shop),
X#shop.quantity < 250
]));

联表查询：
10> test_mnesia:demo(join).
[apple]

test_mnesia:demo(join)代码如下：

demo(join) ->
do(qlc:q([X#shop.item || X <- mnesia:table(shop),
X#shop.quantity < 250,
Y <- mnesia:table(cost),
X#shop.item =:= Y#cost.name,
Y#cost.price < 2
])).

4. 添加行
11> test_mnesia:add_shop_item(tomato,100,1.0).
{atomic,ok}
12> test_mnesia:demo(select_shop).
[{shop,tomato,100,1.0},
{shop,potato,2456,1.2},
{shop,apple,20,2.3},
{shop,orange,100,3.8},
{shop,pear,200,3.6},
{shop,banana,420,4.5}]
13> test_mnesia:add_shop_item(orange,100,1.0).
{atomic,ok}
14> test_mnesia:demo(select_shop).
[{shop,tomato,100,1.0},
{shop,potato,2456,1.2},
{shop,apple,20,2.3},
{shop,orange,100,1.0},
{shop,pear,200,3.6},
{shop,banana,420,4.5}]

shop表的主键是表内的列，也就是shop记录里的item字段。这个表属于“异键”类型。如果新创建的记录和数据表里的某一行具有相同的主键，就会覆盖那一行，否则就会创建一个新行。

5. 删除行
要移除某一行，需要知道该行的对象ID（Object ID，简称OID）。它由表名和主键的值构成。

15> test_mnesia:remove_shop_item(tomato).
{atomic,ok}
16> test_mnesia:demo(select_shop).
[{shop,potato,2456,1.2},
{shop,apple,20,2.3},
{shop,orange,100,1.0},
{shop,pear,200,3.6},
{shop,banana,420,4.5}]

6. Mnesia事务
Mnesia采用一种悲观锁定（pessimistic locking）的策略。每当Mnesia事务管理器访问一个表时，都会根据上下文情况尝试锁定记录甚至整个表。如果它发现这可能导致死锁，就会立即中止事务并撤销之前所做的改动。
如果因为其他进程正在访问数据而导致事务一开始就失败了，系统就会进行短时间的等待，然后再次尝试执行事务。这么做的一种结果就是事务fun里的代码可能会被执行很多次。
出于这个原因，事务fun里的代码不应该做任何带有副作用的事情。举个例子：

F = fun() ->
...
io:format("STH Done"),
...
end,
mnesia:transaction(F).

也许会得到大量输出，因为这个fun可能会被多次重试。
有2点需要注意：

对mnesia:write/1和mnesia:delete/1的调用只应该出现在由mnesia:transaction/1处理的fun内部。
永远不要编写代码来显式捕捉Mnesia访问函数（mnesia:write/1和mnesia: delete/1等）里的异常错误，因为Mnesia的事务机制本身就依赖这些函数在失败时抛出异常错误。如果捕捉这些异常错误并试图自行处理它们，就会破坏事务机制。
另外，可以通过调用mnesia:abort(Reason)终止一个事务。

7. 表查看器
要查看我们保存在Mnesia里的数据，可以使用observer应用程序里内建的表查看器。用命令observer:start()启动observer。

8. 完整代码
%% test_mnesia.erl
-module(test_mnesia).
-compile(export_all).

-include_lib("stdlib/include/qlc.hrl").

-record(shop, {item, quantity, cost}).
-record(cost, {name, price}).

do_only_once() ->
mnesia:create_schema([node()]),
mnesia:start(),
create_table(),
mnesia:stop().

%% 创建数据表
create_table() ->
mnesia:create_table(shop, [{attributes, record_info(fields, shop)}]),
mnesia:create_table(cost, [{attributes, record_info(fields, cost)}]).

start() ->
mnesia:start(),
mnesia:wait_for_tables([shop,cost,design], 20000).%% 等待所有数据表就绪

%% 重置表数据
reset_tables() ->
mnesia:clear_table(shop),%% 删除表中的数据
mnesia:clear_table(cost),
F = fun() ->
lists:foreach(fun mnesia:write/1, example_tables())
end,
mnesia:transaction(F).

example_tables() ->
[%% The shop table
{shop, apple, 20, 2.3},
{shop, orange, 100, 3.8},
{shop, pear, 200, 3.6},
{shop, banana, 420, 4.5},
{shop, potato, 2456, 1.2},
%% The cost table
{cost, apple, 1.5},
{cost, orange, 2.4},
{cost, pear, 2.2},
{cost, banana, 1.5},
{cost, potato, 0.6}
].

%% 查询
%% SQL equivalent
%% SELECT * FROM shop;
demo(select_shop) ->
do(qlc:q([X || X <- mnesia:table(shop)]));


%% SQL equivalent
%% SELECT item, quantity FROM shop;
demo(select_some) ->
do(qlc:q([{X#shop.item, X#shop.quantity} || X <- mnesia:table(shop)]));


%% SQL equivalent
%% SELECT shop.item FROM shop
%% WHERE shop.quantity < 250;
demo(reorder) ->
do(qlc:q([X#shop.item || X <- mnesia:table(shop),
X#shop.quantity < 250
]));

%% 联表
%% SQL equivalent
%% SELECT shop.item
%% FROM shop, cost
%% WHERE shop.item = cost.name
%% AND cost.price < 2
%% AND shop.quantity < 250
demo(join) ->
do(qlc:q([X#shop.item || X <- mnesia:table(shop),
X#shop.quantity < 250,
Y <- mnesia:table(cost),
X#shop.item =:= Y#cost.name,
Y#cost.price < 2
])).

do(Q) ->
F = fun() -> qlc:e(Q) end,
{atomic, Val} = mnesia:transaction(F),
Val.


%% 添加数据
add_shop_item(Name, Quantity, Cost) ->
Row = #shop{item=Name, quantity=Quantity, cost=Cost},
F = fun() ->
mnesia:write(Row)
end,
mnesia:transaction(F).

%% 删除数据
remove_shop_item(Item) ->
Oid = {shop, Item},
F = fun() ->
mnesia:delete(Oid)
end,
mnesia:transaction(F).

注：本博客为通过《Erlang程序设计 第二版》学习Erlang时所做的笔记。学习更详细的内容，建议直接阅读《Erlang程序设计 第二版》。