用qlc进行数据排序与筛选

1.Erlang有一个类似SQL的数据检索机制，叫做QLC（Query Interface to Mnesia, ETS, Dets, etc），可用于对Mnesia、ETS/DETS的数据表进行数据检索，包括常见的按指定域排序（ORDER BY）、按条件筛选（WHERE...）以及限制返回的结果长度（COUNT）。看个简单的例子：

-module(test).
-export([start/0]).
-include_lib("stdlib/include/qlc.hrl").
start() ->
    QH1 = qlc:q([{X, Y} || X <- [8,3,6,2], Y <- [b,a,c]]),
    %以第一个值作为key进行排序
    QH2 = qlc:keysort(1, QH1, [{order, ascending}]),
    QC = qlc:cursor(QH2),
    %获取前两条记录
    qlc:next_answers(QC, 2),
    %获取剩余的其他记录
    qlc:next_answers(QC, all_remainning).

2。再看一个国外网站上的案例：

 

Use QLC's {unique, true} option (See QLC documentation for more info).

I created a mnesia table, called test, with bag semantics. Each row consists of the table name, a Key and a Value, so my rows looked like:

1. test, 1, 1
2. test, 2, 1
3. test, 2, 2
4. test, 3, 1
5. test, 3, 2
6. test, 3, 3
... etc.

Then this simple module illustrates my approach. Notice that you have to include the qlc library and that, in my example, I am selecting distinct Keys.

 

-module(test).
-export([select_distinct/0]).

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

select_distinct()->
    QH = qlc:q( [K || {_TName, K, _V} <- mnesia:table(test)], {unique, true}),
    F = fun() -> qlc:eval(QH) end,
    {atomic, Result} = mnesia:transaction(F),
    Result.

Compiling and running

> c("/home/jim/test", [{outdir, "/home/jim/"}]).
> test:select_distinct().
> [4,1,2,3,5]

If you wanted sorted output then use the following version of the QH = ... line above

QH = qlc:sort(qlc:q( [K || {_TName, K, _V} <- mnesia:table(test)], {unique, true})),

If you wanted to select distinct values, the following would work:

QH = qlc:sort(qlc:q( [V || {_TName, _K, V} <- mnesia:table(test)], {unique, true})),

Again, the code is just to illustrate an approach

 

来自：

 

 

3.另外一个案例：

It is not always easy to do complicated queries over tables or .

The official syntax to make queries with select/2 is really cryptic.

Here is an example from the official Erlang docs. The query returns the name of each male person aged more then 30.

MatchHead = #person{name='$1', ***=male, age='$2', _='_'},
Guard = {'>', '$2', 30},
Result = '$1',
mnesia:select(Tab,[{MatchHead, [Guard], [Result]}]),

Les critères sont exprimé avec des $. L'ensemble devient assez indigeste pour des cas plus compliqué.

De plus il est impossible de réaliser des opérations basiques dans d'autres moteurs de base de données, comme trier le résultat.

Un module existe pourtant pour améliorer la lisibilité des requêtes. pour Query List Comprehension. Il supporte de base mnesia, ets et dets.

Voici une réécriture de l'exemple précédent

Query = qlc:q([Person#person.name || Person <- mnesia:table(Tab), Person#person.*** == male, Person#person.age > 30]),

Dans ce cas, la requête est exprimé sous la forme d'une list comprehension. Les critères sont exprimé d'une manière intelligible dans la deuxième partie de la list comprehension.

Si vous voulez exécuter cette requête dans mnesia, vous devez le faire dans une transaction.

-include_lib("stdlib/include/qlc.hrl")
Transaction = fun() ->
    Query = qlc:q([Person#person.name || Person <- mnesia:table(Tab), Person#person.*** == male, Person#person.age > 30]),
    qlc:eval(Query)
end,
mnesia:transaction(Transaction),

Pour trier d'une manière efficace, qlc fournit qlc:sort.

-include_lib("stdlib/include/qlc.hrl")
Transaction = fun() ->
    Query = qlc:q([Person#person.name || Person <- mnesia:table(Tab), Person#person.*** == male, Person#person.age > 30]),
    Order = fun(A, B) ->
        B#person.age > A#person.age
    end,
    qlc:eval(qlc:sort(Query, [order, Order]))
end,
mnesia:transaction(Transaction),

Je n'ait pas encore exploré toutes les fonctionnalités de QLC, mais la syntaxe que ce module offre m'a convaincu de l'utiliser le plus possible. La maintenance des requêtes devient beaucoup plus facile.

Une dernière chose, il est possible de créer ses propres modules utilisable avec QLC. Vous pouvez ainsi proposer une syntaxe de recherche sympathique avec un backend totalement différent de ets ou mnesia.