Erlang：Mnesia：根据键以外的字段查找和更新-Erlang:Mnesia:Lookupandupdatebasedonfieldsotherthanthekey

1  

You don't have to worry about it. From the mnesia documentation:

你不必担心它。来自mnesia文档：

Read locks may be shared, which means that if one transaction manages to acquire a read lock on an item, other transactions may also acquire a read lock on the same item. However, if someone has a read lock no one can acquire a write lock at the same item. If some one has a write lock no one can acquire a read lock nor a write lock at the same item.

读锁可以是共享的，这意味着如果一个事务设法获取对项的读锁，则其他事务也可以获取对同一项的读锁。但是，如果有人有读锁定，则没有人可以在同一个项目上获得写锁定。如果某个人有写锁定，则没有人可以在同一个项目中获取读锁定或写锁定。

If a transaction has a read lock on an object, that object can't be edited by another transaction.

如果事务对对象具有读锁定，则该对象不能由另一个事务编辑。

Say you have two transactions, T1 and T2, which are executing in parallel:

假设您有两个并行执行的事务T1和T2：

1. T1 does mnesia:match_object, and acquires a read lock on all the returned objects.
2. T1执行mnesia：match_object，并获取所有返回对象的读锁定。
3. T2 does an equivalent mnesia:match_object, and acquires a read lock on the same objects.
4. T2执行等效的mnesia：match_object，并获取相同对象的读锁定。
5. T2 attempts to acquire a write lock on of the objects (to edit it).
6. T2尝试获取对象的写锁定（以编辑它）。
7. Mnesia automatically aborts T2, to be retried later.
8. Mnesia自动中止T2，稍后重试。
9. T1 acquires a write lock on the objects, and edits them.
10. T1获取对象的写锁定，并对其进行编辑。
11. T1 finishes.
12. T1完成。
13. Mnesia retries T2.
14. Mnesia重试T2。

Note that T2 may be retried several times, depending on how long T1 takes to complete (ie. release its locks).

请注意，T2可能会重试几次，具体取决于T1完成所需的时间（即释放其锁定）。

According to my tests, the locking behavior of mnesia:match_object isn't consistent. For example, mnesia:match_object(mytable, {mytable, 2, '_'}, LockType) will lock only the record with Key 2, but mnesia:match_object(mytable, {mytable, '_', test}, LockType) locks the entire table.

根据我的测试，mnesia：match_object的锁定行为不一致。例如，mnesia：match_object（mytable，{mytable，2，'_'}，LockType）将仅锁定具有键2的记录，但是mnesia：match_object（mytable，{mytable，'_'，test}，LockType）锁定整个桌子。

Also note that the documentation isn't correct, mnesia:match_object(Table, Pattern, write) does work, and seems to follow the same pattern as 'read', ie. if you specify the key, only the matching record will be write-locked; if you don't specify the key, the entire table will be write-locked.

另请注意，文档不正确，mnesia：match_object（Table，Pattern，write）确实有效，并且似乎遵循与'read'相同的模式，即。如果指定密钥，则只有匹配的记录会被写入锁定;如果您未指定密钥，则整个表将被写入锁定。

You can test it yourself by doing something like this:

您可以通过执行以下操作来自行测试：

test() ->
    mnesia:transaction(fun()-> 
        Table = mytable,
        Matches = mnesia:match_object(Table, {Table, 2, '_'}, write),
        io:format("matched: ~p~n", [Matches]),
        spawn(fun()->mnesia:transaction(fun()->
                        io:format("trying to read~n",[]),
                        io:format("read: ~p~n", [mnesia:read(Table, 2, read)])
                        end) end),        
        timer:sleep(1000),
        RereadMatches = lists:map(fun(#mytable{id=Id}) -> mnesia:read(Table, Id, write) end, Matches),
        io:format("reread matches: ~p~n", [RereadMatches])
        end).

By changing the pattern and lock type passed to match_object, and the key number and lock type passed to mnesia:read in the spawned process (or by using mnesia:write), you can test the various locking behaviors.

通过更改传递给match_object的模式和锁定类型，以及传递给mnesia的键号和锁类型：在生成的进程中读取（或使用mnesia：write），可以测试各种锁定行为。

Addendum: See this post by Ulf Wiger on the same topic.

附录：见Ulf Wiger关于同一主题的这篇文章。

Addendum 2: See the section on "Isolation" in the Mnesia user guide.

附录2：请参阅Mnesia用户指南中的“隔离”部分。

Edit: The above was all done on a set-type table, match_object locking behavior might be different on a bag-type table.

编辑：以上内容都是在set-type表上完成的，match -object锁定行为可能在bag-type表上有所不同。

2  

Even though it returns them under a read lock, you can still update them with write afterwards. The whole read/wread thing was just an optimization.

即使它在读锁定下返回它们，您仍然可以通过写入更新它们。整个read / wread只是一个优化。

You can use an ordered_set table to implement this mnesia-trick on compound keys.

您可以使用ordered_set表在复合键上实现此mnesia-trick。

2  

Like this,

喜欢这个，

        case mnesia:match_object(#rec{name=Name, _='_'}) of
            [] -> not_found;
            [First|Rest] -> something
        end,

0  

Can't you just lock the table in your transaction beforehand with mnesia:write_lock_table(Tab) ?

你不能事先用mnesia：write_lock_table（Tab）锁定事务中的表吗？