Erlang笔记 -- Mnesia:Erlang数据库简单使用

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是setordered_setbag中的一个。
  • {disc_copies, NodeList}
    NodeList是一个Erlang节点列表,这些节点将保存表的磁盘副本。使用这个选项时,系统还会在执行这个操作的节点上创建一个表的内存副本。
    可以既在一个节点上保存disc_copies类型的副本表,又在另一个节点上保存该表的不同类型。这种做法能满足以下要求:
  1. 读取操作非常快,并在内存里执行;
  2. 写入操作在持久性存储介质里执行。
  • {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点需要注意:

  1. mnesia:write/1mnesia:delete/1的调用只应该出现在由mnesia:transaction/1处理的fun内部。
  2. 永远不要编写代码来显式捕捉Mnesia访问函数(mnesia:write/1mnesia: 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程序设计 第二版》。

上一篇:windows系统安装rabbitmq


下一篇:我的 2020,总结与告别