%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2004-2018. All Rights Reserved.
%%
%% Licensed under the Apache License, Version 2.0 (the "License");
%% you may not use this file except in compliance with the License.
%% You may obtain a copy of the License at
%%
%% http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by applicable law or agreed to in writing, software
%% distributed under the License is distributed on an "AS IS" BASIS,
%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%% See the License for the specific language governing permissions and
%% limitations under the License.
%%
%% %CopyrightEnd%
%%
%%
-module(mnesia_qlc_test).
-export([init_per_testcase/2, end_per_testcase/2,
init_per_group/2, end_per_group/2,
all/0, groups/0]).
-export([frag/1, info/1, mnesia_down/1,
dirty_nice_ram_copies/1, dirty_nice_disc_copies/1,
dirty_nice_disc_only_copies/1,
trans_nice_ram_copies/1, trans_nice_disc_copies/1,
trans_nice_disc_only_copies/1, atomic_eval/1,
nested_qlc/1
]).
-include("mnesia_test_lib.hrl").
-include_lib("stdlib/include/qlc.hrl").
init_per_testcase(Func, Conf) ->
setup(Conf),
mnesia_test_lib:init_per_testcase(Func, Conf).
end_per_testcase(Func, Conf) ->
mnesia_test_lib:end_per_testcase(Func, Conf).
all() ->
case code:which(qlc) of
non_existing -> [];
_ -> all_qlc()
end.
groups() ->
[{dirty, [],
[dirty_nice_ram_copies, dirty_nice_disc_copies,
dirty_nice_disc_only_copies]},
{trans, [],
[trans_nice_ram_copies, trans_nice_disc_copies,
trans_nice_disc_only_copies, {group, atomic}]},
{atomic, [], [atomic_eval]}].
init_per_group(_GroupName, Config) ->
Config.
end_per_group(_GroupName, Config) ->
Config.
all_qlc() ->
[{group, dirty}, {group, trans}, frag, info,
mnesia_down].
init_testcases(Type,Config) ->
Nodes = [N1,N2] = ?acquire_nodes(2, Config),
?match({atomic, ok}, mnesia:create_table(a, [{Type,[N1]}, {index,[3]}])),
?match({atomic, ok}, mnesia:create_table(b, [{Type,[N2]}])),
Write = fun(Id) ->
ok = mnesia:write({a, {a,Id}, 100 - Id}),
ok = mnesia:write({b, {b,100-Id}, Id})
end,
All = fun() -> [Write(Id) || Id <- lists:seq(1,10)], ok end,
?match({atomic, ok}, mnesia:sync_transaction(All)),
?match({atomic, [{b, {b,100-1}, 1}]}, mnesia:transaction(fun() -> mnesia:read({b, {b, 99}}) end)),
Nodes.
%% Test cases
dirty_nice_ram_copies(Setup) -> dirty_nice(Setup,ram_copies).
dirty_nice_disc_copies(Setup) -> dirty_nice(Setup,disc_copies).
dirty_nice_disc_only_copies(Setup) -> dirty_nice(Setup,disc_only_copies).
dirty_nice(suite, _) -> [];
dirty_nice(doc, _) -> [];
dirty_nice(Config, Type) when is_list(Config) ->
Ns = init_testcases(Type,Config),
QA = handle(<<"[Q || Q = {_,{_,Key},Val} <- mnesia:table(a),"
" Val == 90 + Key]">>),
QB = handle(<<"[Q || Q = {_,{_,Key},Val} <- mnesia:table(b),"
" Key == 90 + Val]">>),
QC = qlc:sort(mnesia:table(a, [{n_objects,1}, {lock,write}, {traverse, select}])),
QD = qlc:sort(mnesia:table(a, [{n_objects,1}, {traverse,{select,[{'$1',[],['$1']}]}}])),
FA = fun() -> qlc:e(QA) end,
FB = fun() -> qlc:e(QB) end,
FC = fun() -> qlc:e(QC) end,
FD = fun() -> qlc:e(QD) end,
%% Currently unsupported
?match({'EXIT',{aborted,no_transaction}}, FA()),
?match({'EXIT',{aborted,no_transaction}}, FB()),
%%
CRes = lists:sort(mnesia:dirty_match_object(a, {'_','_','_'})),
?match([{a,{a,5},95}], mnesia:async_dirty(FA)),
?match([{b,{b,95},5}], mnesia:async_dirty(FB)),
?match(CRes, mnesia:async_dirty(FC)),
?match(CRes, mnesia:async_dirty(FD)),
?match([{a,{a,5},95}], mnesia:sync_dirty(FA)),
?match([{b,{b,95},5}], mnesia:sync_dirty(FB)),
?match(CRes, mnesia:sync_dirty(FC)),
?match([{a,{a,5},95}], mnesia:activity(async_dirty, FA)),
?match([{b,{b,95},5}], mnesia:activity(async_dirty, FB)),
?match([{a,{a,5},95}], mnesia:activity(sync_dirty, FA)),
?match([{b,{b,95},5}], mnesia:activity(sync_dirty, FB)),
?match(CRes, mnesia:activity(async_dirty,FC)),
case Type of
disc_only_copies -> skip;
_ ->
?match([{a,{a,5},95}], mnesia:ets(FA)),
?match([{a,{a,5},95}], mnesia:activity(ets, FA))
end,
?verify_mnesia(Ns, []).
trans_nice_ram_copies(Setup) -> trans_nice(Setup,ram_copies).
trans_nice_disc_copies(Setup) -> trans_nice(Setup,disc_copies).
trans_nice_disc_only_copies(Setup) -> trans_nice(Setup,disc_only_copies).
trans_nice(suite, _) -> [];
trans_nice(doc, _) -> [];
trans_nice(Config, Type) when is_list(Config) ->
Ns = init_testcases(Type,Config),
QA = handle(<<"[Q || Q = {_,{_,Key},Val} <- mnesia:table(a),"
" Val == 90 + Key]">>),
QB = handle(<<"[Q || Q = {_,{_,Key},Val} <- mnesia:table(b),"
" Key == 90 + Val]">>),
QC = handle(recs(),
<<"[Q || Q = #a{v=91} <- mnesia:table(a)]"
>>),
QD = qlc:sort(mnesia:table(a, [{n_objects,1}, {lock,write}, {traverse, select}])),
QE = qlc:sort(mnesia:table(a, [{n_objects,1}, {traverse,{select,[{'$1',[],['$1']}]}}])),
DRes = lists:sort(mnesia:dirty_match_object(a, {'_','_','_'})),
FA = fun() -> qlc:e(QA) end,
FB = fun() -> qlc:e(QB) end,
FC = fun() -> qlc:e(QC) end,
FD = fun() -> qlc:e(QD) end,
FE = fun() -> qlc:e(QE) end,
?match({atomic,[{a,{a,5},95}]}, mnesia:transaction(FA)),
?match({atomic,[{b,{b,95},5}]}, mnesia:transaction(FB)),
?match({atomic,[{a,{a,9},91}]}, mnesia:transaction(FC)),
?match({atomic,[{a,{a,5},95}]}, mnesia:sync_transaction(FA)),
?match({atomic,[{b,{b,95},5}]}, mnesia:sync_transaction(FB)),
?match({atomic,[{a,{a,9},91}]}, mnesia:sync_transaction(FC)),
?match([{a,{a,5},95}], mnesia:activity(transaction,FA)),
?match([{b,{b,95},5}], mnesia:activity(transaction,FB)),
?match([{a,{a,9},91}], mnesia:activity(transaction,FC)),
?match([{a,{a,5},95}], mnesia:activity(sync_transaction,FA)),
?match([{b,{b,95},5}], mnesia:activity(sync_transaction,FB)),
?match([{a,{a,9},91}], mnesia:activity(sync_transaction,FC)),
?match({atomic, DRes}, mnesia:transaction(FD)),
?match({atomic, DRes}, mnesia:transaction(FE)),
Rest = fun(Cursor,Loop) ->
case qlc:next_answers(Cursor, 1) of
[] -> [];
[A]-> [A|Loop(Cursor,Loop)]
end
end,
Loop = fun() ->
Cursor = qlc:cursor(QD),
Rest(Cursor,Rest)
end,
?match({atomic, DRes}, mnesia:transaction(Loop)),
?verify_mnesia(Ns, []).
%% -record(a, {k,v}).
%% -record(b, {k,v}).
%% -record(k, {t,v}).
recs() ->
<<"-record(a, {k,v}). "
"-record(b, {k,v}). "
"-record(k, {t,v}). "
>>.
atomic_eval(suite) -> [];
atomic_eval(doc) -> [];
atomic_eval(Config) ->
Ns = init_testcases(ram_copies, Config),
Q1 = handle(recs(),
<<"[Q || Q = #a{k={_,9}} <- mnesia:table(a)]"
>>),
Eval = fun(Q) ->
{qlc:e(Q),
mnesia:system_info(held_locks)}
end,
Self = self(),
?match({[{a,{a,9},91}], [{{a,'______WHOLETABLE_____'},read,{tid,_,Self}}]},
ok(Eval,[Q1])),
Q2 = handle(recs(),
<<"[Q || Q = #a{k={a,9}} <- mnesia:table(a)]"
>>),
?match({[{a,{a,9},91}],[{{a,{a,9}},read,{tid,_,Self}}]},
ok(Eval,[Q2])),
Flush = fun(Loop) -> %% Clean queue
receive _ -> Loop(Loop)
after 0 -> ok end
end,
Flush(Flush),
GrabLock = fun(Father) ->
mnesia:read(a, {a,9}, write),
Father ! locked,
receive cont -> ok end end,
Pid1 = spawn(fun() -> ?match(ok, ok(GrabLock, [Self])) end),
?match(locked,receive locked -> locked after 5000 -> timeout end), %% Wait
put(count,0),
Restart = fun(Locker,Fun) ->
Count = get(count),
case {Count,(catch Fun())} of
{0, {'EXIT', R}} ->
Locker ! cont,
put(count, Count+1),
erlang:yield(),
exit(R);
Else ->
Else
end
end,
?match({1,{[{a,{a,9},91}], [{{a,'______WHOLETABLE_____'},read,{tid,_,Self}}]}},
ok(Restart,[Pid1,fun() -> Eval(Q1) end])),
Pid2 = spawn(fun() -> ?match(ok, ok(GrabLock, [Self])) end),
?match(locked,receive locked -> locked after 5000 -> timeout end), %% Wait
put(count,0),
?match({1,{[{a,{a,9},91}],[{{a,{a,9}},read,{tid,_,Self}}]}},
ok(Restart,[Pid2, fun() -> Eval(Q2) end])),
%% Basic test
Cursor = fun() ->
QC = qlc:cursor(Q1),
qlc:next_answers(QC)
end,
?match([{a,{a,9},91}], ok(Cursor, [])),
%% Lock
Pid3 = spawn(fun() -> ?match(ok, ok(GrabLock, [Self])) end),
?match(locked,receive locked -> locked after 5000 -> timeout end), %% Wait
put(count,0),
?match({1,[{a,{a,9},91}]}, ok(Restart,[Pid3, Cursor])),
QC1 = ok(fun() -> qlc:cursor(Q1) end, []),
?match({'EXIT', _}, (catch qlc:next_answers(QC1))),
?match({aborted,_}, ok(fun()->qlc:next_answers(QC1)end,[])),
?verify_mnesia(Ns, []).
frag(suite) -> [];
frag(doc) -> [];
frag(Config) ->
Ns = init_testcases(ram_copies,Config),
QA = handle(<<"[Q || Q = {_,{_,Key},Val} <- mnesia:table(a),"
" Val == 90 + Key]">>),
QB = handle(<<"[Q || Q = {_,{_,Key},Val} <- mnesia:table(b),"
" Key == 90 + Val]">>),
Activate =
fun(Tab) ->
?match({atomic,ok},mnesia:change_table_frag(Tab, {activate, []})),
Dist = mnesia_frag_test:frag_dist(Tab),
?match({atomic,ok},mnesia:change_table_frag(Tab,{add_frag,Dist}))
end,
Activate(a),
Activate(b),
Fun = fun(Tab) -> mnesia:table_info(Tab, frag_names) end,
FTs = mnesia:activity(sync_dirty, Fun, [a], mnesia_frag) ++
mnesia:activity(sync_dirty, Fun, [b], mnesia_frag),
Size = fun(Tab) -> mnesia:dirty_rpc(Tab, mnesia, table_info, [Tab,size]) end,
%% Verify that all data doesn't belong to the same frag.
?match([], [{Tab,Size(Tab)} || Tab <- FTs,
Size(Tab) =< 0]),
FA = fun() -> qlc:e(QA) end,
FB = fun() -> qlc:e(QB) end,
?match([{a,{a,5},95}], mnesia:activity(transaction,FA,[],mnesia_frag)),
?match([{b,{b,95},5}], mnesia:activity(transaction,FB,[],mnesia_frag)),
?verify_mnesia(Ns, []).
info(suite) -> [];
info(doc) -> [];
info(Config) ->
Ns = init_testcases(ram_copies, Config),
Q1 = handle(recs(),
<<"[Q || Q = #a{k={_,9}} <- mnesia:table(a)]"
>>),
Q2 = handle(recs(),
<<"[Q || Q = #a{k={a,9}} <- mnesia:table(a)]"
>>),
Q3 = handle(recs(),
<<"[Q || Q = #a{v=91} <- mnesia:table(a)]"
>>),
%% FIXME compile and check results!
?match(ok,io:format("~s~n",[qlc:info(Q1)])),
?match(ok,io:format("~s~n",[qlc:info(Q2)])),
?match(ok,io:format("~s~n",[qlc:info(Q3)])),
?verify_mnesia(Ns, []).
ok(Fun,A) ->
case mnesia:transaction(Fun,A) of
{atomic, R} -> R;
E -> E
end.
mnesia_down(suite) -> [];
mnesia_down(doc) ->
["Test bug OTP-7968, which crashed mnesia when a"
"mnesia_down came after qlc had been invoked"];
mnesia_down(Config) when is_list(Config) ->
[N1,N2] = init_testcases(ram_copies,Config),
QB = handle(<<"[Q || Q = {_,{_,Key},Val} <- mnesia:table(b),"
" Val == Key - 90]">>),
Tester = self(),
Eval = fun() ->
Cursor = qlc:cursor(QB), %% Forces another process
Res = qlc:next_answers(Cursor),
Tester ! {qlc, self(), Res},
{Mod, Tid, Ts} = get(mnesia_activity_state),
receive
continue ->
io:format("Continuing ~p ~p ~n",[self(), {Mod, Tid, Ts}]),
io:format("ETS ~p~n",[ets:tab2list(element(2,Ts))]),
io:format("~p~n",[process_info(self(),messages)]),
Res
end
end,
spawn(fun() -> TransRes = mnesia:transaction(Eval), Tester ! {test,TransRes} end),
TMInfo = fun() ->
TmInfo = mnesia_tm:get_info(5000),
mnesia_tm:display_info(user, TmInfo)
end,
receive
{qlc, QPid, QRes} ->
?match([{b,{b,95},5}], QRes),
TMInfo(),
mnesia_test_lib:kill_mnesia([N2]),
%%timer:sleep(1000),
QPid ! continue
after 2000 ->
exit(timeout1)
end,
receive
{test, QRes2} ->
?match({atomic, [{b,{b,95},5}]}, QRes2)
after 2000 ->
exit(timeout2)
end,
?verify_mnesia([N1], [N2]).
nested_qlc(suite) -> [];
nested_qlc(doc) ->
["Test bug in OTP-7968 (the second problem) where nested"
"transaction don't work as expected"];
nested_qlc(Config) when is_list(Config) ->
Ns = init_testcases(ram_copies,Config),
Res = as_with_bs(),
?match([_|_], Res),
top_as_with_some_bs(10),
?verify_mnesia(Ns, []).
%% Code from Daniel
bs_by_a_id(A_id) ->
find(qlc:q([ B || B={_,_,F_id} <- mnesia:table(b), F_id == A_id])).
as_with_bs() ->
find(qlc:q([ {A,bs_by_a_id(Id)} ||
A = {_, {a,Id}, _} <- mnesia:table(a)])).
top_as_with_some_bs(Limit) ->
top(
qlc:q([ {A,bs_by_a_id(Id)} ||
A = {_, {a,Id}, _} <- mnesia:table(a)]),
Limit,
fun(A1,A2) -> A1 < A2 end
).
% --- utils
find(Q) ->
F = fun() -> qlc:e(Q) end,
{atomic, Res} = mnesia:transaction(F),
Res.
% --- it returns top Limit results from query Q ordered by Order sort function
top(Q, Limit, Order) ->
Do = fun() ->
OQ = qlc:sort(Q, [{order,Order}]),
QC = qlc:cursor(OQ),
Res = qlc:next_answers(QC, Limit),
qlc:delete_cursor(QC),
Res
end,
{atomic, Res} = mnesia:transaction(Do),
Res.
%% To keep mnesia suite backward compatible,
%% we compile the queries in runtime when qlc is available
%% Compiles and returns a handle to a qlc
handle(Expr) ->
handle(<<>>,Expr).
handle(Records,Expr) ->
case catch handle2(Records,Expr) of
{ok, Handle} ->
Handle;
Else ->
?match(ok, Else)
end.
handle2(Records,Expr) ->
{FN,Mod} = temp_name(),
ModStr = list_to_binary("-module(" ++ atom_to_list(Mod) ++ ").\n"),
Prog = <<
ModStr/binary,
"-include_lib(\"stdlib/include/qlc.hrl\").\n",
"-export([tmp/0]).\n",
Records/binary,"\n",
"tmp() ->\n",
%% " _ = (catch throw(fvalue_not_reset)),"
" qlc:q( ",
Expr/binary,").\n">>,
?match(ok,file:write_file(FN,Prog)),
{ok,Forms} = epp:parse_file(FN,"",""),
{ok,Mod,Bin} = compile:forms(Forms),
code:load_binary(Mod,FN,Bin),
{ok, Mod:tmp()}.
setup(Config) ->
put(mts_config,Config),
put(mts_tf_counter,0).
temp_name() ->
Conf = get(mts_config),
C = get(mts_tf_counter),
put(mts_tf_counter,C+1),
{filename:join([proplists:get_value(priv_dir,Conf, "."),
"tempfile"++integer_to_list(C)++".tmp"]),
list_to_atom("tmp" ++ integer_to_list(C))}.
